Adversarial Weight Manipulation via Hardware Faults

This direction is split into other directions: parameter corruption vulnerability. Its last version stays readable and citable here.

Version 1 of 1132 papers240 conceptsfrozen 2026-10-04

In the traditional threat model of machine learning security, an adversary manipulates the input to a model to force a misclassification. However, a growing body of research suggests that the most dangerous vulnerabilities may lie not in the data, but in the physical hardware where the model resides. By exploiting hardware-level faults—such as memory bit-flips or electrical glitches—attackers can surgically alter a model's "brain" after it has been deployed, bypassing software-level security entirely.

The Fragility of Quantized Weights

Deep neural networks (DNNs) are often praised for their robustness to noise, but this resilience is largely statistical. While a model can ignore random fluctuations across millions of parameters, it is surprisingly fragile when specific, high-leverage bits are targeted.

As shown in the seminal work Bit-Flip Attack: Crushing Neural Network With Progressive Bit Search, flipping as few as 13 bits out of 93 million in a ResNet-18 model can reduce its accuracy from 70% to 0.1%. This is possible because modern models are often "quantized"—stored as integers to save space. In a quantized format, the most significant bit of a weight carries immense mathematical weight; flipping it can transform a small positive value into a massive negative one, effectively "blinding" a neuron or forcing it to over-activate.

Surgical Sabotage via Rowhammer

The primary mechanism for these attacks is the Rowhammer vulnerability, where rapidly accessing one row of memory causes electrical leakage that flips bits in adjacent rows. Adnan Siraj Rakin, Zhezhi He, and Deliang Fan demonstrated in TBT: Targeted Neural Network Attack with Bit Trojan that this hardware flaw can be used to inject "Bit Trojans."

Unlike traditional Trojans that require poisoning the training data, a Bit Trojan is inserted post-deployment. The attacker identifies a tiny set of vulnerable bits that, when flipped, cause the model to behave normally on most inputs but misclassify a specific target whenever a "trigger" pattern is present. This shifts the security perimeter from the data pipeline to the physical integrity of DRAM.

Beyond Weights: Exploiting Scale Factors and Code

Recent advancements have found even more efficient "leverage points" within the model architecture:

  • Scale Factors: In quantized Vision Transformers, Jialai Wang and colleagues found that targeting "scale factors"—parameters that multiply entire groups of weights—allows for successful attacks with 8x–20x fewer flips than targeting individual weights. Their method, Flip-S, respects the physical 4KB memory page boundaries required for real-world Rowhammer exploits.
  • Compiled Executables: Yanzuo Chen and Zhibo Liu argue that it is often easier to break the model's "nervous system" than its brain. In Compiled Models, Built-In Exploits, they show that flipping bits in the compiled machine code can cause the model to skip entire layers or misalign memory addresses, achieving catastrophic failure without needing to know the model's proprietary weights.
  • Latency Attacks: Sabotage isn't always about accuracy. Manojna Sistla and Yu Wen demonstrated in Bit-Flip Induced Latency Attacks in Object Detection that bit-flips can force a model to generate thousands of "phantom objects," overwhelming the system's processing and slowing down real-time autonomous driving systems by over 20x.

Physical Fault Injection

While Rowhammer is a remote software-based exploit, physical access enables even more precise "fault injection." Xiaolu Hou and Jakub Breier have shown that using lasers or electromagnetic pulses can cause "instruction skipping." By precisely timing a laser pulse to hit a microcontroller during the execution of an activation function (like ReLU), an attacker can force the hardware to skip the logic that would normally zero out a negative value, fundamentally altering the network's mathematical behavior (Experimental Evaluation of Deep Neural Network Resistance Against Fault Injection Attacks).

The Challenge of Defense

Defending against these attacks is difficult because they bypass the software stack. Standard techniques like adversarial training, which improve robustness to input noise, can actually make a model more susceptible to weight manipulation by concentrating influence into fewer, more sensitive parameters (Defending and Harnessing the Bit-Flip Based Adversarial Weight Attack).

While hardware-level protections like Error-Correcting Code (ECC) memory can detect single bit-flips, they are not a panacea. Advanced search algorithms can find "ECC-friendly" multi-bit patterns that bypass these checks. Researchers like Huili Chen suggest that the solution may lie in architectural changes, such as weight decomposition, which spreads the influence of a single parameter across multiple memory locations, significantly raising the "cost of entry" for a successful bit-flip attack (ProFlip).

Papers in this version

Showing 60 of 132 papers.

History & citationVersion 1 · 2026-10-04

Split into other directions · Permanent link

View frozen version 1

Cite this direction

Latest version (a living page):

@misc{lacuna_adversarial_weight_manipulation_via_hard_48683876,
  title = {Adversarial Weight Manipulation via Hardware Faults},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/adversarial-weight-manipulation-via-hardware-faults/rdr_48683876e8b442eaa1fb914be778769b},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-21},
}

This exact version (version 1, frozen text):

@misc{lacuna_adversarial_weight_manipulation_via_hard_48683876_v1,
  title = {Adversarial Weight Manipulation via Hardware Faults},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/adversarial-weight-manipulation-via-hardware-faults/rdr_48683876e8b442eaa1fb914be778769b/v/1},
  note = {Version 1, frozen 2026-10-04. Accessed 2026-11-21},
}