In federated learning, many organizations train one model together without pooling their data. Each client downloads the current model from a coordinating server, computes a gradient (the direction in which the model's weights should change) on its private data, and sends only that gradient back. Most privacy-preserving machinery here assumes the server is "semi-honest": it may look at whatever it receives, but it runs the protocol as written. Recent attacks drop that assumption, and the result is severe. A server that ships carefully altered weights can force a client's gradient to encode one training example almost exactly. Fishing for User Data in Large-Batch Federated Learning via Gradient Magnification isolates single images from batches of 256 in about 8 rounds. Breaking Secure Aggregation: Label Leakage from Aggregated Gradients in Federated Learning recovers 100% of client labels even when gradients are cryptographically summed before the server sees them, because the server sends each client a slightly different model.
We propose that clients stop trusting the model they receive and instead check what their outgoing gradient would actually reveal. Before releasing an update, the client runs a small executable policy that does two things. First, it confirms that it received the same publicly committed model as every other client. Second, it measures, block by block within the update, how many of its own training examples meaningfully contribute to the gradient. Any block dominated by one or a few examples is suppressed or noised, and the decision is logged. Both checks target the outgoing gradient rather than the server's weights, so they apply to any data type and to attacks nobody has catalogued yet.
Core Claim
Every active reconstruction attack in the file works the same way underneath. Class fishing, feature fishing, the neuron-imprinting attacks studied in OASIS: Offsetting Active Reconstruction Attacks in Federated Learning (Robbing the Fed and Curious Abandon Honesty), and the batch-normalization trick in the secure-aggregation attack all make some part of the released gradient depend on very few examples, or make different clients' contributions separable. The first property can be measured locally, on the client's own batch, with no knowledge of how the server built its weights.
Our claim is that a contributor-count test plus a public commitment to the model is a broad defense against active fishing attacks. The contributor-count test measures how many examples drive each block of the update. The public commitment ensures every client receives the same weights, which is what "non-equivocation" means here. The defense should cost far less utility than local differential privacy, which adds noise to the whole update. It should also apply beyond vision, unlike augmentation defenses.
For a parameter block $k$ (one neuron's incoming weights, or one row of the final layer) and a client batch of $n$ examples with per-example gradients $g_{i,k}$, define the effective number of contributors
$$N_k = \frac{\left(\sum_{i=1}^n \lVert g_{i,k}\rVert\right)^2}{\sum_{i=1}^n \lVert g_{i,k}\rVert^2},$$
which equals $n$ when all examples contribute equally and 1 when a single example dominates. The policy releases block $k$ unchanged only if $N_k \ge \tau_k$. The threshold $\tau_k$ is calibrated on honestly trained models so that the false-alarm rate is fixed.
Computing $N_k$ for linear and convolutional layers is cheap. Each per-example row norm is the product of the backpropagated error norm and the input activation norm, so no full per-example backward pass is needed.
This test addresses one specific weakness of semi-honest designs: the server may deviate. Clients are still assumed to run the policy faithfully, since it protects their own data. The guarantee is narrow and stated plainly. The test blocks exact or near-exact isolation of individual examples. It does not by itself stop prior-guided inversion of well-mixed batches of the kind studied in Gradient Inversion with Generative Image Prior.
Relation to Prior Work
Three groups of papers play different roles.
The attack papers motivate the proposal and set the target. The fishing paper explicitly calls for client-side rejection of manipulated parameters but builds none. The secure-aggregation label attack shows that hiding individual updates is not enough once the server can send different models to different clients. Concealing Sensitive Samples against Gradient Leakage in Federated Learning supplies the key observation that reconstruction depends on low entanglement between examples' updates. $N_k$ is a direct, per-block measurement of exactly that entanglement.
The defense papers constrain the design. OASIS accepts the malicious model and then augments images so that several examples collide on each imprinted neuron. It works well on vision: PSNR (peak signal-to-noise ratio, a reconstruction-quality score) falls from about 140 dB to 15–20 dB with at most a 1.5% accuracy drop on CIFAR-100. It has no counterpart for text or tables. Our test enforces the property OASIS induces, namely many co-contributors per neuron, rather than inducing it through a vision-specific transformation.
VeriFL+ and Helen secure the arithmetic of aggregation against malicious parties. Both concede that they cannot stop leakage carried by valid inputs. Helen is also restricted to linear models. Our check sits upstream of such protocols and composes with them.
The policy-enforcement papers supply the execution model. PolicyKit expresses governance as small executable procedures that decide whether an action is pass or fail and can revert it. We reuse that structure. A filter step decides which blocks the policy applies to, a check step runs the commitment and contributor tests, and pass or fail steps release, noise, or withhold.
DID-eFed uses smart contracts (programs executed on a shared ledger) to check who may join a federation. After admission, however, it treats training as an unexamined black box. Federated TrustChain (Blockchain-Based Gradient Inversion and Poisoning Defense for Federated Learning) logs update hashes on Hyperledger Fabric and verifies unlearning against a hosted validation set. It does not address fishing during training.
Our proposal moves enforcement from who participates to what each released gradient reveals. We use a ledger only as an append-only public log, and we test whether something lighter suffices.
Research Program
The system has three parts.
The first is a commitment step. The server publishes a hash of each round's global model to a public log. Each client checks the downloaded weights against that hash and against the hashes other clients report. We implement this two ways: on Hyperledger Fabric, as in TrustChain, and as a plain signed-hash gossip among clients. This lets us measure whether the ledger buys anything.
The second is the contributor test. It computes $N_k$ for every neuron row and every final-layer row. The threshold $\tau_k$ is calibrated per layer type from honest training runs, at a fixed false-alarm rate such as 1% of blocks.
The third is the response rule. Blocks that fail are either withheld or noised with calibrated noise; we compare both. If more than a fraction of blocks fail, the client aborts the round. Every outcome is logged with the round's model hash so that a misbehaving server leaves an audit trail.
There is a known complication. In honest training, a final-layer row for a class that appears once in a batch is naturally single-contributor. That is itself a passive label leak, and the policy will suppress it. We will measure how much this costs in accuracy and whether larger batches or class-row grouping recover it.
The analytic component asks how far an adaptive server can go. Suppose the server knows the policy. It wants the released gradient to leak as much as possible while keeping every $N_k \ge \tau_k$. We will bound reconstruction quality under that constraint, and also attack it empirically.
Baselines
The naive reference point is unprotected federated averaging under each attack, which reproduces the attack papers' leakage. We will also include secure aggregation alone, which the label-leakage paper reports as yielding 100% label recovery on MNIST, CIFAR-10, CIFAR-100, and CelebA.
The strongest existing defense is OASIS. Its reported ImageNet numbers are PSNR of about 140 dB under attack, reduced to about 15–20 dB with defense, and accuracy above 90%. On CIFAR-100 its maximum accuracy drop is 1.5%. We run it with its published augmentation set, on the same models, attacks, client splits, and training budget. Beating it on vision means equal or lower reconstruction PSNR at equal or smaller accuracy loss. Beating it overall means comparable protection on text, where it has no published counterpart; no reported result found on Lacuna for OASIS on IMDB.
Local differential privacy is the second competitor. We tune its noise level so that it matches our method's reconstruction PSNR, then compare accuracy. The file reports only qualitatively that it "significantly" degrades accuracy, with no number.
The third competitor is a static weight-anomaly detector. It flags the server's weights directly: unusually high variance in batch-normalization scale and shift parameters, zeroed classifier rows, or distribution shifts in thresholds. It gets the same calibration data as our test.
Two ablations isolate our ingredients. One runs the contributor test without the commitment step, which should fail against client-specific models. The other runs the commitment step without the contributor test, which should fail against fishing models sent identically to all clients.
Why not just…?
Why not just add local differential privacy? It does stop fishing, but it noises every coordinate, including the vast majority that are well mixed. The fishing paper reports a significant accuracy loss. The label-leakage paper reports that its attack survives noise small enough to preserve utility. Our method noises only the blocks that fail the test. The matched-PSNR accuracy comparison above settles whether targeting matters. If the two methods tie, that is a negative result we will report.
Why not just inspect the server's weights for anomalies? This is the real threat to the proposal. Against today's attacks, a simple detector may catch every case, since zeroed rows and extreme batch-normalization parameters are conspicuous. The case for our test rests on adaptive attacks. We will train fishing models that minimize the static detector's score while still isolating examples. We then check whether the detector misses them while the contributor test, which looks at the released gradient rather than the weights, still catches them. If the static detector holds up against adaptive attacks too, the gradient-level test is unnecessary and we will say so.
Why not just use augmentation as in OASIS? It is strong on images but depends on transformations that leave image labels unchanged. Such transformations do not exist for tokens or table rows. The IMDB experiment tests exactly where OASIS cannot go.
Why not just a hash gossip instead of a blockchain? Possibly a gossip is enough. Non-equivocation only needs clients to compare what they received. The ledger adds a durable audit trail and resistance to a server that controls the gossip channel. TrustChain reports roughly 7.6% runtime overhead for Fabric (30,000 s versus 32,277 s over 999 rounds). We treat the ledger as optional and report both variants.
Proposed Experiments
On vision, we use CIFAR-100 and ImageNet with ResNet-style models. Against class and feature fishing and the two imprinting attacks, we measure reconstruction PSNR and how many rounds it takes to isolate an example; the fishing paper reports 8 rounds for a batch of 256. Against the label attack on CIFAR-10, CIFAR-100, and CelebA, under secure aggregation, we measure label recovery accuracy; the reported figure is 100%, and success means near chance. We report clean accuracy throughout.
On text, we fine-tune GPT-2 with LoRA (low-rank adapters, a small set of extra trainable weights) on IMDB, following the TrustChain setup. We port the imprinting attack to the embedding and adapter layers, and measure token-recovery rate and accuracy.
The decisive checks are four. Can an adaptive server, constrained to pass the test, still exceed a PSNR of 20 dB or recover labels above chance? What is the honest-run false-alarm rate, and what accuracy does that cost? Is the attack-time cost of computing $N_k$ a small fraction of a local training step? Does removing the commitment step reopen the label attack while removing the contributor test reopens fishing?
References
- Fishing for User Data in Large-Batch Federated Learning via Gradient Magnification
- Breaking Secure Aggregation: Label Leakage from Aggregated Gradients in Federated Learning
- OASIS: Offsetting Active Reconstruction Attacks in Federated Learning
- Gradient Inversion with Generative Image Prior
- Concealing Sensitive Samples against Gradient Leakage in Federated Learning
- Fixing Issues and Achieving Maliciously Secure Verifiable Aggregation in "VeriFL: Communication-Efficient and Fast Verifiable Aggregation for Federated Learning"
- Helen: Maliciously Secure Coopetitive Learning for Linear Models
- PolicyKit: Building Governance in Online Communities
- DID-eFed: Facilitating Federated Learning as a Service with Decentralized Identities
- Blockchain-Based Gradient Inversion and Poisoning Defense for Federated Learning