From 13c4672e9a7b4f57305c1dbd7946a90707109fe0 Mon Sep 17 00:00:00 2001 From: Daniele Lacamera Date: Thu, 12 Nov 2026 12:24:57 +0100 Subject: [PATCH 01/13] Fix AES context alignment in heap allocations --- wolfcrypt/src/aes.c | 69 +++++++++++++++++++++++++++++++++++-------- wolfcrypt/test/test.c | 9 ++++-- 2 files changed, 62 insertions(+), 16 deletions(-) diff --git a/wolfcrypt/src/aes.c b/wolfcrypt/src/aes.c index 49420523392..b07318f6268 100644 --- a/wolfcrypt/src/aes.c +++ b/wolfcrypt/src/aes.c @@ -17000,6 +17000,37 @@ int wc_AesCcmEncrypt_ex(Aes* aes, byte* out, const byte* in, word32 sz, #endif /* HAVE_AESCCM */ +/* Aes contains 16-byte-aligned members, but malloc on 32-bit Arm may only + * return an 8-byte-aligned pointer. Keep the original allocation for XFREE. */ +static WC_MAYBE_UNUSED Aes* AesAlloc(void* heap) +{ +#if defined(WOLFSSL_USE_ALIGN) && defined(WC_ALIGNOF) + const size_t align = WC_ALIGNOF(Aes); + byte* raw = (byte*)XMALLOC(sizeof(Aes) + align - 1 + sizeof(void*), heap, + DYNAMIC_TYPE_AES); + wc_ptr_t p; + + if (raw == NULL) + return NULL; + p = ((wc_ptr_t)(raw + sizeof(void*)) + align - 1) & + ~((wc_ptr_t)align - 1); + ((void**)p)[-1] = raw; + return (Aes*)p; +#else + return (Aes*)XMALLOC(sizeof(Aes), heap, DYNAMIC_TYPE_AES); +#endif +} + +static WC_MAYBE_UNUSED void AesAllocFree(Aes* aes, void* heap) +{ +#if defined(WOLFSSL_USE_ALIGN) && defined(WC_ALIGNOF) + if (aes != NULL) + XFREE(((void**)aes)[-1], heap, DYNAMIC_TYPE_AES); +#else + XFREE(aes, heap, DYNAMIC_TYPE_AES); +#endif +} + #ifndef WC_NO_CONSTRUCTORS #define AES_NEW_INIT_PLAIN 0 @@ -17013,7 +17044,7 @@ static Aes* _AesNew_common(void* heap, int devId, int *result_code, int idLen, const char* label) { int ret; - Aes* aes = (Aes*)XMALLOC(sizeof(Aes), heap, DYNAMIC_TYPE_AES); + Aes* aes = AesAlloc(heap); if (aes == NULL) { ret = MEMORY_E; } @@ -17047,7 +17078,7 @@ static Aes* _AesNew_common(void* heap, int devId, int *result_code, break; } if (ret != 0) { - XFREE(aes, heap, DYNAMIC_TYPE_AES); + AesAllocFree(aes, heap); aes = NULL; } } @@ -17092,7 +17123,7 @@ int wc_AesDelete(Aes *aes, Aes** aes_p) return BAD_FUNC_ARG; heap = aes->heap; wc_AesFree(aes); - XFREE(aes, heap, DYNAMIC_TYPE_AES); + AesAllocFree(aes, heap); if (aes_p != NULL) *aes_p = NULL; return 0; @@ -18680,8 +18711,7 @@ int wc_AesKeyWrap(const byte* key, word32 keySz, const byte* in, word32 inSz, return BAD_FUNC_ARG; #ifdef WOLFSSL_SMALL_STACK - if ((aes = (Aes *)XMALLOC(sizeof *aes, NULL, - DYNAMIC_TYPE_AES)) == NULL) + if ((aes = AesAlloc(NULL)) == NULL) return MEMORY_E; #endif @@ -18700,7 +18730,9 @@ int wc_AesKeyWrap(const byte* key, word32 keySz, const byte* in, word32 inSz, wc_AesFree(aes); out: - WC_FREE_VAR_EX(aes, NULL, DYNAMIC_TYPE_AES); +#ifdef WOLFSSL_SMALL_STACK + AesAllocFree(aes, NULL); +#endif return ret; } @@ -18875,8 +18907,7 @@ int wc_AesKeyUnWrap(const byte* key, word32 keySz, const byte* in, word32 inSz, return BAD_FUNC_ARG; #ifdef WOLFSSL_SMALL_STACK - if ((aes = (Aes *)XMALLOC(sizeof *aes, NULL, - DYNAMIC_TYPE_AES)) == NULL) + if ((aes = AesAlloc(NULL)) == NULL) return MEMORY_E; #endif @@ -18896,7 +18927,9 @@ int wc_AesKeyUnWrap(const byte* key, word32 keySz, const byte* in, word32 inSz, wc_AesFree(aes); out: - WC_FREE_VAR_EX(aes, NULL, DYNAMIC_TYPE_AES); +#ifdef WOLFSSL_SMALL_STACK + AesAllocFree(aes, NULL); +#endif return ret; } @@ -19007,7 +19040,10 @@ int wc_AesKeyWrap_Pad(const byte* key, word32 keySz, const byte* in, return BAD_FUNC_ARG; } - WC_ALLOC_VAR_EX(aes, Aes, 1, NULL, DYNAMIC_TYPE_AES, return MEMORY_E); +#ifdef WOLFSSL_SMALL_STACK + if ((aes = AesAlloc(NULL)) == NULL) + return MEMORY_E; +#endif ret = wc_AesInit(aes, NULL, INVALID_DEVID); if (ret != 0) { @@ -19025,7 +19061,9 @@ int wc_AesKeyWrap_Pad(const byte* key, word32 keySz, const byte* in, wc_AesFree(aes); out: - WC_FREE_VAR_EX(aes, NULL, DYNAMIC_TYPE_AES); +#ifdef WOLFSSL_SMALL_STACK + AesAllocFree(aes, NULL); +#endif return ret; } @@ -19180,7 +19218,10 @@ int wc_AesKeyUnWrap_Pad(const byte* key, word32 keySz, const byte* in, return BAD_FUNC_ARG; } - WC_ALLOC_VAR_EX(aes, Aes, 1, NULL, DYNAMIC_TYPE_AES, return MEMORY_E); +#ifdef WOLFSSL_SMALL_STACK + if ((aes = AesAlloc(NULL)) == NULL) + return MEMORY_E; +#endif ret = wc_AesInit(aes, NULL, INVALID_DEVID); if (ret != 0) { @@ -19198,7 +19239,9 @@ int wc_AesKeyUnWrap_Pad(const byte* key, word32 keySz, const byte* in, wc_AesFree(aes); out: - WC_FREE_VAR_EX(aes, NULL, DYNAMIC_TYPE_AES); +#ifdef WOLFSSL_SMALL_STACK + AesAllocFree(aes, NULL); +#endif return ret; } diff --git a/wolfcrypt/test/test.c b/wolfcrypt/test/test.c index d3cffb41e1e..74af52d0a5f 100644 --- a/wolfcrypt/test/test.c +++ b/wolfcrypt/test/test.c @@ -17699,6 +17699,10 @@ static wc_test_ret_t aes_key_size_test(void) aes = wc_AesNew(HEAP_HINT, devId, &ret); if (aes == NULL) return WC_TEST_RET_ENC_EC(ret); +#ifdef WC_ALIGNOF + if (!WC_IS_ALIGNED(aes, WC_ALIGNOF(Aes))) + ERROR_OUT(WC_TEST_RET_ENC_NC, out); +#endif #else ret = wc_AesInit(aes, HEAP_HINT, devId); /* 0 check OK for FIPSv1 */ @@ -26905,9 +26909,8 @@ typedef struct keywrapVector { * byte alignment through its ALIGN16 members, which XMALLOC does not guarantee * on 32-bit targets, where malloc only promises 8 -- and wc_AesSetIV() lowers * to an alignment-qualified NEON store when building for armv8-a+crypto, which - * faults on an under-aligned object. Neither a plain local nor a plain XMALLOC - * (wc_AesNew() included) satisfies both, so allocate with headroom, align by - * hand, and keep the base pointer for XFREE. */ + * faults on an under-aligned object. Allocate with headroom, align by hand, + * and keep the base pointer for XFREE. */ #define AESKEYWRAP_AES_ALIGN 16 static wc_test_ret_t aeskeywrap_caller_aes_test(const keywrapVector* v, byte* output, word32 outputSz, From 234892d8804cd490ebc6f63a14c918b6d01d6ea2 Mon Sep 17 00:00:00 2001 From: Daniele Lacamera Date: Thu, 12 Nov 2026 12:52:21 +0100 Subject: [PATCH 02/13] Fix AES whitebox cleanup for aligned allocations --- tests/unit-mcdc/test_aes_whitebox.c | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/tests/unit-mcdc/test_aes_whitebox.c b/tests/unit-mcdc/test_aes_whitebox.c index 5247cd623f8..93da9fff99b 100644 --- a/tests/unit-mcdc/test_aes_whitebox.c +++ b/tests/unit-mcdc/test_aes_whitebox.c @@ -302,10 +302,8 @@ static void wb_ghash_update(void) { WB_NOTE("AESGCM stream off; GHASH_UPDATE ski * ------------------------------------------------------------------------- */ static void wb_release(Aes* aes) { - if (aes != NULL) { - wc_AesFree(aes); - XFREE(aes, NULL, DYNAMIC_TYPE_AES); - } + if (aes != NULL) + (void)wc_AesDelete(aes, NULL); } static void wb_aesnew_common(void) From 9463c388fa12c47803fa689d1f1d3157d15eff3c Mon Sep 17 00:00:00 2001 From: Daniele Lacamera Date: Thu, 12 Nov 2026 12:55:08 +0100 Subject: [PATCH 03/13] Limit AES alignment assertion to non-FIPS builds --- wolfcrypt/test/test.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/wolfcrypt/test/test.c b/wolfcrypt/test/test.c index 74af52d0a5f..6f450082b6a 100644 --- a/wolfcrypt/test/test.c +++ b/wolfcrypt/test/test.c @@ -17699,7 +17699,8 @@ static wc_test_ret_t aes_key_size_test(void) aes = wc_AesNew(HEAP_HINT, devId, &ret); if (aes == NULL) return WC_TEST_RET_ENC_EC(ret); -#ifdef WC_ALIGNOF +#if defined(WC_ALIGNOF) && !defined(HAVE_FIPS) && \ + !defined(HAVE_SELFTEST) if (!WC_IS_ALIGNED(aes, WC_ALIGNOF(Aes))) ERROR_OUT(WC_TEST_RET_ENC_NC, out); #endif From d9ca519fe5345b54e0c387bfb348b315439f5448 Mon Sep 17 00:00:00 2001 From: Daniele Lacamera Date: Thu, 12 Nov 2026 14:23:31 +0100 Subject: [PATCH 04/13] Keep AES allocation helpers available to TI key wrap --- wolfcrypt/src/aes.c | 65 ++++++++++++++++++++++++--------------------- 1 file changed, 34 insertions(+), 31 deletions(-) diff --git a/wolfcrypt/src/aes.c b/wolfcrypt/src/aes.c index b07318f6268..08826b61a18 100644 --- a/wolfcrypt/src/aes.c +++ b/wolfcrypt/src/aes.c @@ -392,6 +392,40 @@ int wc_local_AesGcmCheckTagSz(word32 authTagSz) { } #endif /* HAVE_AESGCM */ +/* Aes contains 16-byte-aligned members, but malloc on 32-bit Arm may only + * return an 8-byte-aligned pointer. Keep the original allocation for XFREE. + * The TI backend uses its existing plain allocation path. */ +static WC_MAYBE_UNUSED Aes* AesAlloc(void* heap) +{ +#if defined(WOLFSSL_USE_ALIGN) && defined(WC_ALIGNOF) && \ + !defined(WOLFSSL_TI_CRYPT) + const size_t align = WC_ALIGNOF(Aes); + byte* raw = (byte*)XMALLOC(sizeof(Aes) + align - 1 + sizeof(void*), heap, + DYNAMIC_TYPE_AES); + wc_ptr_t p; + + if (raw == NULL) + return NULL; + p = ((wc_ptr_t)(raw + sizeof(void*)) + align - 1) & + ~((wc_ptr_t)align - 1); + ((void**)p)[-1] = raw; + return (Aes*)p; +#else + return (Aes*)XMALLOC(sizeof(Aes), heap, DYNAMIC_TYPE_AES); +#endif +} + +static WC_MAYBE_UNUSED void AesAllocFree(Aes* aes, void* heap) +{ +#if defined(WOLFSSL_USE_ALIGN) && defined(WC_ALIGNOF) && \ + !defined(WOLFSSL_TI_CRYPT) + if (aes != NULL) + XFREE(((void**)aes)[-1], heap, DYNAMIC_TYPE_AES); +#else + XFREE(aes, heap, DYNAMIC_TYPE_AES); +#endif +} + #if defined(WOLFSSL_TI_CRYPT) #include @@ -17000,37 +17034,6 @@ int wc_AesCcmEncrypt_ex(Aes* aes, byte* out, const byte* in, word32 sz, #endif /* HAVE_AESCCM */ -/* Aes contains 16-byte-aligned members, but malloc on 32-bit Arm may only - * return an 8-byte-aligned pointer. Keep the original allocation for XFREE. */ -static WC_MAYBE_UNUSED Aes* AesAlloc(void* heap) -{ -#if defined(WOLFSSL_USE_ALIGN) && defined(WC_ALIGNOF) - const size_t align = WC_ALIGNOF(Aes); - byte* raw = (byte*)XMALLOC(sizeof(Aes) + align - 1 + sizeof(void*), heap, - DYNAMIC_TYPE_AES); - wc_ptr_t p; - - if (raw == NULL) - return NULL; - p = ((wc_ptr_t)(raw + sizeof(void*)) + align - 1) & - ~((wc_ptr_t)align - 1); - ((void**)p)[-1] = raw; - return (Aes*)p; -#else - return (Aes*)XMALLOC(sizeof(Aes), heap, DYNAMIC_TYPE_AES); -#endif -} - -static WC_MAYBE_UNUSED void AesAllocFree(Aes* aes, void* heap) -{ -#if defined(WOLFSSL_USE_ALIGN) && defined(WC_ALIGNOF) - if (aes != NULL) - XFREE(((void**)aes)[-1], heap, DYNAMIC_TYPE_AES); -#else - XFREE(aes, heap, DYNAMIC_TYPE_AES); -#endif -} - #ifndef WC_NO_CONSTRUCTORS #define AES_NEW_INIT_PLAIN 0 From 65417791896ec668a9e876b7b5bb422bbbc967fa Mon Sep 17 00:00:00 2001 From: Daniele Lacamera Date: Mon, 16 Nov 2026 10:56:26 +0100 Subject: [PATCH 05/13] Fix CMAC context alignment in heap allocations --- src/ssl_crypto.c | 10 +++++----- wolfcrypt/src/aes.c | 8 +++++--- wolfcrypt/src/cmac.c | 10 ++++------ wolfcrypt/src/kdf.c | 8 ++++---- wolfssl/wolfcrypt/cmac.h | 35 +++++++++++++++++++++++++++++++++++ 5 files changed, 53 insertions(+), 18 deletions(-) diff --git a/src/ssl_crypto.c b/src/ssl_crypto.c index 4f6be377f3b..b2ace7ae130 100644 --- a/src/ssl_crypto.c +++ b/src/ssl_crypto.c @@ -2254,7 +2254,7 @@ WOLFSSL_CMAC_CTX* wolfSSL_CMAC_CTX_new(void) /* Allocate memory for EVP cipher context object. */ ctx->cctx = wolfSSL_EVP_CIPHER_CTX_new(); if (ctx->cctx == NULL) { - XFREE(ctx->internal, NULL, DYNAMIC_TYPE_CMAC); + CmacAllocFree((Cmac*)ctx->internal, NULL); XFREE(ctx, NULL, DYNAMIC_TYPE_OPENSSL); ctx = NULL; } @@ -2277,7 +2277,7 @@ void wolfSSL_CMAC_CTX_free(WOLFSSL_CMAC_CTX *ctx) #if (!defined(HAVE_FIPS) || FIPS_VERSION_GE(5, 3)) && !defined(HAVE_SELFTEST) wc_CmacFree((Cmac*)ctx->internal); #endif - XFREE(ctx->internal, NULL, DYNAMIC_TYPE_CMAC); + CmacAllocFree((Cmac*)ctx->internal, NULL); } if (ctx->cctx != NULL) { wolfSSL_EVP_CIPHER_CTX_cleanup(ctx->cctx); @@ -2363,7 +2363,7 @@ int wolfSSL_CMAC_Init(WOLFSSL_CMAC_CTX* ctx, const void *key, size_t keySz, } else if (ret == 1) { /* Allocate memory for wolfSSL CMAC object. */ - ctx->internal = (Cmac*)XMALLOC(sizeof(Cmac), NULL, DYNAMIC_TYPE_CMAC); + ctx->internal = (Cmac*)CmacAlloc(NULL); if (ctx->internal == NULL) ret = 0; } @@ -2372,7 +2372,7 @@ int wolfSSL_CMAC_Init(WOLFSSL_CMAC_CTX* ctx, const void *key, size_t keySz, if ((ret == 1) && (wc_InitCmac((Cmac*)ctx->internal, (const byte*)key, (word32)keySz, WC_CMAC_AES, NULL) != 0)) { WOLFSSL_MSG("wolfSSL_CMAC_Init: wc_InitCmac() failed"); - XFREE(ctx->internal, NULL, DYNAMIC_TYPE_CMAC); + CmacAllocFree((Cmac*)ctx->internal, NULL); ctx->internal = NULL; ret = 0; } @@ -2469,7 +2469,7 @@ int wolfSSL_CMAC_Final(WOLFSSL_CMAC_CTX* ctx, unsigned char* out, size_t* len) *len = (size_t)len32; } - XFREE(ctx->internal, NULL, DYNAMIC_TYPE_CMAC); + CmacAllocFree((Cmac*)ctx->internal, NULL); ctx->internal = NULL; } diff --git a/wolfcrypt/src/aes.c b/wolfcrypt/src/aes.c index 08826b61a18..6b3fbe30c6c 100644 --- a/wolfcrypt/src/aes.c +++ b/wolfcrypt/src/aes.c @@ -21202,8 +21202,10 @@ static WARN_UNUSED_RESULT int S2V( if (ret == 0) { if (dataSz >= WC_AES_BLOCK_SIZE) { - WC_ALLOC_VAR_EX(cmac, Cmac, 1, NULL, DYNAMIC_TYPE_CMAC, - ret=MEMORY_E); +#ifdef WOLFSSL_SMALL_STACK + if ((cmac = CmacAlloc(NULL)) == NULL) + ret = MEMORY_E; +#endif if (WC_VAR_OK(cmac)) { #ifdef WOLFSSL_CHECK_MEM_ZERO @@ -21226,7 +21228,7 @@ static WARN_UNUSED_RESULT int S2V( } } #ifdef WOLFSSL_SMALL_STACK - XFREE(cmac, NULL, DYNAMIC_TYPE_CMAC); + CmacAllocFree(cmac, NULL); #elif defined(WOLFSSL_CHECK_MEM_ZERO) wc_MemZero_Check(cmac, sizeof(Cmac)); #endif diff --git a/wolfcrypt/src/cmac.c b/wolfcrypt/src/cmac.c index e14dd4b0316..d6c4a1d872b 100644 --- a/wolfcrypt/src/cmac.c +++ b/wolfcrypt/src/cmac.c @@ -634,8 +634,7 @@ int wc_AesCmacGenerate(byte* out, word32* outSz, } #ifdef WOLFSSL_SMALL_STACK - if ((cmac = (Cmac *)XMALLOC(sizeof *cmac, NULL, - DYNAMIC_TYPE_CMAC)) == NULL) { + if ((cmac = CmacAlloc(NULL)) == NULL) { return MEMORY_E; } #endif @@ -658,7 +657,7 @@ int wc_AesCmacGenerate(byte* out, word32* outSz, #ifdef WOLFSSL_SMALL_STACK ForceZero(cmac, sizeof(Cmac)); - XFREE(cmac, NULL, DYNAMIC_TYPE_CMAC); + CmacAllocFree(cmac, NULL); #elif defined(WOLFSSL_CHECK_MEM_ZERO) wc_MemZero_Check(cmac, sizeof(Cmac)); #endif @@ -737,8 +736,7 @@ int wc_AesCmacVerify(const byte* check, word32 checkSz, } #ifdef WOLFSSL_SMALL_STACK - if ((cmac = (Cmac *)XMALLOC(sizeof *cmac, NULL, - DYNAMIC_TYPE_CMAC)) == NULL) { + if ((cmac = CmacAlloc(NULL)) == NULL) { return MEMORY_E; } #endif @@ -760,7 +758,7 @@ int wc_AesCmacVerify(const byte* check, word32 checkSz, #ifdef WOLFSSL_SMALL_STACK ForceZero(cmac, sizeof(Cmac)); - XFREE(cmac, NULL, DYNAMIC_TYPE_CMAC); + CmacAllocFree(cmac, NULL); #elif defined(WOLFSSL_CHECK_MEM_ZERO) wc_MemZero_Check(cmac, sizeof(Cmac)); #endif diff --git a/wolfcrypt/src/kdf.c b/wolfcrypt/src/kdf.c index 7e1d977e4ea..93dcd63f90a 100644 --- a/wolfcrypt/src/kdf.c +++ b/wolfcrypt/src/kdf.c @@ -1670,7 +1670,7 @@ int wc_KDA_KDF_twostep_cmac(const byte * salt, word32 salt_len, #endif #ifdef WOLFSSL_SMALL_STACK - cmac = (Cmac*)XMALLOC(sizeof(Cmac), heap, DYNAMIC_TYPE_CMAC); + cmac = CmacAlloc(heap); if (cmac == NULL) { #ifdef WOLFSSL_CHECK_MEM_ZERO wc_MemZero_Check(Key_kdk, sizeof(Key_kdk)); @@ -1699,7 +1699,7 @@ int wc_KDA_KDF_twostep_cmac(const byte * salt, word32 salt_len, #ifdef WOLFSSL_SMALL_STACK if (cmac) { ForceZero(cmac, sizeof(Cmac)); - XFREE(cmac, heap, DYNAMIC_TYPE_CMAC); + CmacAllocFree(cmac, heap); cmac = NULL; } #endif /* WOLFSSL_SMALL_STACK */ @@ -1777,7 +1777,7 @@ int wc_KDA_KDF_PRF_cmac(const byte* Kin, word32 KinSz, } #ifdef WOLFSSL_SMALL_STACK - cmac = (Cmac*)XMALLOC(sizeof(Cmac), heap, DYNAMIC_TYPE_CMAC); + cmac = CmacAlloc(heap); if (cmac == NULL) { return MEMORY_E; } @@ -1878,7 +1878,7 @@ int wc_KDA_KDF_PRF_cmac(const byte* Kin, word32 KinSz, #ifdef WOLFSSL_SMALL_STACK if (cmac) { ForceZero(cmac, sizeof(Cmac)); - XFREE(cmac, heap, DYNAMIC_TYPE_CMAC); + CmacAllocFree(cmac, heap); cmac = NULL; } #endif /* WOLFSSL_SMALL_STACK */ diff --git a/wolfssl/wolfcrypt/cmac.h b/wolfssl/wolfcrypt/cmac.h index 385207860d8..747609e09d3 100644 --- a/wolfssl/wolfcrypt/cmac.h +++ b/wolfssl/wolfcrypt/cmac.h @@ -97,6 +97,41 @@ struct Cmac { CmacType type; }; +/* Cmac starts with an Aes whose members are 16-byte aligned, but malloc on + * 32-bit Arm may only return an 8-byte-aligned pointer. Keep the original + * allocation for XFREE. The TI backend uses its existing plain allocation + * path. */ +static inline Cmac* CmacAlloc(void* heap) +{ +#if defined(WOLFSSL_USE_ALIGN) && defined(WC_ALIGNOF) && \ + !defined(WOLFSSL_TI_CRYPT) + const size_t align = WC_ALIGNOF(Cmac); + byte* raw = (byte*)XMALLOC(sizeof(Cmac) + align - 1 + sizeof(void*), + heap, DYNAMIC_TYPE_CMAC); + wc_ptr_t p; + + if (raw == NULL) + return NULL; + p = ((wc_ptr_t)(raw + sizeof(void*)) + align - 1) & + ~((wc_ptr_t)align - 1); + ((void**)p)[-1] = raw; + return (Cmac*)p; +#else + return (Cmac*)XMALLOC(sizeof(Cmac), heap, DYNAMIC_TYPE_CMAC); +#endif +} + +static inline void CmacAllocFree(Cmac* cmac, void* heap) +{ +#if defined(WOLFSSL_USE_ALIGN) && defined(WC_ALIGNOF) && \ + !defined(WOLFSSL_TI_CRYPT) + if (cmac != NULL) + XFREE(((void**)cmac)[-1], heap, DYNAMIC_TYPE_CMAC); +#else + XFREE(cmac, heap, DYNAMIC_TYPE_CMAC); +#endif +} + /* Reasonable defaults */ From 36acd740de1dd3a688b4757c0c32e619f7303868 Mon Sep 17 00:00:00 2001 From: Daniele Lacamera Date: Mon, 16 Nov 2026 10:56:26 +0100 Subject: [PATCH 06/13] Fix CMAC test cleanup for aligned allocations --- wolfcrypt/test/test.c | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/wolfcrypt/test/test.c b/wolfcrypt/test/test.c index 6f450082b6a..c83cfd5785f 100644 --- a/wolfcrypt/test/test.c +++ b/wolfcrypt/test/test.c @@ -86088,8 +86088,13 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t cmac_test(void) WOLFSSL_ENTER("cmac_test"); #if defined(WOLFSSL_SMALL_STACK) && !defined(WOLFSSL_NO_MALLOC) - if ((cmac = (Cmac *)XMALLOC(sizeof *cmac, HEAP_HINT, DYNAMIC_TYPE_CMAC)) == NULL) + if ((cmac = CmacAlloc(HEAP_HINT)) == NULL) ERROR_OUT(WC_TEST_RET_ENC_ERRNO, out); +#if defined(WC_ALIGNOF) && !defined(HAVE_FIPS) && \ + !defined(HAVE_SELFTEST) + if (!WC_IS_ALIGNED(cmac, WC_ALIGNOF(Cmac))) + ERROR_OUT(WC_TEST_RET_ENC_NC, out); +#endif #endif for (i = 0, tc = testCases; @@ -86208,7 +86213,7 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t cmac_test(void) #endif #if defined(WOLFSSL_SMALL_STACK) && !defined(WOLFSSL_NO_MALLOC) - XFREE(cmac, HEAP_HINT, DYNAMIC_TYPE_CMAC); + CmacAllocFree(cmac, HEAP_HINT); #endif return ret; From 587161177621c47f826b49ecdccc15150877ec71 Mon Sep 17 00:00:00 2001 From: Daniele Lacamera Date: Mon, 16 Nov 2026 15:56:36 +0100 Subject: [PATCH 07/13] Fall back to plain CMAC allocation in FIPS builds --- src/ssl_crypto.c | 24 +++++++++++++++++++----- wolfcrypt/test/test.c | 12 ++++++++++++ 2 files changed, 31 insertions(+), 5 deletions(-) diff --git a/src/ssl_crypto.c b/src/ssl_crypto.c index b2ace7ae130..b187c5348c0 100644 --- a/src/ssl_crypto.c +++ b/src/ssl_crypto.c @@ -2232,6 +2232,20 @@ size_t wolfSSL_HMAC_size(const WOLFSSL_HMAC_CTX* ctx) #if defined(OPENSSL_EXTRA) && !defined(WOLFCRYPT_ONLY) #if defined(WOLFSSL_CMAC) && defined(OPENSSL_EXTRA) && \ defined(WOLFSSL_AES_DIRECT) +/* CmacAlloc/CmacAllocFree (wolfcrypt/cmac.h) align the Cmac context. The + * FIPS build compiles this file against the validated overlay's cmac.h, + * which has no helpers, so fall back to plain allocation there, matching + * the validated FIPS cmac.c. */ +#if defined(WOLFSSL_USE_ALIGN) && defined(WC_ALIGNOF) && \ + !defined(WOLFSSL_TI_CRYPT) && !defined(HAVE_FIPS) +#define WOLFSSL_CMAC_CTX_ALLOC(heap) CmacAlloc(heap) +#define WOLFSSL_CMAC_CTX_ALLOC_FREE(p, heap) CmacAllocFree(p, heap) +#else +#define WOLFSSL_CMAC_CTX_ALLOC(heap) \ + ((Cmac*)XMALLOC(sizeof(Cmac), (heap), DYNAMIC_TYPE_CMAC)) +#define WOLFSSL_CMAC_CTX_ALLOC_FREE(p, heap) \ + XFREE((p), (heap), DYNAMIC_TYPE_CMAC) +#endif /* Allocate a new CMAC context object. * * TODO: make fields static. @@ -2254,7 +2268,7 @@ WOLFSSL_CMAC_CTX* wolfSSL_CMAC_CTX_new(void) /* Allocate memory for EVP cipher context object. */ ctx->cctx = wolfSSL_EVP_CIPHER_CTX_new(); if (ctx->cctx == NULL) { - CmacAllocFree((Cmac*)ctx->internal, NULL); + WOLFSSL_CMAC_CTX_ALLOC_FREE(ctx->internal, NULL); XFREE(ctx, NULL, DYNAMIC_TYPE_OPENSSL); ctx = NULL; } @@ -2277,7 +2291,7 @@ void wolfSSL_CMAC_CTX_free(WOLFSSL_CMAC_CTX *ctx) #if (!defined(HAVE_FIPS) || FIPS_VERSION_GE(5, 3)) && !defined(HAVE_SELFTEST) wc_CmacFree((Cmac*)ctx->internal); #endif - CmacAllocFree((Cmac*)ctx->internal, NULL); + WOLFSSL_CMAC_CTX_ALLOC_FREE(ctx->internal, NULL); } if (ctx->cctx != NULL) { wolfSSL_EVP_CIPHER_CTX_cleanup(ctx->cctx); @@ -2363,7 +2377,7 @@ int wolfSSL_CMAC_Init(WOLFSSL_CMAC_CTX* ctx, const void *key, size_t keySz, } else if (ret == 1) { /* Allocate memory for wolfSSL CMAC object. */ - ctx->internal = (Cmac*)CmacAlloc(NULL); + ctx->internal = WOLFSSL_CMAC_CTX_ALLOC(NULL); if (ctx->internal == NULL) ret = 0; } @@ -2372,7 +2386,7 @@ int wolfSSL_CMAC_Init(WOLFSSL_CMAC_CTX* ctx, const void *key, size_t keySz, if ((ret == 1) && (wc_InitCmac((Cmac*)ctx->internal, (const byte*)key, (word32)keySz, WC_CMAC_AES, NULL) != 0)) { WOLFSSL_MSG("wolfSSL_CMAC_Init: wc_InitCmac() failed"); - CmacAllocFree((Cmac*)ctx->internal, NULL); + WOLFSSL_CMAC_CTX_ALLOC_FREE(ctx->internal, NULL); ctx->internal = NULL; ret = 0; } @@ -2469,7 +2483,7 @@ int wolfSSL_CMAC_Final(WOLFSSL_CMAC_CTX* ctx, unsigned char* out, size_t* len) *len = (size_t)len32; } - CmacAllocFree((Cmac*)ctx->internal, NULL); + WOLFSSL_CMAC_CTX_ALLOC_FREE(ctx->internal, NULL); ctx->internal = NULL; } diff --git a/wolfcrypt/test/test.c b/wolfcrypt/test/test.c index c83cfd5785f..387694991f4 100644 --- a/wolfcrypt/test/test.c +++ b/wolfcrypt/test/test.c @@ -86088,8 +86088,15 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t cmac_test(void) WOLFSSL_ENTER("cmac_test"); #if defined(WOLFSSL_SMALL_STACK) && !defined(WOLFSSL_NO_MALLOC) +#if defined(WOLFSSL_USE_ALIGN) && defined(WC_ALIGNOF) && \ + !defined(WOLFSSL_TI_CRYPT) && !defined(HAVE_FIPS) if ((cmac = CmacAlloc(HEAP_HINT)) == NULL) ERROR_OUT(WC_TEST_RET_ENC_ERRNO, out); +#else + if ((cmac = (Cmac *)XMALLOC(sizeof *cmac, HEAP_HINT, + DYNAMIC_TYPE_CMAC)) == NULL) + ERROR_OUT(WC_TEST_RET_ENC_ERRNO, out); +#endif #if defined(WC_ALIGNOF) && !defined(HAVE_FIPS) && \ !defined(HAVE_SELFTEST) if (!WC_IS_ALIGNED(cmac, WC_ALIGNOF(Cmac))) @@ -86213,7 +86220,12 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t cmac_test(void) #endif #if defined(WOLFSSL_SMALL_STACK) && !defined(WOLFSSL_NO_MALLOC) +#if defined(WOLFSSL_USE_ALIGN) && defined(WC_ALIGNOF) && \ + !defined(WOLFSSL_TI_CRYPT) && !defined(HAVE_FIPS) CmacAllocFree(cmac, HEAP_HINT); +#else + XFREE(cmac, HEAP_HINT, DYNAMIC_TYPE_CMAC); +#endif #endif return ret; From bf77abba1a75252ab00fec3395a2c1047a4182c2 Mon Sep 17 00:00:00 2001 From: Daniele Lacamera Date: Mon, 16 Nov 2026 17:51:28 +0100 Subject: [PATCH 08/13] Use WC_INLINE for CmacAlloc helpers in C89 builds --- wolfssl/wolfcrypt/cmac.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/wolfssl/wolfcrypt/cmac.h b/wolfssl/wolfcrypt/cmac.h index 747609e09d3..7af5373f440 100644 --- a/wolfssl/wolfcrypt/cmac.h +++ b/wolfssl/wolfcrypt/cmac.h @@ -101,7 +101,7 @@ struct Cmac { * 32-bit Arm may only return an 8-byte-aligned pointer. Keep the original * allocation for XFREE. The TI backend uses its existing plain allocation * path. */ -static inline Cmac* CmacAlloc(void* heap) +static WC_INLINE Cmac* CmacAlloc(void* heap) { #if defined(WOLFSSL_USE_ALIGN) && defined(WC_ALIGNOF) && \ !defined(WOLFSSL_TI_CRYPT) @@ -121,7 +121,7 @@ static inline Cmac* CmacAlloc(void* heap) #endif } -static inline void CmacAllocFree(Cmac* cmac, void* heap) +static WC_INLINE void CmacAllocFree(Cmac* cmac, void* heap) { #if defined(WOLFSSL_USE_ALIGN) && defined(WC_ALIGNOF) && \ !defined(WOLFSSL_TI_CRYPT) From 82eaa9673a8d453ee75dfc860025d2ffc3009afd Mon Sep 17 00:00:00 2001 From: Daniele Lacamera Date: Mon, 16 Nov 2026 18:20:39 +0100 Subject: [PATCH 09/13] Cast EVP CMAC free arg for C++ builds --- src/ssl_crypto.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/ssl_crypto.c b/src/ssl_crypto.c index b187c5348c0..466018b5093 100644 --- a/src/ssl_crypto.c +++ b/src/ssl_crypto.c @@ -2239,7 +2239,8 @@ size_t wolfSSL_HMAC_size(const WOLFSSL_HMAC_CTX* ctx) #if defined(WOLFSSL_USE_ALIGN) && defined(WC_ALIGNOF) && \ !defined(WOLFSSL_TI_CRYPT) && !defined(HAVE_FIPS) #define WOLFSSL_CMAC_CTX_ALLOC(heap) CmacAlloc(heap) -#define WOLFSSL_CMAC_CTX_ALLOC_FREE(p, heap) CmacAllocFree(p, heap) +#define WOLFSSL_CMAC_CTX_ALLOC_FREE(p, heap) \ + CmacAllocFree((Cmac*)(p), (heap)) #else #define WOLFSSL_CMAC_CTX_ALLOC(heap) \ ((Cmac*)XMALLOC(sizeof(Cmac), (heap), DYNAMIC_TYPE_CMAC)) From 2c69d2284cc67a7aa74e1f5ea0166eadcfae1edc Mon Sep 17 00:00:00 2001 From: Daniele Lacamera Date: Tue, 17 Nov 2026 11:18:00 +0100 Subject: [PATCH 10/13] Consolidate aligned allocation helpers into private header --- src/ssl_crypto.c | 26 +++------ wolfcrypt/src/aes.c | 61 +++++---------------- wolfcrypt/src/alloc_align.h | 103 ++++++++++++++++++++++++++++++++++++ wolfcrypt/src/cmac.c | 9 ++-- wolfcrypt/src/include.am | 3 +- wolfcrypt/src/kdf.c | 9 ++-- wolfcrypt/test/test.c | 17 ++---- wolfssl/wolfcrypt/cmac.h | 36 ------------- 8 files changed, 138 insertions(+), 126 deletions(-) create mode 100644 wolfcrypt/src/alloc_align.h diff --git a/src/ssl_crypto.c b/src/ssl_crypto.c index 466018b5093..272de25ac77 100644 --- a/src/ssl_crypto.c +++ b/src/ssl_crypto.c @@ -20,6 +20,7 @@ */ #include +#include #ifndef WOLFSSL_SSL_CRYPTO_INCLUDED #ifndef WOLFSSL_IGNORE_FILE_WARN @@ -2232,21 +2233,6 @@ size_t wolfSSL_HMAC_size(const WOLFSSL_HMAC_CTX* ctx) #if defined(OPENSSL_EXTRA) && !defined(WOLFCRYPT_ONLY) #if defined(WOLFSSL_CMAC) && defined(OPENSSL_EXTRA) && \ defined(WOLFSSL_AES_DIRECT) -/* CmacAlloc/CmacAllocFree (wolfcrypt/cmac.h) align the Cmac context. The - * FIPS build compiles this file against the validated overlay's cmac.h, - * which has no helpers, so fall back to plain allocation there, matching - * the validated FIPS cmac.c. */ -#if defined(WOLFSSL_USE_ALIGN) && defined(WC_ALIGNOF) && \ - !defined(WOLFSSL_TI_CRYPT) && !defined(HAVE_FIPS) -#define WOLFSSL_CMAC_CTX_ALLOC(heap) CmacAlloc(heap) -#define WOLFSSL_CMAC_CTX_ALLOC_FREE(p, heap) \ - CmacAllocFree((Cmac*)(p), (heap)) -#else -#define WOLFSSL_CMAC_CTX_ALLOC(heap) \ - ((Cmac*)XMALLOC(sizeof(Cmac), (heap), DYNAMIC_TYPE_CMAC)) -#define WOLFSSL_CMAC_CTX_ALLOC_FREE(p, heap) \ - XFREE((p), (heap), DYNAMIC_TYPE_CMAC) -#endif /* Allocate a new CMAC context object. * * TODO: make fields static. @@ -2269,7 +2255,7 @@ WOLFSSL_CMAC_CTX* wolfSSL_CMAC_CTX_new(void) /* Allocate memory for EVP cipher context object. */ ctx->cctx = wolfSSL_EVP_CIPHER_CTX_new(); if (ctx->cctx == NULL) { - WOLFSSL_CMAC_CTX_ALLOC_FREE(ctx->internal, NULL); + WC_FREE_CMAC((Cmac*)ctx->internal, NULL); XFREE(ctx, NULL, DYNAMIC_TYPE_OPENSSL); ctx = NULL; } @@ -2292,7 +2278,7 @@ void wolfSSL_CMAC_CTX_free(WOLFSSL_CMAC_CTX *ctx) #if (!defined(HAVE_FIPS) || FIPS_VERSION_GE(5, 3)) && !defined(HAVE_SELFTEST) wc_CmacFree((Cmac*)ctx->internal); #endif - WOLFSSL_CMAC_CTX_ALLOC_FREE(ctx->internal, NULL); + WC_FREE_CMAC((Cmac*)ctx->internal, NULL); } if (ctx->cctx != NULL) { wolfSSL_EVP_CIPHER_CTX_cleanup(ctx->cctx); @@ -2378,7 +2364,7 @@ int wolfSSL_CMAC_Init(WOLFSSL_CMAC_CTX* ctx, const void *key, size_t keySz, } else if (ret == 1) { /* Allocate memory for wolfSSL CMAC object. */ - ctx->internal = WOLFSSL_CMAC_CTX_ALLOC(NULL); + ctx->internal = WC_ALLOC_CMAC(NULL); if (ctx->internal == NULL) ret = 0; } @@ -2387,7 +2373,7 @@ int wolfSSL_CMAC_Init(WOLFSSL_CMAC_CTX* ctx, const void *key, size_t keySz, if ((ret == 1) && (wc_InitCmac((Cmac*)ctx->internal, (const byte*)key, (word32)keySz, WC_CMAC_AES, NULL) != 0)) { WOLFSSL_MSG("wolfSSL_CMAC_Init: wc_InitCmac() failed"); - WOLFSSL_CMAC_CTX_ALLOC_FREE(ctx->internal, NULL); + WC_FREE_CMAC((Cmac*)ctx->internal, NULL); ctx->internal = NULL; ret = 0; } @@ -2484,7 +2470,7 @@ int wolfSSL_CMAC_Final(WOLFSSL_CMAC_CTX* ctx, unsigned char* out, size_t* len) *len = (size_t)len32; } - WOLFSSL_CMAC_CTX_ALLOC_FREE(ctx->internal, NULL); + WC_FREE_CMAC((Cmac*)ctx->internal, NULL); ctx->internal = NULL; } diff --git a/wolfcrypt/src/aes.c b/wolfcrypt/src/aes.c index 6b3fbe30c6c..7806e3376eb 100644 --- a/wolfcrypt/src/aes.c +++ b/wolfcrypt/src/aes.c @@ -147,6 +147,7 @@ block cipher mechanism that uses n-bit binary string parameter key with 128-bits #endif #include +#include #ifdef WOLFSSL_AESNI #include @@ -392,40 +393,6 @@ int wc_local_AesGcmCheckTagSz(word32 authTagSz) { } #endif /* HAVE_AESGCM */ -/* Aes contains 16-byte-aligned members, but malloc on 32-bit Arm may only - * return an 8-byte-aligned pointer. Keep the original allocation for XFREE. - * The TI backend uses its existing plain allocation path. */ -static WC_MAYBE_UNUSED Aes* AesAlloc(void* heap) -{ -#if defined(WOLFSSL_USE_ALIGN) && defined(WC_ALIGNOF) && \ - !defined(WOLFSSL_TI_CRYPT) - const size_t align = WC_ALIGNOF(Aes); - byte* raw = (byte*)XMALLOC(sizeof(Aes) + align - 1 + sizeof(void*), heap, - DYNAMIC_TYPE_AES); - wc_ptr_t p; - - if (raw == NULL) - return NULL; - p = ((wc_ptr_t)(raw + sizeof(void*)) + align - 1) & - ~((wc_ptr_t)align - 1); - ((void**)p)[-1] = raw; - return (Aes*)p; -#else - return (Aes*)XMALLOC(sizeof(Aes), heap, DYNAMIC_TYPE_AES); -#endif -} - -static WC_MAYBE_UNUSED void AesAllocFree(Aes* aes, void* heap) -{ -#if defined(WOLFSSL_USE_ALIGN) && defined(WC_ALIGNOF) && \ - !defined(WOLFSSL_TI_CRYPT) - if (aes != NULL) - XFREE(((void**)aes)[-1], heap, DYNAMIC_TYPE_AES); -#else - XFREE(aes, heap, DYNAMIC_TYPE_AES); -#endif -} - #if defined(WOLFSSL_TI_CRYPT) #include @@ -17047,7 +17014,7 @@ static Aes* _AesNew_common(void* heap, int devId, int *result_code, int idLen, const char* label) { int ret; - Aes* aes = AesAlloc(heap); + Aes* aes = WC_ALLOC_AES(heap); if (aes == NULL) { ret = MEMORY_E; } @@ -17081,7 +17048,7 @@ static Aes* _AesNew_common(void* heap, int devId, int *result_code, break; } if (ret != 0) { - AesAllocFree(aes, heap); + WC_FREE_AES(aes, heap); aes = NULL; } } @@ -17126,7 +17093,7 @@ int wc_AesDelete(Aes *aes, Aes** aes_p) return BAD_FUNC_ARG; heap = aes->heap; wc_AesFree(aes); - AesAllocFree(aes, heap); + WC_FREE_AES(aes, heap); if (aes_p != NULL) *aes_p = NULL; return 0; @@ -18714,7 +18681,7 @@ int wc_AesKeyWrap(const byte* key, word32 keySz, const byte* in, word32 inSz, return BAD_FUNC_ARG; #ifdef WOLFSSL_SMALL_STACK - if ((aes = AesAlloc(NULL)) == NULL) + if ((aes = WC_ALLOC_AES(NULL)) == NULL) return MEMORY_E; #endif @@ -18734,7 +18701,7 @@ int wc_AesKeyWrap(const byte* key, word32 keySz, const byte* in, word32 inSz, out: #ifdef WOLFSSL_SMALL_STACK - AesAllocFree(aes, NULL); + WC_FREE_AES(aes, NULL); #endif return ret; @@ -18910,7 +18877,7 @@ int wc_AesKeyUnWrap(const byte* key, word32 keySz, const byte* in, word32 inSz, return BAD_FUNC_ARG; #ifdef WOLFSSL_SMALL_STACK - if ((aes = AesAlloc(NULL)) == NULL) + if ((aes = WC_ALLOC_AES(NULL)) == NULL) return MEMORY_E; #endif @@ -18931,7 +18898,7 @@ int wc_AesKeyUnWrap(const byte* key, word32 keySz, const byte* in, word32 inSz, out: #ifdef WOLFSSL_SMALL_STACK - AesAllocFree(aes, NULL); + WC_FREE_AES(aes, NULL); #endif return ret; @@ -19044,7 +19011,7 @@ int wc_AesKeyWrap_Pad(const byte* key, word32 keySz, const byte* in, } #ifdef WOLFSSL_SMALL_STACK - if ((aes = AesAlloc(NULL)) == NULL) + if ((aes = WC_ALLOC_AES(NULL)) == NULL) return MEMORY_E; #endif @@ -19065,7 +19032,7 @@ int wc_AesKeyWrap_Pad(const byte* key, word32 keySz, const byte* in, out: #ifdef WOLFSSL_SMALL_STACK - AesAllocFree(aes, NULL); + WC_FREE_AES(aes, NULL); #endif return ret; @@ -19222,7 +19189,7 @@ int wc_AesKeyUnWrap_Pad(const byte* key, word32 keySz, const byte* in, } #ifdef WOLFSSL_SMALL_STACK - if ((aes = AesAlloc(NULL)) == NULL) + if ((aes = WC_ALLOC_AES(NULL)) == NULL) return MEMORY_E; #endif @@ -19243,7 +19210,7 @@ int wc_AesKeyUnWrap_Pad(const byte* key, word32 keySz, const byte* in, out: #ifdef WOLFSSL_SMALL_STACK - AesAllocFree(aes, NULL); + WC_FREE_AES(aes, NULL); #endif return ret; @@ -21203,7 +21170,7 @@ static WARN_UNUSED_RESULT int S2V( if (dataSz >= WC_AES_BLOCK_SIZE) { #ifdef WOLFSSL_SMALL_STACK - if ((cmac = CmacAlloc(NULL)) == NULL) + if ((cmac = WC_ALLOC_CMAC(NULL)) == NULL) ret = MEMORY_E; #endif if (WC_VAR_OK(cmac)) @@ -21228,7 +21195,7 @@ static WARN_UNUSED_RESULT int S2V( } } #ifdef WOLFSSL_SMALL_STACK - CmacAllocFree(cmac, NULL); + WC_FREE_CMAC(cmac, NULL); #elif defined(WOLFSSL_CHECK_MEM_ZERO) wc_MemZero_Check(cmac, sizeof(Cmac)); #endif diff --git a/wolfcrypt/src/alloc_align.h b/wolfcrypt/src/alloc_align.h new file mode 100644 index 00000000000..4e4ffa14c43 --- /dev/null +++ b/wolfcrypt/src/alloc_align.h @@ -0,0 +1,103 @@ +/* alloc_align.h + * + * Copyright (C) 2006-2026 wolfSSL Inc. + * + * This file is part of wolfSSL. + * + * wolfSSL is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * wolfSSL is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA + */ + +/* + * Private aligned-allocation helpers for heap contexts whose members carry + * alignment attributes (Aes, Cmac). On 32-bit Arm, malloc may only return an + * 8-byte-aligned pointer, so over-allocate, align, and keep the original + * pointer for XFREE. Included only by the files that allocate those contexts + * on the heap; not part of the public API. + */ +#ifndef WOLFSSL_ALLOC_ALIGN_H +#define WOLFSSL_ALLOC_ALIGN_H + +#include +#include + +#if defined(WOLFSSL_USE_ALIGN) && defined(WC_ALIGNOF) && \ + !defined(WOLFSSL_TI_CRYPT) +#define WC_HAVE_ALIGNED_ALLOC +static WC_INLINE void* wc_alloc_aligned(void* heap, size_t size, + size_t align, int type) +{ + byte* raw = (byte*)XMALLOC(size + align - 1 + sizeof(void*), heap, type); + wc_ptr_t p; + + if (raw == NULL) + return NULL; + p = ((wc_ptr_t)(raw + sizeof(void*)) + align - 1) & + ~((wc_ptr_t)align - 1); + ((void**)p)[-1] = raw; + return (void*)p; +} + +static WC_INLINE void wc_free_aligned(void* p, void* heap, int type) +{ + if (p != NULL) + XFREE(((void**)p)[-1], heap, type); +} +#endif + +/* Type-specific wrappers: the alignment requirement is the type's, hidden + * here so call sites stay plain. The TI backend and builds without + * WC_ALIGNOF use the plain allocation path, which needs no indirection. + * Each wrapper exists only where its type does. */ +#ifndef NO_AES +#ifdef WC_HAVE_ALIGNED_ALLOC +static WC_INLINE Aes* WC_ALLOC_AES(void* heap) +{ + return (Aes*)wc_alloc_aligned(heap, sizeof(Aes), WC_ALIGNOF(Aes), + DYNAMIC_TYPE_AES); +} + +static WC_INLINE void WC_FREE_AES(Aes* aes, void* heap) +{ + wc_free_aligned((void*)aes, heap, DYNAMIC_TYPE_AES); +} +#else +#define WC_ALLOC_AES(heap) \ + ((Aes*)XMALLOC(sizeof(Aes), (heap), DYNAMIC_TYPE_AES)) +#define WC_FREE_AES(aes, heap) \ + (XFREE((aes), (heap), DYNAMIC_TYPE_AES)) +#endif +#endif /* !NO_AES */ + +#ifdef WOLFSSL_CMAC +#ifdef WC_HAVE_ALIGNED_ALLOC +static WC_INLINE Cmac* WC_ALLOC_CMAC(void* heap) +{ + return (Cmac*)wc_alloc_aligned(heap, sizeof(Cmac), WC_ALIGNOF(Cmac), + DYNAMIC_TYPE_CMAC); +} + +static WC_INLINE void WC_FREE_CMAC(Cmac* cmac, void* heap) +{ + wc_free_aligned((void*)cmac, heap, DYNAMIC_TYPE_CMAC); +} +#else +#define WC_ALLOC_CMAC(heap) \ + ((Cmac*)XMALLOC(sizeof(Cmac), (heap), DYNAMIC_TYPE_CMAC)) +#define WC_FREE_CMAC(cmac, heap) \ + (XFREE((cmac), (heap), DYNAMIC_TYPE_CMAC)) +#endif +#endif /* WOLFSSL_CMAC */ + +#endif /* WOLFSSL_ALLOC_ALIGN_H */ diff --git a/wolfcrypt/src/cmac.c b/wolfcrypt/src/cmac.c index d6c4a1d872b..867ee0d0836 100644 --- a/wolfcrypt/src/cmac.c +++ b/wolfcrypt/src/cmac.c @@ -49,6 +49,7 @@ #include #include +#include #ifdef WOLF_CRYPTO_CB #include @@ -634,7 +635,7 @@ int wc_AesCmacGenerate(byte* out, word32* outSz, } #ifdef WOLFSSL_SMALL_STACK - if ((cmac = CmacAlloc(NULL)) == NULL) { + if ((cmac = WC_ALLOC_CMAC(NULL)) == NULL) { return MEMORY_E; } #endif @@ -657,7 +658,7 @@ int wc_AesCmacGenerate(byte* out, word32* outSz, #ifdef WOLFSSL_SMALL_STACK ForceZero(cmac, sizeof(Cmac)); - CmacAllocFree(cmac, NULL); + WC_FREE_CMAC(cmac, NULL); #elif defined(WOLFSSL_CHECK_MEM_ZERO) wc_MemZero_Check(cmac, sizeof(Cmac)); #endif @@ -736,7 +737,7 @@ int wc_AesCmacVerify(const byte* check, word32 checkSz, } #ifdef WOLFSSL_SMALL_STACK - if ((cmac = CmacAlloc(NULL)) == NULL) { + if ((cmac = WC_ALLOC_CMAC(NULL)) == NULL) { return MEMORY_E; } #endif @@ -758,7 +759,7 @@ int wc_AesCmacVerify(const byte* check, word32 checkSz, #ifdef WOLFSSL_SMALL_STACK ForceZero(cmac, sizeof(Cmac)); - CmacAllocFree(cmac, NULL); + WC_FREE_CMAC(cmac, NULL); #elif defined(WOLFSSL_CHECK_MEM_ZERO) wc_MemZero_Check(cmac, sizeof(Cmac)); #endif diff --git a/wolfcrypt/src/include.am b/wolfcrypt/src/include.am index f1768771170..5d74492147d 100644 --- a/wolfcrypt/src/include.am +++ b/wolfcrypt/src/include.am @@ -78,7 +78,8 @@ EXTRA_DIST += \ wolfcrypt/src/fp_sqr_comba_8.i \ wolfcrypt/src/fp_sqr_comba_9.i \ wolfcrypt/src/fp_sqr_comba_small_set.i \ - wolfcrypt/src/fe_x25519_128.h + wolfcrypt/src/fe_x25519_128.h \ + wolfcrypt/src/alloc_align.h EXTRA_DIST += wolfcrypt/src/port/ti/ti-aes.c \ wolfcrypt/src/port/ti/ti-des3.c \ diff --git a/wolfcrypt/src/kdf.c b/wolfcrypt/src/kdf.c index 93dcd63f90a..b635eb84691 100644 --- a/wolfcrypt/src/kdf.c +++ b/wolfcrypt/src/kdf.c @@ -43,6 +43,7 @@ #include #include +#include #if defined(WC_SRTP_KDF) || defined(HAVE_CMAC_KDF) #include #endif @@ -1670,7 +1671,7 @@ int wc_KDA_KDF_twostep_cmac(const byte * salt, word32 salt_len, #endif #ifdef WOLFSSL_SMALL_STACK - cmac = CmacAlloc(heap); + cmac = WC_ALLOC_CMAC(heap); if (cmac == NULL) { #ifdef WOLFSSL_CHECK_MEM_ZERO wc_MemZero_Check(Key_kdk, sizeof(Key_kdk)); @@ -1699,7 +1700,7 @@ int wc_KDA_KDF_twostep_cmac(const byte * salt, word32 salt_len, #ifdef WOLFSSL_SMALL_STACK if (cmac) { ForceZero(cmac, sizeof(Cmac)); - CmacAllocFree(cmac, heap); + WC_FREE_CMAC(cmac, heap); cmac = NULL; } #endif /* WOLFSSL_SMALL_STACK */ @@ -1777,7 +1778,7 @@ int wc_KDA_KDF_PRF_cmac(const byte* Kin, word32 KinSz, } #ifdef WOLFSSL_SMALL_STACK - cmac = CmacAlloc(heap); + cmac = WC_ALLOC_CMAC(heap); if (cmac == NULL) { return MEMORY_E; } @@ -1878,7 +1879,7 @@ int wc_KDA_KDF_PRF_cmac(const byte* Kin, word32 KinSz, #ifdef WOLFSSL_SMALL_STACK if (cmac) { ForceZero(cmac, sizeof(Cmac)); - CmacAllocFree(cmac, heap); + WC_FREE_CMAC(cmac, heap); cmac = NULL; } #endif /* WOLFSSL_SMALL_STACK */ diff --git a/wolfcrypt/test/test.c b/wolfcrypt/test/test.c index 387694991f4..e0670b30a79 100644 --- a/wolfcrypt/test/test.c +++ b/wolfcrypt/test/test.c @@ -421,6 +421,7 @@ static const byte const_byte_array[] = "A+Gd\0\0\0"; #include #include #include +#include #ifdef HAVE_ECC #include #endif @@ -86088,15 +86089,8 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t cmac_test(void) WOLFSSL_ENTER("cmac_test"); #if defined(WOLFSSL_SMALL_STACK) && !defined(WOLFSSL_NO_MALLOC) -#if defined(WOLFSSL_USE_ALIGN) && defined(WC_ALIGNOF) && \ - !defined(WOLFSSL_TI_CRYPT) && !defined(HAVE_FIPS) - if ((cmac = CmacAlloc(HEAP_HINT)) == NULL) + if ((cmac = WC_ALLOC_CMAC(HEAP_HINT)) == NULL) ERROR_OUT(WC_TEST_RET_ENC_ERRNO, out); -#else - if ((cmac = (Cmac *)XMALLOC(sizeof *cmac, HEAP_HINT, - DYNAMIC_TYPE_CMAC)) == NULL) - ERROR_OUT(WC_TEST_RET_ENC_ERRNO, out); -#endif #if defined(WC_ALIGNOF) && !defined(HAVE_FIPS) && \ !defined(HAVE_SELFTEST) if (!WC_IS_ALIGNED(cmac, WC_ALIGNOF(Cmac))) @@ -86220,12 +86214,7 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t cmac_test(void) #endif #if defined(WOLFSSL_SMALL_STACK) && !defined(WOLFSSL_NO_MALLOC) -#if defined(WOLFSSL_USE_ALIGN) && defined(WC_ALIGNOF) && \ - !defined(WOLFSSL_TI_CRYPT) && !defined(HAVE_FIPS) - CmacAllocFree(cmac, HEAP_HINT); -#else - XFREE(cmac, HEAP_HINT, DYNAMIC_TYPE_CMAC); -#endif + WC_FREE_CMAC(cmac, HEAP_HINT); #endif return ret; diff --git a/wolfssl/wolfcrypt/cmac.h b/wolfssl/wolfcrypt/cmac.h index 7af5373f440..143f27aefcb 100644 --- a/wolfssl/wolfcrypt/cmac.h +++ b/wolfssl/wolfcrypt/cmac.h @@ -97,42 +97,6 @@ struct Cmac { CmacType type; }; -/* Cmac starts with an Aes whose members are 16-byte aligned, but malloc on - * 32-bit Arm may only return an 8-byte-aligned pointer. Keep the original - * allocation for XFREE. The TI backend uses its existing plain allocation - * path. */ -static WC_INLINE Cmac* CmacAlloc(void* heap) -{ -#if defined(WOLFSSL_USE_ALIGN) && defined(WC_ALIGNOF) && \ - !defined(WOLFSSL_TI_CRYPT) - const size_t align = WC_ALIGNOF(Cmac); - byte* raw = (byte*)XMALLOC(sizeof(Cmac) + align - 1 + sizeof(void*), - heap, DYNAMIC_TYPE_CMAC); - wc_ptr_t p; - - if (raw == NULL) - return NULL; - p = ((wc_ptr_t)(raw + sizeof(void*)) + align - 1) & - ~((wc_ptr_t)align - 1); - ((void**)p)[-1] = raw; - return (Cmac*)p; -#else - return (Cmac*)XMALLOC(sizeof(Cmac), heap, DYNAMIC_TYPE_CMAC); -#endif -} - -static WC_INLINE void CmacAllocFree(Cmac* cmac, void* heap) -{ -#if defined(WOLFSSL_USE_ALIGN) && defined(WC_ALIGNOF) && \ - !defined(WOLFSSL_TI_CRYPT) - if (cmac != NULL) - XFREE(((void**)cmac)[-1], heap, DYNAMIC_TYPE_CMAC); -#else - XFREE(cmac, heap, DYNAMIC_TYPE_CMAC); -#endif -} - - /* Reasonable defaults */ #ifndef WC_CMAC_TAG_MAX_SZ From 9f49ba7a68e51ab391aebe5d4dfb0d9579cfd4ff Mon Sep 17 00:00:00 2001 From: Daniele Lacamera Date: Tue, 17 Nov 2026 11:46:05 +0100 Subject: [PATCH 11/13] Make WC_FREE fallback macros statement-safe --- wolfcrypt/src/alloc_align.h | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/wolfcrypt/src/alloc_align.h b/wolfcrypt/src/alloc_align.h index 4e4ffa14c43..f27345f161c 100644 --- a/wolfcrypt/src/alloc_align.h +++ b/wolfcrypt/src/alloc_align.h @@ -36,7 +36,7 @@ !defined(WOLFSSL_TI_CRYPT) #define WC_HAVE_ALIGNED_ALLOC static WC_INLINE void* wc_alloc_aligned(void* heap, size_t size, - size_t align, int type) + size_t align, int type) { byte* raw = (byte*)XMALLOC(size + align - 1 + sizeof(void*), heap, type); wc_ptr_t p; @@ -65,7 +65,7 @@ static WC_INLINE void wc_free_aligned(void* p, void* heap, int type) static WC_INLINE Aes* WC_ALLOC_AES(void* heap) { return (Aes*)wc_alloc_aligned(heap, sizeof(Aes), WC_ALIGNOF(Aes), - DYNAMIC_TYPE_AES); + DYNAMIC_TYPE_AES); } static WC_INLINE void WC_FREE_AES(Aes* aes, void* heap) @@ -76,7 +76,7 @@ static WC_INLINE void WC_FREE_AES(Aes* aes, void* heap) #define WC_ALLOC_AES(heap) \ ((Aes*)XMALLOC(sizeof(Aes), (heap), DYNAMIC_TYPE_AES)) #define WC_FREE_AES(aes, heap) \ - (XFREE((aes), (heap), DYNAMIC_TYPE_AES)) + do {XFREE((aes), (heap), DYNAMIC_TYPE_AES);} while (0) #endif #endif /* !NO_AES */ @@ -85,7 +85,7 @@ static WC_INLINE void WC_FREE_AES(Aes* aes, void* heap) static WC_INLINE Cmac* WC_ALLOC_CMAC(void* heap) { return (Cmac*)wc_alloc_aligned(heap, sizeof(Cmac), WC_ALIGNOF(Cmac), - DYNAMIC_TYPE_CMAC); + DYNAMIC_TYPE_CMAC); } static WC_INLINE void WC_FREE_CMAC(Cmac* cmac, void* heap) @@ -96,7 +96,7 @@ static WC_INLINE void WC_FREE_CMAC(Cmac* cmac, void* heap) #define WC_ALLOC_CMAC(heap) \ ((Cmac*)XMALLOC(sizeof(Cmac), (heap), DYNAMIC_TYPE_CMAC)) #define WC_FREE_CMAC(cmac, heap) \ - (XFREE((cmac), (heap), DYNAMIC_TYPE_CMAC)) + do {XFREE((cmac), (heap), DYNAMIC_TYPE_CMAC);} while (0) #endif #endif /* WOLFSSL_CMAC */ From 9bec0b7df376dff263625c490a36e16a04235c32 Mon Sep 17 00:00:00 2001 From: Daniele Lacamera Date: Tue, 17 Nov 2026 12:12:21 +0100 Subject: [PATCH 12/13] Copy alloc_align.h in Arduino library install --- IDE/ARDUINO/wolfssl-arduino.sh | 2 ++ 1 file changed, 2 insertions(+) diff --git a/IDE/ARDUINO/wolfssl-arduino.sh b/IDE/ARDUINO/wolfssl-arduino.sh index a381a597ace..115477aea68 100755 --- a/IDE/ARDUINO/wolfssl-arduino.sh +++ b/IDE/ARDUINO/wolfssl-arduino.sh @@ -238,6 +238,8 @@ if [ "$THIS_DIR" = "ARDUINO" ]; then # cp ../../wolfcrypt/src/*.c ./wolfssl/src/wolfcrypt/src echo "Step 09: cp ${WOLFCRYPT_SRC_TOP}/*.c .${WOLFCRYPT_SRC}" $CP_CMD -r "${WOLFCRYPT_SRC_TOP}"/*.c ."${WOLFCRYPT_SRC}" || exit 1 + # private header included by the wolfcrypt sources (aligned allocation) + $CP_CMD "${WOLFCRYPT_SRC_TOP}"/alloc_align.h ".${WOLFCRYPT_SRC}" || exit 1 $CP_CMD -r "${WOLFCRYPT_SRC_TOP}"/port/atmel/*.c ."${WOLFCRYPT_SRC}"/port/atmel || exit 1 $CP_CMD -r "${WOLFCRYPT_SRC_TOP}"/port/Espressif/*.c ."${WOLFCRYPT_SRC}"/port/Espressif || exit 1 From 2ea254fe25f3bbadb49f4bbc16a34175993957bd Mon Sep 17 00:00:00 2001 From: Daniele Lacamera Date: Tue, 17 Nov 2026 13:10:57 +0100 Subject: [PATCH 13/13] Void-cast unused params in wc_free_aligned --- wolfcrypt/src/alloc_align.h | 2 ++ 1 file changed, 2 insertions(+) diff --git a/wolfcrypt/src/alloc_align.h b/wolfcrypt/src/alloc_align.h index f27345f161c..1aff1d7209f 100644 --- a/wolfcrypt/src/alloc_align.h +++ b/wolfcrypt/src/alloc_align.h @@ -51,6 +51,8 @@ static WC_INLINE void* wc_alloc_aligned(void* heap, size_t size, static WC_INLINE void wc_free_aligned(void* p, void* heap, int type) { + (void)heap; + (void)type; if (p != NULL) XFREE(((void**)p)[-1], heap, type); }