Unpairing a Federated Model from Its Own Broadcast History

In federated learning, many devices train one shared model without sending their data to a central server. Each round, the server broadcasts the current global model to participating clients. After training ends, every client that took part therefore holds a record of snapshots of the model the server will deploy. A separate line of work shows that intermediate snapshots from a single training run make unusually strong surrogates for attack. A surrogate is a stand-in model an attacker can inspect freely, and adversarial examples crafted against it tend to fool an unseen target model. This property is called transferability. Put together, these facts imply that the ordinary federated protocol hands every participant a strong attack toolkit against the deployed model, and that no behaviour-based defense can notice this, because the attacker never needs to misbehave.

We propose to measure this threat and to defend against it cheaply. At the end of training, the server spends a small, one-time budget adjusting a small set of parameters in the deployed model. The goal is to make the deployed model's input gradients point in different directions from those of the specific checkpoints each client actually received, while keeping clean accuracy. The server already keeps a ledger of which snapshots went to which client in which round, and this ledger defines the attacker's surrogate pool exactly. The defense uses this record of what clients know instead of trying to infer malice from how clients behave. The expected result is transfer resistance comparable to federated adversarial training, at a small fraction of its cost, with no extra work on client devices.

Core Claim

We make two claims. The first is that in realistic federated deployments, the strongest transfer attack comes from the broadcast checkpoint trajectory, not from a surrogate the attacker trains on their own data. The second is that a server-side, parameter-efficient decorrelation objective targeted at that recorded trajectory removes most of this attack's success. It should do so at far lower cost than on-device adversarial training, and it should outperform decorrelating against the final broadcast model alone.

The first claim rests on combining two findings that have not been put together. Understanding Adversarial Transferability in Federated Learning shows that clients who behave honestly during training can later train a surrogate on their 3–7% share of the data and reach a 70–80% transfer rate against a converged ResNet50 on CIFAR-10, or 85% with AutoAttack. That paper also proves that averaging across heterogeneous clients weakens the gradient similarity between local surrogates and the global model. However, it builds surrogates from local data rather than from the global snapshots the attacker already holds. Enhancing Adversarial Transferability with Checkpoints of a Single Model's Training shows, in a centralized setting only, that an ensemble of checkpoints taken before the model starts to overfit is a far better surrogate than a multi-architecture ensemble: 89.1% versus 52.4% attack success on ImageNet CNN targets. It selects these checkpoints using the gap between training and validation accuracy.

In federated learning, those checkpoints are exactly what the protocol broadcasts. The weakening effect proved by the first paper applies to local-data surrogates. It says nothing about surrogates that are earlier versions of the target. We therefore expect the checkpoint attack to erase federated learning's supposed natural robustness to transfer.

The threat model requires one stated assumption: the deployed model is not identical to the last broadcast. If it were, the attacker would have full white-box access and no transfer defense could help. This assumption holds whenever the server applies a final private adjustment, and our defense creates that adjustment deliberately.

Research Program

The work has three stages.

Stage 1: build the exposure ledger and the attack. For each client, the ledger records the set of global checkpoints $\{\theta_t\}_{t \in E_c}$ that client $c$ received, where $E_c$ is the set of rounds in which it participated. We implement the checkpoint-ensemble attack from each client's ledger entry. The attacker weights checkpoints by the accuracy-gap indicator, which the attacker can compute from their own local training and validation split. We compare this attack against the local-data surrogate attack from the federated transferability paper. We also measure how attack success grows with the number of checkpoints a client holds, $|E_c|$. This gives the server a per-client risk estimate with no behavioural inference at all.

Stage 2: behavioural reputation check. We confirm, and do not simply assume, that behaviour-based reputation cannot see this threat. We run FLDetector, which predicts each client's next update from its past trajectory, and FLTracer, which tracks decomposed update features with a Kalman filter. Both run on the same federation containing covert attackers. We expect detection near chance for these clients. That result would motivate replacing reputation based on client behaviour with reputation based on client exposure.

Stage 3: the defense. Let $\phi$ be a small trainable subset of the deployed model's parameters, and let $f_{\theta,\phi}$ be the deployed model. For vision transformers, $\phi$ is a set of about ten learnable prefix tokens, as in Robustness Tokens. For convolutional networks, $\phi$ is the set of layers that RiFT identifies as not critical for robustness. Using a small server-held root set $D_s$ of about 50 to 500 samples (the scale that AGSD already assumes), the server solves

$$ \min_{\phi}\; \mathbb{E}_{(x,y)\sim D_s}\Big[\mathcal{L}(f_{\theta,\phi}(x),y) + \lambda \sum_{t} w_t \,\cos^2\!\big(\nabla_x \mathcal{L}(f_{\theta,\phi}(x),y),\, \nabla_x \mathcal{L}(f_{\theta_t}(x),y)\big)\Big]. $$

Here $\mathcal{L}$ is cross-entropy, and $\cos$ is the cosine similarity between the deployed model's input gradient and that of broadcast checkpoint $\theta_t$. The weight $w_t$ is the product of two factors. The first is how many clients received checkpoint $t$, taken from the ledger. The second is the accuracy-gap transferability score, so that pre-overfitting checkpoints, which the checkpoint paper found most dangerous, get the most weight. The coefficient $\lambda$ trades clean accuracy against decorrelation. Squaring the cosine penalizes anti-alignment as well as alignment, because a perfectly anti-aligned gradient is just as exploitable.

The objective adapts the similarity-unpairing loss from Publishing Efficient On-device Models Increases Adversarial Vulnerability. That paper decouples a published compressed model from a single server model. We differ in three ways. We modify the private deployed model rather than the published derivative. We decorrelate against a weighted trajectory rather than one fixed partner. And we update only a small parameter subset, so the cost is one server fine-tune of roughly hundreds of steps, which matches the 200-step convergence reported for robustness tokens.

We treat three pieces of prior work as constraints on the design. First, FAT: Federated Adversarial Training found that an apparent 82% robustness under Krum collapsed to 0.29% once the attack was adjusted. We therefore report white-box AutoAttack on the deployed model as a sanity check against gradient masking. We do not claim white-box robustness; if $\phi$ leaked, a white-box attack would succeed. Second, the robustness-tokens paper already notes that its tokens only help while they stay secret, so secrecy of $\phi$ is an explicit assumption. Third, and for the same reason, we evaluate an adaptive attacker who knows the defense and trains their own guessed unpairing.

Baselines

The naive reference point is to deploy the final global model unchanged, with standard FedAvg aggregation. All three attacks (local-data surrogate, final-broadcast surrogate, checkpoint ensemble) are run against it. This sets the ceiling on attack success. The closest reported number is the 70–80% transfer rate, and 85% with AutoAttack, for ResNet50 on CIFAR-10 in Understanding Adversarial Transferability in Federated Learning. No result was found on Lacuna for a checkpoint-ensemble transfer attack in a federated setting, so that number will be new.

The strongest robustness competitor is federated adversarial training with the Jump-Start Policy from FAT. In that method, clients run local projected gradient descent attacks during training, starting with 10% adversarial data and stepping up to 80% once training stabilizes. It is the strongest competitor because it gives the model built-in robustness instead of relying on a secret, which is exactly what a skeptic would prefer. The reported reference is 33.69% adversarial accuracy on FEMNIST, compared with 0% for plain federated adversarial training. We run it on the same client partitions, architectures, and number of rounds, and give it the same hyperparameter search budget as our method. We report robust accuracy under transfer and total compute: client GPU-hours and server GPU-hours, measured separately. Beating it means matching or exceeding its transfer robustness at no more than one-fifth of its total compute, with higher clean accuracy.

The strongest transfer-specific competitor is similarity-unpairing as originally designed, applied between the deployed model and the final broadcast checkpoint only. It uses the same parameter subset, the same root set, and the same number of steps as our method. The only difference is the partner set in the penalty. Its reported effect in the centralized setting is a 50–80% reduction in transferability at about 93% clean accuracy on CIFAR-10. This baseline doubles as the ablation that isolates our key ingredient, the ledger-weighted trajectory.

A second ablation replaces the weights $w_t$ with uniform weights. This tests whether the exposure and accuracy-gap weighting matters. A third ablation replaces the targeted objective with a generic parameter-efficient robustness step: robustness tokens, or RiFT-style fine-tuning, trained on adversarial examples crafted from the final model. This asks whether any cheap private adjustment is enough.

Why not just…?

Why not just rely on behaviour-based reputation to catch the attackers? The attacker in this threat model sends honest updates in every round. Methods like FLDetector, FLTracer, and RECESS all score deviations in submitted updates, so they have nothing to detect. The federated transferability paper chose this "act benign" setting precisely to evade such detectors. Stage 2 of our program measures this directly rather than assuming it. If those detectors unexpectedly flag covert clients, the ledger approach becomes less necessary, and we would report that.

Why not just run federated adversarial training on clients? FAT itself shows that this diverges under non-IID data without ad hoc schedules and still reaches only 33.69% adversarial accuracy on FEMNIST. It also places multi-step attack generation on edge hardware. It remains a real competitor, however, because it does not depend on keeping $\phi$ secret. Our head-to-head comparison reports robustness per unit of compute and states the secrecy assumption openly, so that a reader can choose between the two.

Why not just apply a generic cheap private adjustment, such as robustness tokens trained against the final model? This is the most serious threat. Any secret modification might break alignment with the broadcast history, which would make the trajectory targeting unnecessary. The third ablation settles the question. If robustness tokens trained only against the final model reduce checkpoint-ensemble attack success as much as our trajectory-targeted objective does, then the contribution shrinks to the threat measurement plus a recommendation to use tokens, and we would present it that way. Our reason to expect a gap is that the checkpoint paper found pre-overfitting checkpoints transfer differently from, and better than, the final model. Removing alignment with the final model need not remove alignment with the earlier checkpoints.

Why not just stop broadcasting intermediate checkpoints, or add noise to them? Clients need the current global model to compute their updates, so they cannot avoid holding checkpoints. Noise large enough to break transfer would also damage the clients' local training. We include a small test of noisy broadcasts to show this trade-off rather than simply asserting it.

Proposed Experiments and Decisive Checks

The main setting follows the federated transferability paper: ResNet50 on CIFAR-10, 100 clients, Dirichlet non-IID partitions at several concentration levels, and attackers holding 3–7% of the data. FEMNIST from the LEAF benchmark supplies naturally heterogeneous clients and allows direct comparison with FAT. ImageNet-200 with a vision transformer backbone tests the token-based version of $\phi$. Metrics are:

  • transfer attack success rate under PGD and AutoAttack surrogates at a fixed perturbation budget;
  • clean accuracy;
  • white-box AutoAttack accuracy, reported only as a check for gradient masking;
  • client-side and server-side GPU-hours.

The first decisive check tests the premise. If, in the federated setting, the checkpoint-ensemble attack does not clearly beat the local-data surrogate, the broadcast-history threat is minor, and the project reduces to a negative result on the checkpoint paper's claim when moved to federated learning.

The second check is the trajectory-versus-final-model unpairing comparison. The trajectory objective should cut checkpoint-ensemble attack success by a clear margin beyond the final-model version at matched cost. If it does not, the ledger adds nothing.

The third check is the scaling of attack success with each client's exposure $|E_c|$, before and after the defense. A defense that works should flatten this curve.

The fourth check is the adaptive attacker who knows the defense. If that attacker recovers most of the undefended attack success, the method only relies on hiding its design, and we would report it as such.