Privacy Failure in Split-LLM Training, The Returned Gradient Nullifies the Decoys
Abstract
A split-LLM training system passed privacy checks but leaked real data rows through zero-gradient patterns, allowing token recovery attacks despite gradient clipping and noise.
We present a systems-security case study of a two-node split-LLM training system whose privacy evaluation passed while leaving an observable channel untested. The Trusted Local Node (TLN) sends protected activations to the Untrusted Cloud Node (UCN), the UCN returns its output, and TLN, holding the private loss, returns the output gradient. The frame the UCN receives mixes real rows with decoys, and the loss ignores the decoys. Their gradients are exactly zero, so the pattern of zeros reveals which rows were real. We measure it with a protocol fixed in advance: a leak injected at known strength to prove the instrument can see one, a shuffled-label control to prove it does not report absent leaks, and a threshold set before the runs. Across nine seeds, the zeros identified the real rows on every frame, 4,096 of 4,096 per run. An attack on the frame contents recovered about one extra token per hundred over a constant-guess baseline (+0.65 to +1.50 percentage points); the shuffled controls recovered nothing. A second set of runs repeated this on a configuration that keeps model quality within budget, so the finding is not confined to a setting nobody would deploy. On both datasets, every such run passed the forward-channel privacy check and the quality check, yet failed that same check once the returned gradient was included. Clipping and noising each row of the gradient closed the leak for about 0.01 nats of held-out cross-entropy. The system is not thereby safe: five classes of attack, including those accumulating observations across training steps, were never measured.
Community
In split-LLM training, the security boundary is the network connection between the local node and the cloud. The gap across these elements is the conflict between utility and privacy, you cannot add infinite noise without destroying the model’s ability to learn.
Here is a step-by-step breakdown of the split training architecture, the obfuscation techniques that successfully hide information, and where the weaknesses remain.
The Forward Wire (Activations sent to Cloud)
What can we protect? We can prevent the cloud’s untrusted nodes from seeing raw text. By applying latent-space bottlenecks, injecting Gaussian noise (Differential Privacy), and shuffling row orders, we obfuscate the immediate features of the data.
What cannot we protect (The Gap)? The activations must retain enough semantic meaning for the cloud model to process them usefully. Advanced adversaries can train “shadow models” to map these noisy, compressed activations back to the original text domain.
The Backward Wire (Gradients sent back to Cloud)
What can we protect? We can stop the cloud from identifying real data by exploiting structural flaws. By clipping and noising every single row, including the decoys, we hide the “zero-support” signature that gives away which rows are fake.
What cannot we protect (The Gap)? Gradient inversion attacks. The gradients inherently contain the mathematical direction needed to improve the model. An attacker can use these gradients to reverse-engineer the private labels or inputs, especially since noise is limited by the training budget.
The Decoy Mechanism (Anonymity Sets)
What can we protect? Spatial anonymity within a single training frame. Mixing 32 real rows with 48 synthetic decoys forces the cloud to guess which data to attack at that specific moment.
What cannot we protect (The Gap)? Temporal accumulation over time. If a real row is processed consistently across multiple training epochs, while decoys are randomly generated or handled differently, the cloud can track statistical anomalies across steps to eventually separate real from fake.
The Untrusted Cloud Node Processing
What can we protect? We can withhold the final objective (the loss function) and the ground-truth labels from the cloud’s direct view.
What cannot we protect (The Gap)? The cloud controls its own weights. This forces the trusted local node to send back highly revealing, magnified gradients that bypass standard noise protections. This forces the trusted local node to send back highly revealing, magnified gradients that bypass standard noise protections.
This is an automated message from the Librarian Bot. I found the following papers similar to this paper.
The following papers were recommended by the Semantic Scholar API
- Policy-Masked Private Experts: Auditable and Reversible Capability Access Control in Sparse MoE Models (2026)
- Integrity of peer-to-peer distributed LLM inference under malicious nodes (2026)
- Mind the Hook: Source-Level Auditing of Privacy Defenses in Retrieval-Augmented Generation (2026)
- Private Anytime Selective-Risk Certification for Federated Retrieval-Augmented Generation: Guarantees and Empirical Limits (2026)
- When Do PEFT Adaptations Leak Structure? Measuring Black-Box Structural Bounds in Public-Base Model Services (2026)
- Memorization Is Not Extraction: Tight Differential-Privacy Bounds and Audit Blind Spots (2026)
- When Binaries Talk Back: Representation-Confusion Attacks on LLM-Assisted Reverse Engineering (2026)
Please give a thumbs up to this comment if you found it helpful!
If you want recommendations for any Paper on Hugging Face checkout this Space
You can directly ask Librarian Bot for paper recommendations by tagging it in a comment: @librarian-bot recommend
Get this paper in your agent:
hf papers read 2609.04382 Don't have the latest CLI?
curl -LsSf https://hf.co/cli/install.sh | bash Models citing this paper 0
No model linking this paper
Datasets citing this paper 0
No dataset linking this paper
Spaces citing this paper 0
No Space linking this paper
Collections including this paper 0
No Collection including this paper