Engineer working on a laptop connected to a device test rig, surrounded by wiring harnesses and test hardware

Firmware vulnerabilities & fixes

Secure boot and hardware root of trust, explained

Last updated:

A hardware root of trust — a piece of silicon, fuse-protected key material, or immutable ROM code on a device that cannot be modified after manufacture — is built one of four common ways: a discrete TPM, a secure element, Arm TrustZone, or TCG's DICE architecture, and it anchors every later trust decision the device makes. Secure boot is the sequence of signature checks, each stage verifying the next before it is allowed to run, that extends trust outward from that anchor through the bootloader to the OS or application firmware. Together they are the mechanism that answers a single practical question at every power-on: is the code about to run actually the code the manufacturer signed, or has it been tampered with since?

Key takeaways

  • 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.
  • These are not mutually exclusive.
  • The Trusted Computing Group released the Device Identifier Composition Engine (DICE) Architecture in 2017 specifically because a full TPM is often impractical on low-cost IoT and embedded silicon.
  • Two details decide whether the table holds in practice.

Why a chain, not a single check?

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. The only way out of this bootstrapping problem is to put the first check somewhere software cannot reach: burned into mask ROM, locked by a one-time fuse, or isolated in a separate secure co-processor. From that one immutable starting point, each stage of boot verifies a cryptographic signature on the next stage before handing over execution — Arm's Trusted Boot and Firmware Update specification describes the pattern as an immutable bootloader acting as the hardware root of trust that executes from reset and manages the public key used to verify every subsequent firmware stage. Arm's reference code follows the same design: the Trusted Firmware-A chain of trust trusts its first-stage BL1 image "on the assumption that it resides in ROM so cannot be tampered with", and links every later certificate and image to a Root of Trust Public Key (ROTPK) whose hash sits in the platform's trusted root-key storage. On a UEFI PC the chain runs from firmware through the boot manager and OS loader to the kernel, and a failure at any link halts the boot rather than letting an unverified stage run.

Where does the anchor actually live?

Approach What it is Where it fits
Discrete TPM A separate, standardized chip (Trusted Computing Group's TPM 2.0 line) for measured boot, sealed storage and remote attestation Higher-end platforms (servers, laptops, some industrial PCs) that can afford a second component and its provisioning overhead
Secure element Its own small, tamper-resistant chip, often used for payment credentials and SIMs Devices needing strong physical tamper resistance for a narrow set of secrets, less often the primary boot anchor
Arm TrustZone A CPU feature, not a separate chip, splitting one processor into a secure world and a non-secure world Arm-based SoCs where the processor itself, per Arm, provides "the perfect starting point for establishing a device root of trust based on PSA guidelines" without added bill-of-materials cost
TCG DICE A minimal hardware secret plus a measurement of the first mutable code, combined into a Compound Device Identifier The most resource-constrained microcontrollers and components, where neither a TPM nor TrustZone is practical

These are not mutually exclusive. TCG's own description of DICE notes it can work "standalone on constrained devices, or as complement to TPM in more complex security architectures," and a design can legitimately use TrustZone to isolate secure-world code on the main application processor while a smaller sensor or power-management IC on the same board uses DICE for its own identity.

How does TCG DICE give small devices a root of trust?

The Trusted Computing Group released the Device Identifier Composition Engine (DICE) Architecture in 2017 specifically because a full TPM is often impractical on low-cost IoT and embedded silicon. DICE needs only a protected hardware secret — the Unique Device Secret, accessible solely to the earliest, most trusted layer of code — and a measurement of the first mutable code that runs. Those two inputs feed a one-way function to produce a Compound Device Identifier that is unique to that exact combination of hardware and firmware; change the firmware, and the identifier changes with it, which is what makes tampering detectable without needing a certified security chip at all. TCG frames the result as giving IoT and embedded systems "critical security and privacy benefits... where traditional Trusted Platform Modules (TPM) may be impractical."

What does each boot stage verify on a typical device?

Each stage checks the next one, and the table shows what that means on the two embedded stacks device makers meet most often: an Arm Cortex-A SoC running Trusted Firmware-A and U-Boot, and an Arm Cortex-M microcontroller running MCUboot.

Platform Stage What it verifies before handing over
Cortex-A BL1, in boot ROM The trusted boot firmware certificate and the BL2 image, against the ROTPK hash
Cortex-A BL2 Key and content certificates for BL31, BL32 and BL33; per TF-A, a separate non-trusted world key signs the BL33 certificates
Cortex-A BL33, usually U-Boot Kernel, device tree and initramfs in a signed FIT image, using public keys held in U-Boot's control device tree (U-Boot FIT signature docs)
Cortex-A Linux kernel Optionally the root filesystem, block by block, with dm-verity, a read-only integrity target
Cortex-M ROM or SoC first-stage loader MCUboot itself, where the silicon supports it
Cortex-M MCUboot The application image signature in its TLV area and, when enabled, its security counter

Two details decide whether the table holds in practice. U-Boot only enforces keys marked required ("image" or "conf"); its documentation says "only required keys are normally verified by the FIT image booting algorithm". And U-Boot recommends signing configurations, not only images, because a FIT can otherwise be rebuilt to select a different signed image (a "mix and match attack"). See our U-Boot security guide.

How do you stop rollback to an older signed image?

Add a version check the attacker cannot reset. An old firmware image is still validly signed, so signature checks alone will boot it, vulnerabilities included. U-Boot's documentation names substituting a signed image from an older FIT a "roll-back attack". MCUboot offers two defences:

  • Software downgrade prevention compares image version numbers; it is enabled with MCUBOOT_DOWNGRADE_PREVENTION and works only with the overwrite-only update strategy.
  • Hardware downgrade prevention puts a security counter in the image's protected TLV area (the -s option of imgtool) and compares it with the active value, which must be stored "in a non-volatile and trusted component of the device".

MCUboot notes the counter does not need to increase with every release. Bump it on releases that fix security issues: ordinary downgrades stay possible, while a return to a known-vulnerable image is blocked. Keep a signed recovery image at the current counter value. See firmware OTA update security for the update side.

What does secure boot not do by itself?

Secure boot answers "is this code signed by someone I trust," not "is this code free of vulnerabilities" or "will this device recover if the signed firmware is still compromised." A properly verified chain of trust can still boot firmware with an exploitable bug in it, because the signature only proves provenance, not correctness. This is exactly the gap NIST SP 800-193's roots of trust for detection and recovery are built to cover once verification itself is working, and it is why NSA's December 2025 guidance on managing UEFI Secure Boot, coordinated with CISA, exists at all: the guidance catalogs real incidents — including PKFail, where devices shipped with untrusted test certificates still accepted as trusted roots, and BlackLotus, a bootkit that bypassed Secure Boot enforcement — as evidence that a correctly designed chain of trust can still fail in practice if keys, certificate databases, or revocation lists are misconfigured or left at insecure defaults.

NVD records both. CVE-2024-8105 (PKFail) affects UEFI implementations "that use a hard-coded software-based Platform Key", letting anyone with the matching private key sign code the firmware will trust. CVE-2023-24932 is the Secure Boot security feature bypass that, per Microsoft KB5025885, the BlackLotus UEFI bootkit uses. In both cases the cryptography worked; the keys and revocation lists did not. See our PKFail guide.

What changed for x86 devices that boot through UEFI in 2026?

Microsoft's 2011 Secure Boot certificates expired during 2026. Industrial PCs, gateways and appliances on x86 that boot Linux through a Microsoft-signed shim, or that run Windows, depend on them. Dates from Microsoft's certificate expiration page, read 2026-11-10:

Expiring certificate Expiry date Replacement Role
Microsoft Corporation KEK CA 2011 24 June 2026 Microsoft Corporation KEK 2K CA 2023 Signs updates to db and dbx
Microsoft UEFI CA 2011 27 June 2026 Microsoft UEFI CA 2023 and Microsoft Option ROM UEFI CA 2023 Third-party boot loaders, EFI applications and option ROMs
Microsoft Windows Production PCA 2011 19 October 2026 Windows UEFI CA 2023 Windows boot loader

Microsoft states that devices without the 2023 certificates keep starting normally but can no longer receive new security protections for the early boot process. For a device maker, the action is to check which certificates your shipped firmware's db and KEK hold, and to ship firmware that adds the 2023 certificates.

Which standards and regulations ask for secure boot?

Most name the outcome, integrity of the code that runs, rather than one boot design:

Source Provision What it asks
ETSI EN 303 645 V3.1.3 5.7-1 (recommendation) "The consumer IoT device should verify its software using secure boot mechanisms"
ETSI EN 303 645 V3.1.3 5.3-9 (recommendation) Verify the authenticity and integrity of software updates
ETSI EN 303 645 V3.1.3 5.6-4A (mandatory) Debug interfaces disabled or protected by access control
Cyber Resilience Act, Annex I Part I (2)(f) Protect the integrity of "programs and configuration against any manipulation or modification not authorised by the user, and report on corruptions"
Cyber Resilience Act, Annex I Part I (2)(j) Limit attack surfaces, including external interfaces
NIST SP 800-193 Protection, detection, recovery Platform firmware resiliency; verified boot supports detection

See ETSI EN 303 645 explained and CRA Annex I explained.

Worked example: how would a small sensor maker provision and test secure boot?

Synthetic example. The company and device are invented for this guide.

A hypothetical maker ships a Cortex-M33 environmental sensor with MCUboot and wants evidence for the CRA integrity requirement. The sequence it writes into its manufacturing and release process:

  1. Generate signing keys offline, one key pair per product family, with the private key held in a hardware security module or an offline signing machine, never on the build server.
  2. Build MCUboot with signature checking and hardware downgrade prevention, and embed the product family's public key.
  3. At the factory, program MCUboot, write the key hash or lock the bootloader region as the SoC allows, and set the hardware security counter to the release value.
  4. Lock debug access(SWD/JTAG) through the SoC's lifecycle or fuse settings once programming is done.
  5. Sign each releasewith imgtool, adding the version and, for security releases, a higher security counter (-s).
  6. Keep the evidence: key ceremony record, factory station log, signed-image hashes per release.

Before the first shipment, it runs negative tests on production-state units:

Test Expected result
Flip one byte in the application image MCUboot refuses to boot it and keeps the previous image
Image signed with a different key Refused
Valid image with a lower security counter Refused
Unsigned image written over SWD SWD access denied
Power loss during update Device boots the previous or the new image, never neither

Where should a device team start?

  1. Identify your actual hardware anchor before trusting a vendor's "secure boot enabled" claimConfirm whether the first verification step runs from immutable ROM, a fused key, or a general-purpose flash region that could itself be rewritten.
  2. Map every stage in your boot chain and confirm each one verifies the next, rather than assuming a single signature check at the start covers everything that runs afterward.
  3. Treat key management as the hard part, not the cryptographyMost real-world secure boot failures — PKFail among them — trace back to test keys, shared keys across product lines, or missing revocation paths, not broken algorithms.
  4. Match the root-of-trust approach to the constraint, not the trendA $2 sensor SoC does not need a discrete TPM; TCG DICE or a TrustZone-based design is often the realistic option, and forcing a heavier approach can delay a product without adding real security.
  5. Pair verification with recoveryA chain of trust that only refuses to boot on failure, with no signed recovery path, turns a detected attack into a bricked fleet — the problem NIST SP 800-193's recovery root of trust is designed to solve.

For the resilience model that governs what happens after a verification failure, see NIST SP 800-193: Platform Firmware Resiliency; for the PC/server-specific BIOS update rules that predate and narrow that broader model, see NIST SP 800-147: BIOS Protection Guidelines. Threat models for where a weak or missing root of trust shows up in practice are catalogued in MITRE EMB3D, and testing approaches for verifying boot-chain claims independently are covered in OWASP's firmware security testing methodology.

What are the common pitfalls?

  • Shipping a development key. TF-A allows a development ROTPK embedded in BL1 and BL2 "only for development purposes"; production parts need the real key hash.
  • One signing key for every product line, so one leak exposes the whole portfolio.
  • Keys present but not required in U-Boot, so unsigned images still boot.
  • Signing images but not FIT configurations, which leaves the mix-and-match path open.
  • No rollback protection, so an attacker installs last year's signed, vulnerable release.
  • Debug ports left open, which bypasses the whole chain.
  • No signed recovery path, so a failed check bricks the unit.
  • Expired or outdated certificate databases on x86 platforms.

What can SoftWSP check, and what needs a design review?

Boot-chain design, key handling and fuse settings need an engineer's review against the device and its datasheets. SoftWSP covers the components inside the image: it extracts a software bill of materials from the firmware as CycloneDX JSON and matches the identified components, including a bootloader when it is identified, against NVD, CISA KEV, FIRST EPSS and CISA ICS advisories. An AI-drafted report cites each source, and an engineer reviews it before you receive it. See firmware SBOM and device & firmware security.

This guide draws on NIST's, the Trusted Computing Group's, Arm's, Trusted Firmware's, MCUboot's, U-Boot's, Microsoft's and NSA's published technical materials. It is not a substitute for those organizations' own specifications, or for an engineer's assessment of a specific device's boot architecture.

Put this guide to work

Frequently asked questions

What is the difference between secure boot and a hardware root of trust?

Secure boot is the process — a sequence of signature checks that run every time a device powers on, each stage verifying the next before handing over execution. A hardware root of trust is the anchor that process depends on: a piece of silicon, fuse-protected key, or immutable ROM code that cannot itself be updated or spoofed, and that performs or protects the very first verification step. Arm's Platform Security Architecture materials describe this as an immutable boot ROM forming the trust anchor from which the rest of the chain of trust is built. Without a hardware root of trust, secure boot is only as strong as whatever software performed the first check — and software-only checks can usually be bypassed by an attacker who controls the storage the bootloader lives on.

How does the secure boot chain of trust actually work, step by step?

Each stage verifies a cryptographic signature on the next stage before running it, starting from a stage that nothing software-based can tamper with. On a typical UEFI PC, a hardware vendor embeds a Platform Key representing the root of trust, and the firmware checks the bootloader's signature against a database of trusted keys (the db) and a revocation list (the dbx) before executing it; a widely used secondary description summarizes the resulting flow as "firmware to boot manager to OS loader to kernel," where a failure at any link halts the boot. The well-known Linux shim/GRUB pattern illustrates this concretely: UEFI verifies the signed shim binary using a Microsoft-issued certificate, shim then verifies and launches GRUB using distro-specific keys, and GRUB verifies and starts the kernel — three separate signature checks, each one gating the next stage's execution rather than trusting it by default.

Do I need a TPM, a secure element, or is Arm TrustZone enough?

They solve overlapping but distinct problems, and many designs use more than one together. A discrete TPM (per the Trusted Computing Group's TPM 2.0 work) is a separate, certified chip good for measured boot, sealed storage and remote attestation, but it adds bill-of-materials cost and a second component to provision. Arm TrustZone is not a separate chip — it is a CPU feature that partitions a single processor into a secure world and a non-secure world, and Arm positions it as "the perfect starting point for establishing a device root of trust based on PSA guidelines," useful when the device already has an Arm core and cost or board space rules out a discrete TPM. A secure element (its own small, tamper-resistant chip, common in payment and SIM applications) trades flexibility for strong physical tamper resistance. For the lowest-cost, most resource-constrained devices that cannot justify any of the above, TCG's DICE architecture derives a strong device identity from a hardware secret and firmware measurements using only a small immutable code region — no dedicated security chip required.

How does secure boot relate to NIST SP 800-193, SP 800-147 and the EU Cyber Resilience Act?

They describe adjacent but different layers of the same problem, and this guide deliberately does not re-cover their detail — see the linked guides for that. NIST SP 800-193's roots of trust for update, detection and recovery (RTU, RTD, RTRec) describe what a platform must be able to do if firmware integrity fails, which assumes a working verification chain (secure boot) is already in place to detect the failure; see [NIST SP 800-193: Platform Firmware Resiliency](/guides/nist-sp-800-193-platform-firmware-resiliency/) for that resilience model in depth. NIST SP 800-147 is narrower still, defining an authenticated update mechanism and root of trust for update specifically for PC/server BIOS; see [NIST SP 800-147: BIOS Protection Guidelines](/guides/nist-sp-800-147-bios-protection-guidelines/). The EU Cyber Resilience Act does not mandate a specific boot architecture, but its essential requirements expect products to protect against unauthorized access and ensure data/code integrity, which secure boot and a hardware root of trust are a direct technical answer to; see [CRA Annex I, explained](/guides/cra-annex-i-explained/) for the regulatory text itself.

Sources

  1. NIST Special Publication 800-193, Platform Firmware Resiliency Guidelines (May 2018)
  2. Trusted Computing Group: Device Identifier Composition Engine (DICE) Architecture announcement and overview
  3. Arm: Trusted Boot and Firmware Update, PSA Certified specification (DEN0072)
  4. Arm: TrustZone for Cortex-M (device root of trust based on PSA guidelines)
  5. NSA Cybersecurity Information Sheet: Guidance for Managing UEFI Secure Boot (11 December 2025, coordinated with CISA)
  6. NIST Special Publication 800-147, BIOS Protection Guidelines (April 2011)
  7. Trusted Firmware-A documentation: Trusted Board Boot (chain of trust, ROTPK)
  8. MCUboot documentation: Bootloader design (image verification, downgrade prevention, security counter)
  9. U-Boot documentation: FIT Signature Verification (required keys, signed configurations, roll-back attack)
  10. Linux kernel documentation: dm-verity
  11. NVD: CVE-2024-8105 (PKFail, hard-coded software-based Platform Key)
  12. NVD: CVE-2023-24932 (Secure Boot Security Feature Bypass)
  13. Microsoft KB5025885: Windows Boot Manager revocations for Secure Boot changes associated with CVE-2023-24932
  14. Microsoft Support: Windows Secure Boot certificate expiration and CA updates
  15. ETSI EN 303 645 V3.1.3 (2024-09): Cyber Security for Consumer Internet of Things: Baseline Requirements
  16. Regulation (EU) 2024/2847 (Cyber Resilience Act), Annex I
Was this guide helpful?

In this cluster