Engineering brief
Your GPU Neighbor Can Identify Your Model from Timing Alone
At a glance
The brief is enough
- Relevance
- Practical value
- Radar
- Time horizon
- Now
- Warnings
- Vendor pitch
A shared GPU leaks your model's identity through timing. An attacker on the same H100 can determine architecture, speed, and even whether you're generating code or prose.
Shared GPU side channels threaten secrecy of proprietary AI models and workloads.
Watch if you manage GPU infrastructure with multi-tenant sharing and need to understand side-channel risks.
Summary
The attack surface. A shared GPU is never fully isolated. Even with Nvidia's MIG partitioning, timing channels leak information. An attacker on the same physical GPU can determine which model you run, its layer count with 97% accuracy, decoding speed with 99.3%, and even whether the model generates prose, code, JSON, or performs retrieval. This works without root privileges, without exploiting any vulnerability, and without touching the victim's memory.
How timing betrays models. Memory barriers in Nvidia GPUs flush the entire L2 cache across all MIG slices. When the victim runs inference, the attacker's memory loads take an extra 3 microseconds on average. That is enough to detect every token the victim generates. By averaging timing traces across multiple tokens, the attacker reconstructs the model's layer count as an integer. The approach is under 30 lines of code.
Beyond model identification. The attacker also determines decoding speed, which narrows the candidate set. With speculative decoding enabled, the attacker classifies content type with 77.5% accuracy at half-second intervals. This works because draft acceptance rate varies with text predictability. The attack extends across NVLink to other GPUs in the same server, though layer counts are lost. Token timing still identifies models with 79.2% accuracy.
Detection is possible. The speaker's company Stealthium builds GPU monitoring that catches this attack in real time. A single kernel repeated 3,000 times accessing the same memory region stands out. Stealthium detected it before half the victim's response was generated, under 600ms. Operators can control placement: avoid co-locating sensitive models with untrusted tenants on MIG slices. The tradeoff is that MIG prevents tensor parallelism, so teams may accept NVLink-based partitioning, which leaks only timing, not layer counts.
What teams should do. Audit whether any production models run on shared GPU instances with untrusted tenants. Cloud services offering GPU partitioning may appear safe but are not. Evaluate monitoring tools that detect anomalous kernel behavior. Consider dedicated GPU allocation for sensitive models. The cost increase may be justified by the risk of model theft or workload profiling. Most organizations lack visibility into GPU kernel behavior, leaving them blind to these attacks.
The bottom line. This is not a vulnerability Nvidia will patch. It is a fundamental property of shared hardware with shared caches. The defense is operational: placement, monitoring, and policy. Engineering leaders should treat GPU side channels as a first-class security concern, just as they do CPU side channels like Spectre. The talk is a timely reminder that cloud GPU sharing has security implications few teams have addressed.
My take
I've seen security teams focus on model weights and API access, but rarely on the hardware layer. This talk makes me rethink GPU sharing. The attack is elegant and low-cost, under 30 lines of code, no privileges needed. The fact that it works across NVLink means even multi-GPU setups are not safe. What worries me most is that most teams have no monitoring on GPU kernel behavior. We track CPU memory, but GPU side channels are invisible. The vendor's solution is one option, but the first step is awareness: audit your GPU usage, identify shared instances, and decide which models are sensitive enough to warrant dedicated hardware. This is not a crisis, but it is a blind spot we should address before it becomes one.
What to do with this
- Audit production GPU instances for MIG or NVLink sharing with any untrusted tenants.
- Evaluate GPU monitoring tools that detect repetitive kernel access patterns to the same memory region.
- Create a policy classifying which models require dedicated GPU allocation based on sensitivity.
Watch the video
This video is blocked due to your privacy settings. To watch this video, please accept YouTube marketing cookies.
Related breakdowns
Stop Buying GPU Hours: The Operator Decides Your Real AI Cost
GPU-hour pricing hides the variable that determines your AI cost: operator quality. Same B200, up to 50% output spread. A useful framework, but verify.
Monzo's Slack Agent Writes 10% of PRs. The Platform Did That.
Monzo's Slack agent authors 10% of merge PRs. The real story is the platform, MCP gateway, and sandboxing that made it safe.
Compliance velocity in banks comes from showing work, not better AI.
AI in banks moves from year-long to weeks when you prove CVEs dead, build your own DR, and stop LLM-judge traces leaking PII.
Get TL;DW
Too Long; Didn't Watch.
A concise breakdowns of the AI and devtools videos that actually matter for engineering leaders.
Free. Weekly. No hype.
Video and thumbnails remain the property of their respective creators. tldw.news provides editorial analysis, commentary, and discovery links to original content.