Modern security architectures rely on a fundamental assumption: the underlying hardware faithfully enforces the privilege boundaries defined by the software. An unprivileged user-space application should never be able to access kernel memory, let alone subvert the secure enclave of a trusted execution environment.
However, a growing body of research demonstrates a critical architectural blind spot. Hardware features designed for debugging, performance optimization, or modular hardware integration often operate on a parallel plane that completely bypasses or ignores software privilege levels. When these hardware mechanisms fail to validate the software privilege of the entity interacting with them, they create a dangerous cross-layer synergy. Attackers can exploit these legitimate hardware designs to achieve full system compromise without needing to exploit a single traditional software bug.
The Debugging Backdoor
To understand how hardware features can subvert software isolation, we can look at modern processor debugging architectures. Historically, debugging required physical access to a device to attach hardware probes (such as JTAG). To facilitate debugging on modern, highly integrated System-on-Chips (SoCs), chip designers introduced inter-processor debugging. This feature allows one on-chip core (the host) to debug another core (the target) via memory-mapped interfaces, entirely removing the need for physical access.
As exposed by Fengwei Zhang et al. in Understanding the Security of ARM Debugging Features, this architectural shift introduced a fundamental security flaw. The hardware authentication signals used to authorize a debug session were originally designed for the physical probe model; they verify whether the target core is allowed to be debugged, but they completely fail to validate the software privilege level of the host core initiating the request.
[ Low-Privilege Software (EL0) ]
│
▼ (Writes to Memory-Mapped Registers)
[ Host Core Debug Interface ] ──(No Privilege Check)──► [ Target Core (EL3/TrustZone) ]
│
▼
(Forced Instruction Execution)
This oversight enables the NAILGUN attack. An attacker running low-privilege software on a host core can write to memory-mapped debug registers to halt a target core. As further detailed by Chenxu Wang et al. in Revisiting ARM Debugging Features: Nailgun and its Defense, the attacker can then utilize hardware mechanisms like the Embedded Cross Trigger (ECT) and the Debug Instruction Transfer Register (EDITR) to force the target core to execute arbitrary instructions.
Crucially, the authors demonstrate that an attacker can force the target core to execute the dcps (Debug Change Privilege State) instruction, moving it into the highest privilege level (TrustZone/EL3). Because the hardware executes these legitimate debug commands without checking the host's software privilege, low-privilege software can completely bypass hardware-enforced isolation to steal sensitive data, such as AES keys and cryptographic tokens, directly from secure enclaves.
The Cache Coherence Blindspot
The disconnect between hardware-level mechanisms and software-level visibility extends beyond debugging features to core performance optimizations, such as cache coherence. In modern 2.5D chiplet systems, multiple independent silicon dies (chiplets) are integrated onto a single substrate and must maintain a unified view of memory. They achieve this through hardware-level cache coherence protocols, which automatically exchange messages to ensure that when one core modifies a memory location, all other caches are updated or invalidated.
As demonstrated by Gino A. Chacon et al. in Hardware Trojan Threats to Cache Coherence in Modern 2.5D Chiplet Systems, this hardware-managed layer is entirely transparent to the operating system and higher-level software security tools. The authors show that a malicious chiplet containing a Hardware Trojan can manipulate standard coherence messages to silently modify memory lines it does not own.
Because these transactions occur entirely within the hardware coherence fabric using legitimate architectural messages, they do not trigger page faults, memory management unit (MMU) exceptions, or software-based security alerts. The software layer remains completely unaware of the data corruption, allowing the hardware to silently subvert the system's security state from underneath the operating system.
Hardware-Assisted Software Exploitation
While some attacks exploit purely architectural design flaws, others leverage a coordinated synergy between malicious hardware components and unprivileged software applications. In a traditional operating system, a low-privilege application is heavily sandboxed and lacks the permissions required to interact directly with sensitive kernel structures.
However, Omer Shwartz et al. demonstrated in Shattered Trust: When Replacement Smartphone Components Attack that malicious hardware can act as a catalyst to break these sandboxes. By embedding a tiny, malicious microcontroller inside a replacement smartphone component (such as a touchscreen), an attacker can exploit the implicit trust that operating system drivers place in internal hardware.
The malicious hardware component deliberately triggers complex kernel vulnerabilities at precise, deterministic moments, such as during the boot process. Simultaneously, a companion software application with zero special permissions coordinates with the hardware. When the hardware triggers the kernel vulnerability, the unprivileged application leverages the resulting unstable state to escalate its privileges and gain full root control. This attack bypasses standard security boundaries because the software sandbox assumes the underlying hardware peripheral is benign and trustworthy.
Shifting the Security Paradigm
Why do these attacks work so effectively? The root cause is a mismatch in the mental models of hardware designers and software security architects. Software security models assume that the hardware acts as an immutable execution environment that strictly enforces privilege rings. In reality, hardware features like inter-processor debugging, cache coherence protocols, and peripheral buses operate on their own functional logic, often independent of the software's current privilege state.
To defend against these cross-layer exploits, security mechanisms must bridge this gap. For instance, Chenxu Wang et al. proposed a lightweight virtualization-based defense to mitigate the NAILGUN vulnerability, demonstrating that software-transparent hardware features must be explicitly constrained or monitored by a higher-privilege software layer (like a hypervisor) to prevent unauthorized access. Ultimately, securing modern systems requires abandoning the assumption of implicit hardware trust and ensuring that every hardware-level transaction is explicitly bound to, and validated against, the software privilege model.
Key Foundational Work
Understanding the Security of ARM Debugging Features (2019) — contributed 10 concept elements to this direction.
Shattered Trust: When Replacement Smartphone Components Attack (2018) — contributed 2 concept elements to this direction.