SensorGuard-RV: Sensor-to-Register Data Protection for Resource-Constrained RISC-V Devices

arXiv:2611.08380 · cs.CR, cs.AR · Submitted 2026-11-05 · Read on arXiv

Listen

Radio episode about this paper

Transcript

Introduction to the show: ident: Security Radio. Generated commentary on the latest security and cryptography papers.

Nadia: We're looking at the paper: "SensorGuard-RV: Sensor-to-Register Data Protection for Resource-Constrained RISC-V Devices".

Elias: Here's the gist of the paper. SensorGuard-RV presents Sensor-to-Register Data Protection for Resource-Constrained RISC-V Devices by delivering sensor samples into processor registers without trusting intermediate software, buses, or memory This hardware-first approach involves a write-once ownership switch and hardware-level authenticated encryption to secure sensor data System Architecture

Title and authors: Nadia: We talked about how SensorGuard-RV moves the trust boundary down to the hardware acquisition layer, removing reliance on driver software and intermediate buffers. Now let’s look at what the authors actually proposed in this paper, "SensorGuard-RV: Sensor-to-Register Data Protection for Resource-Constrained RISC-V Devices." >

Elias: They are focusing specifically on how to get sensor samples into the processor registers securely, and they present a hardware acquisition architecture combined with authenticated encryption.

Priya: So, what’s the main problem they’re trying to solve in this specific context? Because sensor data is usually sensitive because it represents physical reality, right >

Nadia: Exactly. Sensor measurements travel through a whole stack—the peripheral interfaces, the communication buses, and all those drivers—and an attacker can intercept or alter that reading before it gets to the application >

Elias: Existing defenses like trusted execution environments are often too heavyweight for resource-constrained devices, which is why they focus on this hardware-first approach >

Priya: I’m curious about the mechanism itself. How do they actually make sure that once the data is in a register, it's genuinely what the sensor sent, and not some fabricated value >

Nadia: They use hardware-level authenticated encryption to secure the data from acquisition all the way to register delivery >

Elias: And then they add this new RISC-V instruction extension that handles verification and decryption in one go >

Priya: That sounds promising, but I want to know about the specific security primitives they’re using for that encryption and authentication part. Is it something standard, or something custom >

Elias: They keep the keys within hardware, which is a big deal because it means even if an attacker gets read access to some memory, they can't just steal the keys to decrypt everything >

Nadia: So the goal here is to create a protection boundary that starts at the moment of sensor acquisition and ends exactly when it lands in the processor register >

Priya: That’s a very tight scope. If I were designing this, I’d wonder how they handle configuration—how do you set up this hardware-first system without introducing new attack surfaces during setup >

Elias: They mention requiring a sensor-specific acquisition front end and serialised access to the CFU's staged tag context for that setup phase >

Nadia: It sounds like the complexity shifts from runtime software checking to a more complex initial configuration process managed by hardware registers >

Priya: So, it’s less about protecting every single piece of code execution and more about securing the data as it moves through the physical path >

Elias: That’s right. They are not trying to isolate the consuming program; they are isolating the acquisition path itself from untrusted software >

Nadia: And that simplifies things for smaller devices, though it means you have to be very precise about configuring those physical memory protections if you don't want vulnerabilities there >

Priya: It seems like a trade-off: less code complexity in the application layer, but more rigor needed in the hardware configuration and initial setup phase >

The paper's summary: Nadia: So we’ve seen the title and the core concept. Now let’s go into what they actually summarized in this paper, "SensorGuard-RV: Sensor-to-Register Data Protection for Resource-Constrained RISC-V Devices." >

Elias: Essentially, the summary is about tackling the fragility of existing defenses that rely on trusted driver software and correctly configured access control in embedded systems >

Priya: So they are saying that those traditional methods aren't robust enough when you consider how easily an attacker can compromise that path from sensor to application >

Nadia: Right, because if you can’t trust the software between the sensor and the register, then your entire defense strategy built on trusting that software becomes fragile >

Elias: And they propose SensorGuard-RV as a hardware-first solution that delivers samples into processor registers without needing to trust any intermediate software or buses >

Priya: The key summary point I’m picking up is the removal of driver software from the trusted path after the initial configuration phase >

Nadia: That means that once you configure it, the intervening code and memory are treated as untrusted, which is a huge simplification for building secure embedded systems >

Elias: They also highlight their contribution of a RISC-V instruction set extension that performs the verification and decryption of the measurement right at the point of register writeback >

Priya: So, it’s not just about stopping eavesdropping; it’s about ensuring data integrity and freshness through replay rejection as well >

Nadia: They also detail how they handle replay attacks by tying the sequence number directly to a per-boot nonce epoch >

Elias: That mechanism means an adversary cannot simply record old packets and replay them later because the sequence number determines that nonce, making it hard to forge a valid packet >

Priya: That seems like a very concrete way to address one of the biggest threats in embedded data integrity, which is replay attacks >

Nadia: Right. And they also showed they can reject replayed packets by verifying that sequence number against this epoch before allowing the register writeback >

Elias: The whole point is that the decision to release a verified measurement happens entirely in hardware, not in software >

Priya: So, if I’m listening to this paper, I should think: "I don't trust anything between the sensor and my register; this instruction handles the verification for me" >

The paper's improvements: Nadia: Okay, let’s talk about the specific improvements they detail. What are the key technical additions that make SensorGuard-RV better than what was out there before? >

Elias: One major improvement is that they introduced a hardware acquisition architecture that combines exclusive sensor ownership with authenticated encryption, removing driver software from the trusted path after configuration >

Priya: That’s the first big thing—the ownership switch combined with encryption to secure the data path itself rather than just trusting a single piece of code >

Nadia: And then they have this RISC-V instruction set extension that performs authentication and decryption, which is really pushing the boundary on where security happens >

Elias: That instruction verifies and decrypts a complete protected measurement, rejects replay, and permits register writeback only after successful authentication and freshness verification >

Priya: So, to summarize the improvements: you have a hardware acquisition that eliminates driver trust, coupled with an instruction that enforces integrity checks on every read operation >

Nadia: And they showed they can reject replayed packets by verifying the sequence number against a per-boot nonce epoch, which is a strong defense against replay attempts >

Elias: That mechanism prevents packets recorded before a system reset from being accepted afterwards because the sequence number determines the nonce, making it hard for an adversary to raise it without invalidating the tag >

Priya: And they also achieved some real gains in performance; they showed sustained throughput for protected sensing can increase by five point three one percent compared to a software-driven SPI baseline >

Nadia: That means moving away from constant per-byte software polling gives them a measurable speedup, hitting nineteen thousand fifteen transactions per second at one hundred MHz >

Elias: And they also addressed the issue of supporting multiple sources or larger payloads by requiring per-source sequence state and authenticated metadata >

Priya: That part is interesting because it shows they aren't just optimizing for a single, simple sensor stream; they’re thinking about real-world multi-sensor setups >

Nadia: So the improvement isn't just security, it’s also efficiency gains by removing that per-byte software polling overhead >

Elias: That overhead is what makes these things slow in practice for low-power devices, so getting rid of that seems like a necessary engineering step >

Conclusion: Nadia: We’ve covered the architecture, the mechanisms, and those performance metrics. So to wrap up this discussion on "SensorGuard-RV: Sensor-to-Register Data Protection for Resource-Constrained RISC-V Devices," what are the big implications here? >

Elias: The implication is that we can move security enforcement from software layers into the core processor instruction set, which fundamentally changes how we think about protecting sensitive sensor data >

Priya: For researchers and practitioners, this suggests a much more practical way to handle data integrity in embedded systems without needing complex, resource-heavy TEE setups >

Nadia: It’s about creating a secure path where the decision to release verified measurements is made entirely in hardware, which simplifies the design of many critical devices >

Elias: And while it adds complexity on the configuration side—needing sensor-specific front ends and strict PMP settings—it seems like a worthwhile trade for gaining strong protection against data tampering and replay attacks >

Priya: I just think it’s a very solid, practical solution that addresses the real-world constraints of embedded hardware very directly, focusing on what happens on the physical bus >

Nadia: So to close out this discussion on SensorGuard-RV: it’s a hardware-first approach that secures sensor data by ensuring that nothing untrusted can ever reach the processor register without going through a verified, authenticated process >

Hamid Noori, Carlton Shepherd

Durham University

cs.CR, cs.AR

Submitted: 2026-11-05

Updated: 2026-11-05

Code: https://github.com/stnolting/neorv32

License: http://arxiv.org/licenses/nonexclusive-distrib/1.0/

Importance score: 86/100

The gist: SensorGuard-RV presents Sensor-to-Register Data Protection for Resource-Constrained RISC-V Devices by delivering sensor samples into processor registers without trusting intermediate software…

Key concepts

Hardware Acquisition Architecture
This architecture removes driver software from the secure path after initial setup. It ensures that sensor samples are delivered into processor registers directly, meaning any intervening software or buses cannot tamper with the data before it reaches the CPU. This establishes a root of trust at the hardware level.
RISC-V Instruction Set Extension
A custom instruction set is developed to handle verification and decryption of protected measurements. This hardware logic checks for authentication, rejects replay attempts, and only allows writing the data to registers after successful validation. This places the critical security decision directly in the hardware.
Sequence Number and Nonce Epoch
The system uses a sequence number that is tied to a per-boot nonce epoch. The sequence number dictates the nonce, making it impossible for an attacker to simply increment it without invalidating the authentication tag. This mechanism also prevents old, replayed packets from being accepted after a system reset.
Hardware-Level Authenticated Encryption
The system employs hardware encryption to secure sensor data. This process ensures that the data is encrypted and authenticated at the hardware level, providing strong protection against eavesdropping and tampering. It is a core component of the defense strategy against untrusted intermediate components.

Terminology

Summary

SensorGuard-RV presents Sensor-to-Register Data Protection for Resource-Constrained RISC-V Devices by delivering sensor samples into processor registers without trusting intermediate software, buses, or memory This hardware-first approach involves a write-once ownership switch and hardware-level authenticated encryption to secure sensor data

System Architecture

Green — the paper says it, and the page is printed. Red — no passage carries it, so treat that sentence as unverified. The same check runs on your own text: check a summary against its source, $5.

Improvements for AI systems

  1. Hardware acquisition architecture removes driver software from the trusted path after configuration, meaning the intervening software and buffers to remain untrusted. This allows for sensor samples to be delivered into processor registers without trusting intermediate software or buses.

  2. A RISC-V instruction set extension is developed that verifies and decrypts a complete protected measurement, rejects replay and permits register writeback only after successful authentication and freshness verification. This ensures that no local mechanism can protect a reading by placing the decision to release a verified measurement in hardware.

  3. The system can reject replayed packets by verifying the sequence number against a per-boot nonce epoch. This is achieved because the sequence number determines the nonce, an adversary cannot raise it without invalidating the tag, and a per-boot epoch prevents packets recorded before a reset from being accepted afterwards.

  4. Sustained throughput for protected sensing can be increased by 5.31% compared to a software-driven SPI baseline, achieving 19,015 transactions/s at 100 MHz, due to the removal of per-byte software polling.

  5. The system can support multiple sources and larger payloads by requiring per-source sequence state and authenticated metadata, which is necessary because a single sequence register only supports one sensor stream in the prototype.

Related papers