/

CVE-2026-71694

Severity:

HIGH RISK

(8.8)

CSRF (CWE-352) in BOOM Processor CSR Trap Handling

CVE-2026-71694

Deferred

Vulnerability type

Category:

Cross-Site Request Forgery

CWE:

CWE-352

Impact:

Arbitrary Code Execution

Severity:

HIGH RISK

(8.8)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

A high-severity flaw in the BOOM RTL benchmark affects CSR trap-return state restoration, MRET handling, and the mstatus.MPRV update path. Under conditions that allow a remote party to reach the affected processor logic, the issue may enable arbitrary code execution or unauthorized changes to processor control flow.

Affected context

The issue occurs in the Berkeley Out-of-Order Machine (BOOM) RTL benchmark, particularly the ProcessorFuzz BOOM implementation and its CSRFile logic in SmallBoomTile_v1.2_state.v. Risk is present when externally influenced execution can reach the affected trap-return and privilege-state restoration paths, and when the resulting CSR state is not restored or constrained as intended.

Exploit preconditions

  • Attack surface: A remotely reachable processor or benchmark execution environment
  • Required access: Ability to cause execution of instructions or events that exercise the affected CSR trap-return logic
  • Trigger point: MRET handling, CSR trap-return state restoration, or the mstatus.MPRV update path
  • Why exploitation is possible: An incorrect state transition may permit attacker-influenced control or privilege state to persist across trap return, potentially redirecting execution or enabling unauthorized operations

Why this happens

The underlying issue is an unsafe state-management condition in processor control and status register handling. Trap-return logic must restore privilege, memory-access, and execution state consistently; an error in the CSRFile, MRET, or mstatus.MPRV update path can leave security-relevant state inconsistent with the architectural context. The supplied classification maps this behavior to CWE-352, although the described weakness is implemented in RTL control-state handling rather than a conventional web request workflow.

Potential impact

  • An attacker may execute arbitrary code in the affected processor environment.
  • Processor control flow could be altered or redirected.
  • Privilege or memory-access boundaries could be weakened.
  • Benchmark, simulation, or dependent verification environments could be compromised.
  • Security-sensitive state may persist incorrectly across exception or trap handling.

General mitigation guidance

Mitigation generally focuses on making CSR trap-return behavior explicit, formally constrained, and resistant to attacker-influenced state transitions.

Common defensive patterns include:

  • Applying strict architectural checks to MRET and related trap-return transitions.
  • Preserving and restoring privilege and memory-access state through a single validated control path.
  • Constraining mstatus.MPRV updates according to the processor privilege model.
  • Using assertions, invariants, and formal verification for CSRFile and exception-return behavior.
  • Restricting remote access to benchmark and simulation interfaces.
  • Running verification workloads with least privilege and isolated resources.

How teams detect issues like this

Detection approaches may include:

  • Static review of MRET, trap-return, CSRFile, and mstatus.MPRV state-transition logic.
  • RTL assertions verifying legal privilege transitions and restoration of security-sensitive CSR fields.
  • Formal analysis of exception entry and return sequences, including nested traps and unusual privilege combinations.
  • Code-review checks for state updates that occur on only some trap-return paths.
  • Policy enforcement requiring security-focused RTL verification before externally reachable benchmark components are deployed.
  • Automated hardware-security analysis tools can help identify inconsistent control-state transitions.

Sources

SourceLink
github.comgithub.com/bu-icsg/ProcessorFuzz
github.comgithub.com/duan528/BOOM-MRET-MPRV-Vulnerability-Report
github.comgithub.com/riscv-boom/riscv-boom
github.comgithub.com/riscv/riscv-isa-manual

Frequently asked

questions

The report identifies a remote attack path, but practical exploitability depends on whether an attacker can reach the affected BOOM execution environment and trigger the relevant CSR trap-return behavior.

Authentication requirements depend on how the benchmark, processor instance, or surrounding service is exposed. The key requirement is the ability to influence execution sufficiently to exercise the vulnerable state-transition path.

Validate and formally constrain MRET and CSR state restoration, especially updates involving privilege and memory-access controls. Security-sensitive state should not be allowed to persist across trap returns without architectural checks.

Combine RTL code review with assertions, formal verification, transition-coverage testing, and strict isolation of remotely reachable simulation or benchmark interfaces.

Find out what's already
exploitable in your codebase.