Menu

Secure Boot

Secure Boot: The Chain of Trust That Starts Before Your Code Runs

Notes · FirmwareNovember 19, 202622 min readSenova Systems Research

A device cannot verify its own first instruction with software. The chain starts in immutable ROM, each stage verifies a signature on the next, and a monotonic counter in fuses refuses every old image, even one signed with your own key. The CRA's main obligations apply from 11 December 2027, and its reporting duty is already live.

Example Labs is a made-up company we use for worked examples.

Picture the hub from the earlier articles, Example Labs' field sensor hub, the little box on the warehouse wall, reporting temperature and vibration over BLE. It has been in the field for two years. Tonight, at 2 a.m., it downloads a firmware update.

The update is signed with Example Labs' real signing key, and the signature verifies perfectly. The hub installs it. The update is version 1.3.0, the version from eighteen months ago, the one with the remote code execution bug that version 1.4.0 fixed.

The attacker who sent it did not break any cryptography. They did not steal a key. They took an old file off a public server and replayed it, and the hub's secure boot, which was working exactly as designed, said yes.

That is the story this article is about. Secure boot is the most misunderstood control in embedded engineering: teams treat it as a checkbox, enable it, pass a demo on a lab bench, and ship a device that is secure against exactly one attacker, the one who tries to run unsigned code. The real attackers do not try to run unsigned code.

They run old signed code, or code signed with a key they stole from a laptop, or code that the signature never covered in the first place. This article builds the chain properly, from the first instruction to the key-leak plan, and shows what it costs in time, flash, and fuses on a real device.

The problem

A device cannot verify its own first instruction with software, because any software-based check can itself be replaced by an attacker who controls where that software lives. If the check is "does this firmware look right?", and the check itself is stored in the same flash the attacker can rewrite, then the attacker rewrites the check first and the firmware second, and the device boots the attacker's code while the check reports that everything is fine.

This is not a subtle point. It is the reason secure boot has to start in hardware.

The chain starts from an immutable root of trust, code burned into the chip at manufacturing, in mask ROM, that cannot be changed afterwards. ROM contents cannot normally be modified after manufacturing, so the code stored there acts as the first trusted software executed during startup (Noxtls). The root of trust is the one link you cannot verify; you trust it by construction (AC6).

It holds, or knows how to find, the hash of the product manufacturer's public key. Everything after it is verified software, and everything before it does not exist.

A root of trust is a component the system trusts without verification. A chain of trust is the sequence that follows: each stage verifies the next before handing over execution, and a failure at any link halts the boot. The OTP fuses, one-time programmable memory, are where the root public key (or, to save scarce fuses, only its SHA-256 hash) is stored.

Once written, it cannot be changed. You never store the full public key in OTP, only its hash, to save fuses; the full key lives in the firmware header, and the ROM checks that its hash matches (AC6). A hash is a fingerprint of data: change one byte of the image and the hash changes completely.

A digital signature is that hash, encrypted with a private key, so that anyone with the public key can check both that the image is unmodified and that it came from the holder of the private key. SHA-256 is the hash. ECDSA P-256, Ed25519, and RSA-2048+ are the signature schemes, ECDSA P-256 is the present-day standard (FIPS 186-5), Ed25519 is the faster modern alternative, RSA-PSS 3072/4096 remains in legacy systems, and for new firmware-signing roots with 15–20-year lifetimes the automotive guides now recommend post-quantum hash-based signatures (LMS, XMSS, SLH-DSA) (Agnile).

The typical chain on a microcontroller has four stages: an immutable ROM, a first-stage bootloader, a second-stage bootloader, and the application image. Each stage verifies the signature of the next against a public key it inherited from the stage above. The root of the chain is a public key fused into one-time-programmable storage at silicon manufacture and read by ROM at every power-on (Agnile).

On a phone, the same shape runs larger: 64–128 KB of Boot ROM reads a 256-bit SHA-256 hash of a 2048/3072-bit RSA or ECDSA P-384 public key from eFuses, then verifies the first mutable bootloader before it runs (Jones Consortium). If the fuses are still zero, an unfused engineering device, it boots anything, a state attackers hunt for on development boards. That is the first rule of the whole subject: the chain is only as strong as the provisioning step that burns the key.

A device that ships unfused has no secure boot at all, whatever the datasheet says.

The chain of trust: each stage checks the next stage's signature; any failure halts the boot or falls back to a signed recovery image

StageRole
Mask ROMImmutable, set at manufacture; the only stage trusted without a check
First-stage bootloaderLocked by a one-time fuse
MCUbootVerifies the application, enforces anti-rollback, selects the slot
ApplicationSigned, versioned, counter-checked
RTOSThe runtime the chain hands over to; TrustZone isolates it

What a signature proves, and what it does not

A valid signature proves exactly one narrow thing: that a holder of an accepted private key authorized some specific byte string at some point (0x434b). That sentence is the whole security model, and everything people get wrong about secure boot is a failure to read it carefully. A valid signature does not prove that every byte the loader later consumes was inside that signed string, a signature covers one specific range, so any header field, metadata, or second payload that sits outside it was never authorized.

It does not prove the signer meant this image for this chip and this lifecycle, the same valid signature could belong to a different product, or to a development build that should never run on a shipped device. It does not prove the image is current, an old build stays bit-for-bit authentic forever, even after a newer version patches a hole in it. It does not prove the caller actually acted on the result, or that the verified buffer stayed put until execution, or that the signed code is safe.

And it does not prove the firmware is secret: signatures authenticate, they do not encrypt, so anyone can still read the image straight off the flash.

The U-Boot history is the case study for the first of those gaps. In U-Boot before v2026.04, configuration-signature verification could be bypassed because verification trusted the hashed-nodes property even though that property was not itself covered by the signature, a crafted FIT could mislead verification about what was actually being checked (CVE-2026-46728, fixed in v2026.04; the same class of flaw was disclosed in 2020, when U-Boot did not verify that the contents of hashed-nodes correlated with the sub-images a configuration actually required).

The fix changed verification so U-Boot rebuilds the node list from the selected configuration's image references instead of trusting hashed-nodes. The lesson is general: verification is only as good as what the signature covers, and the list of what it covers is itself part of the design. If the signature covers the kernel but not the device tree, the device tree is unsigned.

If it covers the image but not the version, the version is unsigned. If it covers the image but not the product identity, the image can be transplanted to another product.

The defence is not more cryptography. It is a checklist, applied to every field the boot stage consumes: image type, hardware target, load range, lifecycle, debug policy, version, rollback floor, and whether this path is permitted in production. Each one is either inside the signed string or it is not, and the ones that are not are the attack surface.

Anti-rollback: signing proves where it came from, not when

The opening story is the anti-rollback problem, and it is the most common omission in shipped secure boot (AC6). Signing proves an image came from you. It does not prove it is the latest.

An old, correctly signed, known-vulnerable image will verify perfectly well, the signature is valid, the chain of trust sees nothing wrong, so an attacker who can supply an old image can reinstall the vulnerability you already fixed. The countermeasure is a monotonic counter in non-reversible storage: a number that only ever goes up, stored in OTP fuses (or a secure-element or TF-M-protected counter), recording the minimum acceptable version. The bootloader refuses any image whose security counter is below the stored value.

MCUboot, the bootloader this article uses throughout, offers two forms. MCUBOOT_DOWNGRADE_PREVENTION compares image versions: the bootloader rejects an update whose version is lower than the currently booted firmware (nRF Connect SDK; CONFIG_MCUBOOT_DOWNGRADE_PREVENTION, with SB_CONFIG_MCUBOOT_MODE_OVERWRITE_ONLY in sysbuild, and the overwrite-only mode means there is no fallback recovery of application images, a trade the article returns to below). MCUBOOT_HW_ROLLBACK_PROT compares a security counter in the image's protected TLVs against a monotonic counter in protected storage: boot the image only if image.security_counter >= device.security_counter, and on confirm set the device counter to the maximum of the two (Kalapi; SoftwareSecurity).

The signing command carries both numbers: imgtool sign --version 1.4.0 --security-counter 5, and the two flags carry different semantics. --version is the image version, used for software downgrade prevention and for humans. --security-counter is the rollback counter burned into the protected TLVs. You bump it only when you want to permanently close the door on every prior firmware, typically when fixing a security bug serious enough that you never want a device to run the vulnerable version again (Kalapi).

Two cautions, both verified in the checked guides, and both easy to get wrong in exactly the way that bricks devices. First, the security version must be separate from the product version: increment it only on a security fix, otherwise you exhaust the available fuses within two years (AC6). Second, the counter must only be advanced after confirming that the new image boots and works, never before, otherwise a failed update permanently blocks the return to a working version (AC6; SoftwareSecurity).

The failure mode is precise: if the counter jumps to 13 before an unsuccessful version 13 trial, the confirmed version 12 fallback becomes forbidden, and the device is stranded. Android Verified Boot handles this by updating its stored rollback indexes only from slots marked successful, on the first boot after the slot succeeded. The rule for MCUboot is the same: advance the irreversible floor only after confirmation.

Secure boot and TrustZone are orthogonal

Three concepts get blurred together constantly, secure boot, TrustZone, and secure firmware update, and the blurring is where designs go wrong (Kalapi). Secure boot answers one question at reset: is the code I am about to run authentic and unmodified? It is a chain that starts from an immutable root of trust and verifies a cryptographic signature over each image before transferring control to it.

If verification fails, the device refuses to run the image. Secure boot is a boot-time, one-shot property. It says nothing about what happens after main() starts.

TrustZone is a runtime isolation mechanism. On a Cortex-M33/M23/M55/M85, the silicon partitions memory and peripherals into a Secure and a Non-secure world, with hardware-enforced boundaries (the SAU and IDAU decide which addresses are secure). Non-secure code physically cannot read secure memory; it can only call into the secure world through a narrow, controlled set of entry points. TrustZone is about protecting secrets and critical services while the device is running, keeping your device private key, your crypto engine, and your secure storage out of reach of a compromised application.

Secure boot and TrustZone are orthogonal. You can have one without the other. An STM32H7 (Cortex-M7) has no TrustZone-M; you can still build a perfectly solid secure boot chain on it, and what you do not get is hardware runtime isolation of your keys from your application. An STM32U5 or nRF5340 (Cortex-M33) gives you both: secure boot brings up a Secure world that then keeps your keys isolated for the entire runtime. If you remember one thing from this section: secure boot proves the code is genuine; TrustZone keeps the code honest after it starts. They solve different problems. The research literature agrees: TrustZone alone does not provide complete secure boot, runtime integrity protection, or remote attestation, and the trust chain stops after static verification, achieving end-to-end trust requires the boot mechanism and runtime integrity protection that continuously verifies the executing software (PDRIMA, arXiv 2512.06500).

The third concept, secure firmware update, is the subject of Article #11, and the relationship is one-directional: secure boot is a prerequisite, it is what verifies the downloaded image, but the update problem adds its own hard parts: partitioning, atomic swap, confirm/revert, and rollback protection (Kalapi). The update arrives over a transport that is itself untrusted; transport security protects the image in flight, and the bootloader signature check is the one gate the attacker cannot walk around without your private key.

DICE: the chain that also gives the device an identity

There is a second chain worth knowing about, because it answers a question secure boot does not ask: not "is this code genuine?" but "which device is this, and what code is it running right now?" DICE, the Device Identifier Composition Engine, is the Trusted Computing Group's lightweight hardware root-of-trust architecture, released in September 2017, for exactly the devices where a full TPM is impractical (TCG). A TPM is a dedicated security chip; most low-cost IoT silicon cannot afford one, in cost, in power, or in board area.

DICE needs only a small immutable code region and a hardware secret, a Unique Device Secret (UDS), a per-device random secret fused in hardware at manufacturing, never accessible to software, used only by the DICE engine during reset.

The mechanism: each boot layer measures the next and derives a unique secret for it. The DICE engine computes a Compound Device Identifier (CDI) from the UDS and the hash of the first mutable firmware, then each layer derives a DeviceID key pair (this device plus this ROM, stable across firmware updates) and an Alias key pair (this device plus this ROM plus this layer, which changes if that layer's firmware is updated).

Each layer wipes its secrets before passing control to the next: the hardware wipes the UDS after computing the CDI, and layer 0 wipes the CDI after computing the DeviceID and Alias keys. The result is an identity that is bound to the device and to the firmware it is running: if firmware changes, the identity changes, and any unauthorised modification is detectable from the certificates the device presents. And because the identity is derived from the measurement, patching the code automatically re-keys the device, a secret disclosed through a vulnerability is protected by the legitimate keys after the patch, because the patch changes the measurement and therefore the keys (TCG; Security Ledger).

DICE is supported in products from TCG members including STMicroelectronics' STM32L0/L4 family, Micron's Authenta-based flash, and Microchip's CEC1702. For the Example Labs hub, DICE is the answer to the question the CRA will ask in the field: not just "is the firmware signed?" but "prove, remotely, that this device is running the patched version", which is remote attestation, built on the same chain.

The four questions

The pipeline for this article states the test plainly, and the checked guides confirm every part of it: the four questions that decide whether a secure boot is a defence or a decoration are who may sign? what may run? what may never run again? and what happens when a key leaks? Each one has a wrong answer that is common in shipped products.

Who may sign? The root key lives offline, in a hardware security module, and never leaves it. It signs intermediate signing keys; the devices store the root public key hash, and the boot images carry a certificate chain to a short-lived image-signing key (Ampheo). The private key must never leave an HSM or a signing service. A private key in a Git repository, even a private one, compromises the whole product range for the rest of its support life (AC6). And the single most common catastrophic mistake in the MCUboot world: shipping with the default MCUboot signing key. That private key is in every copy of the MCUboot repository on Earth (Kalapi). A device that verifies against the default key will happily boot any image signed by anyone who downloaded the repository.

What may run? Only images signed by the current intermediate key, for this product, for this lifecycle, at or above the rollback floor, and the product, lifecycle, and version fields must be inside the signed string, not beside it. Development builds, factory test images, and images for a different product must all fail the check, because the signature that authorises them is real and the device is the thing that has to say no.

What may never run again? Every image below the security counter. The counter is bumped only on security fixes, and only after the new image has confirmed itself in the field.

What happens when a key leaks? This is the question most designs never answer, and it is the one the CRA makes unavoidable. The answer depends on which key. If an intermediate signing key leaks, you revoke it: the next signed image carries a revocation list, the devices stop trusting that intermediate, and the fleet re-keys on the next update. If the root key leaks, there is no software fix, the root hash is burned into OTP fuses and cannot be changed, so every device in the field will trust attacker-signed images for the rest of its life. The only remedies are a pre-provisioned second root slot (a second key hash burned at manufacture, dormant until the first is revoked) or new hardware. That is a design decision made at the provisioning bench, years before the leak, and it cannot be made afterwards. Secure boot is not a checkbox; it is a supply chain contract that binds together every party who can influence what code runs on a device, silicon vendors, ODMs, firmware teams, operating system builders, update services, and even repair centres, and the common failure modes are all outside the cryptography: keys shared across product lines so a single leak becomes a fleet-wide compromise, signing on developer laptops or generic CI runners, debug ports left enabled, recovery images and factory tools not secured to the same standard, and revocation absent so that even a known-compromised key cannot be dealt with without a physical recall (QVLx).

The clock: the Cyber Resilience Act

The EU Cyber Resilience Act, Regulation (EU) 2024/2847, entered into force on 10 December 2024. Its reporting obligations have applied since 11 September 2026, manufacturers must report actively exploited vulnerabilities and severe incidents: an early warning within 24 hours of becoming aware, a fuller notification within 72 hours, and a final report within 14 days after a fix is available, through ENISA's Single Reporting Platform, and the reporting duty applies to products already on the market, including products placed on the market before 11 December 2027. The main obligations apply from 11 December 2027: the essential requirements, the conformity assessment, and CE marking against the CRA, with fines of up to €15 million or 2.5% of total worldwide annual turnover, whichever is higher, for breaching the essential requirements or the manufacturer duties.

The support period is at least five years unless the product's expected use is shorter, and the basis must be recorded in the technical documentation (European Commission; TuxCare; CASRAI).

For the hub, that clock reads: the reporting duty has been live for 69 days already, and the main obligations arrive in 387 days. A device designed this year, shipping next year, will spend its whole five-year support period under the CRA. Secure boot is not one of the CRA's named requirements in so many words, the Regulation sets outcomes, not tools, but a product that cannot prove what code is running, cannot refuse an old image, and cannot be updated securely cannot meet the Annex I essential requirements, and cannot be reported on when a vulnerability is exploited in the field.

The chain of trust is the mechanism by which the outcomes become demonstrable.

the Example Labs hub, secured

The hub, from the cluster: STM32H7, 2 MB flash, 512 kB SRAM, 48 MHz clock, BLE radio, CR2032 cell (230 mAh, 2,484 J). The firmware image is 384 KiB. The demo is the article's own worked example; the arithmetic was run in Python before writing, and the crypto timings are a guide's figures (embedded-ace, Cortex-M4 at 80 MHz), scaled where the clock differs and labelled as such.

Step 1, what verification costs at boot. Two operations, both on the critical path before the application runs. Hashing the 384 KiB image with SHA-256: at 30 cycles per byte in software on the 48 MHz clock, 245.8 ms; with the hardware accelerator at 3 cycles per byte, 24.6 ms. Verifying the ECDSA P-256 signature: the guide's figure is ~200 ms in software at 80 MHz, which scales to ~333 ms at the hub's 48 MHz; with the hardware accelerator, ~15 ms. Total: 579 ms in software, 40 ms with the accelerator, a 14.6× difference. Half a second of boot time, every boot, against forty milliseconds. On a device that wakes, measures, transmits, and sleeps, half a second of full-power CPU before the first measurement is not a cosmetic cost, it is energy, and on a CR2032 cell energy is the budget. The hardware accelerator is not a luxury. It is the thing that makes the security affordable.

Step 2, what the chain costs in flash. MCUboot plus two 384 KiB slots: 768 KiB of image plus 64 KiB for the bootloader is 40.6% of the 2 MB flash. That is the price of the A/B partitioning from Article #11, the guarantee that at every instant, including a power failure mid-swap, at least one complete bootable image exists. The alternative, overwrite-only, costs one slot instead of two, and it costs the fallback: with MCUBOOT_DOWNGRADE_PREVENTION in overwrite-only mode, there is no recovery of the application image if the new one fails. The flash budget and the recovery budget are the same decision.

Step 3, the rollback attack, worked. The hub ships version 1.3.0 with security counter 2. Version 1.4.0 fixes a remote code execution bug and is signed with security counter 3. An attacker replays 1.3.0: the signature verifies, it is Example Labs' real signature, on Example Labs' real image, and without the counter the hub would boot it and the vulnerability would be live again. With MCUBOOT_HW_ROLLBACK_PROT, the bootloader compares the image's counter (2) against the device's stored floor (3) and refuses. The attack fails at the counter, not at the signature, which is the whole point: the signature was never the defence against this attacker. The fuse budget: over five years the hub will ship 28 product releases, but only 3 of them fix security bugs. If the security counter tracked the product version, 28 fuses would burn; tracking security fixes only, 3 burn, a 9.3:1 saving, and the difference between a counter that lasts the product's life and one that is exhausted in two years. And the ordering rule: the floor advances to 3 only after 1.4.0 has confirmed itself in the field. If it advanced before confirmation and 1.4.0 failed its health check, the hub could not return to 1.3.0, and a field device with no working image is a brick, not a security win.

Step 4, the key-leak table, for this hub. Who may sign: the offline root in an HSM, signing a short-lived intermediate; the devices store the root hash in OTP. What may run: images signed by the current intermediate, for this hub, for the production lifecycle, at security counter 3 or above, with the product, lifecycle, and counter fields inside the signed TLVs. What may never run again: 1.3.0 and everything below counter 3. What happens when a key leaks: the intermediate is revoked in the next image's revocation list, and the fleet re-keys on the next update; the root, if it leaks, cannot be revoked, the hash is fused, so the design carries a second root slot, burned at manufacture and dormant, or accepts that a root leak means new hardware. That last line is the one that has to be decided at the provisioning bench, before the first device ships, because afterwards it is not a decision any more.

The decision test

Five questions, before the next firmware release is signed.

  1. What is the first instruction your device executes, and can it be changed? If the answer is "code in flash", there is no chain of trust, there is a hope. The first instruction must be mask ROM or a first-stage bootloader locked by a one-time fuse.
  2. Where does the root public key hash live, and who can replace it? If it lives in flash, or in option bytes that software can rewrite, the chain is decorative. It belongs in OTP fuses, and the provisioning step that burns it must be the most controlled step in manufacturing, because a provisioning mistake turns the board into a paperweight, and a skipped step ships a device that boots anything.
  3. What happens when you replay the previous release? Take the last version, sign it correctly, and try to install it. If it boots, there is no anti-rollback protection, and every vulnerability you have ever fixed is still exploitable in the field.
  4. What happens when a key leaks? Name the key, name the revocation path, and name the blast radius. If the answer is "we would have to recall the fleet", the design is missing a second root slot or a revocation list, and the time to add one is before the leak, not after.
  5. Is the signing key in the repository? If the private key, or the default MCUboot key, is anywhere a developer can reach it, a Git repo, a CI runner, a laptop, the whole product range is compromised for the rest of its support life, and the chain of trust is a story the team tells itself.

Objections

"Secure boot slows the boot too much." Half a second in software, forty milliseconds with the accelerator, on the hub's numbers. The accelerator exists on the silicon you already bought. The cost is a configuration choice, not a law of nature, and the cost of not verifying is the device running whatever it was handed.

"We don't need it, nobody is going to attack our little sensor." The attacker does not care about your sensor. They care about the network it is on, the credentials it holds, and the 2,000 identical devices that share its key. The CRA does not care about your threat model either: it cares about the support period, the reporting duty, and the update mechanism, and all three assume the device can prove what it is running.

"We already have TrustZone." TrustZone keeps the code honest after it starts. It does not prove the code is genuine. A compromised application running in the Non-secure world is still a compromised application, and without secure boot, the Secure world itself is whatever was loaded into it. The two are orthogonal, and you need both.

"We'll add it in the next hardware revision." Secure boot is a provisioning decision, not a software feature. The root key hash has to be burned at manufacture, the fuse layout has to be designed into the board, and the signing pipeline has to exist before the first production image. A device that shipped without it cannot be retrofitted in the field, the fuses are either burned or they are not.

"Rolling our own is simpler, we only need to check a hash." A hash check with no signature is a checksum, and a checksum is forgeable by anyone who can write the flash. In 2026, rolling your own image-validation and swap machinery is no longer a defensible engineering decision, MCUboot is the default (Kalapi). The machinery exists, it is reviewed, it is maintained, and it has already had the bugs found in it that yours has not.

Sources

  1. Ampheo, "How to achieve secure boot in embedded systems" (27 Oct 2025)
    What we used

    Immutable Boot ROM / first-stage, public key or hash in ROM, eFuses/OTP, or a secure element; SHA-256 and ECDSA-P256 / Ed25519 / RSA-2048+; each stage verifies the next, failure → signed recovery or fail-safe; monotonic counter in eFuse/OTP or secure flash; root key offline in HSM → intermediate signing keys; devices store root public key hash, images carry a cert chain to a short-lived image-signing key

  2. Noxtls, "Ultimate Guide to Secure Boot in Microcontrollers"
    What we used

    Root of trust is an immutable boot ROM built into silicon by the chip manufacturer; the chain starts at power-on and continues through firmware execution; if verification fails, the firmware never runs

  3. Agnile, "Secure Boot for Automotive ECUs: Chain of Trust Guide" (reviewed Oct 2026)
    What we used

    Four stages (immutable ROM, first-stage bootloader, second-stage bootloader, application); root key fused into OTP and read by ROM at every power-on; ECDSA P-256/P-384 the present-day standard (FIPS 186-5), RSA-PSS 3072/4096 legacy, post-quantum hash-based signatures (LMS, XMSS, SLH-DSA) for new roots given 15–20-year vehicle lifetimes; feeds ISO/SAE 21434 Clause 10 and UNECE R155 Annex 5

  4. Jones Consortium, "Mobile Secure Boot: Chain of Trust from Bootloader to OS"
    What we used

    Boot ROM 64–128 KB etched in silicon; a 256-bit SHA-256 hash of a 2048/3072-bit RSA or ECDSA P-384 public key in eFuses; unfused engineering devices boot anything, a state attackers hunt for; anti-rollback via a monotonic counter (often 32–64 fuses)

  5. Embedded Ace Guide, "Secure boot and cryptography"
    What we used

    Chain of trust ROM → bootloader → application, each stage checking the signature of the next; root public key (or hash) in OTP fuses; hardware crypto accelerator figures (Cortex-M4 @ 80 MHz): AES-128 ~25 cycles/byte software vs ~2 hardware, SHA-256 ~30 vs ~3, ECC P-256 sign ~100 ms vs ~10 ms, ECC P-256 verify ~200 ms vs ~15 ms

  6. Kalapi Infotech, "Secure Boot and OTA Firmware Updates on ARM Cortex-M: A Production Guide to TrustZone, MCUboot, and Rollback Protection"
    What we used

    Secure boot is a boot-time, one-shot property that says nothing after `main()` starts; TrustZone is runtime isolation (SAU/IDAU, Secure vs Non-secure worlds); "Secure boot and TrustZone are orthogonal. You can have one without the other"; STM32H7 (Cortex-M7) has no TrustZone-M but can have solid secure boot; STM32U5/nRF5340 (Cortex-M33) gives both; "in 2026 rolling your own image-validation and swap machinery is no longer a defensible engineering decision, MCUboot is the default"; shipping with the default MCUboot signing key is the single most common catastrophic mistake; `imgtool sign --version 1.4.0 --security-counter 5`, version vs security counter semantics; hardware rollback protection rule `image.security_counter >= device.security_counter`, counter advanced on confirm

  7. AC6 Training, "Secure boot on microcontrollers"
    What we used

    "The weak link is never the signature itself. It is the storage of the public key hash"; OTP is the strongest mechanism and final, a provisioning mistake turns the board into a paperweight; never store the full key in OTP, only its SHA-256 hash; the private key must never leave an HSM or signing service; without rollback protection secure boot collapses the first time you publish a patch, version 1.3 signed with your real key reinstalls the fixed flaw; security version separate from product version, increment only on a security fix, otherwise fuses exhaust within two years; advance the counter only after confirming the new image boots and works

  8. Nordic Semiconductor, nRF Connect SDK, "Downgrade protection"
    What we used

    Software-based downgrade protection supported only by MCUboot (compares image versions); hardware-based supported by MCUboot and nRF Secure Immutable Bootloader (version in non-volatile storage outside any image); `CONFIG_MCUBOOT_DOWNGRADE_PREVENTION` with `SB_CONFIG_MCUBOOT_MODE_OVERWRITE_ONLY`; enabling overwrite-only prevents fallback recovery of application images; hardware-based protection uses a non-volatile monotonic counter written to slots in the Provision area

  9. SoftwareSecurity, "Secure firmware updates: signing, rollback and A/B recovery"
    What we used

    Advance the anti-rollback counter after confirmation, never before; `MCUBOOT_HW_ROLLBACK_PROT` with the security counter in protected storage, or `MCUBOOT_DOWNGRADE_PREVENTION` comparing versions; the design page limits downgrade prevention to overwrite-only updates, MCUboot 1.10.0 added it for swap modes; Android Verified Boot updates stored rollback indexes only from slots marked successful

  10. Trusted Computing Group, "Device Identifier Composition Engine (DICE)"
    What we used

    And press release, 18 Sep 2017, lightweight hardware root of trust for device identity and attestation, for resource-constrained devices where a traditional TPM may be impractical; anchors trust with minimal silicon; each software layer derives its identity from the one below; identities derived from hardware secrets and cannot be cloned; requires only a small immutable code region and a hardware secret, no dedicated security chip; UDS fused at manufacture, CDI derived from UDS and the measurement of the first mutable firmware, each layer wipes its secrets before passing control on. and https://cdn.wibu.com/fileadmin/wibu_downloads/Press/Press_Reviews/2017/09-2017/TCG_Announces_DICE_Architecture_for_Security_and_Privacy_in_IoT_and_Embedded_Devices___Business_Wire.pdf

  11. Security Ledger, "Breaking the Ice on DICE" (2018)
    What we used

    DICE released September 2017; TPMs are not practical for the vast majority of IoT endpoints; patching the code automatically re-keys the device, so a secret disclosed through a vulnerability is protected by the legitimate keys after the patch

  12. Lynx, "U-Boot FIT Signature Bypass: What CVE-2026-46728 Means for Embedded Linux Verified Boot"
    What we used

    U-Boot before v2026.04: configuration-signature verification could be bypassed because `hashed-nodes` was not itself covered by the signature; the fix rebuilds the node list from the selected configuration's image references

  13. F-Secure / oss-security, "Das U-Boot verified boot improper signature verification" (18 Mar 2020)
    What we used

    U-Boot did not verify that `hashed-nodes` correlated with the sub-images a configuration required to load; an attacker with a properly signed FIT image could craft arbitrary FIT images that would pass signature validation

  14. QVLx Labs, "Secure Boot Supply Chain Contract Guide"
    What we used

    Secure boot is a long-term contract binding silicon vendors, ODMs, firmware teams, OS builders, update services, and repair centres; failure modes: keys shared across product lines, signing on developer laptops or generic CI runners, earlier firmware stages unsigned, debug ports left enabled, recovery images and factory tools not secured, revocation absent, rollback missing

  15. 0x434b, "Breaking secure boot without breaking the crypto"
    What we used

    A valid signature proves only that a holder of an accepted private key authorized some specific byte string at some point; it does not prove every byte consumed was inside the signed string, the image was meant for this chip and lifecycle, the image is current, the caller acted on the result, the verified buffer stayed put, the signed code is safe, or the firmware is secret

  16. PDRIMA, "A Policy-Driven Runtime Integrity Measurement and Attestation Approach for ARM TrustZone-based TEE" (arXiv 2512.06500)
    What we used

    TrustZone alone does not provide complete secure boot, runtime integrity protection, or remote attestation; the trust chain stops after static verification, leaving devices exposed to long-lived runtime attacks

  17. European Commission, Interoperable Europe, "Cyber Resilience Act Now Effective"
    What we used

    The CRA entered into force on 10 December 2024; the main obligations will become applicable from 11 December 2027

  18. European Commission, "Commission publishes for feedback draft guidance to assist companies in applying the Cyber Resilience Act"
    What we used

    The CRA entered into force on 10 December 2024; the main obligations apply from 11 December 2027, with reporting obligations as of 11 September 2026

  19. TuxCare, "Cyber Resilience Act Compliance: Deadlines and Requirements"
    What we used

    Regulation (EU) 2024/2847; reporting of actively exploited vulnerabilities and severe incidents has applied since 11 September 2026; main obligations including SBOMs, CE marking, and fines of up to €15 million apply from 11 December 2027; Article 64(2) fines up to €15 million or 2.5% of total worldwide annual turnover

  20. CASRAI, "EU Cyber Resilience Act: Dates, Scope, Fines"
    What we used

    Adopted 23 October 2024, published 20 November 2024, entered into force 10 December 2024; Article 71 milestones: 11 June 2026 notified-body rules, 11 September 2026 Article 14 reporting, 11 December 2027 general application; support period at least five years (Article 13(8))

More in software meets hardware

The Firmware That Doesn't Get LostMost reactive programs start out simple, but as features are grafted on, more and more flags and variables are introduced, until no human being really has a good idea what part of the code gets executed in response to any given event. The fix is one variable that can only hold one value at a time. This is the method: the state machine, the table, and the rules that keep it from becoming spaghetti again.26 minWatchdog timer embeddedA watchdog is a counter on its own clock that resets the processor when it reaches its limit, but a watchdog kicked from a timer interrupt is faithfully serviced by a dead product, and a reset that returns the device to the state that hung it produces a boot loop, which is worse than a freeze. The internal watchdog is free and shares the die; the external supervisor IC costs $0.30–$1.50 and cannot be disabled by confused firmware. This is the watchdog, the brownout, and the recovery ladder, worked through on the Example Labs field sensor hub.28 minThe Update That Cannot Brick the DeviceAn over-the-air firmware update can either extend the life of an embedded product or brick an entire fleet in the field. The difference is not the transport, it is the architecture: A/B partitions so the old firmware is never touched until the new one proves itself, signing and secure boot so the image is yours and unmodified, trial-then-confirm so a bad build reverts automatically, and a staged rollout with a kill switch. The safety costs one extra flash slot, 512 kB on a 2 MB chip, and its payoff is that a bad build costs one reboot instead of one scrapped unit, one truck roll, and one lost customer.11 minAlarm managementA plant with 400 configured alarms, 60 active at any moment, and operators who acknowledge the horn without reading the screen. EEMUA 191 says an operator can handle about one alarm every ten minutes, and at Milford Haven, two operators had to recognise, acknowledge, and act on 275 alarms in 11 minutes. The warning is a design problem, not a discipline problem.27 minDesign for TestA board that passes the bench and fails in the field is usually untestable by design, no test points, no JTAG chain, no fixture. The IPC-9252A rules, the four test methods, the coverage union, and what a fixture is worth on a real board.20 min