To maximize efficiency and lower costs, cloud providers increasingly allow multiple users to share a single piece of physical hardware. When multiple tenants run workloads on the same Field Programmable Gate Array (FPGA) or Neural Processing Unit (NPU), cloud management software enforces strict logical isolation. It ensures that Tenant A cannot read Tenant B’s memory space or intercept their data routing lines.
However, this logical isolation ignores a fundamental physical reality: all components on a single silicon chip must draw electrical current from the same underlying Power Distribution Network (PDN). As highlighted by Regazzoni et al., sharing these specialized computing resources introduces hardware-level vulnerabilities that bypass traditional software security boundaries. Because the physical power grid is shared, the computational activity of one tenant directly alters the electrical environment of another.
The Physics of Power-Based Vulnerabilities
To understand why these attacks work, we must look at how digital circuits consume power. A CMOS transistor draws significant current primarily when it switches states (from 0 to 1 or vice versa). If a circuit performs a massive parallel operation—such as a matrix multiplication in a deep learning model—millions of transistors switch simultaneously, causing a sudden spike in current demand ($I$).
Because physical power delivery lines possess inherent resistance ($R$) and inductance ($L$), a sudden surge in current causes a localized drop in voltage ($\Delta V$), governed by the relationship:
$$\Delta V = IR + L \frac{di}{dt}$$
This drop is known as a voltage droop. In a shared hardware environment, a voltage droop caused by Tenant A propagates across the shared PDN, instantly affecting the voltage supplied to Tenant B. This physical coupling enables two distinct classes of cross-tenant exploits: passive information leakage and active fault injection.
[Tenant A: High Activity] ──> Draws Massive Current (I)
│
▼
[Shared Power Distribution Network]
│
▼
Causes Voltage Droop (ΔV)
│
┌────────────────────────────┴────────────────────────────┐
▼ ▼
[Passive Side-Channel] [Active Fault Injection]
Attacker measures tiny ΔV Attacker intentionally forces massive ΔV
to infer Victim's data/instructions. to slow down signals and cause bit flips.
Passive Exploitation: Power Side-Channels
In a passive attack, a malicious tenant co-located on the same chip acts as a silent observer. Because a victim's power consumption fluctuates deterministically based on the specific data or instructions they are processing, the shared PDN's voltage fluctuates in tandem.
An attacker can deploy "soft sensors"—such as Time-to-Digital Converters (TDCs) implemented entirely in the reconfigurable logic fabric—to measure these minute voltage fluctuations over time.
- Instruction Extraction: Glamocanin et al. demonstrated that these power fluctuations are precise enough to leak information at the instruction level. By monitoring the shared PDN, an attacker can use deep learning models to identify the exact sequence of instructions being executed by a soft-core CPU sharing the FPGA fabric.
- Model Architecture Theft: This vulnerability is particularly severe for machine learning accelerators. Yan et al. introduced MERCURY, an automated attack targeting deep learning accelerators. By treating the voltage fluctuations recorded during an inference run as a sequence-to-sequence translation problem, the authors successfully reconstructed victim network architectures with less than 1% error.
Active Exploitation: Remote Fault Injection
Instead of merely listening, an attacker can actively manipulate the shared PDN to corrupt a neighbor's computation or crash the system. This is achieved via "power-hammering" or "power-plundering" circuits—structures like highly toggled ring oscillators designed solely to draw maximum current in a fraction of a nanosecond.
When an attacker activates these circuits, they force a massive, sudden voltage droop across the chip.
The security hazard stems from how voltage affects circuit timing. Digital logic relies on signals propagating through gates and arriving at a destination register before the next clock edge (known as the setup time). When the supply voltage drops, the transistors switch more slowly, delaying the signal. If the voltage drops low enough, the signal arrives too late, causing a timing violation and latching an incorrect bit value into memory.
- Surgical Data Corruption: Rakin et al. exploited this mechanism in their Deep-Dup framework. By precisely timing a power-plundering burst during a victim's deep neural network (DNN) data transfer, the authors induced surgical timing faults that caused specific weights to duplicate, effectively neutralizing the model's accuracy. Luo et al. demonstrated a similar capability with DeepStrike, showing that remotely guided fault injections can reliably disrupt DNN accelerators on cloud FPGAs.
- Persistent Reconfiguration Faults: The vulnerability is not limited to runtime data. Chaudhuri et al. showed that if an attacker triggers a power-hammering burst during the exact millisecond window when a neighbor's hardware is undergoing partial reconfiguration, the voltage drop can corrupt the incoming configuration bitstream, embedding permanent logic errors that evade standard runtime detection.
- Denial of Service: If the current draw is severe enough, it can bypass hardware safety fences entirely. La et al. demonstrated that aggressive power-hammering can draw enough current to trigger the physical over-current protection of the host server, crashing the hardware instance and taking it offline for extended periods.
Mitigating the Physical Side-Channel
Because these vulnerabilities stem from physical laws rather than software bugs, mitigating them requires a multi-layered approach spanning circuit analysis, dynamic obfuscation, and architectural redesign.
Netlist and Bitstream Scanning
One line of defense is to intercept malicious designs before they are ever loaded onto the hardware. La et al. developed high-speed bitstream virus scanners to detect known power-hammering configurations. To counter novel or disguised attack circuits, Alrahis et al. proposed MaliGNNoma, a framework that translates hardware netlists into data-flow graphs. By training Graph Neural Networks (GNNs) on these graphs, the system can identify structural patterns indicative of voltage-manipulation circuits with high accuracy.
Dynamic Circuit Obfuscation
If an attacker relies on a stable, predictable power signature to steal data, breaking that predictability can neutralize the side-channel. Alrahis proposed FPGA-Patch, a defense mechanism that automatically generates dozens of structurally diverse but functionally identical variants of a user's circuit. By dynamically swapping these variants at runtime, the system randomizes the power signature, increasing the data collection effort required by an attacker by over 1,000x.
Architectural Isolation and Roots of Trust
Ultimately, hardware architectures must evolve to natively support multi-tenancy. Mbongue et al. introduced a low-footprint "soft" Network-on-Chip (NoC) designed to isolate tenant communication paths while maximizing device utilization. For machine learning workloads, Xue et al. designed Neu10, a hardware-assisted virtualization framework that enables fine-grained, dynamic sharing of NPU compute engines while mitigating cross-tenant interference.
To complement these architectures, researchers use cryptographic primitives to verify tenant boundaries. Ahmed et al. introduced TrustToken, which uses Physical Unclonable Functions (PUFs) to establish a hardware-based root of trust without requiring permanent on-chip storage. Similarly, Shen et al. developed T-Edge, extending the Trusted Execution Environment (TEE) model to heterogeneous edge devices, ensuring that both software and reconfigurable hardware accelerators remain authenticated and isolated from co-located adversaries.
Key Foundational Work
Deep-Dup: An Adversarial Weight Duplication Attack Framework to Crush Deep Neural Network in Multi-Tenant FPGA (2020) — contributed 2 concept elements to this direction.
Denial-of-Service on FPGA-based Cloud Infrastructures - Attack and Defense (2021) — contributed 1 concept elements to this direction.
Architecture Support for FPGA Multi-tenancy in the Cloud (2020) — contributed 1 concept elements to this direction.