harden forcezero and compiler barriers

Author: Emma Stensland

wolfcrypt/src/misc.c

@@ -693,33 +693,34 @@ WC_MISC_STATIC WC_INLINE void xorbuf(void* buf, const void* mask, word32 count)
    with zeros. It ensures compiler optimization doesn't skip it. */
 WC_MISC_STATIC WC_INLINE void ForceZero(void* mem, size_t len)
 {
-    byte *zb = (byte *)mem;
-    unsigned long *zl;
+    /* volatile prevents dead-store elimination; WC_BARRIER() prevents
+     * reordering. */
+    volatile byte *zb = (volatile byte *)mem;
+    volatile unsigned long *zl;
 
-    XFENCE();
+    WC_BARRIER();
 
-    while ((wc_ptr_t)zb & (wc_ptr_t)(sizeof(unsigned long) - 1U)) {
-        if (len == 0)
-            return;
+    while (len > 0 &&
+           ((wc_ptr_t)zb & (wc_ptr_t)(sizeof(unsigned long) - 1U))) {
         *zb++ = 0;
         --len;
     }
 
-    zl = (unsigned long *)zb;
+    zl = (volatile unsigned long *)zb;
 
     while (len >= sizeof(unsigned long)) {
         *zl++ = 0;
         len -= sizeof(unsigned long);
     }
 
-    zb = (byte *)zl;
+    zb = (volatile byte *)zl;
 
     while (len) {
         *zb++ = 0;
         --len;
     }
 
-    XFENCE();
+    WC_BARRIER();
 }
 #endif
 

wolfssl/wolfcrypt/wc_port.h

@@ -1918,16 +1918,30 @@ WOLFSSL_ABI WOLFSSL_API int wolfCrypt_Cleanup(void);
     #endif
 #endif
 
-#ifdef WOLF_C99
-    /* use alternate keyword for compatibility with -std=c99 */
-    #define XASM_VOLATILE(a) __asm__ volatile(a)
-#elif defined(__IAR_SYSTEMS_ICC__)
+/* XASM_VOLATILE_MB() adds a "memory" clobber. IAR/KEIL checked before
+ * WOLF_C99 since both may define __STDC_VERSION__ under --c99.
+ * XASM_VOLATILE() has no in-tree callers now; kept for out-of-tree ports. */
+/* NOLINTBEGIN(bugprone-macro-parentheses) */
+#if defined(__IAR_SYSTEMS_ICC__)
+    /* clobber list supported: see sp_cortexm.c's __asm__/asm redefine. */
     #define XASM_VOLATILE(a) asm volatile(a)
+    #define XASM_VOLATILE_MB(a) asm volatile(a ::: "memory")
 #elif defined(__KEIL__)
+    /* clobber list supported: see sp_cortexm.c's __asm__/__asm redefine. */
     #define XASM_VOLATILE(a) __asm volatile(a)
+    #define XASM_VOLATILE_MB(a) __asm volatile(a ::: "memory")
+#elif defined(WOLF_C99)
+    #define XASM_VOLATILE(a) __asm__ volatile(a)
+    #define XASM_VOLATILE_MB(a) __asm__ volatile(a ::: "memory")
+#elif defined(__GNUC__) || defined(__clang__)
+    #define XASM_VOLATILE(a) __asm__ __volatile__(a)
+    #define XASM_VOLATILE_MB(a) __asm__ __volatile__(a ::: "memory")
 #else
+    /* unknown compiler: assume basic asm only, no clobber list. */
     #define XASM_VOLATILE(a) __asm__ __volatile__(a)
+    #define XASM_VOLATILE_MB(a) XASM_VOLATILE(a)
 #endif
+/* NOLINTEND(bugprone-macro-parentheses) */
 
 #ifndef WOLFSSL_NO_FENCE
     #ifdef XFENCE
@@ -1948,33 +1962,33 @@ WOLFSSL_ABI WOLFSSL_API int wolfCrypt_Cleanup(void);
     #elif defined(WOLFSSL_NO_ASM)
         #define XFENCE() WC_DO_NOTHING
     #elif defined (__i386__) || defined(__x86_64__)
-        #define XFENCE() XASM_VOLATILE("lfence")
+        #define XFENCE() XASM_VOLATILE_MB("lfence")
     #elif defined (__arm__) && (__ARM_ARCH > 6)
-        #define XFENCE() XASM_VOLATILE("isb")
+        #define XFENCE() XASM_VOLATILE_MB("isb")
     #elif defined(_MSC_VER) && defined(_M_ARM64)
         /* MSVC on ARM64 has no __asm__; use the ISB intrinsic barrier. */
         #include <intrin.h>
         #define XFENCE() __isb(_ARM64_BARRIER_SY)
     #elif defined(__aarch64__)
         /* Change ".inst 0xd50330ff" to "sb" when compilers support it. */
         #ifdef WOLFSSL_ARMASM_BARRIER_SB
-            #define XFENCE() XASM_VOLATILE(".inst 0xd50330ff")
+            #define XFENCE() XASM_VOLATILE_MB(".inst 0xd50330ff")
         #elif defined(WOLFSSL_ARMASM_BARRIER_DETECT)
             extern int aarch64_use_sb;
-            #define XFENCE()                                \
-                do {                                        \
-                    if (aarch64_use_sb)                     \
-                        XASM_VOLATILE(".inst 0xd50330ff");  \
-                    else                                    \
-                        XASM_VOLATILE("isb");               \
+            #define XFENCE()                                       \
+                do {                                                \
+                    if (aarch64_use_sb)                             \
+                        XASM_VOLATILE_MB(".inst 0xd50330ff");       \
+                    else                                            \
+                        XASM_VOLATILE_MB("isb");                    \
                 } while (0)
         #else
-            #define XFENCE() XASM_VOLATILE("isb")
+            #define XFENCE() XASM_VOLATILE_MB("isb")
         #endif
     #elif defined(__riscv)
-        #define XFENCE() XASM_VOLATILE("fence")
+        #define XFENCE() XASM_VOLATILE_MB("fence")
     #elif defined(__PPC__) || defined(__POWERPC__)
-        #define XFENCE() XASM_VOLATILE("isync; sync")
+        #define XFENCE() XASM_VOLATILE_MB("isync; sync")
     #else
         #define XFENCE() WC_DO_NOTHING
     #endif