Hardware security verification is essential wherever software relies on a system-on-chip (SoC) to enforce access controls, isolate workloads or protect sensitive information. Yet a design can meet its functional specification and still contain RTL bugs that software can trigger. These flaws may cross module boundaries or depend on timing and hidden microarchitectural state, making them difficult to identify before manufacturing.
A study presented at the 28th USENIX Security Symposium examined this gap using a testbed of 31 real-world-inspired RTL bugs in RISC-V SoCs. Its findings offer a useful perspective for engineers and technical decision-makers responsible for embedded hardware: security assurance must account not only for what a design computes, but also for how its components interact and what software can observe.
Why hardware security verification is challenging
SoCs combine processor cores, memory systems, interconnects, peripherals and third-party intellectual property. Each component may behave correctly in isolation while an interaction between components creates a security weakness. A small RTL error—such as an incorrect address range, conditional statement or state-machine transition—can therefore undermine a system-level security objective.
That risk differs from a typical software defect. Hardware logic is synthesized into the chip, and a flaw may persist after production. A software or firmware update can sometimes reduce exposure, but it may not remove the underlying circuit defect. In some cases, a post-production issue may require a product recall.
Hardware security development processes combine techniques such as manual RTL review, simulation, emulation and formal verification. These methods are valuable, but their effectiveness depends on specifying the right security properties and modeling the relevant parts of the design. The study identified several recurring obstacles.
Four verification gaps behind “HardFails”
Cross-module effects
A vulnerability may begin in one module and become exploitable through logic elsewhere in the SoC. For example, an address-range overlap can let one peripheral reach another peripheral’s registers. Verifying this behavior may require modeling the interconnect and multiple connected modules together. As the modeled design grows, the state space can become difficult to analyze.
Abstraction can help manage complexity, but it must be applied carefully. If a module is treated as a black box or the modeled state is constrained too aggressively, a relevant interaction may be missed. The researchers use the term HardFails for classes of RTL bugs that are especially difficult for current security-verification approaches to detect.
Timing-flow gaps
Functional verification asks whether a circuit produces the right result. Security analysis may also need to ask how many clock cycles it takes to produce that result. If latency depends on an input or internal state, software may be able to measure the difference and infer information.
The study describes a RISC-V processor case in which different types of page faults took different numbers of clock cycles. That timing disparity could reveal information about memory mappings. Checking for this kind of channel requires reasoning about timing across multiple modules, not just the functional values moving through the logic.
Unmodeled cache state
Some verification approaches focus on architectural state, particularly registers. But a processor’s caches also retain state, and changes to that state can be observable through later software behavior. The study discusses a case involving instruction prefetch around a system-return instruction: cache entries fetched at a higher privilege level were not flushed when execution changed to a less privileged level.
This illustrates why verifying privilege transitions may require checking microarchitectural effects as well as register values. If cache behavior is outside the verification model, a security-relevant state change may go unnoticed.
Hardware-software interactions
RTL alone does not always reveal whether a behavior is secure. Firmware may configure access controls, select memory ranges or determine where sensitive data is stored. A hardware design can therefore appear ambiguous until its interaction with firmware is considered.
In one study example, the location of a cryptographic key depended on software configuration. Evaluating the security of the data flow required understanding both the hardware logic and the firmware’s role. Verification methods that analyze each layer separately may not capture the complete risk.
What the testbed revealed
The researchers constructed 31 bugs based on public vulnerability reports, real-world errata and industry experience, then injected them into open-source RISC-V SoC designs. They also organized Hack@DAC, a hardware-security competition involving 54 teams. Participants used methods including manual inspection, simulation and software-based testing.
The evaluation found that some bugs escaped both competition participants and formal-verification tools. The study’s case analyses point to specific challenges: cross-module interactions, timing behavior, non-register state and dependencies on firmware. The results do not mean that formal verification or manual review is ineffective. Rather, they show that no single method can be assumed to cover every security-relevant behavior, particularly when the security property itself is difficult to express or model.
Practical considerations for design teams
For teams developing SoCs and embedded platforms, the findings support treating security as a lifecycle concern rather than a final sign-off step. Useful review questions include:
- Do security properties cover interactions across the interconnect and connected modules, not just individual blocks?
- Could differences in clock-cycle latency reveal information about inputs, privilege levels or internal state?
- Are caches and other non-register states included in the security model where relevant?
- Are firmware configuration and hardware behavior evaluated together when access controls or data locations depend on software?
- Are abstractions and state-space constraints reviewed to ensure they do not hide the behaviors under investigation?
These questions complement functional verification; they do not replace it. The appropriate verification plan depends on the system’s architecture, threat model and security objectives. Clear specifications are particularly important because automated tools can only check the properties that designers successfully define and encode.
Conclusion: verify observable behavior across layers
Software-exploitable hardware bugs can arise from small RTL mistakes but have consequences that span an entire platform. The HardFails analysis shows why security verification must look beyond isolated logic and account for cross-module behavior, timing, cache state and firmware interactions. For engineering organizations, the practical lesson is to make these behaviors explicit in security requirements and verification plans, then use complementary analysis methods to examine them before tape-out. That broader view can help expose gaps that conventional functional checks alone may not reveal.