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.
The framing that wastes everyone's time
Posed as "hardware is secure, software is not", the question produces bad architecture in both directions: teams buy hardware they do not need, and teams dismiss hardware they do.
Software security is not inherently weak. A great deal of extremely well-analysed cryptography is software, and most real compromises exploit logic errors, misconfiguration and stolen credentials rather than anything a hardware module would have prevented.
What only hardware can enforce
- Key isolation from a compromised host. If a key exists in memory the host can read, then host compromise is key compromise. A boundary that never exports the key changes what an attacker gets.
- Tamper response. Detecting physical intrusion and destroying key material is not something code can do to itself.
- An anchor that survives a firmware rewrite. A root of trust in immutable hardware is what makes verified boot mean anything.
- Unpredictable key generation at first boot. Deterministic code cannot create unpredictability, and on a device with no history there is nothing to draw on — which is where devices ship duplicate keys.
What hardware does not fix
An HSM does not prevent an application from asking it to sign the wrong thing. A secure element does not fix an authorisation bug. A root of trust does not stop a vulnerability in the software it verified — it establishes what ran, not that what ran was correct.
Most breach reports describe failures of exactly this kind. Hardware raises the floor on a specific set of attacks and leaves the rest of the attack surface where it was.
How to decide
Enumerate what must remain true if the host is fully compromised. Whatever survives that test has to be enforced below the host — in hardware. Everything else is a software problem and should be solved as one, because hardware is more expensive to buy, to integrate and to change.
Applied to root of trust specifically, the same question has a more concrete answer.
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
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.
- 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.