Shoot on (Core)Sight: Re-enabling Secure Debug on the RP2350 with Photon-Emission Microscopy and Laser Fault Injection

arXiv:2611.06386 · cs.CR · Submitted 2026-11-04 · 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: I'm Nadia.

Elias: And I'm Elias, here with Priya.

Nadia: We're looking at the paper: "Shoot on (Core)Sight".

Elias: Here's the gist of the paper. Fault-resistant policy storage does not guarantee fault-resistant enforcement on the RP2350A4 using differential photon-emission microscopy and laser fault injection The work demonstrates that protecting stored policy alone is insufficient when an attacker can alter the registers that enforce it.

Nadia: Pruning redundant reasoning tokens The paper addresses the distinction between fault-resistant policy storage and fault-resistant enforcement on the RP2350A4.

Elias: It shows how a mutable DEBUGEN register can override CRIT1.DEBUG DISABLE, allowing a fault to bypass the policy.

Nadia: Restoring Secure debug permits an attacker to halt the processor and read firmware and data accessible to Secure software.

Title and authors: Nadia: So we’re talking about this paper called "Shoot on (Core)Sight: Re-enabling Secure Debug on the RP2350 with Photon-Emission Microscopy and Laser Fault Injection". It sounds like they're tackling a problem where just having a policy to protect something isn't enough if someone can mess with the actual registers that enforce it.

Elias: Right, that’s exactly what this paper is about. They show this distinction between fault-resistant policy storage and fault-resistant enforcement on the RP2350A4 using differential photon-emission microscopy and laser fault injection. It's not just about the storage being safe; it's about how an attacker can change those registers that enforce the policy.

Priya: So, what’s the core of this distinction for us? If you store a policy securely in One Time Programmable memory, but an attacker finds a way to flip a control register that says "disable debug," then the storage security is bypassed.

Nadia: Exactly. They demonstrate that protecting stored policy alone isn't enough when an attacker can alter those registers that enforce it. It shows how a mutable DEBUGEN register can override something called CRIT1 point debug disable, letting a fault bypass the policy entirely >

Elias: And they show that this mutable register is the key issue. When you restore secure debug permits, an attacker can halt the processor and read firmware and data that Secure software normally keeps private >

Priya: That implies we need to look at runtime enforcement mechanisms more deeply than just looking at what's stored on disk or in OTP memory >

Nadia: Right. And they developed a way to find these weak points using differential photon-emission microscopy for isolating emission from a memory-mapped register, and then using laser fault injection to test them >

Elias: The methodology here is pretty interesting. They used an atomic XOR excitation loop, acquisition-order balancing, and outlier rejection to build their differential PEM method for isolating the emission associated with that specific register >

Priya: So they successfully localized two adjacent sites on one RP2350A4 that were responsive to laser fault injection, which is a big step in mapping out where the physical circuitry corresponds to those security registers >

Nadia: They used this localization to devise an SWD-guided attack sequence that actually restored sustained core one secure debug access, which shows how online attacks can work against these hardware protections >

Elias: That leads us to the gains they found. The setup involved offline characterization using PEM to toggle those DEBUGEN bits and report the register values during laser fault injection mapping >

Priya: And the differential processing part, removing offsets and shared background, filtering acquisition cycles, and screening pixels within each session was key to finding those localized mean differences >

Nadia: Then they guided laser injection specifically targeted two sites that were about one point seven micrometers apart where pulses produced sustained changes from zero to one in both PROC one and PROC one secure >

Elias: That's a very precise physical targeting. And then they showed a rescue reset sequence that bypassed runtime OTP locks, which affects any RP2350 secret protected by those locks >

Priya: The sequence involved issuing a rescue reset through the RP-AP, reconnecting over SWD, and applying an SWD-guided sequence until DEBUGEN read back as zero C H >

Nadia: That process allowed them to read a one hundred twenty-eight bit test secret directly from OTP without even modifying the stored policy itself > <ref:2611.06386#pg1,a 128 bit test secret>

Elias: So what this means for us is that restoring secure debug provides complete access to the processor state, but it doesn't bypass secure boot signature verification, meaning firmware cannot fully mitigate this attack >

Priya: It really hammers home that redundancy should extend along the whole chain, from OTP storage all the way to those specific registers that grant debug access >

Nadia: We’re wrapping up this look at "Shoot on (Core)Sight," and it shows us that fault-resistant policy storage doesn't guarantee fault-resistant enforcement when an attacker can manipulate the enforcement mechanism itself >

Elias: It’s a reminder that we need to consider the entire chain of trust, not just the static storage layer >

Priya: For me, it shows that even with physical attacks like laser injection, there are still subtle runtime controls like those page locks that can be exploited if you can find a way around them >

Nadia: Exactly. So next time we see a security paper, we need to ask where the enforcement happens and whether an attacker can get in there >

The paper's summary: Nadia: So, we’re talking about this paper called "Shoot on (Core)Sight: Re-enabling Secure Debug on the RP2350 with Photon-Emission Microscopy and Laser Fault Injection". It shows that just having a policy to protect something isn't enough if an attacker can mess with the actual registers that enforce it.

Elias: Right, so they’re looking at this split between how a policy is stored and how the hardware actually enforces it on the RP2350A4. They show you can have safe storage, but if someone targets those specific control registers, like a DEBUGEN register, they can override everything.

Priya: So the core idea here is that the security of your stored policy is only as good as how well protected that enforcement mechanism is at runtime. If the hardware itself has a weak point you can hit with an external fault, the whole security chain breaks down.

Nadia: Exactly. They found that a mutable DEBUGEN register can override settings like CRIT1 point debug disable, which lets them bypass the policy entirely during a fault injection attack on Core One. That means they can halt the processor and read firmware or data that Secure software is supposed to keep locked away >

Elias: And they developed this method using differential photon-emission microscopy to physically locate those memory-mapped registers. They used an atomic XOR excitation loop and some clever filtering to isolate the specific emission signal from just one register >

Priya: That physical mapping is important because it shows you exactly where the weak spots are on the chip, which helps narrow down where you need to aim your laser fault injection attacks >

Nadia: They targeted two points about one point seven micrometers apart, and they used a guided attack sequence over Serial Wire Debug feedback to restore sustained secure debug access even after those faults were injected >

Elias: That leads into the rescue reset sequence they demonstrated. It’s a way to bypass runtime one time programmable locks that protect secrets stored in OTP memory, all while reading that twelve eighty bit test secret without ever changing the stored policy >

Priya: So what this means for us is that even if you have strong storage mechanisms and secure boot checks, if there's a physical access path to manipulate the enforcement registers, those protections are bypassed >

Nadia: They conclude that because restoring secure debug gives complete access to the processor state without breaking secure boot signature verification, firmware can't fully stop this kind of attack >

Elias: The implication is that redundancy needs to cover the whole chain, from where you store the secret in OTP all the way to those final registers that grant debug access >

Priya: It shows us we need to look at runtime controls and physical access paths just as much as we look at cryptographic parameters and storage methods >

Nadia: Next up, we’re going to talk about how these kinds of physical attacks on hardware interact with the AI tools people are building today.

The paper's improvements: Tom: So, we’re talking about how the authors suggest ways to make this whole attack detection system better based on what they found in their experiment with the RP2350A4.

Nadia: They point out that AI systems can actually detect these policy enforcement failures by just monitoring runtime registers like the DEBUGEN register, which can override persistent OTP flags like CRIT1 point debug disable >

Elias: That makes sense. It means an AI doesn't have to wait for a full system crash; it can watch those specific bits flip and flag them as suspicious behavior that bypasses the policy >

Priya: I like that because it moves the detection from just looking at the final state of a secure flag to watching the immediate action of the hardware itself, which is much more reactive >

Nadia: They also suggest using differential photon-emission microscopy to locate those physical circuitry corresponding to memory-mapped security registers, which really narrows down where you should aim your laser fault injection attacks >

Elias: That’s a big step for practical research because it gives you a physical map of the vulnerabilities instead of just guessing where the weak points are on the chip >

Priya: And they also propose an online attack sequence guided by Serial Wire Debug feedback that can restore sustained core one secure debug access, showing that an attacker can do this remotely under specific conditions >

Nadia: So it’s not just about finding a bug; it’s about building a system that actively restores access even when the policy is locked down, which changes how we think about defense >

Elias: It suggests the need for continuous verification because if you can get back in, you have to be able to regain control through feedback loops, not just static defenses >

Priya: The paper flags a limitation though. They don't cover every possible way to manipulate the system; they show what they found, but it’s not a complete blueprint for every hardware security scenario >

Nadia: Right. So while they’ve shown a very targeted physical attack vector, the real challenge is figuring out how much of that manipulation is actually cheap and accessible to an attacker >

Elias: That brings us back to the bigger picture: if we can find these specific physical levers, it makes us wonder what kind of AI tools might be used to automate finding those exact register manipulations >

Conclusion: Tom: So we’re wrapping up "Shoot on (Core)Sight: Re-enabling Secure Debug on the RP2350 with Photon-Emission Microscopy and Laser Fault Injection". It boils down to this: protecting stored policy isn't enough if someone can manipulate the registers that enforce it >

Nadia: That’s right. They showed how an attacker can use a mutable DEBUGEN register to bypass security policies when they have physical fault injection capabilities >

Elias: And the results are pretty clear about the rescue reset sequence; it lets you read secrets like a one two eight bit test secret even if runtime OTP locks are in place >

Priya: What this means for us is that we can't just trust the storage layer anymore, because there’s always a physical path to the enforcement mechanism itself >

Nadia: Exactly. They conclude that redundancy needs to extend all the way from the one time programmable memory all the way to those specific registers that grant debug access >

Elias: It’s a strong statement because it shows that even with secure boot checks, firmware can't fully mitigate this kind of hardware-level bypass >

Priya: I just think it highlights how much we need to consider the physical reality of the chip when designing security systems, not just the mathematical proofs behind them >

Nadia: We’ll keep looking at those physical vulnerabilities. Next time, we’re going to look at how these kinds of hardware attacks interact with the AI tools people are building today >

Antoine Plin

Ledger · ESILV · Georgia Institute of Technology

cs.CR

Submitted: 2026-11-04

Updated: 2026-11-04

Comments: pre-print

Code: https://github.com/raspberrypi/rp2350_hacking_challenge

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

Importance score: 90/100

The gist: Fault-resistant policy storage does not guarantee fault-resistant enforcement on the RP2350A4 using differential photon-emission microscopy and laser fault injection The work demonstrates that…

Key concepts

Fault-resistant policy storage
This refers to securely saving configuration settings, like which features are enabled or disabled, in non-volatile memory (OTP). The goal is to make these stored settings extremely difficult for an attacker to tamper with or change after the device is manufactured. It's a static defense against policy modification.
Fault-resistant enforcement
This is the actual process of checking and applying those stored policies during runtime. The paper shows that even if the policy storage is secure, if an attacker can manipulate specific registers that dictate how enforcement works, they can bypass the intended security rules without changing the stored policy itself.
Differential PEM
This is a technique using differential photon-emission microscopy to precisely locate which physical circuitry corresponds to a specific memory register. By comparing emission patterns under different conditions, researchers can isolate the signal from that exact register, helping them target where faults and attacks are most effective.
Rescue-Reset Sequence
This is a recovery method used when security locks prevent normal operation. The authors demonstrated a specific sequence involving the RP-AP and SWD to force a reset before runtime OTP locks can fully engage. This allows them to recover sensitive data, like test secrets, bypassing persistent security denials.

Terminology

Summary

Fault-resistant policy storage does not guarantee fault-resistant enforcement on the RP2350A4 using differential photon-emission microscopy and laser fault injection The work demonstrates that protecting stored policy alone is insufficient when an attacker can alter the registers that enforce it. p. 0

Pruning redundant reasoning tokens

The paper addresses the distinction between fault-resistant policy storage and fault-resistant enforcement on the RP2350A4. It shows how a mutable DEBUGEN register can override CRIT1. p. 0DEBUG DISABLE, allowing a fault to bypass the policy. p. 0 Restoring Secure debug permits an attacker to halt the processor and read firmware and data accessible to Secure software. p. 0

How the training signal is built

The authors developed a differential PEM method for isolating emission associated with a memory-mapped register using an atomicXOR excitation loop, acquisition-order balancing, and outlier rejection. They successfully localized two adjacent LFI-responsive sites on one RP2350A4 and devised an SWD-guided attack sequence that restored sustained core 1 Secure debug access. p. 0

Where the gains come from

The experimental setup involved offline characterization using PEM to toggle DEBUGEN bits and report register values during LFI mapping. The differential PEM processing involved removing offsets and shared background, filtering acquisition cycles, and screening pixels within each session to find localized mean differences. p. 3 Guided laser injection targeted two sites approximately 1. p. 47 µm apart where pulses produced sustained changes from zero to one in PROC1 and PROC1 SECURE. p. 4

Rescue-Reset Sequence

The authors demonstrated a rescue-reset bypass of runtime OTP locks, which affects any RP2350 secret those locks protect. The sequence involved issuing a rescue reset through the RP-AP, reconnected over SWD, and applying an SWD-guided sequence until DEBUGEN read back as 0xc. p. 6 This process allowed them to read the 128-bit test secret from OTP without modifying the stored OTP policy. p. 6

Conclusion

Restoring Secure debug provides complete access to processor state without bypassing secure-boot signature verification, meaning firmware cannot fully mitigate this attack. The paper concludes that redundancy should extend along the whole chain, from OTP storage to the register that grants debug access. p. 6

ACKNOWLEDGMENT

We disclosed the findings described in this paper to Raspberry Pi Ltd. on July 28, 2026 We thank their team for the prompt, professional response and transparent approach to hardware security. p. 6

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. Improved AI systems can detect fault-resistant policy enforcement failures by monitoring runtime registers like DEBUGEN, which can override persistent OTP flags such as CRIT1.DEBUG DISABLE, allowing for detection of fault-induced bypasses.

  2. The improved system can utilize differential photon-emission microscopy to locate the physical circuitry corresponding to memory-mapped security registers, narrowing the search space for subsequent laser fault injection attacks.

  3. The system can implement a rescue reset sequence that halts boot before user firmware applies runtime OTP locks, enabling recovery of secrets like a 128-bit test secret even when persistent policies deny access.

  4. An online attack sequence guided by Serial Wire Debug feedback can restore sustained core 1 Secure debug access, demonstrating that Protecting stored policy alone does not guarantee fault-resistant enforcement.

Related papers