Merge remote-tracking branch 'agent/benma-agent/merge-bootloader-v1.2.3'
What changed, and why it matters
This commit hardens the BitBox02 bootloader's stored version-rollback protection data. It adds a SHA-256 checksum over the firmware and signing-key version 'floors' and a one-time migration marker, so the device can detect tampering or corruption of those floors. It also improves flash read/write error handling (including ECC memory errors) and makes the bootloader refuse to use invalid boot data on production devices. Development devices can reset corrupt boot data for testing. The change is defensive: it closes a path where an attacker or glitch could potentially downgrade firmware or signing-key versions by corrupting stored data.
Treat this as a security-hardening fix and include it in the next bootloader/firmware release. Verify that production devices have the migration marker set correctly and that the new checksum is present in factory provisioning scripts. Review the development-only recovery path to ensure it is not enabled in production builds.
Security signals we found
Adds integrity checksum (SHA-256) for anti-rollback version floors in bootloader flash data
Introduces one-time migration marker to prevent repeated downgrade/migration windows
Production bootloader now aborts on invalid bootdata instead of silently reinitializing it
Adds ECC-aware, double-read-verified flash read/write primitives
Extensive unit tests cover power-cut, read-error, write-error, and migration-consumed edge cases
CHANGELOG describes change as 'Add a checksum for bootdata'
Evidence from the diff
The patch introduces src/bootloader/bootdata.c/h, which manages a SHA-256 hash over signing_pubkeys_version and firmware_version in the boot_data_t flash structure. A new 32-byte versions_hash field is appended after show_firmware_hash at offset 589. On first boot after this update, an independent ‘migration consumed’ magic marker is written into PERMANENT chunk 7 (offset 36). Until that marker is set, any prior checksum bytes are accepted for one-time migration; once set, checksum mismatches cause bootdata to be rejected. The bootloader now reads and validates bootdata via bootdata_init/read before use, and production builds abort on invalid bootdata. Development builds can recover via bootdata_dev_recover. nvmctrl.c/h adds checked flash reads/writes that reject uncorrectable ECC and other NVM errors, and require double-read consistency for erase blocks. The reset-version.jlink script now also writes the expected versions_hash for factory setup.
Changed components
BitBox02 bootloadersrc/bootloader/bootdata.csrc/bootloader/bootdata.hsrc/bootloader/bootloader.csrc/memory/memory.csrc/memory/memory.hsrc/memory/memory_shared.hsrc/memory/nvmctrl.csrc/memory/nvmctrl.hfactory setup scripts (scripts/reset-version.jlink)Inspect captured patch +2124 / −31
### CHANGELOG.md
@@ -240,6 +240,7 @@ recorded separately.
- Verify firmware with a versioned signature prehash.
- Speed up the empty firmware check when entering bootloader mode.
- Speed up firmware upgrades over USB.
+- Add a checksum for bootdata
- Hold the screen reset pin low until bootloader is ready to initalize it.
### v1.2.2
### scripts/reset-version-hash.bin
@@ -0,0 +1 @@
+d톹 ��P+d����r��X����<����
\ No newline at end of file
### scripts/reset-version.jlink
@@ -1,3 +1,6 @@
+h
+// Always preserve the other bytes in the erase block.
+exec SetFlashDLNoRMWThreshold = 0xFFFFFFFF
mem 0xf8004 4
// signing keys v1
w4 0xf8004 0x00000001
@@ -6,4 +9,7 @@ mem 0xf8188 4
// fw monotonic version 1
w4 0xf8188 0x00000001
mem 0xf8188 4
+// SHA256(signing keys v1 little-endian || firmware v1 little-endian)
+loadfile scripts/reset-version-hash.bin 0xf824d noreset
+mem 0xf824d 0x20
q
### src/CMakeLists.txt
@@ -83,6 +83,7 @@ set(DBB-BOOTLOADER-SOURCES
${CMAKE_SOURCE_DIR}/src/util.c
${CMAKE_SOURCE_DIR}/src/pukcc/curve_p256.c
${CMAKE_SOURCE_DIR}/src/pukcc/pukcc.c
+ ${CMAKE_SOURCE_DIR}/src/bootloader/bootdata.c
${CMAKE_SOURCE_DIR}/src/bootloader/bootloader.c
${CMAKE_SOURCE_DIR}/src/bootloader/bootloader_format.c
${CMAKE_SOURCE_DIR}/src/bootloader/startup.c
### src/bootloader/bootdata.c
@@ -0,0 +1,213 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#include "bootdata.h"
+
+#include <memory/memory.h>
+#include <memory/nvmctrl.h>
+#include <pukcc/pukcc.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+#include <util.h>
+
+#define VERSION_LE32_LEN 4U
+#define VERSIONS_PREIMAGE_LEN (2U * VERSION_LE32_LEN)
+
+#define MIGRATION_CONSUMED_CHUNK_ADDR \
+ (FLASH_APPDATA_START + MEMORY_BOOTDATA_MIGRATION_CONSUMED_CHUNK * CHUNK_SIZE)
+static_assert(FLASH_BOOTDATA_LEN == CHUNK_SIZE, "bootdata must occupy one erase block");
+static_assert(
+ MIGRATION_CONSUMED_CHUNK_ADDR + CHUNK_SIZE <= FLASH_BOOTDATA_START,
+ "migration consumed marker must be independent");
+static_assert(
+ MEMORY_BOOTDATA_MIGRATION_CONSUMED_OFFSET + MEMORY_BOOTDATA_MIGRATION_CONSUMED_LEN <=
+ CHUNK_SIZE,
+ "migration consumed marker must fit inside its chunk");
+
+static const uint8_t _migration_consumed_magic[MEMORY_BOOTDATA_MIGRATION_CONSUMED_LEN] =
+ MEMORY_BOOTDATA_MIGRATION_CONSUMED_MAGIC;
+
+USE_RESULT static bool _compute_versions_hash(
+ const boot_data_t* bootdata,
+ uint8_t hash_out[SHA256_DIGEST_LENGTH])
+{
+ uint8_t preimage[VERSIONS_PREIMAGE_LEN];
+ util_write_le32(preimage, bootdata->fields.signing_pubkeys_version);
+ util_write_le32(preimage + VERSION_LE32_LEN, bootdata->fields.firmware_version);
+
+ return pukcc_sha256_compute(preimage, sizeof(preimage), hash_out) == 0;
+}
+
+bool bootdata_hash_check(const boot_data_t* bootdata, bool* valid_out)
+{
+ if (bootdata == NULL || valid_out == NULL) {
+ return false;
+ }
+ uint8_t expected[SHA256_DIGEST_LENGTH];
+ if (!_compute_versions_hash(bootdata, expected)) {
+ return false;
+ }
+ *valid_out = MEMEQ(expected, bootdata->fields.versions_hash, sizeof(expected));
+ return true;
+}
+
+bool bootdata_hash_set(boot_data_t* bootdata)
+{
+ if (bootdata == NULL) {
+ return false;
+ }
+
+ uint8_t hash[SHA256_DIGEST_LENGTH];
+ if (!_compute_versions_hash(bootdata, hash)) {
+ return false;
+ }
+ memcpy(bootdata->fields.versions_hash, hash, sizeof(hash));
+ return true;
+}
+
+USE_RESULT static bool _write_verify_chunk(uint32_t address, const uint8_t* data)
+{
+ if (!nvmctrl_write_block(address, data)) {
+ return false;
+ }
+ uint8_t readback[CHUNK_SIZE];
+ return nvmctrl_read_block_checked(address, readback) && MEMEQ(readback, data, CHUNK_SIZE);
+}
+
+USE_RESULT static bool _initialized(const boot_data_t* bootdata)
+{
+ return bootdata->fields.is_initialized[0] == sectrue_u8 &&
+ bootdata->fields.is_initialized[1] == sectrue_u8;
+}
+
+/**
+ * The caller must supply initialized data and ensure migration is durably marked consumed.
+ * The RAM checksum and flash may have changed even on failure.
+ */
+USE_RESULT static bool _write_bootdata(boot_data_t* bootdata)
+{
+ if (!bootdata_hash_set(bootdata) ||
+ !nvmctrl_write_block(FLASH_BOOTDATA_START, bootdata->bytes)) {
+ return false;
+ }
+ boot_data_t readback;
+ bool hash_valid;
+ return nvmctrl_read_block_checked(FLASH_BOOTDATA_START, readback.bytes) &&
+ MEMEQ(readback.bytes, bootdata->bytes, sizeof(readback.bytes)) &&
+ _initialized(&readback) && bootdata_hash_check(&readback, &hash_valid) && hash_valid;
+}
+
+USE_RESULT static bool _read_migration_consumed(
+ uint8_t migration_consumed_out[MEMORY_BOOTDATA_MIGRATION_CONSUMED_LEN])
+{
+ const volatile uint8_t* flash =
+ (const volatile uint8_t*)(uintptr_t)(MIGRATION_CONSUMED_CHUNK_ADDR +
+ MEMORY_BOOTDATA_MIGRATION_CONSUMED_OFFSET);
+ uint8_t confirm[MEMORY_BOOTDATA_MIGRATION_CONSUMED_LEN];
+ return nvmctrl_read(flash, migration_consumed_out, sizeof(confirm)) &&
+ nvmctrl_read(flash, confirm, sizeof(confirm)) &&
+ MEMEQ(migration_consumed_out, confirm, sizeof(confirm));
+}
+
+/**
+ * Writes the consumed magic, preserving and verifying the entire PERMANENT chunk. Returns false
+ * if a read fails, the reread marker already matches, or the checked write/readback fails.
+ * Never modifies bootdata; migration may write it only after success.
+ * On failure, the nonmatching marker might already be marked consumed, so device might not boot.
+ */
+USE_RESULT static bool _mark_migration_consumed(void)
+{
+ uint8_t chunk[CHUNK_SIZE];
+ if (!nvmctrl_read_block_checked(MIGRATION_CONSUMED_CHUNK_ADDR, chunk) ||
+ MEMEQ(
+ chunk + MEMORY_BOOTDATA_MIGRATION_CONSUMED_OFFSET,
+ _migration_consumed_magic,
+ sizeof(_migration_consumed_magic))) {
+ return false;
+ }
+ memcpy(
+ chunk + MEMORY_BOOTDATA_MIGRATION_CONSUMED_OFFSET,
+ _migration_consumed_magic,
+ sizeof(_migration_consumed_magic));
+ // Preserve the existing attestation hash and all other bytes. A cut during this write cannot
+ // affect bootdata: it is not touched until the whole marker chunk has been verified.
+ return _write_verify_chunk(MIGRATION_CONSUMED_CHUNK_ADDR, chunk);
+}
+
+bool bootdata_init(boot_data_t* bootdata_out)
+{
+ if (bootdata_out == NULL ||
+ !nvmctrl_read_block_checked(FLASH_BOOTDATA_START, bootdata_out->bytes) ||
+ !_initialized(bootdata_out)) {
+ return false;
+ }
+ bool hash_valid;
+ uint8_t migration_consumed[MEMORY_BOOTDATA_MIGRATION_CONSUMED_LEN];
+ if (!bootdata_hash_check(bootdata_out, &hash_valid) ||
+ !_read_migration_consumed(migration_consumed)) {
+ return false;
+ }
+ if (MEMEQ(migration_consumed, _migration_consumed_magic, sizeof(migration_consumed))) {
+ // In particular, zero must never reopen migration after a torn bootdata write.
+ return hash_valid;
+ }
+ if (!_mark_migration_consumed()) {
+ return false;
+ }
+ if (hash_valid) {
+ // A cut while rewriting the marker chunk may leave a nonmatching marker. Restore it before
+ // allowing any bootdata write, even when no checksum migration is needed.
+ return true;
+ }
+ // Trust the inherited legacy state once, regardless of the old checksum bytes. A marker that
+ // does not match the magic permits migration. This does not bypass normal authentication before
+ // running firmware or accepting an update, and also works with an incomplete carrier image.
+ return _write_bootdata(bootdata_out);
+}
+
+bool bootdata_read(boot_data_t* bootdata_out)
+{
+ if (bootdata_out == NULL) {
+ return false;
+ }
+ bool hash_valid;
+ if (nvmctrl_read_block_checked(FLASH_BOOTDATA_START, bootdata_out->bytes) &&
+ _initialized(bootdata_out) && bootdata_hash_check(bootdata_out, &hash_valid) &&
+ hash_valid) {
+ uint8_t migration_consumed[MEMORY_BOOTDATA_MIGRATION_CONSUMED_LEN];
+ return _read_migration_consumed(migration_consumed) &&
+ MEMEQ(migration_consumed, _migration_consumed_magic, sizeof(migration_consumed));
+ }
+ return false;
+}
+
+#ifdef BOOTLOADER_DEVELOPMENT
+bool bootdata_dev_recover(boot_data_t* bootdata_out)
+{
+ uint8_t migration_consumed[MEMORY_BOOTDATA_MIGRATION_CONSUMED_LEN];
+ if (bootdata_out == NULL || !_read_migration_consumed(migration_consumed) ||
+ (!MEMEQ(migration_consumed, _migration_consumed_magic, sizeof(migration_consumed)) &&
+ !_mark_migration_consumed())) {
+ return false;
+ }
+ // Development devices must remain usable after corrupt/erased bootdata, including uncorrectable
+ // ECC/other NVM read errors. Reset both floors rather than sealing inflated versions that would
+ // prevent reflashing. Never clear the consumed marker to reopen migration; preserve the
+ // PERMANENT chunk.
+ memset(bootdata_out->bytes, 0, sizeof(bootdata_out->bytes));
+ memset(
+ bootdata_out->fields.is_initialized,
+ sectrue_u8,
+ sizeof(bootdata_out->fields.is_initialized));
+ return _write_bootdata(bootdata_out) && bootdata_read(bootdata_out);
+}
+#endif
+
+bool bootdata_write(boot_data_t* bootdata)
+{
+ boot_data_t current;
+ if (bootdata == NULL || !_initialized(bootdata) || !bootdata_read(¤t)) {
+ return false;
+ }
+ return _write_bootdata(bootdata);
+}
### src/bootloader/bootdata.h
@@ -0,0 +1,66 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#ifndef _BOOTDATA_H_
+#define _BOOTDATA_H_
+
+#include <compiler_util.h>
+#include <memory/memory_shared.h>
+#include <stdbool.h>
+
+/**
+ * Checks the checksum protecting the bootdata version floors.
+ *
+ * @param[in] bootdata Bootdata containing the version floors and stored checksum.
+ * @param[out] valid_out Whether the checksum matches; only set on success.
+ * @return true if the check completed, or false if an argument is null or SHA-256 fails.
+ */
+USE_RESULT bool bootdata_hash_check(const boot_data_t* bootdata, bool* valid_out);
+
+/**
+ * Computes and stores the checksum protecting the bootdata version floors.
+ *
+ * The checksum is SHA256(signing_pubkeys_version_le32 || firmware_version_le32). The bootdata is
+ * unchanged if SHA-256 fails.
+ *
+ * @param[in,out] bootdata Bootdata whose checksum should be updated.
+ * @return true if the computed checksum was stored, otherwise false.
+ */
+USE_RESULT bool bootdata_hash_set(boot_data_t* bootdata);
+
+/**
+ * Reads and validates bootdata from flash, performing the one-time legacy migration if permitted.
+ *
+ * @param[out] bootdata_out Initialized, checksummed bootdata matching flash on success;
+ * must not be used on failure.
+ * @return true if bootdata was validated and migration is marked consumed, otherwise false.
+ */
+USE_RESULT bool bootdata_init(boot_data_t* bootdata_out);
+
+/**
+ * Reads initialized, checksummed bootdata with migration marked consumed. Never repairs it.
+ *
+ * @param[out] bootdata_out Initialized, checksummed bootdata matching flash on success;
+ * must not be used on failure.
+ * @return true if bootdata was read and validated with migration marked consumed, otherwise false.
+ */
+USE_RESULT bool bootdata_read(boot_data_t* bootdata_out);
+
+/**
+ * Updates the checksum and writes bootdata, verifying the complete readback.
+ *
+ * @param[in,out] bootdata Initialized bootdata to write; its checksum may change even on failure.
+ * @return true if bootdata was written and the complete readback verified, otherwise false.
+ */
+USE_RESULT bool bootdata_write(boot_data_t* bootdata);
+
+#ifdef BOOTLOADER_DEVELOPMENT
+/**
+ * Resets bootdata to zero version floors with a fresh checksum on development devices.
+ *
+ * @param[out] bootdata_out Recovered bootdata on success; must not be used on failure.
+ * @return true if bootdata was reset, written, and validated, otherwise false.
+ */
+USE_RESULT bool bootdata_dev_recover(boot_data_t* bootdata_out);
+#endif
+
+#endif
### src/bootloader/bootloader.c
@@ -1,6 +1,7 @@
// SPDX-License-Identifier: Apache-2.0
#include "bootloader.h"
+#include "bootdata.h"
#include "bootloader_format.h"
#include "bootloader_version.h"
#include "mpu_regions.h"
@@ -10,6 +11,7 @@
#include <bootloader/bootloader_product.h>
#include <driver_init.h>
#include <flags.h>
+#include <hardfault.h>
#include <memory/memory.h>
#include <memory/memory_shared.h>
#include <memory/nvmctrl.h>
@@ -124,6 +126,10 @@ static uint8_t _firmware_next_chunk = 0;
// The value is computed at bootloader enter.
static bool _is_app_flash_empty = false;
+#ifdef BOOTLOADER_DEVELOPMENT
+static bool _bootdata_warning_pending = false;
+#endif
+
#if PLATFORM_BITBOX02PLUS == 1
extern struct RustByteQueue* uart_write_queue;
#endif
@@ -244,6 +250,17 @@ static void _render_message(const char* message, int duration)
delay_ms(duration);
}
+#ifdef BOOTLOADER_DEVELOPMENT
+/** USB handlers pass zero to avoid blocking their response. */
+static void _show_bootdata_warning(int duration)
+{
+ if (_bootdata_warning_pending) {
+ _render_message("Bootdata invalid\nDEV DEVICE", duration);
+ _bootdata_warning_pending = false;
+ }
+}
+#endif
+
void bootloader_render_default_screen(void)
{
UG_ClearBuffer();
@@ -561,9 +578,8 @@ static void _firmware_hash(const boot_data_t* data, uint8_t* hash_out)
sha_sync_sha256_finish(&HASH_ALGORITHM_0, hash_out);
}
-static void _maybe_show_hash(void)
+static void _maybe_show_hash(const boot_data_t* data)
{
- const boot_data_t* data = (const boot_data_t*)FLASH_BOOTDATA_START;
if (!data->fields.show_firmware_hash) {
return;
}
@@ -579,7 +595,7 @@ static void _maybe_show_hash(void)
static secbool_u32 _firmware_verified_jump(const boot_data_t* data, secbool_u32 jump)
{
if (jump) {
- _maybe_show_hash();
+ _maybe_show_hash(data);
}
for (uint32_t i = 0; i < (uint32_t)FLASH_APP_PAGE_NUM; i += FLASH_REGION_PAGE_NUM) {
@@ -643,6 +659,36 @@ static uint8_t _write_chunk(uint32_t address, const uint8_t* data)
return OP_STATUS_OK;
}
+USE_RESULT static bool _handle_invalid_bootdata(boot_data_t* bootdata_out)
+{
+#ifdef BOOTLOADER_DEVELOPMENT
+ _bootdata_warning_pending = true;
+ return bootdata_dev_recover(bootdata_out);
+#else
+ (void)bootdata_out;
+ Abort("Invalid bootloader data");
+#endif
+}
+
+USE_RESULT static bool _read_valid_bootdata(boot_data_t* bootdata_out)
+{
+ return bootdata_read(bootdata_out) || _handle_invalid_bootdata(bootdata_out);
+}
+
+USE_RESULT static uint8_t _write_bootdata(boot_data_t* bootdata)
+{
+ if (!bootdata_write(bootdata)) {
+#ifdef BOOTLOADER_DEVELOPMENT
+ // A failed request stays failed; the next read/boot may explicitly recover its damage.
+ _bootdata_warning_pending = true;
+ return OP_STATUS_ERR_WRITE;
+#else
+ Abort("Failed to write bootloader data");
+#endif
+ }
+ return OP_STATUS_OK;
+}
+
/*
* input: firmware version | i signatures of the double hash of
* [0x01 | product id | version | firmware app]
@@ -702,7 +748,9 @@ static uint8_t _set_signing_pubkey_data(boot_data_t* data, const uint8_t* input)
static size_t _api_write_sig_data(const uint8_t* input, uint8_t* output)
{
boot_data_t data;
- memcpy(data.bytes, (uint8_t*)(FLASH_BOOTDATA_START), FLASH_BOOTDATA_LEN);
+ if (!_read_valid_bootdata(&data)) {
+ return _report_status(OP_STATUS_ERR_CHECK, output);
+ }
uint8_t status = _set_signing_pubkey_data(&data, input);
if (status != OP_STATUS_OK) {
return _report_status(status, output);
@@ -714,24 +762,27 @@ static size_t _api_write_sig_data(const uint8_t* input, uint8_t* output)
if (status != OP_STATUS_OK) {
return _report_status(status, output);
}
- return _report_status(_write_chunk(FLASH_BOOTDATA_START, data.bytes), output);
+ return _report_status(_write_bootdata(&data), output);
}
/*
* output filled with the firmware and signing-key prehashes passed to PUKCC verification.
*/
static size_t _api_get_hashes(const uint8_t* input, uint8_t* output)
{
- const boot_data_t* data = (const boot_data_t*)FLASH_BOOTDATA_START;
+ boot_data_t data;
+ if (!_read_valid_bootdata(&data)) {
+ return _report_status(OP_STATUS_ERR_CHECK, output);
+ }
uint8_t hash[SHA256_DIGEST_LENGTH];
- _firmware_hash(data, hash);
+ _firmware_hash(&data, hash);
memcpy(output + BOOT_OP_LEN, hash, SHA256_DIGEST_LENGTH);
if (input[0]) {
_render_hash("Firmware hash", hash);
}
- _hash_signing_keys(data, hash);
+ _hash_signing_keys(&data, hash);
memcpy(output + BOOT_OP_LEN + SHA256_DIGEST_LENGTH, hash, SHA256_DIGEST_LENGTH);
if (input[1]) {
@@ -749,13 +800,15 @@ static size_t _api_get_hashes(const uint8_t* input, uint8_t* output)
static size_t _api_set_show_firmware_hash(const uint8_t* input, uint8_t* output)
{
boot_data_t data;
- memcpy(data.bytes, (uint8_t*)(FLASH_BOOTDATA_START), FLASH_BOOTDATA_LEN);
+ if (!_read_valid_bootdata(&data)) {
+ return _report_status(OP_STATUS_ERR_CHECK, output);
+ }
uint8_t result = OP_STATUS_OK;
uint8_t value = input[0];
if (value == 0 || value == 1) {
if (data.fields.show_firmware_hash != value) {
data.fields.show_firmware_hash = value;
- result = _write_chunk(FLASH_BOOTDATA_START, data.bytes);
+ result = _write_bootdata(&data);
}
}
output[BOOT_OP_LEN] = data.fields.show_firmware_hash;
@@ -767,11 +820,14 @@ static size_t _api_set_show_firmware_hash(const uint8_t* input, uint8_t* output)
*/
static size_t _api_versions(uint8_t* output)
{
- const boot_data_t* data = (const boot_data_t*)FLASH_BOOTDATA_START;
- memcpy(output + BOOT_OP_LEN, (const uint8_t*)&data->fields.firmware_version, sizeof(version_t));
+ boot_data_t data;
+ if (!_read_valid_bootdata(&data)) {
+ return _report_status(OP_STATUS_ERR_CHECK, output);
+ }
+ memcpy(output + BOOT_OP_LEN, (const uint8_t*)&data.fields.firmware_version, sizeof(version_t));
memcpy(
output + BOOT_OP_LEN + sizeof(version_t),
- (const uint8_t*)&data->fields.signing_pubkeys_version,
+ (const uint8_t*)&data.fields.signing_pubkeys_version,
sizeof(version_t));
_report_status(OP_STATUS_OK, output);
return BOOT_OP_LEN + sizeof(version_t) * 2;
@@ -874,6 +930,9 @@ static size_t _api_command(const uint8_t* input, uint8_t* output, const size_t m
break;
}
+#ifdef BOOTLOADER_DEVELOPMENT
+ _show_bootdata_warning(0);
+#endif
return len;
}
@@ -890,7 +949,7 @@ static void _api_setup(void)
usb_processing_register_cmds(usb_processing_hww(), cmd_callbacks, 1);
}
-static void _check_init(boot_data_t* data)
+static void _configure_security(void)
{
#ifdef BOOTLOADER_LOCKED
// Enable boot protection if not already enabled. The
@@ -940,14 +999,6 @@ static void _check_init(boot_data_t* data)
}
}
#endif
-
- // Check bootdata initialized
- const uint8_t expected_initialized[2] = {sectrue_u8, sectrue_u8};
- if (!MEMEQ(data->fields.is_initialized, expected_initialized, 2)) {
- memset(data->bytes, 0, sizeof(data->bytes));
- memcpy(data->fields.is_initialized, expected_initialized, 2);
- _write_chunk(FLASH_BOOTDATA_START, data->bytes);
- }
}
#ifdef BOOTLOADER_DEVELOPMENT
@@ -1005,11 +1056,13 @@ void bootloader_jump(void)
boot_data_t bootdata;
chunk_shared_t shared_data;
- memcpy(bootdata.bytes, (uint8_t*)(FLASH_BOOTDATA_START), FLASH_BOOTDATA_LEN);
+ _configure_security();
+ bool bootdata_valid = bootdata_init(&bootdata);
+ if (!bootdata_valid) {
+ bootdata_valid = _handle_invalid_bootdata(&bootdata);
+ }
memory_read_shared_bootdata(&shared_data);
- _check_init(&bootdata);
-
const bool boot_args_valid = boot_args_is_valid();
bool upside_down = shared_data.fields.upside_down != 0;
if (boot_args_valid) {
@@ -1026,7 +1079,12 @@ void bootloader_jump(void)
UG_FontSelect(&font_regular_9);
- if (!bootloader_wait && shared_data.fields.auto_enter != sectrue_u8) {
+#ifdef BOOTLOADER_DEVELOPMENT
+ _show_bootdata_warning(2000);
+#endif
+
+ // Failed development recovery leaves the update interface available, without using bad data.
+ if (bootdata_valid && !bootloader_wait && shared_data.fields.auto_enter != sectrue_u8) {
#ifdef BOOTLOADER_DEVELOPMENT
if (!_development_enter(_firmware_verified_jump(&bootdata, secfalse_u32))) {
_binary_exec();
### src/flags.h
@@ -72,6 +72,7 @@
#define FLASH_ERASE_PAGE_NUM (16U)
#define FLASH_ERASE_MIN_LEN \
(FLASH_ERASE_PAGE_NUM * FLASH_PAGE_SIZE) // 8kB; minimum erase granularity
+#define ERASE_BLOCK_SIZE (FLASH_ERASE_MIN_LEN)
// Bootloader memory area - 64kB total, first 56kB read-only, last 8kB R/W data reserved for
// bootloader
#define FLASH_BOOT_START (FLASH_ADDR)
@@ -100,7 +101,7 @@
#define FLASH_APP_VERSION_LEN (4) // 4 byte big endian unsigned int
#define FLASH_APP_VERSION_START (FLASH_APP_START + FLASH_APP_LEN - FLASH_APP_VERSION_LEN)
-#define CHUNK_SIZE (FLASH_ERASE_MIN_LEN) // 8kB; minimum erase granularity
+#define CHUNK_SIZE (ERASE_BLOCK_SIZE) // 8kB; minimum erase granularity
// Shared temporary storage for stage1 and firmware. Contents may not survive a reboot:
// stage0 currently overwrites this space with a factory randomness backup when updating stage1.
### src/memory/memory.c
@@ -141,19 +141,26 @@ static_assert(sizeof(((chunk_2_t*)0)->fields) <= (size_t)CHUNK_SIZE, "chunk too
#endif
// CHUNK_7: A chunk that survives device resets (is not erased during `memory_reset_hww()`).
-#define CHUNK_7_PERMANENT (7)
+#define CHUNK_7_PERMANENT MEMORY_BOOTDATA_MIGRATION_CONSUMED_CHUNK
typedef union {
struct __attribute__((__packed__)) {
// Hash of bootloader used in the attestation sighash.
// If not set, the actual bootloader area is hashed.
secbool_u8 attestation_bootloader_hash_set;
uint8_t reserved[3];
uint8_t attestation_bootloader_hash[32];
+ // Written by stage1 before sealing bootdata. Never reset this field, including during
+ // factory attestation updates. See MEMORY_BOOTDATA_MIGRATION_CONSUMED_* in memory.h.
+ uint8_t bootdata_migration_consumed[MEMORY_BOOTDATA_MIGRATION_CONSUMED_LEN];
} fields;
uint8_t bytes[CHUNK_SIZE];
} chunk_7_t;
static_assert(sizeof(((chunk_7_t*)0)->fields) <= (size_t)CHUNK_SIZE, "chunk too large");
+static_assert(
+ offsetof(chunk_7_t, fields.bootdata_migration_consumed) ==
+ MEMORY_BOOTDATA_MIGRATION_CONSUMED_OFFSET,
+ "bootdata migration consumed marker offset must remain fixed");
#pragma GCC diagnostic pop
### src/memory/memory.h
@@ -18,6 +18,14 @@
// Maximum length of the stage1 bootloader marketing version, excluding a null terminator.
#define MEMORY_BOOTLOADER_VERSION_MAX_LEN 37
+// Fixed layout for stage1's consumed migration marker; preserve the chunk across writes and resets.
+// Only the exact magic prevents migration. If the chunk is erased, keep bootdata valid and
+// untouched until stage1 restores and verifies the marker.
+#define MEMORY_BOOTDATA_MIGRATION_CONSUMED_CHUNK 7U
+#define MEMORY_BOOTDATA_MIGRATION_CONSUMED_OFFSET 36U
+#define MEMORY_BOOTDATA_MIGRATION_CONSUMED_LEN 4U
+#define MEMORY_BOOTDATA_MIGRATION_CONSUMED_MAGIC {0x2F, 0x19, 0x4F, 0x78}
+
typedef enum {
// Legacy/initial value, corresponds to the original Optiga factorysetup config.
MEMORY_OPTIGA_CONFIG_V0,
### src/memory/memory_shared.h
@@ -4,10 +4,12 @@
#define _MEMORY_SHARED_H_
#include <assert.h>
+#include <stddef.h>
#include <stdint.h>
#include <compiler_util.h>
#include <flags.h>
+#include <sha256.h>
#if (FLASH_SHARED_DATA_LEN != CHUNK_SIZE)
#error "Shared data chunk not correct length"
@@ -20,6 +22,8 @@
#define BOOT_PUBKEY_LEN 64u
#define BOOT_SIG_LEN 64u
+#define BOOTDATA_VERSIONS_HASH_OFFSET 589U
+
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wpacked"
#pragma GCC diagnostic ignored "-Wattributes"
@@ -31,6 +35,11 @@ typedef union {
// `hardware_version` is deprecated/unused, as MPU prevents the firmware from easily reading
// this.
uint16_t hardware_version;
+ // Both bytes must be `sectrue_u8` in valid bootdata. Once set, this field is otherwise
+ // unused. Up to stage1 v1.2.2, any other value caused bootdata to be initialized
+ // automatically. Starting with production stage1 v1.2.3, the bootloader never changes
+ // these bytes and rejects bootdata unless both have the expected value. Development
+ // builds may reinitialize corrupt bootdata.
uint8_t is_initialized[2];
version_t signing_pubkeys_version;
uint8_t signing_pubkeys
@@ -42,11 +51,30 @@ typedef union {
firmware_signatures[BOOT_SIG_LEN * BOOT_NUM_FIRMWARE_SIGNING_KEYS]; // Keep after
// firmware_version
uint8_t show_firmware_hash;
+ // SHA256(signing_pubkeys_version_le32 || firmware_version_le32).
+ // In production, any prior checksum bytes are allowed for migration while the independent
+ // marker in PERMANENT chunk 7 does not match the consumed magic. With an exact magic match,
+ // every checksum mismatch (including zero) is invalid. Development builds can reset
+ // invalid bootdata with a fresh checksum.
+ uint8_t versions_hash[SHA256_DIGEST_LENGTH];
} fields;
uint8_t bytes[FLASH_BOOTDATA_LEN];
} boot_data_t;
#pragma GCC diagnostic pop
+static_assert(
+ offsetof(boot_data_t, fields.versions_hash) ==
+ offsetof(boot_data_t, fields.show_firmware_hash) +
+ sizeof(((boot_data_t*)0)->fields.show_firmware_hash),
+ "versions_hash must immediately follow show_firmware_hash");
+static_assert(
+ offsetof(boot_data_t, fields.versions_hash) == BOOTDATA_VERSIONS_HASH_OFFSET,
+ "versions_hash persistent offset changed");
+static_assert(
+ offsetof(boot_data_t, fields.versions_hash) + sizeof(((boot_data_t*)0)->fields.versions_hash) <=
+ FLASH_BOOTDATA_LEN,
+ "versions_hash does not fit in bootdata");
+
// CHUNK_SHARED: Shared data between the bootloader and firmware.
// auto_enter: if sectrue_u8, bootloader mode is entered on reboot
// upside_down: passes screen orientation to the bootloader
### src/memory/nvmctrl.c
@@ -3,6 +3,13 @@
#include "nvmctrl.h"
#include <driver_init.h>
+#include <flags.h>
+#include <hri_nvmctrl_d51.h>
+#include <string.h>
+
+#define NVMCTRL_NON_ECC_ERROR_FLAGS \
+ (NVMCTRL_INTFLAG_ADDRE | NVMCTRL_INTFLAG_PROGE | NVMCTRL_INTFLAG_LOCKE | NVMCTRL_INTFLAG_NVME)
+#define NVMCTRL_ERROR_FLAGS (NVMCTRL_NON_ECC_ERROR_FLAGS | NVMCTRL_INTFLAG_ECCDE)
void nvmctrl_exec_cmd(uint16_t cmd)
{
@@ -12,3 +19,89 @@ void nvmctrl_exec_cmd(uint16_t cmd)
NVMCTRL->CTRLB.reg = NVMCTRL_CTRLB_CMDEX_KEY | cmd;
while (NVMCTRL->STATUS.bit.READY == 0);
}
+
+void nvmctrl_clear_errors(void)
+{
+ // Reading ECCERR clears ECCSE and ECCDE. The remaining error flags are
+ // write-one-to-clear.
+ (void)hri_nvmctrl_read_ECCERR_reg(NVMCTRL);
+ hri_nvmctrl_clear_INTFLAG_reg(NVMCTRL, NVMCTRL_NON_ECC_ERROR_FLAGS);
+}
+
+bool nvmctrl_wait_ready_and_check_errors(void)
+{
+ while (!hri_nvmctrl_get_STATUS_READY_bit(NVMCTRL)) {
+ }
+
+ const uint16_t flags_before = hri_nvmctrl_read_INTFLAG_reg(NVMCTRL) & NVMCTRL_ERROR_FLAGS;
+ // Reading ECCERR both captures the error type and clears ECCSE/ECCDE.
+ const uint32_t eccerr = hri_nvmctrl_read_ECCERR_reg(NVMCTRL);
+ const uint16_t flags_after = hri_nvmctrl_read_INTFLAG_reg(NVMCTRL) & NVMCTRL_ERROR_FLAGS;
+ hri_nvmctrl_clear_INTFLAG_reg(NVMCTRL, NVMCTRL_NON_ECC_ERROR_FLAGS);
+
+ // Single-bit errors are corrected by hardware. Accept only NONE/SINGLE in both halves;
+ // a dual-bit or unexpected type remains fatal even if ECCDE was not set.
+ const uint32_t type_low = eccerr & NVMCTRL_ECCERR_TYPEL_Msk;
+ const uint32_t type_high = eccerr & NVMCTRL_ECCERR_TYPEH_Msk;
+ return (flags_before | flags_after) == 0 &&
+ (type_low == NVMCTRL_ECCERR_TYPEL_NONE || type_low == NVMCTRL_ECCERR_TYPEL_SINGLE) &&
+ (type_high == NVMCTRL_ECCERR_TYPEH_NONE || type_high == NVMCTRL_ECCERR_TYPEH_SINGLE);
+}
+
+bool nvmctrl_read(const volatile uint8_t* flash, uint8_t* out, size_t len)
+{
+ nvmctrl_clear_errors();
+ for (size_t i = 0; i < len; i++) {
+ out[i] = flash[i];
+ }
+ return nvmctrl_wait_ready_and_check_errors();
+}
+
+bool nvmctrl_read_block_checked(uintptr_t address, uint8_t* out)
+{
+ const volatile uint8_t* flash = (const volatile uint8_t*)address;
+ uint8_t confirm[ERASE_BLOCK_SIZE];
+ return nvmctrl_read(flash, out, ERASE_BLOCK_SIZE) &&
+ nvmctrl_read(flash, confirm, ERASE_BLOCK_SIZE) &&
+ memcmp(out, confirm, ERASE_BLOCK_SIZE) == 0;
+}
+
+bool nvmctrl_write_block(uint32_t address, const uint8_t* data)
+{
+ if (data == NULL || address % ERASE_BLOCK_SIZE != 0 ||
+ address > FLASH_SIZE - ERASE_BLOCK_SIZE) {
+ return false;
+ }
+ const uint32_t lock_size = FLASH_REGION_PAGE_NUM * FLASH_PAGE_SIZE;
+ const uint32_t lock_addr = address & ~(lock_size - 1U);
+
+ nvmctrl_clear_errors();
+ const int32_t unlock_result = flash_unlock(&FLASH_0, lock_addr, FLASH_REGION_PAGE_NUM);
+ if (!nvmctrl_wait_ready_and_check_errors() || unlock_result != FLASH_REGION_PAGE_NUM) {
+ return false;
+ }
+
+ nvmctrl_clear_errors();
+ const int32_t erase_result = flash_erase(&FLASH_0, address, FLASH_ERASE_PAGE_NUM);
+ if (!nvmctrl_wait_ready_and_check_errors() || erase_result != ERR_NONE) {
+ return false;
+ }
+
+ uint32_t page_words[FLASH_PAGE_SIZE / sizeof(uint32_t)];
+ for (size_t offset = 0; offset < ERASE_BLOCK_SIZE; offset += FLASH_PAGE_SIZE) {
+ memcpy(page_words, data + offset, FLASH_PAGE_SIZE);
+ nvmctrl_clear_errors();
+ const int32_t write_result =
+ flash_append(&FLASH_0, address + offset, (uint8_t*)page_words, FLASH_PAGE_SIZE);
+ if (!nvmctrl_wait_ready_and_check_errors() || write_result != ERR_NONE) {
+ return false;
+ }
+ }
+
+ nvmctrl_clear_errors();
+ const int32_t lock_result = flash_lock(&FLASH_0, lock_addr, FLASH_REGION_PAGE_NUM);
+ if (!nvmctrl_wait_ready_and_check_errors() || lock_result != FLASH_REGION_PAGE_NUM) {
+ return false;
+ }
+ return true;
+}
### src/memory/nvmctrl.h
@@ -3,8 +3,12 @@
#ifndef __NVMCTRL_H
#define __NVMCTRL_H
+#include <stdbool.h>
+#include <stddef.h>
#include <stdint.h>
+#include <compiler_util.h>
+
/**
* Writes a command to the NVM controller, and
* waits for it to be completed.
@@ -13,4 +17,39 @@
*/
void nvmctrl_exec_cmd(uint16_t cmd);
+/**
+ * Clears NVM controller errors before a checked flash operation.
+ *
+ * This clears address, programming, lock, single- and dual-bit ECC, and
+ * generic NVM errors.
+ */
+void nvmctrl_clear_errors(void);
+
+/**
+ * Waits for the NVM controller and checks errors from a flash operation.
+ *
+ * The checked error state is cleared before returning.
+ * Corrected single-bit ECC errors are accepted; dual-bit/unexpected ECC types and other NVM
+ * errors are rejected. Corrected data must still pass the caller's integrity checks.
+ *
+ * @return true if the controller became ready without an uncorrectable ECC or other NVM error.
+ */
+USE_RESULT bool nvmctrl_wait_ready_and_check_errors(void);
+
+/** Copies flash through volatile reads, rejecting uncorrectable ECC and other NVM errors. */
+USE_RESULT bool nvmctrl_read(const volatile uint8_t* flash, uint8_t* out, size_t len);
+
+/**
+ * Reads one erase block twice, rejecting NVM errors or differing reads.
+ * out must hold 8192 bytes; its contents must not be used on failure.
+ */
+USE_RESULT bool nvmctrl_read_block_checked(uintptr_t address, uint8_t* out);
+
+/**
+ * Erases and writes one aligned erase block of main flash, checking unlock, erase, each
+ * page write and relock for NVM/ECC errors. The caller must verify the complete readback and
+ * abort on failure; the block may have been erased or partially written.
+ */
+USE_RESULT bool nvmctrl_write_block(uint32_t address, const uint8_t* data);
+
#endif // __NVMCTRL_H
### src/platform/driver_init.h
@@ -29,8 +29,8 @@
#include <utils_assert.h>
#include "platform_config.h"
+#include <sha256.h>
-#define SHA256_DIGEST_LENGTH 32
// 64 is our typical packet size and it gets a little bit longer over UART due to framing. Set the
// buffer size so we can handle at least one whole frame. Must be a power of 2.
#define USART_0_BUFFER_SIZE 512
### src/sha256.h
@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#ifndef _SHA256_H_
+#define _SHA256_H_
+
+#define SHA256_DIGEST_LENGTH 32
+
+#endif
### src/util.c
@@ -28,6 +28,14 @@ void util_zero(volatile void* dst, size_t len)
#endif
}
+void util_write_le32(uint8_t out[4], uint32_t value)
+{
+ out[0] = (uint8_t)value;
+ out[1] = (uint8_t)(value >> 8);
+ out[2] = (uint8_t)(value >> 16);
+ out[3] = (uint8_t)(value >> 24);
+}
+
void util_strlcpy(char* dst, const char* src, size_t dst_len)
{
if (dst_len == 0) {
### src/util.h
@@ -48,6 +48,7 @@ typedef uint8_t secbool_u8;
#define secfalse_u8 0x00u
void util_zero(volatile void* dst, size_t len);
+void util_write_le32(uint8_t out[4], uint32_t value);
void util_strlcpy(char* dst, const char* src, size_t dst_len);
/**
### test/unit-test/CMakeLists.txt
@@ -29,6 +29,12 @@ else()
# Tests
set(TEST_LIST
+ bootdata
+ "-Wl,--wrap=pukcc_sha256_compute,--wrap=nvmctrl_read,--wrap=nvmctrl_read_block_checked,--wrap=nvmctrl_write_block"
+ bootdata_dev
+ "-Wl,--wrap=pukcc_sha256_compute,--wrap=nvmctrl_read,--wrap=nvmctrl_read_block_checked,--wrap=nvmctrl_write_block"
+ nvmctrl
+ ""
atecc
"-Wl,--gc-sections"
bootloader_format
@@ -84,7 +90,11 @@ else()
list(GET TEST_LIST ${I} TEST_NAME)
list(GET TEST_LIST ${I2} TEST_LINK_ARGS)
set(EXE test_${TEST_NAME})
- add_executable(${EXE} test_${TEST_NAME}.c)
+ if(TEST_NAME STREQUAL "bootdata_dev")
+ add_executable(${EXE} test_bootdata.c)
+ else()
+ add_executable(${EXE} test_${TEST_NAME}.c)
+ endif()
# asan must be first library in linking order
target_link_libraries(${EXE} PRIVATE
$<$<BOOL:${SANITIZE_ADDRESS}>:-fsanitize=address>
@@ -111,6 +121,21 @@ else()
${CMAKE_SOURCE_DIR}/external/asf4-drivers/hal/utils/include
)
endif()
+ if(TEST_NAME STREQUAL "bootdata" OR TEST_NAME STREQUAL "bootdata_dev")
+ target_sources(${EXE} PRIVATE ${CMAKE_SOURCE_DIR}/src/bootloader/bootdata.c)
+ if(TEST_NAME STREQUAL "bootdata_dev")
+ target_compile_definitions(${EXE} PRIVATE BOOTLOADER_DEVELOPMENT)
+ else()
+ target_compile_definitions(${EXE} PRIVATE BOOTLOADER_LOCKED)
+ endif()
+ endif()
+ if(TEST_NAME STREQUAL "nvmctrl")
+ target_sources(${EXE} PRIVATE ${CMAKE_SOURCE_DIR}/src/memory/nvmctrl.c)
+ target_include_directories(${EXE} BEFORE PRIVATE
+ ${CMAKE_CURRENT_SOURCE_DIR}/fakes/nvmctrl
+ ${CMAKE_SOURCE_DIR}/external/asf4-drivers/hal/utils/include
+ )
+ endif()
if(TEST_NAME STREQUAL "stage0_sigcheck")
target_sources(${EXE} PRIVATE
${CMAKE_SOURCE_DIR}/src/bootloader/stage0/stage1_sigcheck.c
### test/unit-test/fakes/nvmctrl/driver_init.h
@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#ifndef TEST_NVMCTRL_DRIVER_INIT_H
+#define TEST_NVMCTRL_DRIVER_INIT_H
+
+#include <stdint.h>
+
+#include <err_codes.h>
+
+struct flash_descriptor {
+ uint8_t unused;
+};
+extern struct flash_descriptor FLASH_0;
+
+int32_t flash_unlock(struct flash_descriptor* flash, uint32_t address, uint32_t pages);
+int32_t flash_lock(struct flash_descriptor* flash, uint32_t address, uint32_t pages);
+int32_t flash_erase(struct flash_descriptor* flash, uint32_t address, uint32_t pages);
+int32_t flash_append(struct flash_descriptor* flash, uint32_t address, uint8_t* data, uint32_t len);
+
+typedef union {
+ struct {
+ uint16_t READY : 1;
+ uint16_t : 15;
+ } bit;
+ uint16_t reg;
+} fake_nvmctrl_status_t;
+
+typedef struct {
+ fake_nvmctrl_status_t STATUS;
+ struct {
+ uint32_t reg;
+ } ADDR;
+ struct {
+ uint32_t reg;
+ } CTRLB;
+ struct {
+ uint16_t reg;
+ } INTFLAG;
+ struct {
+ uint32_t reg;
+ } ECCERR;
+ uint32_t eccerr_reads;
+ uint16_t flags_on_ready;
+ uint32_t eccerr_on_ready;
+ void (*on_ready)(void);
+} fake_nvmctrl_t;
+
+extern fake_nvmctrl_t fake_nvmctrl;
+
+#define NVMCTRL (&fake_nvmctrl)
+#define NVMCTRL_USER 0x00804000U
+#define NVMCTRL_CTRLB_CMDEX_KEY 0xA500U
+
+#endif // TEST_NVMCTRL_DRIVER_INIT_H
### test/unit-test/fakes/nvmctrl/hri_nvmctrl_d51.h
@@ -0,0 +1,60 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#ifndef TEST_HRI_NVMCTRL_D51_H
+#define TEST_HRI_NVMCTRL_D51_H
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#include <driver_init.h>
+
+#define NVMCTRL_INTFLAG_DONE (1U << 0)
+#define NVMCTRL_INTFLAG_ADDRE (1U << 1)
+#define NVMCTRL_INTFLAG_PROGE (1U << 2)
+#define NVMCTRL_INTFLAG_LOCKE (1U << 3)
+#define NVMCTRL_INTFLAG_ECCSE (1U << 4)
+#define NVMCTRL_INTFLAG_ECCDE (1U << 5)
+#define NVMCTRL_INTFLAG_NVME (1U << 6)
+
+#define NVMCTRL_ECCERR_TYPEL_Msk (3UL << 28)
+#define NVMCTRL_ECCERR_TYPEH_Msk (3UL << 30)
+#define NVMCTRL_ECCERR_TYPEL_NONE (0UL << 28)
+#define NVMCTRL_ECCERR_TYPEL_SINGLE (1UL << 28)
+#define NVMCTRL_ECCERR_TYPEL_DUAL (2UL << 28)
+#define NVMCTRL_ECCERR_TYPEH_NONE (0UL << 30)
+#define NVMCTRL_ECCERR_TYPEH_SINGLE (1UL << 30)
+#define NVMCTRL_ECCERR_TYPEH_DUAL (2UL << 30)
+
+static inline bool hri_nvmctrl_get_STATUS_READY_bit(void* const hw)
+{
+ fake_nvmctrl_t* nvmctrl = hw;
+ nvmctrl->INTFLAG.reg |= nvmctrl->flags_on_ready;
+ nvmctrl->ECCERR.reg |= nvmctrl->eccerr_on_ready;
+ if (nvmctrl->on_ready != NULL) {
+ nvmctrl->on_ready();
+ }
+ return nvmctrl->STATUS.bit.READY != 0;
+}
+
+static inline uint16_t hri_nvmctrl_read_INTFLAG_reg(const void* const hw)
+{
+ return ((const fake_nvmctrl_t*)hw)->INTFLAG.reg;
+}
+
+static inline void hri_nvmctrl_clear_INTFLAG_reg(void* const hw, uint16_t mask)
+{
+ fake_nvmctrl_t* nvmctrl = hw;
+ nvmctrl->INTFLAG.reg &= (uint16_t)~mask;
+}
+
+static inline uint32_t hri_nvmctrl_read_ECCERR_reg(void* const hw)
+{
+ fake_nvmctrl_t* nvmctrl = hw;
+ const uint32_t result = nvmctrl->ECCERR.reg;
+ nvmctrl->ECCERR.reg = 0;
+ nvmctrl->INTFLAG.reg &= (uint16_t)~(NVMCTRL_INTFLAG_ECCSE | NVMCTRL_INTFLAG_ECCDE);
+ nvmctrl->eccerr_reads++;
+ return result;
+}
+
+#endif // TEST_HRI_NVMCTRL_D51_H
### test/unit-test/test_bootdata.c
@@ -0,0 +1,970 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#include <setjmp.h>
+#include <stdarg.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+#include <cmocka.h>
+
+#include "bootloader/bootdata.h"
+#include "memory/memory.h"
+#include "memory/nvmctrl.h"
+#include "pukcc/pukcc.h"
+#include "rust/rust.h"
+
+#define VERSIONS_PREIMAGE_LEN 8U
+#define MIGRATION_CONSUMED_CHUNK_ADDR \
+ (FLASH_APPDATA_START + MEMORY_BOOTDATA_MIGRATION_CONSUMED_CHUNK * CHUNK_SIZE)
+
+static const uint8_t _migration_consumed_magic[MEMORY_BOOTDATA_MIGRATION_CONSUMED_LEN] =
+ MEMORY_BOOTDATA_MIGRATION_CONSUMED_MAGIC;
+static boot_data_t _flash_bootdata;
+static uint8_t _migration_consumed_chunk[CHUNK_SIZE];
+static size_t _read_calls;
+static size_t _write_calls;
+static size_t _migration_consumed_writes;
+static size_t _bootdata_writes;
+static size_t _migration_consumed_readback_calls;
+static bool _migration_consumed_needs_verification;
+static size_t _fail_read_call;
+static size_t _unstable_read_call;
+static size_t _fail_write_call;
+static size_t _cut_after_bytes;
+static size_t _corrupt_write_call;
+
+static void _reset_io(void)
+{
+ _read_calls = 0;
+ _write_calls = 0;
+ _migration_consumed_writes = 0;
+ _bootdata_writes = 0;
+ _migration_consumed_readback_calls = 0;
+ _migration_consumed_needs_verification = false;
+ _fail_read_call = 0;
+ _unstable_read_call = 0;
+ _fail_write_call = 0;
+ _cut_after_bytes = 0;
+ _corrupt_write_call = 0;
+}
+
+USE_RESULT bool __wrap_nvmctrl_read(const volatile uint8_t* flash, uint8_t* out, size_t len)
+{
+ const uintptr_t address = (uintptr_t)flash;
+ _read_calls++;
+ if (address == FLASH_BOOTDATA_START) {
+ assert_int_equal(len, CHUNK_SIZE);
+ memcpy(out, _flash_bootdata.bytes, len);
+ } else if (address == MIGRATION_CONSUMED_CHUNK_ADDR) {
+ assert_int_equal(len, CHUNK_SIZE);
+ memcpy(out, _migration_consumed_chunk, len);
+ if (_migration_consumed_needs_verification && ++_migration_consumed_readback_calls == 2) {
+ _migration_consumed_needs_verification = false;
+ }
+ } else {
+ assert_int_equal(
+ address, MIGRATION_CONSUMED_CHUNK_ADDR + MEMORY_BOOTDATA_MIGRATION_CONSUMED_OFFSET);
+ assert_int_equal(len, MEMORY_BOOTDATA_MIGRATION_CONSUMED_LEN);
+ memcpy(out, _migration_consumed_chunk + MEMORY_BOOTDATA_MIGRATION_CONSUMED_OFFSET, len);
+ }
+ if (_read_calls == _unstable_read_call) {
+ out[0] ^= 1;
+ }
+ return _read_calls != _fail_read_call;
+}
+
+USE_RESULT bool __wrap_nvmctrl_read_block_checked(uintptr_t address, uint8_t* out)
+{
+ const volatile uint8_t* flash = (const volatile uint8_t*)address;
+ const size_t first_read = _read_calls + 1;
+ if (!__wrap_nvmctrl_read(flash, out, CHUNK_SIZE) ||
+ !__wrap_nvmctrl_read(flash, out, CHUNK_SIZE)) {
+ return false;
+ }
+ return _unstable_read_call != first_read && _unstable_read_call != first_read + 1;
+}
+
+USE_RESULT bool __wrap_nvmctrl_write_block(uint32_t address, const uint8_t* data)
+{
+ _write_calls++;
+ uint8_t* dest;
+ if (address == MIGRATION_CONSUMED_CHUNK_ADDR) {
+ _migration_consumed_writes++;
+ _migration_consumed_needs_verification = true;
+ _migration_consumed_readback_calls = 0;
+ dest = _migration_consumed_chunk;
+ } else {
+ assert_int_equal(address, FLASH_BOOTDATA_START);
+ assert_memory_equal(
+ _migration_consumed_chunk + MEMORY_BOOTDATA_MIGRATION_CONSUMED_OFFSET,
+ _migration_consumed_magic,
+ sizeof(_migration_consumed_magic));
+ assert_false(_migration_consumed_needs_verification);
+ _bootdata_writes++;
+ dest = _flash_bootdata.bytes;
+ }
+ memset(dest, UINT8_MAX, CHUNK_SIZE);
+ if (_write_calls == _fail_write_call) {
+ assert_true(_cut_after_bytes <= CHUNK_SIZE);
+ memcpy(dest, data, _cut_after_bytes);
+ return false;
+ }
+ memcpy(dest, data, CHUNK_SIZE);
+ if (_write_calls == _corrupt_write_call) {
+ // Detect mismatches outside the hashed fields through the complete write readback.
+ dest[CHUNK_SIZE - 1] ^= 1;
+ }
+ return true;
+}
+
+static bool _sha_succeeds;
+static size_t _sha_calls;
+static size_t _fail_sha_call;
+static uint8_t _sha_input[VERSIONS_PREIMAGE_LEN];
+
+static void _reset_sha(void)
+{
+ _sha_succeeds = true;
+ _sha_calls = 0;
+ _fail_sha_call = 0;
+ memset(_sha_input, 0, sizeof(_sha_input));
+}
+
+USE_RESULT int32_t
+__wrap_pukcc_sha256_compute(const uint8_t* message, uint32_t message_len, uint8_t* hash)
+{
+ assert_int_equal(message_len, VERSIONS_PREIMAGE_LEN);
+ memcpy(_sha_input, message, sizeof(_sha_input));
+ _sha_calls++;
+ if (!_sha_succeeds || _sha_calls == _fail_sha_call) {
+ return -1;
+ }
+ rust_sha256(message, message_len, hash);
+ return 0;
+}
+
+USE_RESULT static boot_data_t _bootdata(
+ version_t signing_pubkeys_version,
+ version_t firmware_version)
+{
+ boot_data_t bootdata = {0};
+ memset(bootdata.fields.is_initialized, sectrue_u8, sizeof(bootdata.fields.is_initialized));
+ bootdata.fields.signing_pubkeys_version = signing_pubkeys_version;
+ bootdata.fields.firmware_version = firmware_version;
+ return bootdata;
+}
+
+static void _reset_flash(void)
+{
+ _reset_sha();
+ _reset_io();
+ _flash_bootdata = _bootdata(3, 42);
+ // No valid firmware signatures are provided: first sealing must not depend on the carrier.
+ memset(_migration_consumed_chunk, 0xA5, sizeof(_migration_consumed_chunk));
+ memset(
+ _migration_consumed_chunk + MEMORY_BOOTDATA_MIGRATION_CONSUMED_OFFSET,
+ UINT8_MAX,
+ MEMORY_BOOTDATA_MIGRATION_CONSUMED_LEN);
+}
+
+static void test_migration_consumed_persistent_format(void** state)
+{
+ (void)state;
+ const uint8_t expected_magic[] = {0x2F, 0x19, 0x4F, 0x78};
+ assert_int_equal(MEMORY_BOOTDATA_MIGRATION_CONSUMED_OFFSET, 36);
+ assert_int_equal(MEMORY_BOOTDATA_MIGRATION_CONSUMED_LEN, sizeof(expected_magic));
+ assert_memory_equal(_migration_consumed_magic, expected_magic, sizeof(expected_magic));
+}
+
+static void test_set_known_hash(void** state)
+{
+ (void)state;
+ _reset_sha();
+ boot_data_t bootdata = _bootdata(0x01020304U, 0xA1B2C3D4U);
+ const uint8_t expected_input[VERSIONS_PREIMAGE_LEN] = {
+ 0x04,
+ 0x03,
+ 0x02,
+ 0x01,
+ 0xD4,
+ 0xC3,
+ 0xB2,
+ 0xA1,
+ };
+ const uint8_t expected_hash[SHA256_DIGEST_LENGTH] = {
+ 0xF5, 0x46, 0x83, 0xD6, 0x1E, 0x15, 0xBA, 0x25, 0xBE, 0x7B, 0xCD,
+ 0x9B, 0x83, 0xBD, 0x5A, 0x06, 0xBB, 0xB9, 0x13, 0x04, 0xCB, 0xE4,
+ 0x78, 0x50, 0x4D, 0xBC, 0x23, 0xB2, 0x0C, 0x3E, 0xC5, 0x7D,
+ };
+
+ assert_true(bootdata_hash_set(&bootdata));
+ assert_int_equal(_sha_calls, 1);
+ assert_memory_equal(_sha_input, expected_input, sizeof(expected_input));
+ assert_memory_equal(bootdata.fields.versions_hash, expected_hash, sizeof(expected_hash));
+}
+
+static void test_hash_check_zero(void** state)
+{
+ (void)state;
+ _reset_sha();
+ boot_data_t bootdata = _bootdata(1, 2);
+ bool hash_valid = true;
+
+ assert_true(bootdata_hash_check(&bootdata, &hash_valid));
+ assert_false(hash_valid);
+ assert_int_equal(_sha_calls, 1);
+}
+
+static void test_hash_check_valid_and_changed_versions(void** state)
+{
+ (void)state;
+ _reset_sha();
+ boot_data_t bootdata = _bootdata(1, 2);
+ assert_true(bootdata_hash_set(&bootdata));
+
+ bool hash_valid;
+ assert_true(bootdata_hash_check(&bootdata, &hash_valid));
+ assert_true(hash_valid);
+
+ bootdata.fields.signing_pubkeys_version--;
+ assert_true(bootdata_hash_check(&bootdata, &hash_valid));
+ assert_false(hash_valid);
+ bootdata.fields.signing_pubkeys_version++;
+
+ bootdata.fields.firmware_version--;
+ assert_true(bootdata_hash_check(&bootdata, &hash_valid));
+ assert_false(hash_valid);
+}
+
+static void test_hash_check_nonzero_mismatches(void** state)
+{
+ (void)state;
+ _reset_sha();
+ boot_data_t bootdata = _bootdata(1, 2);
+ bool hash_valid;
+
+ memset(bootdata.fields.versions_hash, UINT8_MAX, sizeof(bootdata.fields.versions_hash));
+ assert_true(bootdata_hash_check(&bootdata, &hash_valid));
+ assert_false(hash_valid);
+
+ memset(bootdata.fields.versions_hash, 0, sizeof(bootdata.fields.versions_hash));
+ bootdata.fields.versions_hash[0] = 1;
+ assert_true(bootdata_hash_check(&bootdata, &hash_valid));
+ assert_false(hash_valid);
+}
+
+static void test_hash_failures(void** state)
+{
+ (void)state;
+ _reset_sha();
+ boot_data_t bootdata = _bootdata(1, 2);
+ memset(bootdata.fields.versions_hash, 0x42, sizeof(bootdata.fields.versions_hash));
+ boot_data_t original = bootdata;
+ bool hash_valid;
+
+ _sha_succeeds = false;
+ assert_false(bootdata_hash_set(&bootdata));
+ assert_memory_equal(bootdata.bytes, original.bytes, sizeof(bootdata.bytes));
+ assert_false(bootdata_hash_check(&bootdata, &hash_valid));
+}
+
+static void test_null_arguments(void** state)
+{
+ (void)state;
+ boot_data_t bootdata = _bootdata(1, 2);
+ bool hash_valid;
+
+ assert_false(bootdata_hash_set(NULL));
+ assert_false(bootdata_hash_check(NULL, &hash_valid));
+ assert_false(bootdata_hash_check(&bootdata, NULL));
+}
+
+static void test_bootdata_init_legacy_once(void** state)
+{
+ (void)state;
+ _reset_flash();
+ boot_data_t expected = _flash_bootdata;
+ assert_true(bootdata_hash_set(&expected));
+ uint8_t expected_marker_chunk[CHUNK_SIZE];
+ memcpy(expected_marker_chunk, _migration_consumed_chunk, sizeof(expected_marker_chunk));
+ memcpy(
+ expected_marker_chunk + MEMORY_BOOTDATA_MIGRATION_CONSUMED_OFFSET,
+ _migration_consumed_magic,
+ sizeof(_migration_consumed_magic));
+
+ boot_data_t result;
+ assert_true(bootdata_init(&result));
+ assert_int_equal(_migration_consumed_writes, 1);
+ assert_int_equal(_bootdata_writes, 1);
+ assert_memory_equal(_flash_bootdata.bytes, expected.bytes, sizeof(expected.bytes));
+ assert_memory_equal(result.bytes, expected.bytes, sizeof(expected.bytes));
+ assert_memory_equal(
+ _migration_consumed_chunk, expected_marker_chunk, sizeof(expected_marker_chunk));
+
+ // Repeated boots neither reseal bootdata nor rewrite the consumed marker.
+ assert_true(bootdata_init(&result));
+ assert_true(bootdata_read(&result));
+ assert_int_equal(_write_calls, 2);
+}
+
+static void test_bootdata_init_invalid_initialization(void** state)
+{
+ (void)state;
+ const uint8_t invalid[] = {0, 1, UINT8_MAX};
+ boot_data_t result;
+ for (size_t marker = 0; marker < 2; marker++) {
+ for (size_t i = 0; i < sizeof(invalid); i++) {
+ _reset_flash();
+ _flash_bootdata.fields.is_initialized[marker] = invalid[i];
+ assert_false(bootdata_init(&result));
+ assert_int_equal(_write_calls, 0);
+ }
+ }
+ _reset_flash();
+ memset(_flash_bootdata.bytes, UINT8_MAX, sizeof(_flash_bootdata.bytes));
+ assert_false(bootdata_init(&result));
+ assert_int_equal(_write_calls, 0);
+}
+
+static void test_bootdata_init_accepts_nonmagic_marker(void** state)
+{
+ (void)state;
+ boot_data_t result;
+ // Every nonmagic value permits migration, including all-zero and all-0xFF.
+ for (uint16_t marker = 0; marker <= UINT8_MAX; marker++) {
+ _reset_flash();
+ memset(
+ _migration_consumed_chunk + MEMORY_BOOTDATA_MIGRATION_CONSUMED_OFFSET,
+ marker,
+ MEMORY_BOOTDATA_MIGRATION_CONSUMED_LEN);
+ boot_data_t expected = _flash_bootdata;
+ assert_true(bootdata_hash_set(&expected));
+ uint8_t expected_marker_chunk[CHUNK_SIZE];
+ memcpy(expected_marker_chunk, _migration_consumed_chunk, sizeof(expected_marker_chunk));
+ memcpy(
+ expected_marker_chunk + MEMORY_BOOTDATA_MIGRATION_CONSUMED_OFFSET,
+ _migration_consumed_magic,
+ sizeof(_migration_consumed_magic));
+ assert_true(bootdata_init(&result));
+ assert_int_equal(_migration_consumed_writes, 1);
+ assert_int_equal(_bootdata_writes, 1);
+ assert_memory_equal(result.bytes, expected.bytes, sizeof(expected.bytes));
+ assert_memory_equal(
+ _migration_consumed_chunk, expected_marker_chunk, sizeof(expected_marker_chunk));
+ }
+ // Matching three bytes is not consumed, regardless of which byte differs.
+ for (size_t byte = 0; byte < sizeof(_migration_consumed_magic); byte++) {
+ _reset_flash();
+ memcpy(
+ _migration_consumed_chunk + MEMORY_BOOTDATA_MIGRATION_CONSUMED_OFFSET,
+ _migration_consumed_magic,
+ sizeof(_migration_consumed_magic));
+ _migration_consumed_chunk[MEMORY_BOOTDATA_MIGRATION_CONSUMED_OFFSET + byte] ^= 1;
+ assert_true(bootdata_init(&result));
+ assert_int_equal(_migration_consumed_writes, 1);
+ assert_int_equal(_bootdata_writes, 1);
+ }
+}
+
+static void test_bootdata_init_never_reseals_consumed_migration(void** state)
+{
+ (void)state;
+ const uint8_t bad_hash_bytes[] = {0, 0xA5, UINT8_MAX};
+ boot_data_t result;
+ for (size_t i = 0; i < sizeof(bad_hash_bytes); i++) {
+ _reset_flash();
+ assert_true(bootdata_init(&result));
+ _reset_io();
+ // Simulate a torn write lowering both floors and leaving a zero/corrupt/erased hash.
+ _flash_bootdata.fields.signing_pubkeys_version = 0;
+ _flash_bootdata.fields.firmware_version = 0;
+ memset(_flash_bootdata.fields.versions_hash, bad_hash_bytes[i], SHA256_DIGEST_LENGTH);
+ assert_false(bootdata_init(&result));
+ assert_false(bootdata_init(&result));
+ assert_false(bootdata_read(&result));
+ assert_false(bootdata_write(&result));
+ assert_int_equal(_write_calls, 0);
+ }
+}
+
+static void test_bootdata_init_accepts_any_hash_before_migration(void** state)
+{
+ (void)state;
+ boot_data_t result;
+ // The independent marker, not any pattern in the checksum bytes, authorizes first sealing.
+ for (uint16_t value = 0; value <= UINT8_MAX; value++) {
+ _reset_flash();
+ memset(_flash_bootdata.fields.versions_hash, value, SHA256_DIGEST_LENGTH);
+ boot_data_t expected = _flash_bootdata;
+ assert_true(bootdata_hash_set(&expected));
+ assert_false(bootdata_read(&result));
+ assert_false(bootdata_write(&result));
+ assert_int_equal(_write_calls, 0);
+ assert_true(bootdata_init(&result));
+ assert_int_equal(_migration_consumed_writes, 1);
+ assert_int_equal(_bootdata_writes, 1);
+ assert_memory_equal(result.bytes, expected.bytes, sizeof(expected.bytes));
+ assert_memory_equal(_flash_bootdata.bytes, expected.bytes, sizeof(expected.bytes));
+ assert_true(bootdata_init(&result));
+ assert_true(bootdata_read(&result));
+ assert_int_equal(_write_calls, 2);
+ }
+
+ // A stale checksum is no different from any other pre-migration value.
+ _reset_flash();
+ assert_true(bootdata_hash_set(&_flash_bootdata));
+ _flash_bootdata.fields.firmware_version--;
+ boot_data_t expected = _flash_bootdata;
+ assert_true(bootdata_hash_set(&expected));
+ assert_true(bootdata_init(&result));
+ assert_int_equal(_migration_consumed_writes, 1);
+ assert_int_equal(_bootdata_writes, 1);
+ assert_memory_equal(result.bytes, expected.bytes, sizeof(expected.bytes));
+ assert_memory_equal(_flash_bootdata.bytes, expected.bytes, sizeof(expected.bytes));
+
+ // The same mismatch is fatal once migration is marked consumed, without any repair writes.
+ _reset_io();
+ _flash_bootdata.fields.firmware_version--;
+ assert_false(bootdata_init(&result));
+ assert_false(bootdata_init(&result));
+ assert_false(bootdata_read(&result));
+ assert_false(bootdata_write(&result));
+ assert_int_equal(_write_calls, 0);
+}
+
+static void test_bootdata_init_restores_consumed_marker_before_writes(void** state)
+{
+ (void)state;
+ _reset_flash();
+ boot_data_t result;
+ assert_true(bootdata_init(&result));
+ boot_data_t original = _flash_bootdata;
+
+ // A later interrupted PERMANENT-chunk migration can change the marker, but must leave valid
+ // bootdata untouched. Neither a read for USB nor a write may bypass restoring the marker on
+ // boot.
+ uint8_t markers[3 + MEMORY_BOOTDATA_MIGRATION_CONSUMED_LEN]
+ [MEMORY_BOOTDATA_MIGRATION_CONSUMED_LEN] = {
+ {0}, {0xFF, 0xFF, 0xFF, 0xFF}, {0xA5, 0x5A, 0x12, 0x34}};
+ for (size_t byte = 0; byte < sizeof(_migration_consumed_magic); byte++) {
+ memcpy(markers[3 + byte], _migration_consumed_magic, sizeof(_migration_consumed_magic));
+ markers[3 + byte][byte] ^= 1;
+ }
+ for (size_t i = 0; i < sizeof(markers) / sizeof(markers[0]); i++) {
+ memcpy(
+ _migration_consumed_chunk + MEMORY_BOOTDATA_MIGRATION_CONSUMED_OFFSET,
+ markers[i],
+ sizeof(markers[i]));
+ _reset_io();
+ assert_false(bootdata_read(&result));
+ assert_false(bootdata_write(&result));
+ assert_int_equal(_write_calls, 0);
+ assert_true(bootdata_init(&result));
+ assert_true(bootdata_read(&result));
+ assert_int_equal(_migration_consumed_writes, 1);
+ assert_int_equal(_bootdata_writes, 0);
+ assert_memory_equal(_flash_bootdata.bytes, original.bytes, sizeof(original.bytes));
+ }
+
+ result.fields.firmware_version++;
+ assert_true(bootdata_write(&result));
+ assert_int_equal(_migration_consumed_writes, 1);
+ assert_int_equal(_bootdata_writes, 1);
+ assert_true(bootdata_read(&result));
+ assert_int_equal(result.fields.firmware_version, original.fields.firmware_version + 1);
+}
+
+static void test_bootdata_init_migration_consumed_power_cuts(void** state)
+{
+ (void)state;
+ const size_t cuts[] = {
+ 0,
+ 1,
+ MEMORY_BOOTDATA_MIGRATION_CONSUMED_OFFSET,
+ MEMORY_BOOTDATA_MIGRATION_CONSUMED_OFFSET + 1,
+ MEMORY_BOOTDATA_MIGRATION_CONSUMED_OFFSET + 2,
+ MEMORY_BOOTDATA_MIGRATION_CONSUMED_OFFSET + 3,
+ MEMORY_BOOTDATA_MIGRATION_CONSUMED_OFFSET + MEMORY_BOOTDATA_MIGRATION_CONSUMED_LEN,
+ FLASH_PAGE_SIZE,
+ CHUNK_SIZE};
+ for (size_t valid_hash = 0; valid_hash < 2; valid_hash++) {
+ for (size_t i = 0; i < sizeof(cuts) / sizeof(cuts[0]); i++) {
+ _reset_flash();
+ if (valid_hash) {
+ assert_true(bootdata_hash_set(&_flash_bootdata));
+ }
+ boot_data_t original = _flash_bootdata;
+ _fail_write_call = 1;
+ _cut_after_bytes = cuts[i];
+ boot_data_t result;
+ assert_false(bootdata_init(&result));
+ assert_int_equal(_bootdata_writes, 0);
+ assert_memory_equal(_flash_bootdata.bytes, original.bytes, sizeof(original.bytes));
+ _reset_io(); // Reboot without changing flash.
+ const bool partial_marker = cuts[i] < MEMORY_BOOTDATA_MIGRATION_CONSUMED_OFFSET +
+ MEMORY_BOOTDATA_MIGRATION_CONSUMED_LEN;
+ if (partial_marker || valid_hash) {
+ // A partial marker authorizes retry: bootdata has never been touched. Valid
+ // bootdata never needs resealing, even if writing/restoring the marker was
+ // interrupted.
+ assert_true(bootdata_init(&result));
+ assert_int_equal(_migration_consumed_writes, partial_marker ? 1 : 0);
+ assert_int_equal(_bootdata_writes, valid_hash ? 0 : 1);
+ if (valid_hash) {
+ assert_memory_equal(
+ _flash_bootdata.bytes, original.bytes, sizeof(original.bytes));
+ }
+ } else {
+ // Includes a cut after the full marker but before the checksum write.
+ assert_false(bootdata_init(&result));
+ assert_false(bootdata_init(&result));
+ assert_int_equal(_write_calls, 0);
+ }
+ }
+ }
+}
+
+static void test_bootdata_init_bootdata_power_cuts(void** state)
+{
+ (void)state;
+ // Exercise erase, every partial checksum length, and every page boundary. A cut after all
+ // protected fields have been written may leave valid floors, which is safe to retain.
+ const size_t hash_end = BOOTDATA_VERSIONS_HASH_OFFSET + SHA256_DIGEST_LENGTH;
+ for (size_t cut = 0; cut <= CHUNK_SIZE; cut++) {
+ if (cut % FLASH_PAGE_SIZE != 0 && (cut < BOOTDATA_VERSIONS_HASH_OFFSET || cut > hash_end)) {
+ continue;
+ }
+ _reset_flash();
+ _fail_write_call = 2;
+ _cut_after_bytes = cut;
+ boot_data_t result;
+ assert_false(bootdata_init(&result));
+ assert_int_equal(_migration_consumed_writes, 1);
+ assert_int_equal(_bootdata_writes, 1);
+ assert_memory_equal(
+ _migration_consumed_chunk + MEMORY_BOOTDATA_MIGRATION_CONSUMED_OFFSET,
+ _migration_consumed_magic,
+ sizeof(_migration_consumed_magic));
+ _reset_io();
+ assert_int_equal(bootdata_init(&result), cut >= hash_end);
+ assert_int_equal(bootdata_init(&result), cut >= hash_end);
+ assert_int_equal(_write_calls, 0);
+ }
+}
+
+static void test_bootdata_init_read_failures(void** state)
+{
+ (void)state;
+ // Legacy migration has ten reads: bootdata twice, consumed marker twice, marker chunk twice,
+ // marker write readback twice, bootdata write readback twice.
+ for (size_t read = 1; read <= 10; read++) {
+ _reset_flash();
+ _fail_read_call = read;
+ boot_data_t result;
+ assert_false(bootdata_init(&result));
+ if (read <= 8) {
+ assert_int_equal(_bootdata_writes, 0);
+ }
+ }
+ for (size_t read = 2; read <= 10; read += 2) {
+ _reset_flash();
+ _unstable_read_call = read;
+ boot_data_t result;
+ assert_false(bootdata_init(&result));
+ if (read <= 8) {
+ assert_int_equal(_bootdata_writes, 0);
+ }
+ }
+}
+
+static void test_bootdata_init_checks_full_readback(void** state)
+{
+ (void)state;
+ for (size_t write = 1; write <= 2; write++) {
+ _reset_flash();
+ _corrupt_write_call = write;
+ boot_data_t result;
+ assert_false(bootdata_init(&result));
+ assert_int_equal(_write_calls, write);
+ }
+}
+
+static void test_bootdata_write_power_cut(void** state)
+{
+ (void)state;
+ _reset_flash();
+ boot_data_t result;
+ assert_true(bootdata_init(&result));
+ _reset_io();
+ result.fields.firmware_version++;
+ _fail_write_call = 1;
+ // Erase the whole block while trying to raise the version floor.
+ assert_false(bootdata_write(&result));
+ _reset_io();
+ assert_false(bootdata_init(&result));
+ assert_false(bootdata_init(&result));
+ assert_int_equal(_write_calls, 0);
+}
+
+static void test_bootdata_init_hash_failure(void** state)
+{
+ (void)state;
+ // Fail initial checksum check, checksum generation, or readback validation.
+ for (size_t fail_call = 1; fail_call <= 3; fail_call++) {
+ _reset_flash();
+ _fail_sha_call = fail_call;
+ boot_data_t result;
+ assert_false(bootdata_init(&result));
+ assert_int_equal(_migration_consumed_writes, fail_call == 1 ? 0 : 1);
+ assert_int_equal(_bootdata_writes, fail_call == 3 ? 1 : 0);
+ _reset_sha();
+ _reset_io();
+ // Only failure between marking migration consumed and writing the checksum is permanent.
+ // Before consumption migration can retry; after the write bootdata is already valid.
+ assert_int_equal(bootdata_init(&result), fail_call != 2);
+ assert_int_equal(_write_calls, fail_call == 1 ? 2 : 0);
+ }
+}
+
+static void test_bootdata_preserves_valid_data(void** state)
+{
+ (void)state;
+ const uint8_t markers[][MEMORY_BOOTDATA_MIGRATION_CONSUMED_LEN] = {
+ {0},
+ {0xFF, 0xFF, 0xFF, 0xFF},
+ MEMORY_BOOTDATA_MIGRATION_CONSUMED_MAGIC,
+ {0xA5, 0x5A, 0x12, 0x34}};
+ for (size_t i = 0; i < sizeof(markers) / sizeof(markers[0]); i++) {
+ _reset_flash();
+ memcpy(
+ _migration_consumed_chunk + MEMORY_BOOTDATA_MIGRATION_CONSUMED_OFFSET,
+ markers[i],
+ sizeof(markers[i]));
+ _flash_bootdata.fields.show_firmware_hash = 1;
+ _flash_bootdata.bytes[CHUNK_SIZE - 1] = 0x42;
+ assert_true(bootdata_hash_set(&_flash_bootdata));
+ boot_data_t original = _flash_bootdata;
+ boot_data_t result;
+ assert_true(bootdata_init(&result));
+ assert_true(bootdata_read(&result));
+ assert_memory_equal(result.bytes, original.bytes, sizeof(original.bytes));
+ assert_memory_equal(_flash_bootdata.bytes, original.bytes, sizeof(original.bytes));
+ assert_int_equal(_bootdata_writes, 0);
+ assert_int_equal(
+ _migration_consumed_writes,
+ memcmp(markers[i], _migration_consumed_magic, sizeof(_migration_consumed_magic)) != 0);
+ }
+}
+
+#ifdef BOOTLOADER_DEVELOPMENT
+static void _assert_dev_reset(const boot_data_t* result)
+{
+ boot_data_t expected = _bootdata(0, 0);
+ assert_true(bootdata_hash_set(&expected));
+ assert_memory_equal(result->bytes, expected.bytes, sizeof(expected.bytes));
+ assert_memory_equal(_flash_bootdata.bytes, expected.bytes, sizeof(expected.bytes));
+ assert_memory_equal(
+ _migration_consumed_chunk + MEMORY_BOOTDATA_MIGRATION_CONSUMED_OFFSET,
+ _migration_consumed_magic,
+ sizeof(_migration_consumed_magic));
+}
+
+static void test_bootdata_dev_recovers_corrupt_floors(void** state)
+{
+ (void)state;
+ const version_t corrupt_versions[] = {0, UINT32_MAX};
+ const uint8_t markers[][MEMORY_BOOTDATA_MIGRATION_CONSUMED_LEN] = {
+ {0},
+ {0xFF, 0xFF, 0xFF, 0xFF},
+ MEMORY_BOOTDATA_MIGRATION_CONSUMED_MAGIC,
+ {0xA5, 0x5A, 0x12, 0x34}};
+ for (size_t field = 0; field < 2; field++) {
+ for (size_t i = 0; i < sizeof(corrupt_versions) / sizeof(corrupt_versions[0]); i++) {
+ for (size_t marker = 0; marker < sizeof(markers) / sizeof(markers[0]); marker++) {
+ _reset_flash();
+ memcpy(
+ _migration_consumed_chunk + MEMORY_BOOTDATA_MIGRATION_CONSUMED_OFFSET,
+ markers[marker],
+ sizeof(markers[marker]));
+ assert_true(bootdata_hash_set(&_flash_bootdata));
+ if (field == 0) {
+ _flash_bootdata.fields.signing_pubkeys_version = corrupt_versions[i];
+ } else {
+ _flash_bootdata.fields.firmware_version = corrupt_versions[i];
+ }
+ uint8_t expected_marker_chunk[CHUNK_SIZE];
+ memcpy(
+ expected_marker_chunk,
+ _migration_consumed_chunk,
+ sizeof(expected_marker_chunk));
+ memcpy(
+ expected_marker_chunk + MEMORY_BOOTDATA_MIGRATION_CONSUMED_OFFSET,
+ _migration_consumed_magic,
+ sizeof(_migration_consumed_magic));
+ boot_data_t result;
+ assert_false(bootdata_read(&result));
+ assert_int_equal(_write_calls, 0);
+ assert_true(bootdata_dev_recover(&result));
+ _assert_dev_reset(&result);
+ assert_memory_equal(
+ _migration_consumed_chunk,
+ expected_marker_chunk,
+ sizeof(expected_marker_chunk));
+ assert_int_equal(
+ _migration_consumed_writes,
+ memcmp(
+ markers[marker],
+ _migration_consumed_magic,
+ sizeof(_migration_consumed_magic)) != 0);
+ assert_int_equal(_bootdata_writes, 1);
+ assert_true(bootdata_init(&result));
+ assert_int_equal(_bootdata_writes, 1);
+ }
+ }
+ }
+}
+
+static void test_bootdata_dev_recovers_missing_or_invalid_hash(void** state)
+{
+ (void)state;
+ const uint8_t hashes[] = {0, 0xA5, UINT8_MAX};
+ for (size_t i = 0; i < sizeof(hashes); i++) {
+ _reset_flash();
+ memcpy(
+ _migration_consumed_chunk + MEMORY_BOOTDATA_MIGRATION_CONSUMED_OFFSET,
+ _migration_consumed_magic,
+ sizeof(_migration_consumed_magic));
+ _flash_bootdata.fields.signing_pubkeys_version = UINT32_MAX;
+ _flash_bootdata.fields.firmware_version = UINT32_MAX;
+ memset(_flash_bootdata.fields.versions_hash, hashes[i], SHA256_DIGEST_LENGTH);
+ boot_data_t result;
+ assert_false(bootdata_init(&result));
+ assert_int_equal(_write_calls, 0);
+ assert_true(bootdata_dev_recover(&result));
+ _assert_dev_reset(&result);
+ assert_int_equal(_migration_consumed_writes, 0);
+ assert_int_equal(_bootdata_writes, 1);
+ }
+}
+
+static void test_bootdata_dev_recovers_erased_or_uninitialized_data(void** state)
+{
+ (void)state;
+ const uint8_t fills[] = {0, 0xA5, UINT8_MAX};
+ for (size_t i = 0; i < sizeof(fills); i++) {
+ _reset_flash();
+ memset(_flash_bootdata.bytes, fills[i], sizeof(_flash_bootdata.bytes));
+ boot_data_t result;
+ assert_false(bootdata_init(&result));
+ assert_int_equal(_write_calls, 0);
+ assert_true(bootdata_dev_recover(&result));
+ _assert_dev_reset(&result);
+ }
+ for (size_t marker = 0; marker < 2; marker++) {
+ _reset_flash();
+ assert_true(bootdata_hash_set(&_flash_bootdata));
+ _flash_bootdata.fields.is_initialized[marker] = 0;
+ boot_data_t result;
+ assert_false(bootdata_init(&result));
+ assert_int_equal(_write_calls, 0);
+ assert_true(bootdata_dev_recover(&result));
+ _assert_dev_reset(&result);
+ }
+}
+
+static void test_bootdata_dev_recovers_read_errors(void** state)
+{
+ (void)state;
+ for (size_t read = 1; read <= 2; read++) {
+ _reset_flash();
+ assert_true(bootdata_hash_set(&_flash_bootdata));
+ _fail_read_call = read;
+ boot_data_t result;
+ assert_false(bootdata_init(&result));
+ assert_int_equal(_write_calls, 0);
+ assert_true(bootdata_dev_recover(&result));
+ _assert_dev_reset(&result);
+ }
+ _reset_flash();
+ assert_true(bootdata_hash_set(&_flash_bootdata));
+ _unstable_read_call = 2;
+ boot_data_t result;
+ assert_false(bootdata_init(&result));
+ assert_int_equal(_write_calls, 0);
+ assert_true(bootdata_dev_recover(&result));
+ _assert_dev_reset(&result);
+}
+
+static void test_bootdata_dev_recovers_on_api_read(void** state)
+{
+ (void)state;
+ _reset_flash();
+ assert_true(bootdata_hash_set(&_flash_bootdata));
+ boot_data_t result;
+ assert_true(bootdata_init(&result));
+ _reset_io();
+ _flash_bootdata.fields.firmware_version = UINT32_MAX;
+ assert_false(bootdata_read(&result));
+ assert_int_equal(_write_calls, 0);
+ assert_true(bootdata_dev_recover(&result));
+ _assert_dev_reset(&result);
+
+ // The replacement firmware's normal version checks now see zero floors, not corrupt highs.
+ result.fields.signing_pubkeys_version = 1;
+ result.fields.firmware_version = 1;
+ assert_true(bootdata_write(&result));
+ assert_true(bootdata_read(&result));
+ assert_int_equal(result.fields.signing_pubkeys_version, 1);
+ assert_int_equal(result.fields.firmware_version, 1);
+ assert_int_equal(_migration_consumed_writes, 0);
+}
+
+static void test_bootdata_dev_interrupted_recovery(void** state)
+{
+ (void)state;
+ const size_t cuts[] = {
+ 0,
+ FLASH_PAGE_SIZE,
+ BOOTDATA_VERSIONS_HASH_OFFSET,
+ BOOTDATA_VERSIONS_HASH_OFFSET + SHA256_DIGEST_LENGTH - 1,
+ CHUNK_SIZE};
+ for (size_t i = 0; i < sizeof(cuts) / sizeof(cuts[0]); i++) {
+ _reset_flash();
+ memcpy(
+ _migration_consumed_chunk + MEMORY_BOOTDATA_MIGRATION_CONSUMED_OFFSET,
+ _migration_consumed_magic,
+ sizeof(_migration_consumed_magic));
+ _fail_write_call = 1;
+ _cut_after_bytes = cuts[i];
+ boot_data_t result;
+ assert_false(bootdata_dev_recover(&result));
+ assert_int_equal(_bootdata_writes, 1);
+ _reset_io();
+ // No permanent panic latch: recovery can be retried after another power cut.
+ if (!bootdata_init(&result)) {
+ assert_true(bootdata_dev_recover(&result));
+ }
+ _assert_dev_reset(&result);
+ assert_true(bootdata_read(&result));
+ }
+}
+
+static void test_bootdata_dev_checks_recovery_write(void** state)
+{
+ (void)state;
+ _reset_flash();
+ memcpy(
+ _migration_consumed_chunk + MEMORY_BOOTDATA_MIGRATION_CONSUMED_OFFSET,
+ _migration_consumed_magic,
+ sizeof(_migration_consumed_magic));
+ _corrupt_write_call = 1;
+ boot_data_t result;
+ assert_false(bootdata_dev_recover(&result));
+
+ // Check both complete write readback and the final common bootdata_read() validation.
+ for (size_t read = 3; read <= 8; read++) {
+ _reset_flash();
+ memcpy(
+ _migration_consumed_chunk + MEMORY_BOOTDATA_MIGRATION_CONSUMED_OFFSET,
+ _migration_consumed_magic,
+ sizeof(_migration_consumed_magic));
+ _fail_read_call = read;
+ assert_false(bootdata_dev_recover(&result));
+ }
+
+ _reset_flash();
+ memcpy(
+ _migration_consumed_chunk + MEMORY_BOOTDATA_MIGRATION_CONSUMED_OFFSET,
+ _migration_consumed_magic,
+ sizeof(_migration_consumed_magic));
+ _sha_succeeds = false;
+ assert_false(bootdata_dev_recover(&result));
+ assert_int_equal(_write_calls, 0);
+}
+
+static void test_bootdata_dev_checks_recovery_migration_consumed(void** state)
+{
+ (void)state;
+ boot_data_t result;
+ for (size_t read = 1; read <= 6; read++) {
+ _reset_flash();
+ boot_data_t original = _flash_bootdata;
+ _fail_read_call = read;
+ assert_false(bootdata_dev_recover(&result));
+ assert_int_equal(_bootdata_writes, 0);
+ assert_memory_equal(_flash_bootdata.bytes, original.bytes, sizeof(original.bytes));
+ }
+ _reset_flash();
+ _corrupt_write_call = 1;
+ assert_false(bootdata_dev_recover(&result));
+ assert_int_equal(_bootdata_writes, 0);
+
+ // Cuts anywhere in the marker must remain retryable without reopening migration permission.
+ for (size_t cut = 0; cut <= MEMORY_BOOTDATA_MIGRATION_CONSUMED_LEN; cut++) {
+ _reset_flash();
+ boot_data_t original = _flash_bootdata;
+ _fail_write_call = 1;
+ _cut_after_bytes = MEMORY_BOOTDATA_MIGRATION_CONSUMED_OFFSET + cut;
+ assert_false(bootdata_dev_recover(&result));
+ assert_int_equal(_bootdata_writes, 0);
+ assert_memory_equal(_flash_bootdata.bytes, original.bytes, sizeof(original.bytes));
+ _reset_io();
+ assert_true(bootdata_dev_recover(&result));
+ _assert_dev_reset(&result);
+ assert_int_equal(_migration_consumed_writes, cut < MEMORY_BOOTDATA_MIGRATION_CONSUMED_LEN);
+ assert_true(bootdata_read(&result));
+ }
+}
+#endif
+
+static void test_bootdata_io_null_arguments(void** state)
+{
+ (void)state;
+ _reset_flash();
+ assert_false(bootdata_init(NULL));
+ assert_false(bootdata_read(NULL));
+ assert_false(bootdata_write(NULL));
+#ifdef BOOTLOADER_DEVELOPMENT
+ assert_false(bootdata_dev_recover(NULL));
+#endif
+ assert_int_equal(_read_calls, 0);
+ assert_int_equal(_write_calls, 0);
+}
+
+int main(void)
+{
+ const struct CMUnitTest tests[] = {
+ cmocka_unit_test(test_migration_consumed_persistent_format),
+ cmocka_unit_test(test_set_known_hash),
+ cmocka_unit_test(test_hash_check_zero),
+ cmocka_unit_test(test_hash_check_valid_and_changed_versions),
+ cmocka_unit_test(test_hash_check_nonzero_mismatches),
+ cmocka_unit_test(test_hash_failures),
+ cmocka_unit_test(test_null_arguments),
+ cmocka_unit_test(test_bootdata_init_legacy_once),
+ cmocka_unit_test(test_bootdata_init_invalid_initialization),
+ cmocka_unit_test(test_bootdata_init_accepts_nonmagic_marker),
+ cmocka_unit_test(test_bootdata_init_never_reseals_consumed_migration),
+ cmocka_unit_test(test_bootdata_init_accepts_any_hash_before_migration),
+ cmocka_unit_test(test_bootdata_init_restores_consumed_marker_before_writes),
+ cmocka_unit_test(test_bootdata_init_migration_consumed_power_cuts),
+ cmocka_unit_test(test_bootdata_init_bootdata_power_cuts),
+ cmocka_unit_test(test_bootdata_init_read_failures),
+ cmocka_unit_test(test_bootdata_init_checks_full_readback),
+ cmocka_unit_test(test_bootdata_write_power_cut),
+ cmocka_unit_test(test_bootdata_init_hash_failure),
+ cmocka_unit_test(test_bootdata_preserves_valid_data),
+#ifdef BOOTLOADER_DEVELOPMENT
+ cmocka_unit_test(test_bootdata_dev_recovers_corrupt_floors),
+ cmocka_unit_test(test_bootdata_dev_recovers_missing_or_invalid_hash),
+ cmocka_unit_test(test_bootdata_dev_recovers_erased_or_uninitialized_data),
+ cmocka_unit_test(test_bootdata_dev_recovers_read_errors),
+ cmocka_unit_test(test_bootdata_dev_recovers_on_api_read),
+ cmocka_unit_test(test_bootdata_dev_interrupted_recovery),
+ cmocka_unit_test(test_bootdata_dev_checks_recovery_write),
+ cmocka_unit_test(test_bootdata_dev_checks_recovery_migration_consumed),
+#endif
+ cmocka_unit_test(test_bootdata_io_null_arguments),
+ };
+ return cmocka_run_group_tests(tests, NULL, NULL);
+}
### test/unit-test/test_memory.c
@@ -110,7 +110,8 @@ static const memory_interface_functions_t _ifs = {
static void _expect_reset(uint8_t* empty_chunk1, uint8_t* empty_chunk2)
{
- // Reset all except first and last chunk.
+ // Reset all except first and last chunk, preserving the bootdata migration consumed marker in
+ // chunk 7.
for (uint32_t write_calls = 0; write_calls < FLASH_APP_DATA_LEN / CHUNK_SIZE - 2;
write_calls++) {
expect_value(__wrap_memory_write_chunk_fake, chunk_num, write_calls + 1);
@@ -797,6 +798,38 @@ static void _test_memory_set_attestation_certificate(void** state)
assert_true(memory_set_attestation_certificate(pubkey, certificate, root_pubkey_identifier));
}
+static void _test_memory_set_attestation_bootloader_hash_preserves_migration_consumed(void** state)
+{
+ (void)state;
+ const uint8_t markers[][MEMORY_BOOTDATA_MIGRATION_CONSUMED_LEN] = {
+ {0},
+ {0xFF, 0xFF, 0xFF, 0xFF},
+ MEMORY_BOOTDATA_MIGRATION_CONSUMED_MAGIC,
+ {0xA5, 0x5A, 0x12, 0x34}};
+ uint8_t salt[32];
+ memset(salt, 0x42, sizeof(salt));
+ for (size_t i = 0; i < sizeof(markers) / sizeof(markers[0]); i++) {
+ uint8_t chunk[CHUNK_SIZE];
+ for (size_t byte = 0; byte < sizeof(chunk); byte++) {
+ chunk[byte] = (uint8_t)byte;
+ }
+ memcpy(chunk + MEMORY_BOOTDATA_MIGRATION_CONSUMED_OFFSET, markers[i], sizeof(markers[i]));
+ expect_value(
+ __wrap_memory_read_chunk_fake, chunk_num, MEMORY_BOOTDATA_MIGRATION_CONSUMED_CHUNK);
+ will_return(__wrap_memory_read_chunk_fake, chunk);
+
+ uint8_t expected[CHUNK_SIZE];
+ memcpy(expected, chunk, sizeof(expected));
+ expected[0] = sectrue_u8;
+ memcpy(expected + 4, salt, sizeof(salt));
+ expect_value(
+ __wrap_memory_write_chunk_fake, chunk_num, MEMORY_BOOTDATA_MIGRATION_CONSUMED_CHUNK);
+ expect_memory(__wrap_memory_write_chunk_fake, chunk, expected, sizeof(expected));
+ will_return(__wrap_memory_write_chunk_fake, true);
+ assert_true(memory_set_attestation_bootloader_hash(salt));
+ }
+}
+
int main(void)
{
const struct CMUnitTest tests[] = {
@@ -832,6 +865,7 @@ int main(void)
cmocka_unit_test(_test_memory_get_stage0_version_invalid_argument),
cmocka_unit_test(_test_memory_set_attestation_device_pubkey),
cmocka_unit_test(_test_memory_set_attestation_certificate),
+ cmocka_unit_test(_test_memory_set_attestation_bootloader_hash_preserves_migration_consumed),
};
return cmocka_run_group_tests(tests, NULL, NULL);
}
### test/unit-test/test_nvmctrl.c
@@ -0,0 +1,411 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#include <setjmp.h>
+#include <stdarg.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+#include <cmocka.h>
+
+#include "memory/nvmctrl.h"
+
+#include <driver_init.h>
+#include <flags.h>
+#include <hri_nvmctrl_d51.h>
+
+fake_nvmctrl_t fake_nvmctrl;
+struct flash_descriptor FLASH_0;
+
+static uint8_t _flash[ERASE_BLOCK_SIZE];
+static uint32_t _address;
+static size_t _operation;
+static size_t _fail_operation;
+static uint16_t _error_flag;
+static uint32_t _error_types;
+static bool _return_error;
+
+// Operation order: unlock, erase, sixteen page writes, relock.
+USE_RESULT static bool _flash_operation(void)
+{
+ _operation++;
+ if (_operation == _fail_operation) {
+ fake_nvmctrl.INTFLAG.reg |= _error_flag;
+ fake_nvmctrl.ECCERR.reg |= _error_types;
+ return !_return_error;
+ }
+ return true;
+}
+
+int32_t flash_unlock(struct flash_descriptor* flash, uint32_t address, uint32_t pages)
+{
+ assert_ptr_equal(flash, &FLASH_0);
+ assert_int_equal(address, _address & ~(FLASH_REGION_PAGE_NUM * FLASH_PAGE_SIZE - 1U));
+ assert_int_equal(pages, FLASH_REGION_PAGE_NUM);
+ assert_int_equal(_operation, 0);
+ return _flash_operation() ? (int32_t)FLASH_REGION_PAGE_NUM : ERR_DENIED;
+}
+
+int32_t flash_lock(struct flash_descriptor* flash, uint32_t address, uint32_t pages)
+{
+ assert_ptr_equal(flash, &FLASH_0);
+ assert_int_equal(address, _address & ~(FLASH_REGION_PAGE_NUM * FLASH_PAGE_SIZE - 1U));
+ assert_int_equal(pages, FLASH_REGION_PAGE_NUM);
+ assert_int_equal(_operation, 2 + ERASE_BLOCK_SIZE / FLASH_PAGE_SIZE);
+ return _flash_operation() ? (int32_t)FLASH_REGION_PAGE_NUM : ERR_DENIED;
+}
+
+int32_t flash_erase(struct flash_descriptor* flash, uint32_t address, uint32_t pages)
+{
+ assert_ptr_equal(flash, &FLASH_0);
+ assert_int_equal(address, _address);
+ assert_int_equal(pages, FLASH_ERASE_PAGE_NUM);
+ assert_int_equal(_operation, 1);
+ memset(_flash, UINT8_MAX, sizeof(_flash));
+ return _flash_operation() ? ERR_NONE : ERR_DENIED;
+}
+
+int32_t flash_append(struct flash_descriptor* flash, uint32_t address, uint8_t* data, uint32_t len)
+{
+ assert_ptr_equal(flash, &FLASH_0);
+ assert_int_equal(len, FLASH_PAGE_SIZE);
+ assert_int_equal((uintptr_t)data % sizeof(uint32_t), 0);
+ const size_t offset = (_operation - 2) * FLASH_PAGE_SIZE;
+ assert_int_equal(address, _address + offset);
+ assert_true(offset + len <= ERASE_BLOCK_SIZE);
+ memcpy(_flash + offset, data, len);
+ return _flash_operation() ? ERR_NONE : ERR_DENIED;
+}
+
+static void _reset_nvmctrl(void)
+{
+ memset(&fake_nvmctrl, 0, sizeof(fake_nvmctrl));
+ fake_nvmctrl.STATUS.bit.READY = 1;
+ _operation = 0;
+ _fail_operation = 0;
+ _error_flag = 0;
+ _error_types = 0;
+ _return_error = false;
+ _address = FLASH_BOOTDATA_START;
+}
+
+static void test_clear_errors(void** state)
+{
+ (void)state;
+ _reset_nvmctrl();
+ const uint16_t error_flags = NVMCTRL_INTFLAG_ADDRE | NVMCTRL_INTFLAG_PROGE |
+ NVMCTRL_INTFLAG_LOCKE | NVMCTRL_INTFLAG_ECCSE |
+ NVMCTRL_INTFLAG_ECCDE | NVMCTRL_INTFLAG_NVME;
+ fake_nvmctrl.INTFLAG.reg = error_flags | NVMCTRL_INTFLAG_DONE;
+ fake_nvmctrl.ECCERR.reg = NVMCTRL_ECCERR_TYPEL_SINGLE | 0x1234U;
+
+ nvmctrl_clear_errors();
+
+ assert_int_equal(fake_nvmctrl.INTFLAG.reg, NVMCTRL_INTFLAG_DONE);
+ assert_int_equal(fake_nvmctrl.ECCERR.reg, 0);
+ assert_int_equal(fake_nvmctrl.eccerr_reads, 1);
+}
+
+static void test_check_no_errors(void** state)
+{
+ (void)state;
+ _reset_nvmctrl();
+
+ assert_true(nvmctrl_wait_ready_and_check_errors());
+ assert_int_equal(fake_nvmctrl.eccerr_reads, 1);
+}
+
+static void test_check_each_error_flag(void** state)
+{
+ (void)state;
+ const uint16_t error_flags[] = {
+ NVMCTRL_INTFLAG_ADDRE,
+ NVMCTRL_INTFLAG_PROGE,
+ NVMCTRL_INTFLAG_LOCKE,
+ NVMCTRL_INTFLAG_ECCDE,
+ NVMCTRL_INTFLAG_NVME,
+ };
+
+ for (size_t i = 0; i < sizeof(error_flags) / sizeof(error_flags[0]); i++) {
+ for (size_t corrected = 0; corrected < 2; corrected++) {
+ _reset_nvmctrl();
+ fake_nvmctrl.INTFLAG.reg = error_flags[i];
+ if (corrected) {
+ fake_nvmctrl.INTFLAG.reg |= NVMCTRL_INTFLAG_ECCSE;
+ fake_nvmctrl.ECCERR.reg = NVMCTRL_ECCERR_TYPEL_SINGLE | NVMCTRL_ECCERR_TYPEH_SINGLE;
+ }
+
+ assert_false(nvmctrl_wait_ready_and_check_errors());
+ assert_int_equal(fake_nvmctrl.INTFLAG.reg, 0);
+ assert_int_equal(fake_nvmctrl.ECCERR.reg, 0);
+ assert_int_equal(fake_nvmctrl.eccerr_reads, 1);
+ }
+ }
+}
+
+static void test_check_ecc_types_and_flags(void** state)
+{
+ (void)state;
+ const uint32_t low_types[] = {
+ NVMCTRL_ECCERR_TYPEL_NONE,
+ NVMCTRL_ECCERR_TYPEL_SINGLE,
+ NVMCTRL_ECCERR_TYPEL_DUAL,
+ NVMCTRL_ECCERR_TYPEL_Msk, // Unexpected type 3.
+ };
+ const uint32_t high_types[] = {
+ NVMCTRL_ECCERR_TYPEH_NONE,
+ NVMCTRL_ECCERR_TYPEH_SINGLE,
+ NVMCTRL_ECCERR_TYPEH_DUAL,
+ NVMCTRL_ECCERR_TYPEH_Msk, // Unexpected type 3.
+ };
+ const uint16_t flags[] = {
+ 0,
+ NVMCTRL_INTFLAG_ECCSE,
+ NVMCTRL_INTFLAG_ECCDE,
+ NVMCTRL_INTFLAG_ECCSE | NVMCTRL_INTFLAG_ECCDE,
+ };
+
+ for (size_t low = 0; low < sizeof(low_types) / sizeof(low_types[0]); low++) {
+ for (size_t high = 0; high < sizeof(high_types) / sizeof(high_types[0]); high++) {
+ for (size_t flag = 0; flag < sizeof(flags) / sizeof(flags[0]); flag++) {
+ _reset_nvmctrl();
+ fake_nvmctrl.ECCERR.reg = low_types[low] | high_types[high];
+ fake_nvmctrl.INTFLAG.reg = flags[flag];
+ // Only NONE/SINGLE in both halves, without ECCDE, may succeed.
+ assert_int_equal(
+ nvmctrl_wait_ready_and_check_errors(), low < 2 && high < 2 && flag < 2);
+ assert_int_equal(fake_nvmctrl.INTFLAG.reg, 0);
+ assert_int_equal(fake_nvmctrl.ECCERR.reg, 0);
+ assert_int_equal(fake_nvmctrl.eccerr_reads, 1);
+ }
+ }
+ }
+}
+
+static void test_check_ignores_non_errors(void** state)
+{
+ (void)state;
+ _reset_nvmctrl();
+ fake_nvmctrl.INTFLAG.reg = NVMCTRL_INTFLAG_DONE;
+ fake_nvmctrl.ECCERR.reg = 0x00123450U;
+
+ assert_true(nvmctrl_wait_ready_and_check_errors());
+ assert_int_equal(fake_nvmctrl.INTFLAG.reg, NVMCTRL_INTFLAG_DONE);
+}
+
+static void test_read(void** state)
+{
+ (void)state;
+ _reset_nvmctrl();
+ const uint8_t flash[] = {1, 2, 3, 4, 5};
+ uint8_t readback[sizeof(flash)] = {0};
+ assert_true(nvmctrl_read(flash, readback, sizeof(flash)));
+ assert_memory_equal(readback, flash, sizeof(flash));
+ // One ECCERR read before the operation, one when checking its result.
+ assert_int_equal(fake_nvmctrl.eccerr_reads, 2);
+}
+
+static void test_read_errors(void** state)
+{
+ (void)state;
+ const uint16_t flags[] = {
+ NVMCTRL_INTFLAG_ADDRE,
+ NVMCTRL_INTFLAG_PROGE,
+ NVMCTRL_INTFLAG_LOCKE,
+ NVMCTRL_INTFLAG_NVME,
+ NVMCTRL_INTFLAG_ECCDE,
+ };
+ const uint8_t flash[] = {1, 2, 3};
+ uint8_t readback[sizeof(flash)];
+ for (size_t i = 0; i < sizeof(flags) / sizeof(flags[0]); i++) {
+ for (size_t corrected = 0; corrected < 2; corrected++) {
+ _reset_nvmctrl();
+ // Inject an error after stale flags are cleared and the flash read has finished.
+ fake_nvmctrl.flags_on_ready = flags[i];
+ if (corrected) {
+ fake_nvmctrl.flags_on_ready |= NVMCTRL_INTFLAG_ECCSE;
+ fake_nvmctrl.eccerr_on_ready =
+ NVMCTRL_ECCERR_TYPEL_SINGLE | NVMCTRL_ECCERR_TYPEH_SINGLE;
+ }
+ assert_false(nvmctrl_read(flash, readback, sizeof(readback)));
+ assert_memory_equal(readback, flash, sizeof(flash));
+ assert_int_equal(fake_nvmctrl.INTFLAG.reg, 0);
+ assert_int_equal(fake_nvmctrl.ECCERR.reg, 0);
+ }
+ }
+}
+
+static void test_read_correctable_ecc(void** state)
+{
+ (void)state;
+ const uint32_t types[] = {
+ NVMCTRL_ECCERR_TYPEL_NONE | NVMCTRL_ECCERR_TYPEH_NONE,
+ NVMCTRL_ECCERR_TYPEL_SINGLE,
+ NVMCTRL_ECCERR_TYPEH_SINGLE,
+ NVMCTRL_ECCERR_TYPEL_SINGLE | NVMCTRL_ECCERR_TYPEH_SINGLE,
+ };
+ const uint8_t flash[] = {1, 2, 3};
+ uint8_t readback[sizeof(flash)];
+ for (size_t i = 0; i < sizeof(types) / sizeof(types[0]); i++) {
+ for (size_t flagged = 0; flagged < 2; flagged++) {
+ _reset_nvmctrl();
+ fake_nvmctrl.flags_on_ready = flagged ? NVMCTRL_INTFLAG_ECCSE : 0;
+ fake_nvmctrl.eccerr_on_ready = types[i];
+ assert_true(nvmctrl_read(flash, readback, sizeof(readback)));
+ assert_memory_equal(readback, flash, sizeof(flash));
+ assert_int_equal(fake_nvmctrl.INTFLAG.reg, 0);
+ assert_int_equal(fake_nvmctrl.ECCERR.reg, 0);
+ assert_int_equal(fake_nvmctrl.eccerr_reads, 2);
+ }
+ }
+}
+
+static void test_read_block_checked(void** state)
+{
+ (void)state;
+ _reset_nvmctrl();
+ for (size_t i = 0; i < sizeof(_flash); i++) {
+ _flash[i] = (uint8_t)i;
+ }
+ uint8_t readback[ERASE_BLOCK_SIZE];
+ assert_true(nvmctrl_read_block_checked((uintptr_t)_flash, readback));
+ assert_memory_equal(readback, _flash, sizeof(readback));
+ assert_int_equal(fake_nvmctrl.eccerr_reads, 4);
+}
+
+static void _read_block_error(void)
+{
+ _operation++;
+ if (_operation == _fail_operation) {
+ fake_nvmctrl.INTFLAG.reg |= NVMCTRL_INTFLAG_ECCDE;
+ fake_nvmctrl.ECCERR.reg |= NVMCTRL_ECCERR_TYPEL_DUAL;
+ }
+}
+
+static void test_read_block_checked_errors(void** state)
+{
+ (void)state;
+ uint8_t readback[ERASE_BLOCK_SIZE];
+ for (size_t read = 1; read <= 2; read++) {
+ _reset_nvmctrl();
+ _fail_operation = read;
+ fake_nvmctrl.on_ready = _read_block_error;
+ assert_false(nvmctrl_read_block_checked((uintptr_t)_flash, readback));
+ assert_int_equal(_operation, read);
+ }
+}
+
+static void _change_flash_after_read(void)
+{
+ _flash[ERASE_BLOCK_SIZE - 1] ^= 1;
+ fake_nvmctrl.on_ready = NULL;
+}
+
+static void test_read_block_checked_mismatch(void** state)
+{
+ (void)state;
+ _reset_nvmctrl();
+ fake_nvmctrl.on_ready = _change_flash_after_read;
+ uint8_t readback[ERASE_BLOCK_SIZE];
+ assert_false(nvmctrl_read_block_checked((uintptr_t)_flash, readback));
+ assert_int_equal(fake_nvmctrl.eccerr_reads, 4);
+}
+
+static void test_write_block(void** state)
+{
+ (void)state;
+ uint8_t chunk[ERASE_BLOCK_SIZE];
+ for (size_t i = 0; i < sizeof(chunk); i++) {
+ chunk[i] = (uint8_t)i;
+ }
+ const uint32_t addresses[] = {FLASH_BOOTDATA_START, FLASH_APPDATA_START + 7 * ERASE_BLOCK_SIZE};
+ for (size_t i = 0; i < sizeof(addresses) / sizeof(addresses[0]); i++) {
+ _reset_nvmctrl();
+ _address = addresses[i];
+ assert_true(nvmctrl_write_block(_address, chunk));
+ assert_int_equal(_operation, 3 + ERASE_BLOCK_SIZE / FLASH_PAGE_SIZE);
+ assert_memory_equal(_flash, chunk, sizeof(chunk));
+ assert_int_equal(fake_nvmctrl.eccerr_reads, 2 * _operation);
+ }
+}
+
+static void test_write_block_errors(void** state)
+{
+ (void)state;
+ const uint8_t chunk[ERASE_BLOCK_SIZE] = {0};
+ const uint16_t flags[] = {
+ 0, // HAL error without any NVM flag
+ NVMCTRL_INTFLAG_ADDRE,
+ NVMCTRL_INTFLAG_PROGE,
+ NVMCTRL_INTFLAG_LOCKE,
+ NVMCTRL_INTFLAG_NVME,
+ NVMCTRL_INTFLAG_ECCDE,
+ };
+ for (size_t operation = 1; operation <= 3 + ERASE_BLOCK_SIZE / FLASH_PAGE_SIZE; operation++) {
+ for (size_t flag = 0; flag < sizeof(flags) / sizeof(flags[0]); flag++) {
+ for (size_t corrected = 0; corrected < 2; corrected++) {
+ _reset_nvmctrl();
+ _fail_operation = operation;
+ _return_error = flags[flag] == 0;
+ _error_flag = flags[flag];
+ if (corrected) {
+ _error_flag |= NVMCTRL_INTFLAG_ECCSE;
+ _error_types = NVMCTRL_ECCERR_TYPEL_SINGLE | NVMCTRL_ECCERR_TYPEH_SINGLE;
+ }
+ assert_false(nvmctrl_write_block(_address, chunk));
+ assert_int_equal(_operation, operation);
+ assert_int_equal(fake_nvmctrl.INTFLAG.reg, 0);
+ assert_int_equal(fake_nvmctrl.ECCERR.reg, 0);
+ }
+ }
+ }
+}
+
+static void test_write_block_correctable_ecc(void** state)
+{
+ (void)state;
+ const uint8_t chunk[ERASE_BLOCK_SIZE] = {0};
+ for (size_t operation = 1; operation <= 3 + ERASE_BLOCK_SIZE / FLASH_PAGE_SIZE; operation++) {
+ _reset_nvmctrl();
+ _fail_operation = operation;
+ _error_flag = NVMCTRL_INTFLAG_ECCSE;
+ _error_types = NVMCTRL_ECCERR_TYPEL_SINGLE | NVMCTRL_ECCERR_TYPEH_SINGLE;
+ assert_true(nvmctrl_write_block(_address, chunk));
+ assert_int_equal(_operation, 3 + ERASE_BLOCK_SIZE / FLASH_PAGE_SIZE);
+ assert_memory_equal(_flash, chunk, sizeof(chunk));
+ assert_int_equal(fake_nvmctrl.INTFLAG.reg, 0);
+ assert_int_equal(fake_nvmctrl.ECCERR.reg, 0);
+ }
+}
+
+static void test_write_block_invalid_arguments(void** state)
+{
+ (void)state;
+ _reset_nvmctrl();
+ const uint8_t chunk[ERASE_BLOCK_SIZE] = {0};
+ assert_false(nvmctrl_write_block(FLASH_BOOTDATA_START, NULL));
+ assert_false(nvmctrl_write_block(FLASH_BOOTDATA_START + 1, chunk));
+ assert_false(nvmctrl_write_block(FLASH_SIZE, chunk));
+ assert_int_equal(_operation, 0);
+}
+
+int main(void)
+{
+ const struct CMUnitTest tests[] = {
+ cmocka_unit_test(test_clear_errors),
+ cmocka_unit_test(test_check_no_errors),
+ cmocka_unit_test(test_check_each_error_flag),
+ cmocka_unit_test(test_check_ecc_types_and_flags),
+ cmocka_unit_test(test_check_ignores_non_errors),
+ cmocka_unit_test(test_read),
+ cmocka_unit_test(test_read_errors),
+ cmocka_unit_test(test_read_correctable_ecc),
+ cmocka_unit_test(test_read_block_checked),
+ cmocka_unit_test(test_read_block_checked_errors),
+ cmocka_unit_test(test_read_block_checked_mismatch),
+ cmocka_unit_test(test_write_block),
+ cmocka_unit_test(test_write_block_errors),
+ cmocka_unit_test(test_write_block_correctable_ecc),
+ cmocka_unit_test(test_write_block_invalid_arguments),
+ };
+ return cmocka_run_group_tests(tests, NULL, NULL);
+}Why this scored 60/100
Community notes
Notes can correct, qualify, or add evidence to the AI analysis. Every note shown here has been validated by a human moderator.
The AI analysis stands alone for now. Submit a note if you can add evidence or important context.