In federated learning, many clients train a shared model on their own data and send back only parameter updates (gradients). The most damaging known attacks on this setup do not try to reverse-engineer the gradients. Instead, they rely on a dishonest server that sends clients a specially doctored model. Examples include planting "trap" weights before a ReLU so that each neuron fires for only one private example, inserting an extra layer whose gradient contains a verbatim copy of the input, or retuning one batch-normalization layer so that summed gradients can be pulled apart again. These attacks recover images at machine precision and labels with 100% accuracy, even when the clients' updates are cryptographically summed before the server sees them. Each one depends on the same capability: the server alone decides what parameters the clients will train on next.
We propose to remove that capability rather than detect its misuse. A client trains only on a model it can check. It must come from a public seed through a standard initializer, and it must have been advanced in every round by the publicly specified update rule applied to an aggregate. That aggregate is decrypted and endorsed by a threshold committee of aggregators, meaning at least $t$ of $k$ servers must cooperate. Before endorsing, the committee checks under encryption that each individual client contribution has bounded size. The building blocks are cheap and secure only against "semi-honest" parties, those who follow the protocol but read everything they see: threshold homomorphic encryption, which lets servers add and multiply encrypted numbers, and threshold secret sharing of the decryption key. We argue that, assembled this way and assuming fewer than $t$ committee members collude, they turn a fully malicious server into something much weaker: a coalition of at most $f$ fake clients, each capped at norm $B$. The open empirical question is how much an adaptive attacker can still steal under that constraint. Answering it is the core of the work.
Core Claim
Every active reconstruction attack in the file requires a parameter change that no honest training round would produce. This holds for trap weights (When the Curious Abandon Honesty), imprint modules (Robbing the Fed), and batch-norm fishing (Breaking Secure Aggregation). Hear No Evil shows how large these changes are: fishing models push bias Z-scores as high as $9.75\times10^{10}$. Our claim is that the certified update rule makes such changes unreachable, which detecting them after the fact cannot guarantee. Let $W_r$ be the global model at round $r$, $\eta$ the public learning rate, $u_i$ client $i$'s update, $S_r$ the set of registered clients whose encrypted update passed the norm check, and $\mathrm{clip}_B$ the rule that drops contributions with $\|u_i\|_2 > B$. A client accepts $W_{r+1}$ only if it carries $t$ committee signatures over
$$W_{r+1} = W_r - \frac{\eta}{|S_r|}\sum_{i \in S_r} \mathrm{clip}_B(u_i), \qquad W_0 = \mathrm{Init}(\text{seed}),$$
where the seed comes from a committee coin-flip. If at most $f$ of the contributions are adversarial, the server can move the model by at most $\eta f B/|S_r|$ per round. That movement is also continuously pulled back by the honest clients' loss-reducing updates. The proposal is new in three respects. It targets model provenance instead of update confidentiality. It obtains a malicious-server guarantee from semi-honest primitives plus an honest-majority committee, with no zero-knowledge proofs. And it measures leakage under adaptive, budget-constrained steering attacks, which no paper in the file evaluates.
Relation to Prior Work
Three systems supply the cryptographic machinery, and none addresses model tampering. Helen achieves malicious security by combining threshold Paillier encryption, zero-knowledge proofs, and SPDZ multi-party computation, but it is restricted to linear models trained with ADMM. We give up its dishonest-majority guarantee in exchange for an approach that works with deep networks. VTSAFL splits decryption among several aggregators and proves partial decryptions correct. It protects the confidentiality and correctness of the sum, but it never constrains what model is sent down to clients, and it needs a trusted authority at setup. ATASSES makes threshold decryption with arbitrary $t$ cheaper, at $O(N^2+NK)$ computation for $N$ parties and data length $K$, but stays semi-honest and never touches learning. We reuse its threshold scheme and add one homomorphic multiplication per client to compute $\|u_i\|^2$ under encryption, so that only a single in-bound/out-of-bound bit per client is ever decrypted.
Two papers motivate the gap. The attack papers above show that secure aggregation alone does not stop a server that controls the model. SRATTA shows that even an honest-but-curious server can recover more than 58% of samples from correctly computed sums on CIFAR-10 with 5 clients. We therefore expect passive leakage from the aggregate to survive our protocol, and we pair it with SRATTA's own q-defense rather than claiming to solve that problem. Evaluating Selective Encryption encrypts 10–40% of gradient entries to stop passive inversion. It assumes the model is honest, and that is precisely the assumption we enforce. Finally, Hear No Evil and Evaluating Attacks & Defenses disagree about whether normalization layers shield clients from fishing attacks. We sidestep that disagreement: under certified updates, the server cannot set batch-norm $\gamma$ and $\beta$ at all.
Research Program
We will build the protocol on a threshold version of a lattice-based homomorphic scheme (BFV or CKKS), with $k\in\{3,5,7\}$ aggregators. Clients register with the committee, which bounds the number of fake clients the server can insert. Each client encrypts its update. The committee homomorphically sums the in-bound updates and computes each client's encrypted squared norm. It then threshold-decrypts only the comparison bits and the sum, and signs the hash of $(W_r, \text{aggregate}, W_{r+1})$. Before training, each client checks the signatures and recomputes $W_{r+1}$ from $W_r$, which costs one vector addition.
On the analysis side, we will state the reduction formally. A malicious coordinator plus fewer than $t$ colluding committee members can do no more than $f$ norm-capped malicious clients, as long as the semi-honest threshold scheme stays private against fewer than $t$ share-holders.
The empirical core is a family of adaptive attacks that we design ourselves. Each controls $f$ fake clients and uses their capped updates to steer the global model, over many rounds, toward a trap-weight, imprint, or fishing configuration. We will run these attacks with and without the honest clients pushing back, and measure how many rounds the attacker needs and how much fidelity it reaches. This is the experiment that could falsify the claim.
Baselines
The naive reference point is FedAvg with ordinary secure aggregation and no further defense. Here we reimplement the published attacks and should reproduce their reported strength. Robbing the Fed reports a PSNR of 75.75 on ImageNet batches and 161.36 for one image from a batch of 16,384. When the Curious Abandon Honesty reports more than 50% of ImageNet and more than 65% of IMDB examples perfectly reconstructed at batch size 100. Breaking Secure Aggregation reports 100% label recovery.
The strongest existing empirical defense against active image attacks is OASIS. It reports that attack PSNR falls from about 140 dB to about 15–20 dB on ImageNet, with a maximum accuracy drop of 1.5% on CIFAR-100. The strongest detection-based defense is Hear No Evil, whose Z-score warm-up check takes 0.72–0.88 s. We found no reported result on Lacuna for either defense under adaptive attacks.
All defenses will face the same attacks, the same models (ResNet variants, plus a LayerNorm transformer for text), the same client counts, and the same number of rounds. Every adaptive attacker gets the same tuning budget against every defense, and we tune each defense's own hyperparameters (OASIS augmentation set, Z-score threshold) on held-out attack runs. We beat these baselines if we hold attack PSNR below 20 dB for images, ROUGE-1 at or below 0.2 for text, and label recovery near chance, against both static and adaptive attacks. This must hold with accuracy within 1.5 points of undefended FedAvg, and on text and tabular data, where OASIS does not apply.
Three ablations isolate the ingredients. Provenance-only keeps the seeded initialization and committee signatures but drops the per-client norm check. Norm-check-only keeps the encrypted norm check but lets the server choose the model. The crypto-free variant has clients verify a seeded initialization themselves and reject any global update whose plaintext norm exceeds a bound, with no committee and no encryption.
Why not just…?
Why not just run client-side statistical checks like Hear No Evil? Detection catches the large, static modifications it was tested on, and its authors say adaptive attackers who stay under the threshold were not evaluated. It also needs per-client historical baselines, which break down when clients join and leave. Our adaptive steering attacks will be run against the Z-score detector. If the detector catches them as reliably as certification prevents them, the cryptographic layer is not justified for that threat model, and we will say so.
Why not just have clients check a public seed and cap the norm of the global update themselves, with no cryptography? This is the real threat to the proposal, and it is our crypto-free ablation. It blocks poisoned initialization and one-shot tampering cheaply. However, the server can still fabricate a plausible-looking aggregate every round, with a direction chosen freely inside the norm cap and no honest clients pulling the other way. The committee is what forces the aggregate to be a true average of registered, individually capped contributions. The decisive test is the number of rounds the adaptive attacker needs to reach a working trap under each variant. If the gap is small, we will narrow the contribution to the encrypted per-client norm bound.
Why not just add differential privacy noise or prune gradients? Deep Leakage from Gradients finds that noise must exceed variance $10^{-2}$ to stop leakage, which hurts accuracy. Evaluating Attacks & Defenses reports that pruning alone needs more than 99% sparsity and costs about 10% accuracy. Breaking Secure Aggregation reports that its attack survives both. We will include differential privacy, tuned to equal accuracy, as a secondary comparison.
Why not just use Helen-style zero-knowledge proofs for full malicious security? Helen works only for linear models solved with ADMM. Its speedups of 3 to 5 orders of magnitude are measured against SPDZ, not against plaintext training. Our design accepts an honest-majority committee in order to avoid proofs over deep-network gradients.
Proposed Experiments
Active-attack experiments use CIFAR-10, CIFAR-100, and ImageNet for images, IMDB and Wikitext for text, and the attack configurations from the three attack papers. Cross-silo passive leakage uses SRATTA's FashionMNIST, TCGA-BRCA, and splice-junction settings, with the q-defense layered on top. SRATTA reports that its q-defense brings attack success near zero at under 1% accuracy cost.
Metrics are PSNR and LPIPS for images, BLEU and ROUGE-1 for text, label-recovery accuracy, fraction of samples perfectly reconstructed, test accuracy, rounds-to-successful-trap for adaptive attacks, and per-round wall-clock time and communication. Overhead is reported against ATASSES's published 3.83–15.4× speedup over earlier threshold schemes, to show where the norm-check multiplication adds cost.
Three checks decide the outcome. The first is whether adaptive steering with $f/|S_r|$ up to 10% of clients ever achieves attack PSNR above 20 dB within a realistic training run. The second is whether the crypto-free ablation matches the full protocol; if it does, we report that the committee is unnecessary. The third is whether accuracy stays within 1.5 points of undefended FedAvg on the CIFAR-100 setting where OASIS reports its maximum drop.
References
- When the Curious Abandon Honesty: Federated Learning Is Not Private
- Robbing the Fed: Directly Obtaining Private Data in Federated Learning with Modified Models
- Breaking Secure Aggregation: Label Leakage from Aggregated Gradients in Federated Learning
- Hear No Evil: Detecting Gradient Leakage by Malicious Servers in Federated Learning
- Helen: Maliciously Secure Coopetitive Learning for Linear Models
- Privacy-Preserving Federated Learning from Partial Decryption Verifiable Threshold Multi-Client Functional Encryption
- Arbitrary-Threshold Fully Homomorphic Encryption with Lower Complexity
- SRATTA: Sample Re-ATTribution Attack of Secure Aggregation in Federated Learning.
- Evaluating Selective Encryption Against Gradient Inversion Attacks
- Evaluating Gradient Inversion Attacks and Defenses in Federated Learning
- OASIS: Offsetting Active Reconstruction Attacks in Federated Learning
- Deep Leakage from Gradients