RISC-V security reality check, what matters first
RISC-V is an instruction set architecture, not a security feature. The openness of the ISA does not automatically make products secure or insecure. The real security outcome depends on how a chip is built, integrated, configured, verified, provisioned, updated, and operated. For security buyers and builders, the only credible claims are the ones you can measure and verify. That is why verifiable roots of trust, secure boot, measured boot, attestation, lifecycle controls, and update protections matter more than marketing about open silicon.
If you are shipping a RISC-V SoC into devices that handle credentials, payments, industrial control, automotive functions, or critical infrastructure, your minimum bar is a root of trust that can prove what code booted, prove what keys exist, resist common hardware fault and debug attacks, and recover safely with updates. If you cannot produce evidence, such as boot measurements, attestation reports, key provenance, and documented lifecycle states, you do not have a security posture, you have hope.
This article from QVLx Labs provides a reality check and a practical blueprint for building verifiable roots of trust on open silicon. The goal is to help architects, platform teams, and security engineers prioritize the highest leverage controls first, then add deeper details that improve assurance over time.
Executive checklist, verifiable root of trust for a RISC-V SoC
What “verifiable” actually means
A root of trust is verifiable when you can independently confirm, by observation or cryptographic proof, that the device is running authorized code and that its critical secrets are handled according to policy. Verification can be local, such as a secure boot check that prevents unauthorized firmware from running, and it can be remote, such as attestation that lets a server decide whether to trust the device in the field.
Verifiability is not achieved by making source code available. Openness helps review and can improve confidence, but a real attacker targets integration mistakes, misconfigurations, key handling flaws, and glitchable state machines. A verifiable design produces stable evidence that survives these pressures, including fault injection attempts and supply chain complications.
Threat model first, because security is not one size fits all
The right root of trust design depends on the threats you must resist. A consumer gadget that only needs to prevent casual firmware tampering has different requirements than a gateway that holds long lived private keys for fleets. Before specifying features, define a threat model that answers these questions.
Many RISC-V security failures come from skipping this step and assuming that “secure boot” is enough. Secure boot helps prevent unauthorized code from running, but it does not automatically provide fleet visibility, resistance to rollback, or strong isolation from DMA and debug abuse.
Roots of trust, the minimum set of building blocks
A practical root of trust typically includes an immutable boot stage, a way to store or derive keys securely, cryptographic engines, entropy, and a lifecycle mechanism that controls configuration and debug. These blocks can be integrated into the main SoC or delivered by a companion security chip. Open silicon efforts often expose these blocks for review, but you must still validate the implementation choices and the integration in your own product.
Immutable code, boot ROM done right
The boot ROM is the first code that runs after reset and is the foundation for all later trust. If it is patchable in the field, it is not a true root. If it is too complex, it becomes a large attack surface that is hard to verify. A good ROM is small, deterministic, and designed around one job, establish the next trust step safely.
A common pitfall is adding features like complex decompression, rich filesystems, or networking in ROM. Those features belong in later stages after verification, because parsers are historically fragile and frequently exploited.
Keys and identity, the difference between “a device” and “this device”
Device identity is the anchor for attestation, provisioning, and secure communication. In practice, you need a private key that cannot be extracted easily, plus a certificate chain that binds it to a vendor root. There are several patterns, each with tradeoffs.
Whatever you choose, verifiability requires documentation of key provenance. Auditors and customers will ask how keys are generated, how they are protected during provisioning, how they are rotated, and how compromised keys are revoked.
Measured boot and attestation, making trust observable
Secure boot prevents unauthorized code from running. Measured boot records cryptographic hashes of each boot stage and configuration. Attestation reports those measurements to a relying party, typically a server, so the server can decide whether the device is trustworthy at that moment.
Measured boot changes the security game because it gives you fleet visibility. It can also support more flexible policies. For example, you can allow a device to boot with a known vulnerable but operational image and restrict its permissions at the service layer, rather than bricking it in the field.
Attestation is where verifiable roots of trust earn their value. Without attestation, you cannot tell a genuine device from a counterfeit running copied firmware, and you cannot distinguish a patched device from a compromised one based only on network behavior.
Lifecycle states, controlling who can do what and when
Modern SoCs are not built once and shipped unchanged. They pass through wafer test, package test, board test, factory provisioning, developer enablement, field operation, and sometimes RMA analysis. Each stage needs different permissions. A lifecycle controller is a hardware governed state machine that controls debug, key exposure, boot policy strictness, and manufacturing features.
Many “secure boot” designs fail because production devices accidentally ship in a permissive lifecycle configuration. Verifiable designs make lifecycle state observable, measurable, and difficult to spoof.
Debug is a security feature, when designed as one
RISC-V has a standard debug architecture, and many implementations support rich debug access. That is great for developers and catastrophic if left open in production. Attackers love debug because it can bypass software protections and expose secrets directly from memory or registers.
A common trap is allowing a “temporary” debug unlock feature that remains in shipping firmware. If the unlock uses weak secrets, shared passwords, or challenge response without anti-replay, it becomes a universal skeleton key.
RISC-V specific security considerations, reality versus assumptions
RISC-V’s modular privilege architecture is flexible. Flexibility is a double edged sword. The same ISA can be used to build a microcontroller with no MMU or a server class CPU with virtualization. Security depends on which extensions and privilege modes exist, how they are configured, and what firmware enforces.
Privilege modes and where the root of trust should live
Many RISC-V systems use Machine mode (M-mode) as the highest privilege level. It is tempting to place a lot of security logic in M-mode firmware. The reality check is that M-mode firmware becomes part of your trusted computing base, and it tends to grow over time, especially when it also handles power management, interrupts, and platform initialization. A large privileged firmware is hard to verify and attractive to attackers.
PMP, memory protection, and DMA threats
Physical Memory Protection (PMP) is a key tool on many RISC-V microcontrollers and embedded cores. It can enforce execute and read or write permissions even without an MMU. However, PMP typically controls CPU access, not peripheral DMA access. Many real world compromises happen through DMA capable peripherals that can read secrets from memory or overwrite control data structures.
If you can only protect against CPU access and not against DMA, an attacker who controls a peripheral driver, or a malicious peripheral, may still extract secrets.
Virtualization, TEEs, and the myth of “free enclaves”
Some products try to treat a RISC-V TEE or enclave as a drop in security solution. The reality is that confidential computing needs strong isolation boundaries, robust interrupt handling, careful microarchitectural considerations, and a threat model that includes side channels. Without that, an enclave becomes a comforting label rather than a guarantee.
Open silicon advantages, and where openness does not help
Open silicon and open source hardware can improve security outcomes by enabling review, reproducible builds, and broader verification participation. Projects like OpenTitan demonstrate that open development can focus the community on security properties, threat modeling, and verification artifacts.
However, openness does not automatically address the hardest parts of product security.
In other words, open silicon helps you see the design. Verifiable roots of trust help you prove the device is behaving according to that design.
Secure boot versus measured boot, choose both when you can
Secure boot is a gate. It allows or blocks execution. Measured boot is a log. It records what happened. Most systems should implement both. Secure boot without measurement hides valuable forensic information and fleet health signals. Measurement without enforcement may allow compromised devices to run, which can be acceptable in some monitoring use cases but is often unacceptable for safety or credential holding roles.
A robust boot chain often looks like this.
Design for deterministic failure handling. For example, define whether a verification failure triggers a permanent stop, a recovery image boot, or a restricted safe mode that still allows over the air repair.
Anti-rollback, the most neglected requirement
Attackers rarely need to defeat signature verification if they can install an older signed firmware with known vulnerabilities. Anti-rollback is the control that prevents this. It is frequently omitted because it complicates development and field recovery. But without it, secure boot becomes a speed bump.
Be careful with schemes that store version counters in regular flash. If an attacker can rewrite flash, they can often reset the counter as well.
Firmware update security, where roots of trust meet operations
Even excellent boot security does not help if updates are fragile, unaudited, or easily interrupted. Secure update design must cover authenticity, integrity, rollback resistance, and robustness to power loss and network failure.
For verifiability, the update system should also produce evidence. It should be possible to answer, for any device, what version is running, what it booted from, what failed previously, and whether rollback protections are intact.
Choosing cryptography and key management for long lifetimes
RISC-V products span tiny IoT nodes to servers. In embedded devices, cryptographic choices must balance security, performance, and side channel resilience. The important reality check is that algorithm choice is less important than correct implementation, correct key handling, and correct integration with the root of trust.
Also decide what happens when algorithms age. Devices shipped today may live for a decade. Plan for algorithm agility, including the ability to rotate keys and migrate to stronger primitives as ecosystems evolve.
Physical attacks, fault injection, and why “open” can increase attacker advantage
In open silicon settings, attackers may have easier access to implementation details, including exact state machines and timing behavior. That can help them craft glitch and fault injection attacks. Your root of trust should assume an attacker can reset the device repeatedly, induce clock and voltage glitches, and observe behavior with precision.
Do not rely on “the attacker cannot do that” assumptions without evidence. If you are selling into adversarial environments, budget for lab testing that includes voltage and clock glitch campaigns, and validate that the boot chain cannot be tricked into skipping verification.
Side channels and microarchitecture, the uncomfortable topics
Side channel attacks exploit information leakage through timing, power, electromagnetic emissions, and microarchitectural state such as caches and branch predictors. Many embedded RISC-V designs will not face sophisticated side channel adversaries, but products holding valuable credentials might. The reality check is that side channel resilience is rarely achieved accidentally.
A practical approach is to classify devices into tiers, for example low risk consumer, enterprise, critical infrastructure, and then align side channel investments to the tier. Verifiability includes documenting these decisions so customers know what was assumed.
Common integration failures in RISC-V SoCs
Most security bugs are not “ISA bugs.” They are integration and policy bugs. Here are recurring failure modes seen across embedded platforms, including RISC-V.
Each of these failures can exist even when the CPU core is perfectly correct. Verifiable roots of trust focus on preventing these classes of errors, and on making misconfiguration detectable via measurement and attestation.
Architecture patterns that work well on open silicon
There are multiple ways to implement a root of trust on a RISC-V platform. The best pattern depends on performance, cost, and assurance goals. The following patterns tend to scale well.
Pattern 1, minimal ROM plus measured chain, with derived keys
This is a common approach for cost sensitive embedded devices. The ROM verifies a first stage, measures it, and then uses a Unique Device Secret to derive keys bound to measurements. This reduces stored secrets and ties identity to software state.
Pattern 2, dedicated security core or compartment for the root of trust
Some SoCs add a small core dedicated to security services, sometimes with its own memory. The main application core, RISC-V or otherwise, cannot directly access the security core’s secrets. This resembles the split between an application processor and a secure element, but inside one chip.
Pattern 3, external root of trust chip
When physical attacks and supply chain threats are high, an external secure element or TPM like chip can provide a hardened boundary. The main SoC can be open silicon while the root of trust is physically protected.
Attestation in practice, what to include in evidence
Attestation is only useful if the evidence is meaningful and policy engines can act on it. A minimal attestation payload should include identity, software measurements, and critical configuration. A more mature payload includes runtime posture and anti-rollback state.
To keep attestation verifiable, define a stable measurement strategy early. Changing what is measured or how measurements are computed can break fleet policy engines and make incident response harder.
Manufacturing and provisioning, where many real breaches happen
Security engineering often focuses on cryptography and boot logic, but many compromises happen during manufacturing and provisioning. If an attacker can access provisioning equipment or intercept key injection, they can create devices with cloned identities or embedded backdoors that still pass secure boot checks.
If you plan to use open silicon across multiple fabs and assembly houses, treat supply chain security as a first class requirement. Document who can access test modes, what access they have, and how that access is revoked when devices transition to production state.
Verification and assurance, how to earn trust instead of requesting it
“Open” makes it easier for others to inspect your design. Verifiable roots of trust require you to inspect and test it yourself, then ship evidence. Mature assurance programs combine multiple methods because no single method catches everything.
When teams claim verifiability, they should be able to show artifacts, threat model documents, test plans, formal properties, and results summaries. This is increasingly important for regulated markets and enterprise buyers.
What to publish or provide to customers, practical evidence packages
Not every product can publish every detail, but you can still provide evidence in a structured way. For open silicon products, you may publish more by default. For commercial products, you can provide information under NDA. Either way, verifiable roots of trust benefit from consistent deliverables.
These deliverables help customers integrate devices into larger trust systems. They also force internal clarity, which reduces misconfigurations and late surprises.
Putting it together, an example verifiable boot and attestation flow
Consider a mid-range embedded gateway built around a RISC-V SoC. The vendor wants verifiable identity, secure updates, and remote attestation for enterprise deployments. A clean design might operate like this.
This flow makes security observable. If a device is downgraded, the rollback counter reveals it. If debug is enabled, the attestation report reveals it. If a modified image runs, the measurements reveal it. That is the essence of verifiable roots of trust.
RISC-V security reality check, myths to discard
Security programs often stall because stakeholders cling to myths. Here are the most common ones, with the practical reality.
Prioritized roadmap, build the core first, then increase assurance
Teams shipping on tight schedules need a phased plan. The inverted pyramid approach applies here too, implement the core controls that prevent catastrophic failures, then add enhancements that improve resilience and observability.
Phase 1, must have for shipping
Phase 2, verifiability and fleet control
Phase 3, higher assurance and physical resilience
By structuring the program this way, you avoid spending months on advanced features while the basics remain vulnerable. You also create a clear story for customers, what is guaranteed today, and what is planned for higher assurance variants.
Conclusion, what “security reality check” should change in your design
RISC-V is enabling a wave of open silicon innovation, and that is good for security when it comes with disciplined engineering. The security reality check is that trust comes from evidence, not from branding. Verifiable roots of trust turn security from an internal claim into an externally confirmable property.
If you are building or buying a RISC-V platform, ask for the evidence package: boot and update policies, anti-rollback design, lifecycle and debug controls, measurement strategy, and attestation verification guidance. If you are building it yourself, prioritize a minimal ROM, robust key handling, measured boot, attestation, and strict lifecycle control, then harden against DMA, faults, and side channels based on your threat model. That is the path to security you can defend in reviews, audits, and real attacks, on open silicon and beyond.