Fenrir fixes 2026-08 -11 + build regressions fixes

.github/workflows/test-configs.yml

@@ -784,6 +784,21 @@ jobs:
       arch: aarch64
       config-file: ./config/examples/zynqmp_sdcard.config
 
+  # Only build that compiles the DISK_ENCRYPT paths of src/update_disk.c.
+  zynqmp_sdcard_encrypt_test:
+    uses: ./.github/workflows/test-build-aarch64.yml
+    with:
+      arch: aarch64
+      config-file: ./config/examples/zynqmp_sdcard.config
+      make-args: ENCRYPT=1 ENCRYPT_WITH_AES256=1
+
+  zynqmp_sdcard_encrypt_chacha_test:
+    uses: ./.github/workflows/test-build-aarch64.yml
+    with:
+      arch: aarch64
+      config-file: ./config/examples/zynqmp_sdcard.config
+      make-args: ENCRYPT=1 ENCRYPT_WITH_CHACHA=1
+
   zynqmp_fsbl_test:
     uses: ./.github/workflows/test-build-aarch64.yml
     with:

.gitignore

@@ -204,24 +204,29 @@ tools/unit-tests/unit-otp-keystore
 tools/unit-tests/unit-otp-keystore-gen-zeroize
 tools/unit-tests/unit-tpm-api-names
 tools/unit-tests/unit-tpm-nsc-cert
+tools/unit-tests/unit-tpm-advio-zeroize
+tools/unit-tests/unit-tpm-mfgid-eh-zeroize
 tools/unit-tests/unit-elf-bss-guard
 tools/unit-tests/unit-fit-fpga
 tools/unit-tests/unit-flash-erase-c0
 tools/unit-tests/unit-flash-erase-g0
 tools/unit-tests/unit-flash-erase-l0
 tools/unit-tests/unit-flash-erase-u3
 tools/unit-tests/unit-flash-erase-wb
+tools/unit-tests/unit-flash-erase-mcxw
 tools/unit-tests/unit-fwtpm-nv-oob
 tools/unit-tests/unit-x86-paging-oob
 tools/unit-tests/unit-ahci-unlock-panic
 tools/unit-tests/unit-ata-security-passphrase-zeroize
 tools/unit-tests/unit-arm-tee-psa-ipc
 tools/unit-tests/unit-flash-write-mcxa
+tools/unit-tests/unit-flash-write-nrf52
 tools/unit-tests/unit-flash-write-same51
 tools/unit-tests/unit-flash-write-samr21
 tools/unit-tests/unit-image-elf-scatter
 tools/unit-tests/unit-image-hybrid
 tools/unit-tests/unit-imx-rt-cache-align
+tools/unit-tests/unit-update-disk-fit
 tools/unit-tests/unit-update-disk-oob
 tools/unit-tests/unit-update-ram-enc
 tools/unit-tests/unit-update-ram-enc-nopart

hal/mcxw.c

@@ -22,6 +22,7 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA
  */
 
+#ifndef WOLFBOOT_UNIT_TEST_FLASH_ERASE
 #include <stdint.h>
 #include <target.h>
 #include "image.h"
@@ -44,8 +45,11 @@
 /*!< Core clock frequency: 48000000Hz */
 #define BOARD_BOOTCLOCKRUN_CORE_CLOCK              48000000U
 static flash_config_t pflash;
+#endif /* !WOLFBOOT_UNIT_TEST_FLASH_ERASE */
+
 static uint32_t pflash_sector_size = WOLFBOOT_SECTOR_SIZE;
 
+#ifndef WOLFBOOT_UNIT_TEST_FLASH_ERASE
 uint32_t SystemCoreClock;
 
 #ifdef TZEN
@@ -223,15 +227,26 @@ static void erase_flash_sector(uint32_t *dst) {
     /* Wait for completion */
     while (!(FMU0->FSTAT & 0x00000080)) {}
 }
+#endif /* !WOLFBOOT_UNIT_TEST_FLASH_ERASE */
 
 int RAMFUNCTION hal_flash_erase(uint32_t address, int len)
 {
-    if (address % pflash_sector_size)
-        address -= address % pflash_sector_size;
+    uint32_t sector_size = pflash_sector_size;
+
+    if (sector_size == 0U)
+        sector_size = WOLFBOOT_SECTOR_SIZE;
+
+    /* Rounding the start down extends the range, so the length must grow by
+     * the same amount or the last sector of the request is left unerased. */
+    if (address % sector_size) {
+        uint32_t offset = address % sector_size;
+        address -= offset;
+        len += (int)offset;
+    }
     while (len > 0) {
         erase_flash_sector((uint32_t *)address);
-        address += WOLFBOOT_SECTOR_SIZE;
-        len -= WOLFBOOT_SECTOR_SIZE;
+        address += sector_size;
+        len -= (int)sector_size;
     }
     return 0;
 }

hal/nrf52.c

@@ -73,25 +73,33 @@ int RAMFUNCTION hal_flash_write(uint32_t address, const uint8_t *data, int len)
 
     while (i < len) {
         if ((len - i > 3) && ((((address + i) & 0x03) == 0)  && ((((uint32_t)data) + i) & 0x03) == 0)) {
-            src = (uint32_t *)data;
-            dst = (uint32_t *)address;
+            /* Index by "i" directly: the condition above only guarantees
+             * that "address + i" and "data + i" are word aligned, so
+             * dst[i >> 2] off the unaligned base would address the wrong
+             * word (and fault on a strict-alignment core). */
+            src = (uint32_t *)(data + i);
+            dst = (uint32_t *)(address + i);
             NVMC_CONFIG = NVMC_CONFIG_WEN;
             flash_wait_complete();
-            dst[i >> 2] = src[i >> 2];
+            *dst = *src;
             flash_wait_complete();
             i+=4;
         } else {
             uint32_t val;
             uint8_t *vbytes = (uint8_t *)(&val);
-            int off = (address + i) - (((address + i) >> 2) << 2);
-            dst = (uint32_t *)(address - off);
-            val = dst[i >> 2];
-            vbytes[off] = data[i];
+            uint32_t off = ((address + i) % 4);
+            dst = (uint32_t *)(address + i - off);
+            val = *dst;
+            while (off < 4) {
+                if (i < len)
+                    vbytes[off++] = data[i++];
+                else
+                    off++;
+            }
             NVMC_CONFIG = NVMC_CONFIG_WEN;
             flash_wait_complete();
-            dst[i >> 2] = val;
+            *dst = val;
             flash_wait_complete();
-            i++;
         }
     }
     return 0;

hal/nrf5340.c

@@ -317,31 +317,39 @@ int RAMFUNCTION hal_flash_write(uint32_t address, const uint8_t *data, int len)
     while (i < len) {
         if ((len - i > 3) && ((((address + i) & 0x03) == 0)  &&
                       ((((uint32_t)data) + i) & 0x03) == 0)) {
-            src = (uint32_t *)data;
-            dst = (uint32_t *)address;
+            /* Index by "i" directly: the condition above only guarantees
+             * that "address + i" and "data + i" are word aligned, so
+             * dst[i >> 2] off the unaligned base would address the wrong
+             * word (and fault on a strict-alignment core). */
+            src = (uint32_t *)(data + i);
+            dst = (uint32_t *)(address + i);
 #if TZ_SECURE() || defined(TARGET_nrf5340_net)
             NVMC_CONFIG = NVMC_CONFIG_WEN;
 #endif
             NVMC_CONFIGNS = NVMC_CONFIG_WEN;
             while (NVMC_READY == 0);
-            dst[i >> 2] = src[i >> 2];
+            *dst = *src;
             while (NVMC_READY == 0);
             i+=4;
         } else {
             uint32_t val;
             uint8_t *vbytes = (uint8_t *)(&val);
-            int off = (address + i) - (((address + i) >> 2) << 2);
-            dst = (uint32_t *)(address - off);
-            val = dst[i >> 2];
-            vbytes[off] = data[i];
+            uint32_t off = ((address + i) % 4);
+            dst = (uint32_t *)(address + i - off);
+            val = *dst;
+            while (off < 4) {
+                if (i < len)
+                    vbytes[off++] = data[i++];
+                else
+                    off++;
+            }
 #if TZ_SECURE() || defined(TARGET_nrf5340_net)
             NVMC_CONFIG = NVMC_CONFIG_WEN;
 #endif
             NVMC_CONFIGNS = NVMC_CONFIG_WEN;
             while (NVMC_READY == 0);
-            dst[i >> 2] = val;
+            *dst = val;
             while (NVMC_READY == 0);
-            i++;
         }
     }
     return 0;

hal/stm32l0.c

@@ -111,23 +111,31 @@ int RAMFUNCTION hal_flash_write(uint32_t address, const uint8_t *data, int len)
 
     while (i < len) {
         if ((len - i > 3) && ((((address + i) & 0x03) == 0)  && ((((uint32_t)data) + i) & 0x03) == 0)) {
-            src = (uint32_t *)data;
-            dst = (uint32_t *)(address + FLASHMEM_ADDRESS_SPACE);
+            /* Index by "i" directly: the condition above only guarantees
+             * that "address + i" and "data + i" are word aligned, so
+             * dst[i >> 2] off the unaligned base would address the wrong
+             * word, and the Cortex-M0+ faults on the unaligned access. */
+            src = (uint32_t *)(data + i);
+            dst = (uint32_t *)(address + i + FLASHMEM_ADDRESS_SPACE);
             flash_wait_complete();
-            dst[i >> 2] = src[i >> 2];
+            *dst = *src;
             flash_wait_complete();
             i+=4;
         } else {
             uint32_t val;
             uint8_t *vbytes = (uint8_t *)(&val);
-            int off = (address + i) - (((address + i) >> 2) << 2);
-            dst = (uint32_t *)(address + FLASHMEM_ADDRESS_SPACE - off);
-            val = dst[i >> 2];
-            vbytes[off] = data[i];
+            uint32_t off = ((address + i) % 4);
+            dst = (uint32_t *)(address + FLASHMEM_ADDRESS_SPACE + i - off);
+            val = *dst;
+            while (off < 4) {
+                if (i < len)
+                    vbytes[off++] = data[i++];
+                else
+                    off++;
+            }
             flash_wait_complete();
-            dst[i >> 2] = val;
+            *dst = val;
             flash_wait_complete();
-            i++;
         }
     }
     return 0;

options.mk

@@ -1885,3 +1885,14 @@ endif
 # includers (test-app), where a self-referencing += would not terminate.
 AUX_WOLFCRYPT_OBJS_NEW:=$(filter-out $(WOLFCRYPT_OBJS),$(sort $(AUX_WOLFCRYPT_OBJS)))
 WOLFCRYPT_OBJS+=$(AUX_WOLFCRYPT_OBJS_NEW)
+
+# Under WOLFSSL_ARMASM, chacha.c defers the block function to
+# wc_chacha_crypt_bytes(), which lives in the port. arch.mk adds the aes/sha
+# equivalents unconditionally; ChaCha is only selected here, so add it last.
+ifeq ($(ARCH),AARCH64)
+  ifneq ($(NO_ARM_ASM),1)
+    ifneq (,$(filter %/wolfcrypt/src/chacha.o,$(WOLFCRYPT_OBJS)))
+      WOLFCRYPT_OBJS+=$(WOLFBOOT_LIB_WOLFSSL)/wolfcrypt/src/port/arm/armv8-chacha-asm_c.o
+    endif
+  endif
+endif

src/elf.c

@@ -107,9 +107,6 @@ int elf_load_image_mmu(uint8_t *image, uint32_t image_sz, uintptr_t *pentry,
         is_elf32 ? 32 : 64, is_le ? "little" : "big");
 #endif
 
-    /* set entry point */
-    *pentry = GET_H64(entry);
-
     /* programs */
     ph_offset = GET_H32(ph_offset);
     entry_size = GET_H16(ph_entry_size);
@@ -222,6 +219,11 @@ int elf_load_image_mmu(uint8_t *image, uint32_t image_sz, uintptr_t *pentry,
 #endif /* !ELF_PARSER */
     }
 
+    /* Publish the entry point only once every check above has passed: callers
+     * fall back to the raw binary on failure and must not be left with a
+     * partially validated ELF's declared entry. */
+    *pentry = GET_H64(entry);
+
 #ifdef DEBUG_ELF
     wolfBoot_printf("Entry point %p\r\n", (void*)*pentry);
 #endif