What is a hardware root of trust, and what it actually protects
A hardware root of trust is an immutable anchor — typically a key and verification logic in silicon — that the rest of a system's trust chain is built on. It establishes what code was allowed to run and protects the key material underneath, and it cannot verify anything about its own correctness.
Why a chain needs an anchor
Verification is recursive. The application is trusted because the operating system verified it, the OS because the bootloader did, the bootloader because an earlier stage did. Something has to end the regress, and it has to be something an attacker cannot replace.
That is the root of trust: logic and key material fixed at manufacture, in hardware, not modifiable by software running on the device.
What it is made of
- An immutable public key or its hash, fused at manufacture, against which signatures are checked.
- Verification logic that runs before anything mutable does.
- Protected key storage for device-unique secrets.
- An entropy source, if the device generates its own keys — which is what makes device identity possible without a per-device secret injected at the factory.
What it actually stops
Persistent firmware modification. An attacker who compromises a running system but cannot alter what boots loses their foothold on reset, which turns a permanent compromise into a temporary one. That is a substantial difference in practice.
It also enables attestation: a device can present evidence about which firmware it booted, so a remote party can decline to enrol a device running something it does not recognise.
What it does not stop
A vulnerability in correctly signed firmware. The root of trust verified the signature, not the code's correctness, and a signed vulnerable image boots exactly as intended.
It also does not help if the key it anchors was predictable. A root of trust holding a device key generated from a weak source at first boot is an anchor into soft ground — which is why provisioning is where this argument actually lives.
The dependency worth naming
Every property above rests on key material being unpredictable. The root of trust protects the key; it does not make the key good. Designing one around a local entropy source is how that gap closes.
Keep reading
- Foundations
Device identity and secure provisioning
A device identity is a key pair generated inside the device and bound to it, which the device uses to prove what it is. Its strength is fixed at the moment of generation: entropy available at first provisioning determines whether the identity is unique and unpredictable for the device's entire life.
- Foundations
Hardware or software root of trust
A software root of trust relies on the platform's existing protections to keep its key secret; a hardware one puts the key somewhere software cannot reach. Software is a defensible choice when the threat model excludes physical access and the platform already isolates well, and it stops being one when either assumption fails.
- Foundations
Hardware security or software security, framing the question properly
Hardware and software security are layers, not rivals. Cryptography always executes on physical hardware, so the question is never which to use but which properties must be enforced physically — key isolation, tamper response and unpredictable key generation — and which can be enforced in code.