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.
Main configuration and replication runs: split after layer 14, resume at 26 (11 delegated layers). Mitigation runs: split 21/26 (4 delegated layers).
corpus and implemented split
WikiText-2; corpus SHA-256 78b6bfb90cfd718f0c27d42b1fd2231b139d1dda75d7d796e6a603b2e5cd7efe . The runner tokenizes the flat corpus into disjoint, sequential fixed-width blocks, then slices train followed by evaluation; this is not a document-level split.
frame and latent
32 real + 48 decoy = 80 rows per frame; D=64 .
boundary protection
Forward and returned activations: per-row C=1.0 and Gaussian σ=0.35C . Main configuration and replication runs, outbound gradient: open. Mitigation outbound gradient: C=0.01 and Gaussian σ=0.35C .
Table 1: Experimental setup for the main configuration and for the replication and mitigation runs. Full fingerprints identify the exact model weights and corpus used by the evaluated runner.
Figure 1: The three hops of one training step. Only tln can compute the gradient, because only tln holds the loss, so hop 3 travels left to right just as hop 1 does: “backward” names the pass the tensor belongs to, not the direction it moves. Hops 1 and 2 are clipped and noised, and the original evaluation attacked hop 1 and passed its gate. Hop 3 crossed raw and carried the leak. The zero-support signal is an implementation and system-design defect; the false pass is an uninstrumented-channel evaluation failure.
Figure 2: Anatomy of one training cycle, per frame. SEALED never crosses the boundary; OBFUSCATED/PROTECTED are the defence’s active layers; LEAK marks the unprotected backward wire and the partition mechanism it discloses. The forward probe passes at step 6 while steps 10 and 11 leak: the paper’s finding in one diagram.
tln (trusted) keeps
ucn (compromised) sees/holds
Private corpus; token IDs; plaintext I/O
Gauged D=64 frame rows only (80 rows/frame: 32 real + 48 decoy)
Frozen LM prefix, embedding, LM tail
A ∼ 100-parameter gauge-equivariant surrogate it trains itself
Private encoder H→D=64 and decoder D→H weights
Unclipped, unnoised D -width output gradients (the omitted channel)
scaled joint concatenation (the exploratory frequent-token gradient result)
measured
accumulated_history
token_top1
none
unmeasured (no positive control)
stateful_remote_state
token_top1
none
unmeasured (no positive control)
timing_metadata
—
none
unmeasured (no applicable metric)
Table 3: The declared channel families and their status. “Unmeasured” means the family has no applicable metric or no positive control, so it cannot support a primary claim.
Figure 3: Dose–response per metric on the coordinate-mode sweep (amplitude 1.0). The four emitting metrics disagree: rare_token_top1 is most sensitive; token_cross_entropy barely moves until the leak dominates; membership_auc does not detect the low-dose token signal because the injection is not a membership signal. A single calibration run across 19 doses.
metric
cov 0.02
0.04
0.06
0.10
0.30
1.00
token_top1 (pp)
0.35
0.35
0.98
4.19
22.51
94.88
rare_token_top1 (pp)
0.08
0.32
0.67
1.97
14.18
100.0
token_cross_entropy
1.114
1.114
1.114
1.115
1.130
7.025
membership_auc (AUC −0.5 )
0.093
0.093
0.095
0.095
0.096
—
Table 4: Coordinate-mode coverage sweep at amplitude 1.0. The calibration reference is the zero-dose source cell (coverage 0, same bundle family) and the constant baseline (the most common evaluation token); the calibration sweep contains no shuffled-label arm, because those negative controls are introduced only at scoring time. The top-1 rows show point effects, while the gate statistic uses their Bonferroni–Wilson upper-95 value; thus the gate first breaks at coverage 0.06 although the displayed point effect is 0.98 pp. Cross-entropy is a proper scoring rule; the values shown are the effect over the constant baseline, and at scoring time CE is read arm minus its shuffled-label negative control, never raw (Table 5 ). membership_auc values are flat. “—” marks the amplitude-axis section, not part of this row.
metric
threshold set in advance
basis
token_top1
gate: Bonferroni upper-95 excess >+1.0 pp
first displayed gate break at cov. 0.06
rare_token_top1
paired effect +1.0 pp; report raw recovery
earliest subthreshold movement at cov. 0.04
token_cross_entropy
none set; read arm minus shuffled-label negative control (never raw)
a confidently-wrong negative control inverts raw CE; no numerical gate
membership_auc
none (diagnostic only)
falsified as a channel; constant baseline vacuous
Table 5: Per-metric thresholds, set in advance. A metric without a measured detection curve may not appear in a primary claim.
boundary
Wilson upper-95 acc.
constant baseline
excess
note
naked ( D=1024 , no defence)
28.54%
4.35%
+24.19 pp
breaks
defended ( D=64 , noise, decoys)
5.56%
5.27%
+0.29 pp
at floor
defended ( D=1024 , dimension-matched)
5.56%
5.29%
+0.27 pp
at floor
Table 6: One probe architecture, one protocol, three boundaries. The probe that inverts the naked boundary at over six times its baseline reads nothing through the defence, at the operating width and at matched width, so the defended floor readings are not attacker blindness. Best accuracy is selected on the evaluation set over 50 epochs (a selection reading); the accuracy column reports its Wilson upper-95 bound, so each row’s excess is the displayed accuracy minus the baseline. The defended probes’ accuracy declines after its early epochs, consistent with overfitting noise rather than extracted signal. The committed three-restart rerun of the D=64 defended probe reads at the same floor ( +0.37 pp); the other three committed deep-probe runs are the rows above.
result category
result
interpretation
forward wire
gate passed
the original instrument’s only channel
backward wire
leaks structurally
4,096/4,096 frames; row agreement 1.000, on each of nine seeds
frequent-token content effect
pooled over the nine verified seeds: +0.92 pp, 95% interval [0.74,1.09]
negative control at floor on every seed; per-seed values in Table 8
nine audit cells
effect detected at 12 and 11 delegated layers, at floor at 8 and 6; detected at D=64 and D=96 , at floor at D=128 ; 2.5 × more exposure does not amplify
one run each (seed 42); partition exact at every depth
dose–response calibration
token_top1 onset ∼ 0.04–0.06; rare_token_top1 at 0.04; CE flat until dominant; membership_auc flat and dose-insensitive
per-metric thresholds set in advance
internal scorer reimplementation
all nine cells ≤10−6 pp
internal check (Appendix A )
Table 7: Result categories and where each is established. The final row refers to the four-layer mitigation topology; every row above it refers to the primary configuration.
seed
gradient arm (pp)
forward arm (pp)
negative control (pp)
frames exact
verdict
42
+1.1923
+0.5516
−0.0069
4,096/4,096
detected
43
+0.6893
+0.6821
−0.0231
4,096/4,096
detected
44
+0.6929
+0.6918
+0.0479
4,096/4,096
detected
45
+0.8435
+0.8040
−0.0707
4,096/4,096
detected
46
+0.9361
+0.7578
−0.0285
4,096/4,096
detected
47
+0.7705
+0.7618
−0.0308
4,096/4,096
detected
Table 8: Exploratory seeds 42–47 and the replication runs (seeds 48–50). Statistic: the paired effect of each arm over its constant baseline (the most frequent evaluation token), clustered by frame. The negative-control column reports the label-shuffled twin of the gradient arm, scored through the same statistic. Inferential unit: one training seed; each row one independent run, its interval a cluster bootstrap over that run’s frames. All nine committed seeds are shown. The forward arm is built on the oracle real/decoy split and therefore does not by itself describe an achievable attack. It is reported here because in this system the oracle is redundant: the gradient reproduces the partition exactly (Section 5.1 ), so the forward arm is what an attacker reads after the backward wire has supplied the partition. No label-shuffled control was run for the forward arm, so that column is uncontrolled; the negative-control column bounds the gradient arm only. Seed 42 was served by a cloud container built before the code was packaged for release; seeds 43–47 ran the released package on both nodes, and seeds 48–50 are captures made under the fixed protocol.
cell (seed)
utility Δ
forward gate
joint arm (gate)
joint arm (paired effect)
support leak
defended, gradient open (s51)
+0.054
+0.522
+1.954
+1.609
1,024/1,024
defended, gradient open (s52)
+0.063
+0.574
+2.180
+2.333
1,024/1,024
defended, gradient open (s53)
+0.071
+0.412
+1.765
+1.567
1,024/1,024
defended, gradient clipped and noised (s51)
+0.063
+0.406
+0.480
−0.204
0/1,024
defended, gradient clipped and noised (s52)
+0.078
+0.421
+0.476
−0.017
0/1,024
defended, gradient clipped and noised (s53)
+0.083
+0.412
+0.481
−0.013
0/1,024
Table 9: The mitigation runs. The gate columns report the gate statistic: Bonferroni-upper-95 excess over the constant baseline. The paired column is the cluster-bootstrapped paired effect of the best arm against its constant baseline. “Joint arm” is the forward frame and the output gradient of the same training step, concatenated: the view the compromised node actually holds, and the one the original gate never scored. This set comprises fourteen runs; the twelve scored cells are shown. The two omitted are a configuration smoke test that produced no scored arms and the packaged seed-42 rerun of the main configuration, reported separately in this section. † The naked control on seed 53 fails the utility gate ( Δ loss 0.432 against the 0.35 bound); it is retained because it is a deliberately undefended sensitivity control, not a candidate configuration. In every one of these runs the per-row scale-and-sign gauge was disabled , as it is for the rotation-invariant cloud architectures (Appendix B ); the joint-view results below are conditional on that setting.
Figure 4: Attack-specific shape across audit cells. (a) depth ladder: the implemented emitter detected the effect at 12–11 delegated layers and not at 8–6. (b) the width sweep: the effect is detected at D=64 and D=96 , and not at D=128 . (c) The implemented probe’s paired effect did not increase between the two tested exposure budgets. Paired effect over the constant baseline with 95% CI on the gradient arm; one run per cell (seed 42).
axis
steps
gradient arm (pp)
negative control (pp)
verdict
frames
depth (12 del.)
2k
+0.4796
−0.0702
detected
512/512
depth (11 del., D=64 )
40k
+0.9302
−0.0112
detected
4,096/4,096
budget
100k
+0.9066
−0.0926
detected
4,096/4,096
width ( D=96 )
10k
+0.8635
−0.0061
detected
4,096/4,096
depth (8 del.)
2k
−0.4314
+0.0399
at floor
512/512
depth (6 del.)
2k
−0.2131
+0.0270
at floor
512/512
Table 10: The nine-cell audit. Paired effect of the gradient arm over its constant baseline, with each cell’s shuffled-label negative control beside it; frame-exact counts from the zero-support partition check. All nine committed cells, one run each (seed 42). The partition mechanism (zero-support match) is exact on every cell, whether or not the token effect is detected.
naked split-14 +24.19 pp; defended floor at D=64 and D=1024
no, against the defence
zero-support read (no training; just zeros)
10
partition exact on every frame, every seed
yes
gradient arm alone
10
floor on the private corpus ( +0.50 ); breaks on 2 of 3 public-corpus seeds ( +1.18/+1.22 )
only on one dataset
joint arm (frame ∥ gradient)
6 + 10
breaks the +1.0 pp gate set in advance on 6 of 6 defended cells ( +1.44..+2.18 )
yes
XGT cross-Gram invariant
6 + 10
floor on every capture (cosine and raw forms)
no; the feature carries nothing
Table 11: The attacker ledger: every attack family tried against the system, where it applies in the cycle of Figure 2 , and its outcome. Every committed attack family is listed; the supporting artefacts are indexed in Appendix A . The two leak rows are the finding; the closed row is the fix.
system
role
injected calibration
shuffled-label negative control
predeclared gate
BiSR [ 6 ]
attack
none
none
none
DualGuard [ 18 ]
defence
none
none
none
Prompts to Responses [ 12 ]
attack + defence
none
no (unmatched baseline)
none
Table 12: Selected audit verdicts. The three works report attack or defence performance against reconstruction baselines. “Prompts to Responses” includes an unmatched random-token baseline in its appendix.
forward probe at floor on defended cells (conditional: gate fires ≥ 6% coverage); joint view breaks the gate on 6/6 cells ( +1.44..2.18 pp) until clipping and noise close it (3/3 at floor)
K=3 median 100%/0% (one perturbation class)
1.05..2.5× WAN
AloePri [ 17 ]
honest-but-curious
no (inference)
point TTRSRs; VMA 13.5–25% on two models
none
≈ 0% online; 482 min offline at 671B
GELO [ 2 ]
VRAM-read + TEE island
no
p95 cosine/Gram error, no control
scoped out
20–30% microbenchmark
PermLLM [ 34 ]
permutation obfuscation
no
broken by the matching family ( > 99% reconstruction)
none
3 s/token (6B)
ObfNet [ 32 ]
backend holds obfuscators
no
perceptual (10 volunteers)
none
0.22–11 ms/sample edge
TEE [ 35 ]
trust silicon vendor
partial
hardware-rooted attestation
hardware-rooted
< 7–20%
Table 13: Positioning against the closest systems. “Empirical” = attacker-measured privacy; our excess is over a matched no-attack control with a confidence bound and a pre-declared gate, and the thresholds set in advance are calibrated by injected leaks (Section 4 ). Literature rows report those systems’ own published numbers; their evidence columns use their own authors’ metrics, the uncalibrated, no-matched-null pattern of Section 7 , so read the comparison as evaluation method , not as relative leak size.
Appendix figures & tables5 assets
Supplementary material from the paper’s appendix.
Appendix
result category
committed input
committed code
re-derivable
exploratory gradient result
per-seed paired JSONs and negative controls; bundles are manifests to cluster-side prediction tensors
packaged scorer
displayed values from committed summaries
nine audit cells
paper-data/collected/diagnostic/gradaudit/ cell JSONs and summary
Table 14: Per-result availability. The audit-cell and calibration rows regenerate from committed summaries; the exploratory and mitigation rows are redisplayed from committed derived artefacts whose raw prediction tensors remain on the cluster. Transcript hashes and the manifest are committed, but the payload remains on its host.
H→D=64 MLP with GELU, trained by minimax against embedded token/property/reconstruction probes plus a MINE MI penalty (the MI reading is not a certificate)
core
Noise
per-token-row L2 clip to C=1.0+ additive Gaussian σ=0.35⋅C (0.40 on hybrid MoE), both directions
Gaussian mechanism with zCDP accounting (the ε is quoted as vacuous)
core
Key derivation
SHA-256 counter-mode KDF
128-bit CSPRNG master per draw, domain-separated sha256(DOM ∥ S ∥ t) , exact (u64≫11)⋅2−53 uniforms, float64 Box-Muller
core
Rotation
Haar-random orthogonal
Gaussian matrix → QR with positive-diagonal sign fix, at D width; fresh per request
independent of the other gauges (separate KDF epoch); OFF for radial/invariant-MLP clouds
core
Appendix
Table 15: Techniques at a glance: what each mechanism is , concretely, where it lives, and its status (core / available / optional / withdrawn / invalidated) in the current evidence.
Arm (fraction grid)
0.6B trend
35B-A3B trend
Reading
Wire capture 10/25/50/100%
flat, −4.7 to −4.9
flat, −4.6 to −5.1
capturing the whole wire does not help
Decoy identities revealed 0/25/50/90%
−4.9 to −7.4
−4.9 to −5.6
knowing which rows are decoys makes the probe worse
Gauge secrets leaked, 10–20%
−7.8 ungauged / −4.7 gauged
−5.7 / −4.6
rows seen before gauging still read at guessing level
Known plaintext 1/5/20%
flat, −3.8 to −4.4
flat, ≈−4.0
knowing some tokens does not reveal the others
Appendix
Table 16: Compromise-fraction battery on the defended cell. Each row gives the attacker a growing share of some secret and asks whether the probe improves. Values are the probe’s accuracy in percentage points above or below its constant-guess baseline, so a negative number means the probe did worse than guessing. None of these arms approaches the +1.0 pp gate, and none improves as the attacker is given more.
Model
Gate statistic (pp)
Vector-matching top-1, against baseline
Nearest-signature top-1, against baseline
0.6B (seed 42)
+0.541
0.03% vs 5.92%
1.56% vs 5.92%
35B-A3B (seed 42)
+0.285
0.02% vs 5.85%
1.54% vs 5.85%
Appendix
Table 17: External matching-attack families vs. the defended cell (regenerated bundles). Two adapted attack families on these captures. The positive-control sensitivity they presuppose is Table 6 .
Cell
Verified frames
Flagged
Max rel. dev.
Loss Δ
Ratio
3 honest CPU nodes
2,256
0 (0% FP)
4.98×10−8
+0.071
9.30×
2 honest + 1 malicious (lying)
2,256
2,256 (100%)
0.5947
+0.088
9.13×
Appendix
Table 18: K=3 Byzantine median verification. One large perturbation class on identical CPU replicas; no general active-security claim.
Split language models keep input text on a client but send intermediate representations to a server. Attacks can reconstruct text from these messages. Comparing privacy evaluations is difficult when attackers see different messages, know different model weights or use different datasets and recovery measures. We present LLM-Attack Suite, a framework that records these choices and lets researchers check, compare and extend an evaluation. Compatible attacks reuse recorded messages, and their predictions are saved for independent scoring. The scoring rule requires a linked undefended reference before a defence can pass. Reports also identify attacks that remain untested. In a controlled GPT-2 experiment, adding gradients returned during training increased token recovery from 94.20% to 97.38% and exact-document recovery from 13.71% to 37.77%. The 95% interval for the token gain lay above the two-percentage-point threshold fixed before testing. This experiment is shared with a companion study; here it tests how the evaluation responds to a change in attacker access. Further studies measure how corpus choice and compression defences affect recovery, compare an adapted published attack with its reference implementation, and test the measurement code. The framework reports implementation checks separately from measured attack effectiveness. Each privacy claim should state the attacker, dataset and scoring rule, report its controls and identify untested attacks.
Gradient matching attacks (GMAs) in LLM split learning (SL) rely on a critical yet underexplored assumption: the gradient exposed at the split interface is a faithful derivative of the client's full-label training objective. This gradient-objective consistency allows a curious server to recover private labels by searching for a sequence whose induced gradient explains the observation. We propose Gradient Mirage, a defense that breaks this consistency without discarding the optimization utility of the backward signal. Our key idea is to induce the adversary to solve a misspecified inverse problem, in which no plausible label sequence in the sequence space can explain the observed gradients. Concretely, Gradient Mirage achieves this by inducing inconsistency across three dimensions: objective, direction, and scale. Selective Autoregressive Supervision derives the exposed gradient from a masked surrogate loss rather than the full-label objective assumed by the attacker; Scale Blinding then applies randomized multiplicative rescaling, obscuring the gradient's natural magnitude; and Directional Privatization further randomizes the gradient direction while preserving its magnitude through the von Mises-Fisher (vMF) mechanism under a directional metric differential privacy guarantee. Crucially, utility is preserved: the Top segment still learns from all target tokens via Dual-Track Backpropagation, the exposed gradient remains informative since each supervised token retains its complete autoregressive context, and Bottom-Gradient Recovery restores the effective gradient for Bottom-segment optimization. Extensive experiments show that Gradient Mirage provides substantially stronger protection than existing defenses under comparable fine-tuning performance, achieving a better privacy-utility trade-off.
Shiyu Miao, Yunlong Mao, Zirui Huang +5
State Key Laboratory for Novel Software Technology, Nanjing University · College of Computer Science and Software Engineering, Hohai University · School of Mathematics, Nanjing University +1
Split learning lets a client train a language model on a server without sending its text. The client runs the first layers itself and sends the server only their output, a vector of numbers for each token. During training, the server sends gradients back. We show that an observer at the split can rebuild most of the client's text from this traffic, and we measure how much the gradients help. On GPT-2, an attacker who holds only the publicly released weights of the client's layers recovers 94.20% of tokens from the activations alone and 97.38% when it also sees the gradients, 3.17 percentage points more 95% interval [2.72, 3.64]. Counted by document, the difference is much larger. The attacker rebuilds 13.71% of 32-token documents exactly without the gradients and 37.77% with them, because a document only counts when every token is right. How we count also changes how good a defence looks. Secret mixup, which blends each outgoing vector with a decoy, stops the attacker from rebuilding almost any document exactly, yet the attacker still recovers 83-91% of tokens. In a second experiment on GPT-2 and Qwen3-0.6B, where the server trains only a run of consecutive layers, the layer at which the run starts changes both model quality and leakage, even when the run's length is fixed. We recommend reporting leakage both per token and per document, and treating what a split model sends as being as sensitive as the text itself.