Repository navigation
Fix AES context alignment in heap allocations - #12110
Conversation
|
wolfSSL-Fenrir-bot
left a comment
There was a problem hiding this comment.
Fenrir Automated Review — PR #12110
Scan targets checked: wolfcrypt-src, wolfcrypt-bugs
Coverage: 2 of 2 in-scope changed file(s) opened by the reviewer
Findings: 1
1 finding(s) posted as inline comments (see file-level comments below)
This review was generated automatically by Fenrir. Reported findings require changes before merge.
Review tier: Max
wolfSSL-Fenrir-bot
left a comment
There was a problem hiding this comment.
Fenrir Automated Review — PR #12110
Scan targets checked: wolfcrypt-src, wolfcrypt-bugs, wolfssl-bugs
Coverage: 2 of 2 in-scope changed file(s) opened by the reviewer
Fenrir result: Approved ✅
No new issues found in the changed files.
Advisory only — this automated result does not count as a GitHub approval.
Review tier: Lite
Fenrir's latest completed scan found no issues; clearing the prior automated change request.
|
@claude review |
There was a problem hiding this comment.
Beyond the inline findings, I also checked the pointer arithmetic in AesAlloc/AesAllocFree and found no problem with it. Rounding raw + sizeof(void*) up leaves room for the stored base pointer. The Aes object fits in the extra align - 1 + sizeof(void*) bytes. The base-pointer slot is pointer-aligned. The key-wrap allocation-failure paths return before reaching out:, so they never free a NULL aes.
Extended reasoning...
I checked the AesAlloc/AesAllocFree pointer arithmetic and the key-wrap small-stack cleanup paths in wolfcrypt/src/aes.c and found no problem in either. The inline comments already cover the open problems.
Findings marked 🟡 are optional suggestions and need no follow-up push.
dgarske
left a comment
There was a problem hiding this comment.
Reproduced F-11986 on a Raspberry Pi 4 (32-bit armhf binary, clang 18, -march=armv8-a -mfpu=crypto-neon-fp-armv8) and under qemu-arm. gcc 13 does not fault: it only puts :64 hints on stores into Aes. clang emits vst1.64 {d16-d17}, [r0 :128] on the iv == NULL branch of wc_AesSetIV() and in wc_AesKeyWrap(), so any NULL-IV wc_AesSetKey()/wc_AesSetIV() on a heap Aes that is 8 mod 16 faults.
With this PR applied and an allocator returning blocks at 8 mod 16, these still SIGBUS on the Pi 4:
wc_AesSetKey(aes, key, len, NULL, dir)on anXMALLOC(sizeof(Aes))wc_InitCmac()on anXMALLOC(sizeof(Cmac)), as inkdf.candssl_crypto.cwc_AesCmacGenerate()withWOLFSSL_SMALL_STACKwc_SRTP_KDF()
So this fixes key wrap and wc_AesNew(), but the class stays open across the other heap Aes/Cmac allocations (TLS record layer, DTLS 1.3, PKCS7, ECIES, HPKE, SHE, KDF, EVP).
The root cause is the declaration rather than the call sites. On 32-bit Arm, ALIGN16 promises the compiler more than malloc guarantees, and the 32-bit Arm AES/GCM assembly uses no alignment hints, so the over-alignment buys nothing there. Capping WOLFSSL_ALIGN() at 8 on 32-bit Arm with NEON, next to the existing IAR cap in types.h, removes every one of these faults on the Pi 4 and under qemu, and AES/GCM/CMAC throughput on the Pi 4 is unchanged. It leaves Cortex-M alone (no NEON). It does change the Aes/Cmac/Gcm layout on those builds, so it needs to land at a release boundary. With it in place, the helper in this PR is not needed.
Suggested patch, against current master:
diff --git a/wolfssl/wolfcrypt/types.h b/wolfssl/wolfcrypt/types.h
--- a/wolfssl/wolfcrypt/types.h
+++ b/wolfssl/wolfcrypt/types.h
@@ -2005,6 +2005,10 @@ WOLFSSL_API word32 CheckRunTimeSettings(void);
* higher alignment. */
#if defined(__ICCARM__)
#define WOLFSSL_ALIGN(x) XALIGNED(8)
+ #elif defined(__arm__) && (defined(__ARM_NEON) || defined(__ARM_NEON__))
+ /* 32-bit Arm malloc only guarantees 8 bytes. Over-aligned heap
+ * contexts let the compiler emit faulting :128 NEON stores. */
+ #define WOLFSSL_ALIGN(x) XALIGNED(((x) > 8) ? 8 : (x))
#else
#define WOLFSSL_ALIGN(x) XALIGNED(x)
#endifNotes on the patch:
min(x, 8)rather than the flatXALIGNED(8)used for IAR, soALIGN4members keep their layout. Only types that were over-aligned change.- Every
ALIGNxxmacro is still#ifndef-guarded, so a port that really needs a 16-byte buffer on armhf can override it. - On armhf with the patch: no
:128/:256-hinted stores remain in the library, all of the cases above pass on the Pi 4 with every allocation at 8 mod 16, and--enable-all --enable-smallstacktestwolfcrypt and the API tests pass under the same allocator. - One port to check:
se050_port.cdeclaresalignedIn/alignedOutasALIGN16, and they become 8-aligned on an armhf NEON host build. - #11969 documents 16-byte alignment for these contexts. On 32-bit Arm with NEON that becomes 8, so the note needs that exception.
7da1ac7 to
36acd74
Compare
22e79d9 to
2c69d22
Compare
|
jenkins retest this please |
0ed5196 to
1b2e8b2
Compare
The merge-base changed after approval.
1b2e8b2 to
99d10f1
Compare
|
Squashed after @dgarske 's approval, as requested. |
|
jenkins retest this please |
Aes and Cmac contexts carry alignment attributes on members, but malloc only guarantees 8-byte alignment: on 32-bit Arm the contexts are misaligned and the AES-NI/NEON paths SIGBUS (Fenrir F-11986). Over-allocate, align, and keep the original pointer for XFREE: - wc_alloc_aligned/wc_free_aligned in aes.c, WOLFSSL_API, guarded by WOLFSSL_USE_ALIGN && WC_ALIGNOF && !WOLFSSL_TI_CRYPT. aes.c is compiled exactly where the allocation macros can be active: WOLFSSL_CMAC implies AES, so every consumer has this object linked. - WC_ALLOC_AES/WC_FREE_AES in aes.h, WC_ALLOC_CMAC/WC_FREE_CMAC in cmac.h, with plain XMALLOC/XFREE fallback macros so builds without the aligned allocator pay no indirection. The free fallbacks are statement-safe (XFREE is a do-while in static-memory builds) and the alloc fallbacks cast for C++. - Prototypes are unguarded and inside the extern "C" block: memory.h is included mid-types.h, before WOLFSSL_USE_ALIGN exists in ARMASM/AESNI builds, so a guarded declaration there is invisible exactly where it is needed, and a C++-linked declaration would mangle the definition. - The cmac aligned branch additionally requires WC_ALLOC_AES: in FIPS bundle builds the aes.h/aes.c pair is the frozen module version, so the macro falls back to plain allocation there. Call sites: aes.c, cmac.c, kdf.c, ssl_crypto.c, test.c, plus AES whitebox test cleanup for aligned allocations. Bridge to wolfSSL#11949 (generic aligned allocators) when it lands: the call sites then switch to wc_MallocAlign/wc_FreeAlign.
99d10f1 to
68b7b6d
Compare
Description
Summary
Fix heap allocation alignment for Aes and Cmac contexts. Both structures carry alignment attributes on members, but XMALLOC only guarantees 8-byte alignment, which faults on 32-bit Arm where the aligned members need 16 bytes.
Root cause
The reported armhf SIGBUS was initially attributed to _sp_div because the runtime PC was translated using the executable's file offset. This PIE executable's text virtual address is 0x10000 higher than that offset. Correcting the translation places the fault in wc_AesSetKeyLocal, at a NEON store to aes->reg that requires 16-byte alignment.
The fault address was only 8-byte aligned. Aes has 16-byte-aligned members, but XMALLOC can return an 8-byte-aligned pointer on 32-bit Arm. Passing that pointer as an Aes* lets the compiler emit an alignment-qualified store that faults. Cmac has the same property: its members are alignment-qualified, so heap-allocated Cmac contexts (EVP CMAC, KDF) carry the same hazard.
Changes
wc_alloc_aligned/wc_free_alignedinaes.c(WOLFSSL_API, active whenWOLFSSL_USE_ALIGN && WC_ALIGNOF && !WOLFSSL_TI_CRYPT). They over-allocate, align to the requested boundary, and keep the original XMALLOC pointer so the matching free uses the correct address, heap, and allocation type. aes.c is compiled exactly where the allocation macros can be active: WOLFSSL_CMAC implies AES, so every consumer (cmac.c, kdf.c, ssl_crypto.c, test.c) has this object linked, including leantls and --disable-memory builds where memory.c is excluded.WC_ALLOC_AES/WC_FREE_AESinaes.handWC_ALLOC_CMAC/WC_FREE_CMACincmac.h. The aligned branches route through the helpers; the fallback branches are plain XMALLOC/XFREE macros so builds without the aligned allocator pay no indirection. Free fallbacks are statement-safe (XFREE is a do-while in static-memory builds); alloc fallbacks cast for C++.#ifndef WC_ALLOC_CMACfallback in ssl_crypto.c and test.c.The helpers apply wherever alignment is enabled, regardless of architecture or assembly settings. The Aes and Cmac structure layouts are unchanged.
Relationship to #11949
PR 11949 adds general aligned-allocation APIs, but it does not switch wc_AesNew, the AES key-wrap wrappers, or the Cmac contexts to those APIs. It converts one test helper that already aligned its allocation manually. Merging PR 11949 alone therefore leaves the faulting allocations unchanged. If PR 11949 lands first, the call sites here switch to its wc_MallocAlign/wc_FreeAlign pair and the local helpers go away; the caller updates are still needed either way.
Validation
Fenrir