Federated learning trains a shared model across many devices or institutions by having each one send gradient updates (the directions in which it wants the model's weights to move) instead of raw data. Homomorphic encryption, a family of schemes that let a server add or multiply numbers while they stay encrypted, is the standard way to stop the aggregating server from reading any single client's update. A sharp line of attack work shows that this protection is aimed at the wrong place. A malicious coordinator does not need to read a client's ciphertext if it can choose the model the client trains on. By editing one batch-normalization layer, it can recover every client's labels from a securely aggregated sum. By "fishing", meaning subtly reshaping ordinary layers, it can isolate single images out of batches of 256. Encryption hides the update. It does nothing about the model that produces the update.
We propose to make each round's global model a publicly checkable state rather than something the coordinator chooses. Every round's model must equal a fixed, published update rule applied to the previous committed model and the jointly decrypted encrypted aggregate. That rule includes a hard cap on how far the parameters attackers rely on (normalization scales and shifts, final-layer biases) may move per round. A short commitment to each model is posted to a base blockchain, so the coordinator cannot show different models to different clients. The heavy encrypted aggregation stays off-chain, and the chain is called only to settle disputes. In two sentences: fishing attacks work because a server can hand a client a hand-crafted model, so we force every model to be a verifiable, rate-limited consequence of encrypted aggregates and publish its fingerprint. Encrypted aggregation then becomes a defense against active attackers, not only passive ones, at the cost of one on-chain commitment per round.
Where the existing pieces stop
Three lines of work each hold part of this design, and none combines them. BatchCrypt supplies the encryption method. It packs low-bit quantized gradients into single additive-HE ciphertexts, which gives 23x to 93x training speedups and 66x to 101x less communication with under 1% accuracy loss, and it keeps weights on the client side. It assumes an honest-but-curious aggregator, and it never asks whether the models that clients agree on could have been steered. EdgeDetect makes the same assumption. It encrypts binarized gradients with Paillier and lowers passive inversion PSNR from 31.7 dB to 15.1 dB on CIC-IDS2017, but it has no answer to a coordinator that ships crafted models. PBSL is the closest system. It removes the central aggregator by running threshold CKKS aggregation and encrypted cosine-similarity Byzantine filtering inside smart contracts. That puts polynomial arithmetic in base-layer consensus, which limits it to MNIST-scale models over 10 nodes. It also does not evaluate fishing or generative inversion at all. Our design moves the opposite way: the chain does almost no computation, and what it guarantees is model provenance rather than aggregation.
The attack papers motivate the design and also constrain it. Breaking Secure Aggregation reports 100% label recovery at batch sizes up to 5,120 by perturbing a single normalization layer. Fishing for User Data isolates one image from a batch of 256 in about 8 rounds of binary search. OASIS catalogues weight-trap attacks that reach ~140 dB PSNR undefended. The common ingredient is a model whose parameters the attacker sets freely and often adapts per target, and that ingredient is what we remove. Gradient Inversion with Generative Image Prior constrains the design in a different way. It shows passive inversion survives batch 32 and 99% gradient pruning, so the decrypted aggregate that every client sees must itself be tested as a leak.
The dispute machinery comes from Scalable and Privacy-preserving Design of On/Off-chain Smart Contracts. In that design, parties pre-sign off-chain code, and when someone submits a disputed state, the chain re-executes only that transition. Deployment costs 225,082 gas and enforcement 37,745 gas on Kovan. Its authors tested it only on a betting contract. Our extension makes the disputed transition one shard of a model update. Because the transition operates on the already-decrypted aggregate, the dispute never requires putting ciphertext arithmetic or plaintext client data on-chain. The SoK: Off The Chain Transactions rollup pattern, which posts one root per batch, sets the target cost of one commitment per round.
Core Claim
Let $W_t$ be the committed model at round $t$, $A_t$ the aggregate obtained by threshold decryption of the summed client ciphertexts, and $U$ a published update rule. The protocol requires
$$W_{t+1} = U(W_t, A_t), \qquad \|(W_{t+1} - W_t)_S\|_\infty \le \tau,$$
where $S$ is the set of attack-sensitive parameters and $\tau$ is a per-round movement cap enforced inside $U$. A Merkle root of $W_{t+1}$ is posted on-chain, and clients train only on a model that matches the posted root.
We claim three things. First, equivocation-based targeting (sending a fishing model to one victim) becomes impossible. Second, any non-equivocating fishing attempt must be built from many rounds of bounded, public parameter changes, so it costs many rounds and leaves a detectable trace. Third, the overhead stays near BatchCrypt's encryption cost plus constant gas per round, independent of model size.
The second claim is the scientific question. The 8-round binary search of class fishing and the single-shot normalization edit of LIA-SA both need large, targeted parameter changes. We hypothesize that a $\tau$ small enough to slow these attacks by an order of magnitude costs little accuracy, because honest training moves normalization parameters slowly. That hypothesis could fail, and the experiments are built to find out.
Research Program
We will build the protocol on BatchCrypt-style packed additive encryption with a threshold key split across a committee, so that no single party decrypts. Clients encrypt quantized, clipped updates. An off-chain aggregator sums the ciphertexts, the committee jointly decrypts the sum, and the aggregator publishes $A_t$ together with the root of $U(W_t, A_t)$. Any client can recompute $U$ locally. On a mismatch, the client opens an on-chain challenge that bisects the model down to one layer shard and re-executes $U$ for that shard alone, following Li et al.'s pre-signed-code pattern. The aggregator posts a deposit that is slashed if the challenge succeeds.
The analysis has two parts. The first is a provenance argument: under a binding commitment and a chain that does not fork, every honest client trains on the same $W_t$. The second is an attack-cost study. Attackers who control the aggregator, or a fraction of clients, inject crafted contributions inside the encrypted sum to steer $W$ toward a fishing configuration, and we measure how many rounds this takes as a function of $\tau$, the per-client clip, and the attacker's client fraction.
Poisoning through contributions is the honest threat. Under encryption, a malicious client's update cannot be inspected. The update rule must therefore bound any single client's influence through the clip and the quantization range. Since a client can encrypt an out-of-range value, we will measure how much the post-decryption cap $\tau$ alone limits that client, as opposed to the clip. We will also add a public detector that runs over the committed trajectory of changes to $S$ and flags low-entropy, targeted patterns such as one class's weights being zeroed.
Baselines
The naive reference is plain FedAvg with no encryption and coordinator-chosen models. It fixes the undefended attack ceiling (LIA-SA at 100% label recovery, active traps at ~140 dB PSNR per OASIS) and the utility ceiling.
The strongest encryption-side competitor is BatchCrypt, reimplemented with the same packing, quantization bit-width, clipping, client count and models. We use it because it is the most efficient encrypted aggregation in the file and because it already keeps weights on the client side, so it isolates exactly what provenance and rate limiting add. BatchCrypt's reported operating point is a 23x to 93x speedup over unbatched HE with under 1% accuracy loss. Beating it means matching its wall-clock and communication cost within a small constant, adding only one root per round plus the cost of rare disputes, while cutting LIA-SA label recovery and fishing PSNR from their undefended values.
The strongest active-attack defense is OASIS, run on the same models and attacks. On ImageNet it suppresses active attacks from ~140 dB to ~15–20 dB with utility above 90%, and its largest drop is 1.5% on CIFAR-100. To beat it, we need comparable or lower PSNR against RTF, CAH and fishing at no larger accuracy loss, and the defense must hold when the attacker adapts to the defense, the regime where we expect OASIS-style augmentation to be weakest.
PBSL is the decentralized competitor. We compare against it on gas and latency as model size grows. It reports 96–97% MNIST accuracy with half the nodes malicious, and the file gives no FashionMNIST number. All methods get the same seeds and the same tuning budget for clip and quantization settings.
Three ablations isolate the ingredients. The first removes $\tau$, leaving provenance only. The second replaces the chain with an append-only transparency log without slashing, leaving provenance without enforcement. The third drops threshold decryption and keeps a single decrypting aggregator.
Why not just…?
Why not just have clients recompute the model themselves, with no blockchain? Recomputation alone fails against equivocation. If the coordinator shows each client a different aggregate, every client's check passes while one victim receives a fishing model. Clients need agreement on a single $A_t$ and $W_t$, which is the job of a consensus log. This alternative becomes a real threat once it is paired with gossip. The transparency-log ablation tests it directly: if a log without slashing matches our attack suppression, the blockchain's contribution reduces to economic enforcement of correct updates, and we will report that rather than claim more.
Why not just add local differential privacy? OASIS and Fishing for User Data both report that local differential privacy strong enough to stop these attacks substantially degrades accuracy. The Breaking Secure Aggregation authors also report that LIA-SA survives noise as long as the model stays useful. We will still run Gaussian local differential privacy at matched final accuracy and compare attack success, because a fair head-to-head is cheaper than an argument.
Why not just run PBSL-style aggregation on-chain? PBSL performs CKKS arithmetic and encrypted cosine similarity in smart contracts. Its gas and latency grow with parameter count, and it has only been demonstrated on MNIST-scale models. We will measure gas per round for both designs as the model grows from a small fully connected network to a ResNet-sized model. Our design's on-chain cost should stay flat apart from disputes, and the file has no reported dispute-gas number for ML-sized shards.
Why not just detect fishing models on the client, without changing who controls the model? A client-side detector is an arms race against an adaptive coordinator who can make crafted models look statistically ordinary, and Wen et al. explicitly design fishing to avoid suspicious architectures. Our trajectory detector reads the same signals, but over public, rate-limited history, which forces an attacker to drift slowly instead of jumping. The no-$\tau$ ablation shows how much of the gain comes from the cap rather than from detection.
Proposed Experiments
Utility and overhead runs use FMNIST with a three-layer network, CIFAR-10 with AlexNet, and Shakespeare with an LSTM, matching BatchCrypt's setup, plus CIC-IDS2017 to compare with EdgeDetect. Attack runs use CIFAR-10/100, CelebA and downsampled ImageNet with LIA-SA, class and feature fishing, RTF, CAH, and passive GIAS against the decrypted aggregate. Gas is measured on an Ethereum testnet using Li et al.'s create-based dispute pattern. Metrics are label-recovery accuracy, reconstruction PSNR, rounds-to-success for multi-round attacks, final test accuracy, client time and communication, and gas per round and per dispute.
The decisive check is the sweep over $\tau$. If some value pushes class-fishing rounds-to-success well beyond the ~8-round baseline and keeps LIA-SA label recovery near chance, while costing accuracy within BatchCrypt's under-1% envelope on CIFAR-10, the central hypothesis holds. If every $\tau$ that blocks the attacks also costs several points of accuracy, the claim fails, and the honest conclusion is that provenance alone, which blocks targeted equivocation, is the deliverable.
A second check runs GIAS on the public $A_t$ while varying the number of clients. Every participant sees the aggregate, so we must show it does not reopen the passive leak that encryption closed.
A third check is the adversarial-client experiment. Here we measure how many colluding clients, hiding contributions inside the encrypted sum, can assemble a fishing configuration under the cap. That number is the security parameter users would actually need to choose.
References
- BatchCrypt: Efficient Homomorphic Encryption for Cross-Silo Federated Learning
- EdgeDetect: Importance-Aware Gradient Compression with Homomorphic Aggregation for Federated Intrusion Detection
- Privacy-Preserving Byzantine-Resilient Swarm Learning for E-Healthcare
- Breaking Secure Aggregation: Label Leakage from Aggregated Gradients in Federated Learning
- Fishing for User Data in Large-Batch Federated Learning via Gradient Magnification
- OASIS: Offsetting Active Reconstruction Attacks in Federated Learning
- Gradient Inversion with Generative Image Prior
- Scalable and Privacy-Preserving Design of On/Off-Chain Smart Contracts
- SoK: Off The Chain Transactions