In federated learning, many clients train one shared model without pooling their data. Each client downloads the current model, computes an update on its private examples, and sends that update back to a coordinating server. The most damaging privacy attacks on this setup do not passively study the updates. Instead, the server quietly edits the model it sends out. When the Curious Abandon Honesty plants "trap weights" in the first layer so that most neurons go silent, and it then reconstructs more than half of ImageNet mini-batches of 100 exactly. Breaking Secure Aggregation changes only the scale and shift parameters of one batch-normalization layer, producing a "fishing model" that recovers client labels with 100% accuracy even after secure aggregation, the cryptographic summing step that hides individual updates. Both attacks need the same thing: the server must be free to send any weights it likes.
This note proposes taking that freedom away. The model's whole history becomes publicly checkable. It starts from a random initialization derived from a public seed. Each new version must provably equal the previous one plus an aggregate of updates. Each update must come from a holder of an anonymous credential, issued by authorities that are independent of the aggregator, and must carry a zero-knowledge proof that its size is bounded. A zero-knowledge proof convinces a verifier that a statement is true without revealing the secret behind it. Under this design, a server can reach a trap configuration only by steering the model through bounded updates from clients it controls. That turns "can the server plant a trap?" into a measurable question: how many rounds, and what fraction of colluding credentialed clients, does the steering take?
Core Claim
Active gradient-leakage attacks are attacks on where the model came from, not on how gradients are aggregated. A client that can check three things can bound the attacker's reach with a single quantity. The three things are that the current model descends from a public seed, that every step is a correct aggregate, and that every contributing update came from a distinct credential and has squared size below a public bound $C^2$. If at most a fraction $f$ of the $n$ contributors in a round are adversarial and the aggregate is a mean, the adversarial push per round is at most $fC$ in L2 distance. Any configuration at distance $D$ from the honest trajectory therefore needs at least
$$ T \ge \frac{D}{fC} $$
rounds to reach, before counting the honest clients pulling back. Here $D$ is measured in parameter space, and the bound follows from the triangle inequality applied round by round. The empirical question is the size of $D$ for real trap and fishing configurations relative to the drift of honest training. If even a modest attack configuration sits far from anything honest training visits, the protocol rules out these attacks in practice, at the cost of norm proofs rather than full aggregation proofs.
The three directions play different roles. Zero-knowledge attribute verification is the mechanism. Clients prove attributes of hidden updates, namely "credentialed holder, not yet used this round" and "norm at most $C$", in the way selective-disclosure credentials prove "age at least 21". Gradient leakage is the threat being bounded. The non-collusion assumption is relocated. It no longer guards secret shares, where failure is total, as Secure Multi-User k-Means Clustering and Range search on encrypted spatial data show. It now guards credential issuance, where failure only increases $f$, and the guarantee weakens in proportion rather than vanishing.
What Is New Relative to Closest Work
zkFL has clients commit to updates with Pedersen commitments, which are cryptographic sealed envelopes. It has the server prove with a succinct proof that the new model is the correct sum. We reuse this commitment-and-sum idea for the step-to-step check. zkFL, however, proves only aggregation correctness over whatever commitments arrive. It does not bind commitments to independently issued identities, does not bound their size, and does not anchor the starting model. A server could therefore begin from a trapped initialization, or inject its own commitments, and still produce a valid proof. Coconut supplies threshold-issued selective-disclosure credentials, meaning credentials that a group of authorities must jointly sign. It has never been connected to collaborative learning, and we borrow it so the aggregator cannot mint clients. The survey Towards Verifiable Federated Learning lists verifying aggregation, local information, and updates as separate targets, and calls collusion-resilient designs open. We combine the first two targets around a specific threat model, and treat issuer–aggregator collusion as a parameter rather than an assumption.
The proposal deliberately does not address passive attacks on an honest model. Cocktail Party Attack unmixes aggregated fully connected gradients for batches up to 1,024, and SPEAR inverts batches exactly. These attacks work on unmodified models, so provenance does not stop them. We scope our claim to active attacks and report passive-attack results unchanged, so that we do not overclaim.
Research Program
The work has three parts.
The first part builds the protocol. It covers public-seed initialization; Coconut-style anonymous credentials with one-use-per-round tags so a credential cannot be counted twice; a zero-knowledge proof that a Pedersen-committed update vector has bounded norm; and a homomorphic sum of commitments with a step proof that clients check cheaply. Secure aggregation, in the style of LightSecAgg, stays in place to hide individual updates. Clients run local SGD; "local" here simply means on their own data. They clip their updates to $C$, as many deployments already do, so honest clients pay no accuracy cost beyond clipping. We found no reported result on Lacuna for the cost of norm-bound proofs over model-sized vectors, so measuring that cost is a deliverable in its own right. The only nearby figures are zkFL's roughly 54 minutes of server proof time and 10–20 minutes of client encryption.
The second part is analysis. For each known active attack we construct the attack configuration starting from honest checkpoints and measure its distance $D$, both overall and restricted to the layers it touches. We then design an adaptive steering attack, the strongest attack consistent with the protocol. Here a fraction $f$ of credentialed malicious clients submit norm-bounded updates chosen to minimize the distance to a trap or fishing configuration, while the honest majority keeps training. Low-dimensional attacks such as the batch-normalization fishing model are the hardest case, because their $D$ may be small. For that case we also test tighter per-layer norm bounds on normalization parameters.
The third part examines collusion. We simulate issuer–aggregator collusion as unlimited Sybil credentials, meaning fake clients the attacker controls, and as partial collusion below and above the issuance threshold. We report how quickly attack success climbs as $f$ grows.
Baselines
The naive reference point is standard federated averaging with secure aggregation and no verification. Under it, trap weights and fishing models are applied directly. This reproduces the reported attack strength: Breaking Secure Aggregation reports 100% label recovery on CIFAR-10, CIFAR-100, CelebA, and ImageNet, and When the Curious Abandon Honesty reports exact reconstruction of over 50% of ImageNet and over 65% of IMDB points at batch size 100. Matching these numbers checks that our attack implementations are faithful.
The strongest existing defense against active reconstruction is OASIS, which applies client-side augmentation. It reports that ImageNet reconstruction PSNR falls from about 140 dB to about 15–20 dB, with accuracy above 90%, and a maximum accuracy drop of 1.5% on CIFAR-100. It is the strongest competitor because it targets exactly the active-server threat without cryptography. We run it on the same models, data splits, rounds, and attack implementations, with its augmentation strength tuned on the same validation budget we give our clipping bound $C$. Beating OASIS means one of two outcomes at equal or better clean accuracy. Either we push label recovery against fishing models toward chance where OASIS does not, since OASIS targets input reconstruction rather than label leakage. Or we deliver protection on IMDB text, where OASIS concedes it has no augmentation.
zkFL is the cryptographic baseline. We run it with the server allowed to choose the initialization and inject commitments, on the same architectures, and expect it to provide no protection. Its proof costs serve as the cost reference.
Three ablations isolate the key ingredient. The first keeps provenance but drops norm bounds. The second keeps credentials and norm bounds but lets the starting model be server-chosen. The third keeps provenance and norm bounds but drops credentials, so that $f$ is unbounded. Each removes one leg of the bound, and the claim predicts each fails in a specific way.
Why not just…?
Why not just have clients inspect the downloaded weights for traps? Clients do receive the model in the clear, so a local anomaly check is cheap, and this is the most serious threat to the proposal. Trap weights are blatant, but the fishing model changes only one normalization layer. An adaptive server can also pick configurations that resemble honest weight statistics while still disaggregating sums. We include a client-side detector, a per-layer statistics check trained on honest checkpoints, as an extra baseline, and attack it with fishing models optimized to evade it. If the detector holds against adaptive attacks at matched false-alarm rates, provenance is unnecessary and we will say so. A hybrid, where provenance supplies the reference distribution the detector needs, is the fallback.
Why not just add differential privacy to local updates? Differential privacy adds calibrated noise so that no single example noticeably changes the update. SPEAR reports high-quality reconstruction despite DP-SGD noise. The authors of the label-leakage attack also report resilience to noise as long as the model stays useful. Evaluating Gradient Inversion reports CIFAR-10 accuracy of 86.10% under its combined defense versus 93.37% without it. We include DP-SGD at the noise levels needed to cut fishing-model label recovery to our protocol's level, and compare clean accuracy.
Why not just use larger batches or more clients? Active attacks are designed to beat aggregation: label recovery stays at 100% with batches up to 5,120 in Breaking Secure Aggregation. We sweep batch size anyway, as a sanity check.
Why not just rely on zkFL's aggregation proof? A proof that the sum is correct says nothing about whether the starting model was trapped, or whether the summed commitments came from real clients. The second ablation and the zkFL baseline test this directly.
Proposed Experiments
We train ResNet-style and fully connected ReLU models on CIFAR-10, CIFAR-100, CelebA, and an ImageNet subset. We also run IMDB with the text setting from the trap-weights paper. For each, we run the naive reference, OASIS, DP-SGD, zkFL, the client-side detector, our protocol, and the three ablations. Each attack is applied under its published settings and under our adaptive steering attack, with $f \in \{0.05, 0.1, 0.2, 0.3\}$.
Attack success is measured as label recovery accuracy, the fraction of exactly reconstructed inputs, and PSNR. Utility is measured as clean accuracy. Protocol cost is client proof time, verification time, and bandwidth per round.
The decisive check comes in two parts. The first is the measured rounds-to-success against $f$ and $C$: the claim predicts growth near $1/(fC)$, with an attack on an honest-trained model never succeeding within a realistic training horizon for small $f$. The second is the measured $D$ for the fishing model. If adaptive steering reaches a working fishing model within a few rounds at $f=0.1$ even under per-layer bounds, then the core claim fails for low-dimensional attacks and the proposal reduces to a defense against high-$D$ attacks such as trap weights. That is still informative, and it would point to normalization layers as the place where verification must tighten.
References
- When the Curious Abandon Honesty: Federated Learning Is Not Private
- Breaking Secure Aggregation: Label Leakage from Aggregated Gradients in Federated Learning
- Secure Multi-User k-Means Clustering Based on Encrypted IoT Data
- Range search on encrypted spatial data with dynamic updates
- zkFL: Zero-Knowledge Proof-based Gradient Aggregation for Federated Learning
- Coconut: Threshold Issuance Selective Disclosure Credentials with Applications to Distributed Ledgers
- Towards Verifiable Federated Learning
- Cocktail Party Attack: Breaking Aggregation-Based Privacy in Federated Learning Using Independent Component Analysis
- SPEAR: Exact Gradient Inversion of Batches in Federated Learning
- LightSecAgg: Rethinking Secure Aggregation in Federated Learning
- OASIS: Offsetting Active Reconstruction Attacks in Federated Learning
- Evaluating Gradient Inversion Attacks and Defenses in Federated Learning