Qu4z4r
36 min read
09 Jul
09Jul

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

  • Immutable boot ROM that verifies the next stage with modern cryptography, supports revocation, and enforces anti-rollback.
  • Strong device identity with keys protected by hardware, not by software conventions, and a certificate chain that can be validated.
  • Measured boot and attestation so the device can prove its boot state remotely, not just enforce a signature check locally.
  • Lifecycle controller with explicit states (manufacturing, development, production, RMA) and irreversible transitions guarded by policy.
  • Secure debug policy that defaults to off in production, supports authentication, and prevents debug from bypassing boot policy.
  • Isolated execution for the root of trust using hardware isolation, memory protection, and limited privilege, not a large monolithic M-mode firmware.
  • Protected key storage using OTP, eFuses, secure NVM, or a derived key scheme, plus secure erase and revocation where feasible.
  • Secure firmware update with signed payloads, rollback resistance, failure safe A or B partitions, and auditability.
  • DMA and bus protection so peripherals cannot read or overwrite root of trust memory, secrets, or page tables.
  • Evidence-driven verification including formal checks for boot policy, fuzzing of parsers, side channel review, and red teaming.

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.

  • Attacker access, remote only, local physical access, or lab access with fault injection tools.
  • Attacker goals, piracy, bypassing subscriptions, data theft, persistent implant, counterfeit devices, or sabotage.
  • Assets, device identity keys, user data, cryptographic material, safety functions, model weights, or proprietary firmware.
  • Trust boundaries, which code is trusted, which peripherals are trusted, and which external services are trusted.
  • Recovery expectations, whether you can revoke keys, patch firmware, and quarantine devices after compromise.

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.

  • Verify signatures using well reviewed algorithms, such as Ed25519 or ECDSA P-256, or RSA-3072 when required by ecosystems.
  • Validate image metadata carefully, including lengths, offsets, and version numbers, with constant time parsing where feasible.
  • Implement anti-rollback based on a monotonic counter or version fuse scheme, not just a version field in firmware.
  • Support key revocation by allowing multiple trusted public keys and a policy that can disable compromised keys.
  • Fail safe, a failed verification should halt or enter a limited recovery state, not fall back to unverified boot.

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.

  • Injected keys in OTP or secure NVM, provision a unique private key per device at manufacturing. Strong but requires secure provisioning operations.
  • Derived keys, DICE style, derive keys from a Unique Device Secret plus measurements of the boot chain, reducing reliance on storing multiple long lived keys.
  • PUF derived secrets, use a physically unclonable function to regenerate secrets on demand, but validate stability over temperature, aging, and process variation.
  • External secure element, store identity keys outside the main SoC, improving physical resistance but increasing BOM and integration complexity.

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.

  • Measure each stage, ROM measures the first stage, first stage measures the second stage, and so on, including key configuration and critical fuses.
  • Bind measurements to identity, sign or MAC the measurement log using an attestation key rooted in hardware.
  • Use structured evidence, such as EAT tokens or a well defined custom format, to avoid parsing ambiguity and enable policy engines.
  • Include freshness, use nonces or challenges so an attacker cannot replay an old “good” report.

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.

  • Manufacturing state, allow test features, allow temporary keys, and enable bring-up diagnostics.
  • Development state, permit debug with authentication, and allow non production signing keys for rapid iteration.
  • Production state, disable or strictly gate debug, enforce signature verification, and lock sensitive fuses.
  • RMA state, enable limited diagnostics while preventing key disclosure, often by erasing or invalidating secrets first.

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.

  • Default to debug disabled in production lifecycle state.
  • Require cryptographic authentication to enable any debug function on deployed devices.
  • Ensure debug cannot read root of trust memory regions, key storage, or security registers, even after authentication, unless explicitly required.
  • Prevent debug from altering boot measurements, version counters, or lifecycle state.
  • Audit debug unlock events and optionally rate limit them to reduce brute force attempts.

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.

  • Keep the immutable ROM minimal, and keep early M-mode code small.
  • Move complexity to less privileged modes after verification, for example Supervisor mode for an OS, or a dedicated security monitor with a tiny interface.
  • Use hardware mechanisms like PMP or enhanced PMP where available to protect root of trust memory regions from later stages.
  • Design clear ownership for interrupts, timers, and platform devices so that a compromised component cannot escalate privileges.

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.

  • Ensure your interconnect and peripheral subsystem enforce access control for DMA, often via an IOMMU or bus firewall.
  • Partition memory so that root of trust code and data are in regions that DMA cannot access.
  • Lock PMP configuration after the root of trust sets it, and measure the configuration as part of boot evidence.

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.

  • Decide whether you need isolation from the OS, or only from applications.
  • Account for shared caches, speculative execution, and timing side channels in high value designs.
  • Use attestation to prove enclave or TEE identity and version, not just boot chain state.

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.

  • Integration risk, a secure core can be placed into an insecure SoC with a misconfigured bus, debug, or memory map.
  • Configuration drift, a secure default can be overridden by build flags, fuses, or board straps.
  • Supply chain realities, counterfeit parts, unauthorized test access, and mishandled provisioning are not solved by open RTL.
  • Physical attacks, glitching, probing, and side channel leakage require careful hardware countermeasures and validation.

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.

  • ROM, verifies and measures first stage bootloader, configures minimal isolation, then transfers control.
  • First stage, configures clocks, memory, and bus protection, verifies and measures the second stage, sets up anti-rollback checks, then transfers control.
  • Second stage, verifies and measures the OS or application images, configures runtime isolation, and initializes attestation services.
  • Runtime, periodically reports attestation evidence, enforces update policies, and monitors critical configuration.

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.

  • Use a monotonic version counter stored in OTP, eFuses, or a secure monotonic storage mechanism.
  • Bind the counter to a specific image type, for example bootloader versus OS, to avoid cross downgrade tricks.
  • Define an emergency recovery process that can still increase versions safely if an update fails.
  • Measure the rollback state, and include it in attestation evidence so servers can detect risky devices.

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.

  • Signed update packages with explicit targets, versions, dependencies, and expected measurements.
  • A or B partitions or dual bank flash so devices can revert safely if a new image fails to boot.
  • Update authorization policies, for example staged rollout, device group targeting, and minimum version requirements.
  • Atomicity via verified staging areas and careful write ordering to survive resets.
  • Telemetry that reports update success, failure reasons, and boot measurements for fleet analysis.

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.

  • Entropy, validate your TRNG and health tests. Weak entropy collapses otherwise strong schemes.
  • Key derivation, use HKDF or similar constructions, with domain separation labels for each key usage.
  • Key separation, never reuse the same key for signing, encryption, and attestation across contexts.
  • Hardware acceleration, ensure accelerators are constant time and do not leak via shared resources.
  • Certificate strategy, define how device certificates are issued, rotated, and revoked, including offline and constrained deployments.

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.

  • Glitch resistance, add redundancy or temporal checks around critical comparisons, such as signature verification results and lifecycle checks.
  • Fault detection, detect abnormal clocks and voltages where feasible, and enter a safe failure state.
  • Secure counters, protect monotonic counters against fault bypass and tearing.
  • Physical hardening, consider shielding, sensors, and secure packaging for high value products.

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.

  • Use constant time cryptographic implementations, and verify them with testing, not just code review.
  • Prefer hardened crypto blocks where appropriate, and validate their leakage properties.
  • Be cautious with shared caches between trusted and untrusted contexts, especially in TEEs.
  • Consider masking or blinding for private key operations in high value designs.

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.

  • Boot measurements not covering configuration, measuring firmware but not measuring fuses, debug state, or memory protection settings.
  • DMA bypass, peripherals can read secure memory because the bus fabric lacks firewalls.
  • Insecure recovery mode, a recovery UART or USB path accepts unsigned images “for factory use” and remains enabled.
  • Key reuse, the same key used across devices, or the same key used for both update signing and attestation.
  • Weak lifecycle transitions, production lock is reversible, or depends on a software flag stored in flash.
  • Debug left open, JTAG accessible, or debug authentication uses shared secrets.
  • Parser vulnerabilities, bootloaders parse complex container formats without robust bounds checking.

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.

  • Small ROM attack surface.
  • Measurements enable fleet visibility.
  • Derived keys reduce provisioning complexity.

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.

  • Stronger isolation against application core compromise.
  • Clearer security boundary.
  • Potentially easier certification story.

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.

  • Strong physical resistance options.
  • Independent update and certification cycle.
  • Added cost, board complexity, and interface attack surface.

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.

  • Device identity, a public key or certificate chain identifier.
  • Boot chain measurements, hashes of ROM configuration, bootloaders, OS, and key config blocks.
  • Security configuration, debug lock state, lifecycle state, secure boot enabled flags, and memory protection mode.
  • Version and rollback counters, current and minimum allowed versions for critical components.
  • Freshness, nonce challenge from the server, and optional secure time if available.

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.

  • Use HSM-backed key generation and signing infrastructure.
  • Minimize exposure of private keys in test and factory environments.
  • Separate manufacturing keys from production endorsement keys, and ensure manufacturing keys cannot sign production firmware.
  • Log provisioning operations and link them to device serials for auditability.
  • Define a secure disposal process for scrap parts that may still contain secrets.

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.

  • Formal verification, prove key properties such as “no unsigned code executes before policy lock” and “rollback counter monotonicity cannot be bypassed.”
  • Static analysis, especially for ROM and bootloaders, to reduce memory safety and parsing bugs.
  • Fuzzing, target image parsers, update package parsers, and communication interfaces used in recovery.
  • Emulation and differential testing, run boot code across many configurations to catch strap and fuse corner cases.
  • Penetration testing, include debug abuse, fault injection attempts, and attempts to subvert lifecycle transitions.

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.

  • Root of trust architecture overview, including boot stages and trust boundaries.
  • Lifecycle state definitions and debug policy.
  • Attestation format and sample verification code for relying parties.
  • Key management description, including provisioning and revocation processes.
  • Firmware update threat model and failure behavior.
  • Security advisories and patch policy, including how rollback protections interact with emergency fixes.

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.

  • At reset, ROM reads lifecycle state and debug configuration, sets PMP regions for ROM and key handling memory, and locks them.
  • ROM reads a first stage image from flash, verifies its signature with a vendor root public key stored in ROM or locked OTP, checks an anti-rollback counter, measures the image, and stores the hash in a protected measurement log.
  • ROM derives an attestation key from the Unique Device Secret and the measurement log, then hands control to first stage.
  • First stage configures bus firewalls so DMA peripherals cannot access root of trust regions, then verifies and measures the OS loader and configuration blobs.
  • After boot, an attestation service signs a report that includes device identity, lifecycle state, debug state, rollback counters, and all boot measurements, plus a server-provided nonce.
  • The server validates the signature, checks certificate chains, compares measurements to an allow list, and issues authorization tokens only to devices that match policy.

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.

  • Myth: Open ISA means insecure. Reality: openness can improve review. Security failures usually come from integration, keys, and policy, not the ISA.
  • Myth: Secure boot equals device security. Reality: without anti-rollback, lifecycle control, and debug policy, secure boot can be bypassed indirectly.
  • Myth: Putting security code in M-mode makes it safe. Reality: privilege helps, but large privileged codebases are hard to verify and easy to misuse.
  • Myth: Attestation is optional. Reality: for fleets and high value assets, you need remote visibility to manage risk over time.
  • Myth: Keys are safe if stored in flash and “encrypted.” Reality: attackers often recover keys through debug, DMA, faults, or firmware bugs. Hardware backed protection matters.

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

  • Immutable ROM that verifies next stage signatures.
  • Production lifecycle lock and debug disabled by default.
  • Anti-rollback for boot-critical components.
  • Basic key protection, either derived keys or OTP-stored secrets.
  • Secure update with signature verification and failure safe rollback behavior.

Phase 2, verifiability and fleet control

  • Measured boot across all stages and critical configuration.
  • Remote attestation with freshness and a stable evidence format.
  • Revocation strategy for signing keys and device identities.
  • DMA and bus isolation improvements, with testing to confirm.

Phase 3, higher assurance and physical resilience

  • Formal verification of boot policy state machines and rollback logic.
  • Glitch and fault injection hardening, plus lab validation.
  • Side channel testing and hardened crypto implementations where needed.
  • Supply chain audits and stronger provisioning controls, including HSM integration.

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.