GPUHammer Explained: How GPU Rowhammer Hits NVIDIA Memory
Rowhammer plagued CPUs for a decade. Now researchers have proven it works on NVIDIA GPU DRAM too — and GPU memory has far fewer defenses than CPU memory.
Eight bit-flips across four DRAM banks. That's what researchers from the University of Toronto achieved on an NVIDIA RTX A6000 with GDDR6 DRAM in 2025, and it should worry anyone running GPU compute in production. For over a decade, Rowhammer has been the hardware vulnerability that refuses to die. Every time the industry builds a defense, researchers punch through it. But it was always a CPU memory problem — DRAM attached to your processor, targeted through careful cache manipulation. That changed when the GPUHammer paper dropped at USENIX Security 2025, proving the same attack works on NVIDIA GPUs. NVIDIA's response was to advise turning on ECC, which corrects single-bit flips at some cost in performance.

I've spent years working with systems that depend on GPU compute for inference workloads and rendering pipelines. The idea that an attacker could corrupt GPU memory with the same physics-level trick that plagued CPUs isn't just academically interesting. It's a real threat to the multi-tenant GPU infrastructure the entire AI industry runs on.
What Is GPU Rowhammer and How Does It Work?
Rowhammer is a hardware vulnerability rooted in DRAM physics, not software bugs. When you repeatedly access ("hammer") a specific row in DRAM, the electrical interference bleeds into adjacent rows and flips bits — a 0 becomes a 1, or the other way around. This happens because DRAM cells are packed so tightly that the voltage disturbance from rapid reads leaks into neighbors.

On CPUs, Rowhammer has been exploited since 2014 to escape browser sandboxes, escalate privileges in Linux, and attack virtual machines through memory deduplication. The defenses built over the past decade — Target Row Refresh (TRR), increased refresh rates, ECC memory — have focused almost entirely on DDR4 and DDR5 DRAM attached to the CPU.
GPU DRAM uses the same fundamental physics. Same tiny capacitors, same electrical interference. The only difference was that nobody had figured out how to hammer it precisely enough. Until now.
The GPUHammer attack, presented at the 34th USENIX Security Symposium, solved three hard problems that had kept GPU Rowhammer theoretical. The researchers reverse-engineered GDDR6 DRAM row mappings on NVIDIA GPUs — something NVIDIA doesn't publicly document. They developed GPU-specific hammering patterns that account for how the GPU's memory controller actually behaves. And they demonstrated that the resulting bit-flips are exploitable, not just random corruption.
The attack targets GDDR6 memory. The confirmed target was the RTX A6000, a 48 GB workstation card. In the researchers' tests an RTX 3080 showed no flips and neither did an HBM-based A100, and newer cards like the H100 and RTX 5090 have on-die ECC that likely masks single-bit flips. That narrows who is exposed today. It doesn't change the physics.
Can Rowhammer Actually Steal Data From a GPU?
I see this question constantly, and the honest answer is: not directly, but that's the wrong framing. The GPUHammer research demonstrated reliable bit-flips in GPU memory. That's the prerequisite. Once you can flip bits in GPU DRAM, several attack classes open up:

- Data corruption. Flipping bits in framebuffers, texture memory, or compute buffers corrupts GPU workload output. For AI inference, this means silently wrong results. No error message, no crash. Just wrong answers.
- Privilege escalation. If page table entries stored in GPU memory can be targeted, an attacker could remap memory to access regions they shouldn't touch. This is exactly how CPU Rowhammer has been used to escape sandboxes.
- Cross-tenant attacks. In cloud environments where multiple users share a physical GPU through NVIDIA's MIG (Multi-Instance GPU), bit-flips could cross partition boundaries.
- Model weight manipulation. Corrupting model weights in GPU memory during inference could cause targeted misclassification — an adversarial attack that bypasses every software-level defense you've built.
Eight bit-flips across four banks of GDDR6. That's not theoretical. That's a working exploit primitive. The distance between "I can flip bits" and "I can steal data" is an engineering problem, not a physics barrier. History is clear on how fast that gap closes. CPU Rowhammer went from academic curiosity to practical browser exploit in under two years.
If you've been following how supply chain attacks target developer tools, you know the security industry reacts to attacks after they become practical, not before. GPU Rowhammer is in that dangerous pre-exploitation window right now.
That same “assumptions break when the domain changes” pattern is also playing out at the network edge, where policy decisions can reshape what hardware ends up in real deployments. I dug into the practical fallout in FCC Banned Router List: 5 Chinese Companies Blocked and What It Means for Your Home Network [2026].
Does ECC Memory Protect GPUs From Rowhammer?
Here's where things get uncomfortable.
ECC (Error-Correcting Code) memory can detect and correct single-bit errors, which makes it a partial defense against Rowhammer. But partial is doing a lot of heavy lifting in that sentence.
NVIDIA's data center GPUs — the A100 (HBM2e), H100 (HBM3), and H200 (HBM3e) — use ECC-protected HBM (High Bandwidth Memory). These are the GPUs powering AI training clusters at OpenAI, Google, and every major cloud provider. ECC on these chips can correct single-bit errors and detect (but not correct) double-bit errors.
Outside the data center, protection is thinner. The RTX A6000 the GPUHammer researchers attacked supports ECC, and NVIDIA's response to the paper was to advise administrators to enable it. Newer cards such as the RTX 5090 (GDDR7) have on-die ECC that likely masks single-bit flips. Many professional workloads, rendering farms, and even some inference deployments run on GPUs without ECC turned on.
If you're weighing GPU hardware for inference workloads, it's worth noting that raw throughput claims deserve the same scrutiny as security assumptions — I dug into one such claim in ZGX Fury LLM Benchmark: 3,000 Tok/s Tested [2026], including how it stacks up against the RTX 5090 you might be running GDDR6-exposed workloads on right now.
Even where ECC exists, it's not a complete fix. Professor Onur Mutlu at ETH Zurich, whose research group has published some of the most important Rowhammer work over the past decade, has demonstrated that multi-bit Rowhammer errors can overwhelm ECC. If an attacker induces 2+ bit-flips in a single ECC word, the correction fails silently. The GPUHammer attack already achieved 8 bit-flips. On ECC-protected memory the attack would need more precision, but the physics doesn't care about your error correction code.
Having worked on systems where we depended on GPU compute for critical workloads, I can tell you most engineering teams don't think about GPU memory integrity at all. CPU memory? Sure, we run ECC, we monitor for correctable errors. GPU memory? Black box. Most monitoring tools don't even surface GPU memory errors at the application level.
Are Cloud GPU Instances Vulnerable to GPU Rowhammer?
This is where I start losing sleep. Cloud GPU instances from AWS, Google Cloud, and Azure are the highest-value targets because they're multi-tenant by design.
Think about how cloud GPU sharing actually works. NVIDIA's MIG technology on A100 and H100 GPUs partitions a single physical GPU into up to 7 isolated instances. Each tenant gets their own compute resources and memory slice. But "isolated" means logically isolated through the GPU's memory controller. The physical DRAM is still shared on the same chip. Rowhammer is a physical attack. It doesn't respect logical boundaries.
Cloud providers have invested heavily in CPU-side memory isolation. AWS's Nitro system provides hardware-level isolation for CPU memory and I/O. Google's Confidential Computing initiative encrypts CPU memory to protect against physical attacks. But these protections stop at the CPU. GPU memory operates in a different trust domain — managed by the GPU's own memory controller, with its own refresh policies and its own (often absent) error correction.
A second USENIX Security 2025 paper turned a Rowhammer defense into an attack surface. In "Not so Refreshing: Attacking GPUs using RFM Rowhammer Mitigation," Nazaraliyev et al. looked at Refresh Management (RFM), a feature built into modern memory to mitigate Rowhammer. They found that the refresh events RFM triggers create measurable timing differences on GPUs, and used that leakage to build a covert channel and side-channel attacks on GDDR6 GPUs, including fingerprinting which application is running and which 3D object is being rendered in Blender. They also showed a denial-of-service attack that slowed applications by over 4.8x on average. Mitigations designed for CPU memory controllers don't translate cleanly to GPU workloads, and here one became a leak.
I've written about this pattern before: security assumptions that hold in one domain break completely when you move to another. Same dynamic behind how giving an LLM OS-level control creates new attack surfaces. The threat model didn't anticipate the new context.
Why GPU Rowhammer Is So Difficult to Mitigate
CPU Rowhammer mitigations took a decade to mature, and they're still imperfect. GPU Rowhammer faces the same physics with fewer defenses and far less institutional attention.
Memory controller opacity. NVIDIA's GPU memory controllers are proprietary. Unlike CPU DRAM controllers where Intel and AMD publish specifications and collaborate with memory vendors on mitigations like TRR, GPU memory controller behavior is a black box. Security researchers can't even audit the refresh policies without reverse engineering.
Performance sensitivity. GPUs are throughput machines. Every mitigation that adds latency — extra refreshes, row-level tracking, ECC checks — directly hits the performance that makes GPUs valuable in the first place. Adding TRR-equivalent protection to GDDR6 would measurably slow down every game, every render, every training run. Good luck getting that past product management.
No software-level defense. On CPUs, operating systems can implement Rowhammer-aware memory allocation, DRAM-aware page placement, and monitoring for suspicious access patterns. GPU memory allocation is managed by the driver and firmware. Application developers can't control it. They can't even observe it.
Scale of the installed base. A very large number of NVIDIA GPUs with GDDR6 memory are already deployed. Rowhammer lives in the physics of the memory chips, so a software update can't remove the root cause. On cards that support it, turning on ECC is the main defense. Beyond that, mitigation requires hardware changes, such as better cell isolation, or memory controller changes that may not be possible on existing silicon.
Here's what nobody wants to say out loud: the GPU security model was designed for a world where GPUs rendered pixels. Not one where they run the world's most valuable AI models and handle sensitive data in multi-tenant cloud environments. The threat model is ten years out of date.
What GPU Rowhammer Defenses to Expect Next
GPU Rowhammer is at the stage where CPU Rowhammer was around 2015. Proven in the lab. Not yet weaponized in the wild. Clear path from research to exploitation. The two USENIX Security 2025 papers are the starting gun, not the finish line.
I expect three things to happen. First, NVIDIA will need to implement Rowhammer-aware refresh policies in future GPU memory controllers. Second, cloud providers will face pressure to offer ECC-protected GPU instances as the default for sensitive workloads, not just on data center SKUs. Third, the security research community will close the gap between bit-flips and practical exploits within 12-18 months. That's the same trajectory we saw with CPU Rowhammer.
If you're running GPU workloads in production — especially multi-tenant or inference workloads handling sensitive data — start asking your cloud provider uncomfortable questions about GPU memory integrity. Ask about ECC. Ask about refresh policies. Ask about cross-tenant isolation at the DRAM level, not just the logical level. If you're building hardware security models, with the same rigor you'd apply to evaluating encryption and privacy trade-offs, it's time to extend your threat model below the GPU's software stack.
The physics hasn't changed. DRAM is DRAM, whether it's attached to a CPU or a GPU. The only thing that changed is that someone finally proved it.
Photo by Mahdi Bafande on Unsplash.
Kunal Ganglani (2026, April 3). GPUHammer Explained: How GPU Rowhammer Hits NVIDIA Memory. Kunal Ganglani. Retrieved November 14, 2026, from https://www.kunalganglani.com/blog/gpu-rowhammer-nvidia-attack
Frequently Asked Questions
What is GPUHammer?
GPUHammer is the first demonstrated practical Rowhammer attack on NVIDIA GPU memory, presented at the 34th USENIX Security Symposium in 2025. Researchers from the University of Toronto reverse-engineered GDDR6 DRAM row mappings on NVIDIA GPUs and developed GPU-specific hammering patterns that achieved 8 bit-flips across four DRAM banks of an RTX A6000. It proved that the physics-level vulnerability long known to affect CPU memory also applies to graphics card memory.
What is a Rowhammer GPU attack?
A Rowhammer GPU attack rapidly reads a specific row of GPU DRAM so many times that electrical interference bleeds into adjacent rows and flips bits — turning 0s into 1s or vice versa. On NVIDIA GPUs with GDDR6 memory, this can corrupt framebuffers, compute buffers, model weights, or page table entries without triggering any software-level error. The GPUHammer researchers demonstrated it on an NVIDIA RTX A6000 workstation GPU; an RTX 3080 showed no flips in their tests.
Is there an AWS Nitro cross-tenant vulnerability related to GPU attacks?
GPU Rowhammer introduces a cross-tenant threat model relevant to cloud environments like AWS Nitro, where multiple tenants share physical hardware. While NVIDIA MIG provides logical isolation between GPU partitions, Rowhammer is a physical attack that operates below logical boundaries, meaning bit-flips could potentially cross partition lines. Cloud GPU memory currently operates under a less protected trust model than CPU memory, where providers have spent years hardening Rowhammer defenses.
What is the NVIDIA MIG cache partitioning side-channel attack?
It comes from "Behind Bars: A Side-Channel Attack on NVIDIA MIG Cache Partitioning Using Memory Barriers" by Cheng Gu and colleagues, a USENIX Security 2026 paper. NVIDIA's Multi-Instance GPU (MIG) feature splits one GPU into isolated instances for different tenants. The researchers found that L2 cache interference still crosses those partitions through memory barriers, and built a timing side-channel that lets an attacker in one instance infer the kernel launch patterns of a victim in another, which can leak information about workloads such as LLM inference. It is a timing attack, not a Rowhammer bit-flip attack, but it shows MIG's isolation is not complete.
How does the GPUHammer attack on NVIDIA GPUs work?
The GPUHammer attack solved three key problems to make GPU Rowhammer practical: it reverse-engineered undocumented GDDR6 DRAM row mappings on NVIDIA GPUs, developed hammering patterns tuned to GPU memory controller behavior, and demonstrated that resulting bit-flips are exploitable primitives rather than random corruption. On an RTX A6000 with GDDR6, the attack achieved 8 bit-flips across four DRAM banks, and a single flip in FP16 model weights cut the accuracy of the tested ImageNet models to below 1%.
Can existing Rowhammer mitigations like RFM protect NVIDIA GPUs?
Not cleanly. Refresh Management (RFM) is built into modern memory to mitigate Rowhammer, but a USENIX Security 2025 paper, "Not so Refreshing" by Nazaraliyev et al., showed that the refresh events RFM triggers leak timing information on GPUs. The researchers used that leakage for a covert channel, for application and Blender rendering fingerprinting on GDDR6 GPUs, and for a denial-of-service attack. The paper doesn't show RFM failing to stop bit-flips; it shows the mitigation creating a new side channel. Against GPUHammer itself, NVIDIA's advice was to enable ECC.



