Federated learning trains a shared model across many devices without pooling their raw data, and when device data is statistically mismatched, personalized federated learning gives each device a model tuned to its own distribution. A newer problem, unseen client generalization, asks what happens when a device that never participated in training joins after deployment: it has unlabeled data, no trained local components, and no budget for retraining, so recent systems generate a tailored model on demand — for example, a hypernetwork that reads a compact summary of the client's unlabeled data and writes custom classifier weights for it. Separately, backdoor research studies attacks in which a compromised participant hides a trigger-activated misbehavior inside the shared model while keeping normal accuracy intact. These two threads have never been made to meet: every backdoor-against-personalization study evaluates only clients who trained local components on labeled data during the federated phase.
This gap matters because the one result suggesting personalization is protective does not transfer. Revisiting Personalized Federated Learning: Robustness Against Backdoor Attacks found a "firewall effect": in FedRep-style systems (Exploiting Shared Representations for Personalized Federated Learning), the classifier head is never shared and is trained only on local clean data, which cut BadNet/Blended attack success from above 90% (FedAvg) to under 10% on CIFAR-10. But an unseen client has no locally trained head — its head is synthesized from unlabeled data. Whether that synthesized head restores the firewall, or leaves the client defenseless, is completely unmeasured: no reported result found on Lacuna for attack success rates on unseen, non-participating clients, from any attack or defense.
Core Claim
The claim is two-part. First, empirically: the firewall effect depends on supervised local head training, so it collapses at the cold start — backdoors planted in the shared encoder during federated training (as in BapFL and Bad-PFL) will fire at high rates through hypernetwork-generated and test-time-adapted heads on unseen clients, and unsupervised adaptation may actively amplify them. Second, constructively: the same machinery that creates the exposure can be turned into a defense. Because a hypernetwork regenerates the head from a data descriptor, an unseen client can regenerate many heads from deliberately perturbed descriptors and treat prediction invariance across those heads as a backdoor signature — moving STRIP's intentional-perturbation idea from input space into weight space, where it cannot be dodged by natural, sample-specific triggers in the input.
Background and Why the Intersection Is Open
Three lines of work bracket the question. The attacks: You Can Backdoor Personalized Federated Learning (BapFL) poisons the shared encoder so triggers land in the target class's representation region while Gaussian noise on the attacker's head forces the trigger to fire across heterogeneous decision boundaries — 94.21% attack success on MNIST, 58.89% on CIFAR-10 at Dirichlet $\alpha=0.5$, and above 70% even against Multi-Krum with projected gradient help. Bad-PFL: Exploiting Backdoor Attacks against Personalized Federated Learning replaces artificial patches with generative natural-feature triggers entangled with the classifier's own manifolds, exceeding 90% attack success on FedRep where earlier attacks fell below 30%, holding roughly 77% against Median aggregation, and barely decaying after 45 steps of clean fine-tuning. Both evaluate only seen clients with labeled data — explicitly leaving unseen clients, hypernetworks, and test-time adaptation open. The defenses: Lockdown: Backdoor Defense for Federated Learning with Isolated Subspace Training trains clients in isolated sparse subspaces to prevent poison-coupling, cutting attack success by up to 90% (83% under extreme non-IID with only a 2.7% clean-accuracy drop), but assumes a static aggregated model, not a weight-generating hypernetwork. The personalization systems we will stress: HyperFedZero (Deploying Models to Non-participating Clients in Federated Learning without Fine-tuning), whose NoisyEmbed and balancing penalty keep descriptor embeddings spread out, reaches 52.40% zero-shot accuracy on CIFAR-10 unseen clients versus 40.41% for FedAvg; ODPFL-HN (Inference-Time Personalized Federated Learning) reaches 33.6% on CIFAR-100 novel clients versus 30.2% for FedAvg; and FedTTA (UPFL: Unsupervised Personalized Federated Learning towards New Clients) adapts the base model unsupervisedly, with entropy-based early stopping, for a reported 9–10% accuracy gain. None has ever been evaluated under poisoning.
Research Program
Phase one is a measurement grid. We train federated systems with a small malicious fraction running BadNet/Blended (static triggers, from the Revisiting-pFL protocol), BapFL, and Bad-PFL, then deploy to held-out unseen clients through four personalization routes: the plain global model, a hypernetwork-generated head (HyperFedZero-style), a meta-learned generator (PeFLL-style, Personalized Federated Learning by Learning to Learn), and FedTTA adaptation. The key comparison is seen-client versus unseen-client attack success under identical poisoning: if the firewall is real, seen clients with trained heads should show low attack success while unseen clients show high — quantifying exactly how much protection supervised head training was providing. For FedTTA we additionally trace attack success across adaptation steps when the unlabeled batch contains triggered samples, testing a specific suspicion: STRIP (STRIP: A Defence Against Trojan Attacks on Deep Neural Networks) showed triggered inputs produce pathologically low prediction entropy, so FedTTA's entropy-minimizing early stopping may lock in a backdoored state rather than escape it.
Phase two builds the defense, which we call descriptor churn. Let $\phi$ be the shared encoder, $z_x$ the descriptor a client computes from its unlabeled batch, and $H$ the hypernetwork that maps a descriptor to classifier weights. The client regenerates $M$ heads from perturbed descriptors, $h_j = H(z_x + \epsilon_j)$ for $j = 1,\dots,M$, reusing HyperFedZero's learned NoisyEmbed noise as the perturbation source, and flags an input $x$ when
$$\arg\max_c\, h_j(\phi(x))_c \text{ is the same class } c \text{ for all } j, \text{ with low output entropy.}$$
The logic: clean inputs sit near genuine class boundaries, so heads personalized to slightly different pseudo-distributions should disagree on them; a backdoor that lives in the shared encoder (the BapFL/Bad-PFL design) fires through any plausible head, producing suspicious invariance. Flagged inputs get majority-vote or abstention treatment, and FedTTA's early stopping is replaced by cross-head disagreement, which does not reward the backdoor's low entropy. Phase three is an honest adaptive stress test: a descriptor-conditioned Trojan, where a malicious participant poisons the hypernetwork itself so backdoored weights are emitted only for descriptors in a narrow region — the unseen-client analogue of Sniper Backdoor's client targeting (Sniper Backdoor: Single Client Targeted Backdoor Attack in Federated Learning), which needed the victim's training updates and so cannot reach non-participants. Against this attack, invariance across nearby perturbed descriptors may fail (the Trojan's activation region is narrow), so we also test a server-side descriptor sweep that probes the generator's output across descriptor space before deployment.
Proposed Experiments
We run CIFAR-10 and CIFAR-100 with Dirichlet $\alpha=0.5$ partitions of 50 clients (matching BapFL's setup), FEMNIST (the Revisiting-pFL setting, with writers held out as unseen clients), and SVHN for Bad-PFL's natural triggers. Infrastructure is BackFed (BackFed: An Efficient & Standardized Benchmark Suite for Backdoor Attacks in Federated Learning) for poisoning protocols and the pFL-Bench unseen-client splits (pFL-Bench: A Comprehensive Benchmark for Personalized Federated Learning) for generalization evaluation, with the FederatedScope backdoor-bench from the Revisiting-pFL authors as a cross-check. Metrics are attack success rate on unseen clients, clean zero-shot accuracy, false-flag rate on clean unseen data (which must stay near the 1–2% regime STRIP reports, or the defense is unusable), and per-query compute overhead. Every attack–defense pair gets the same malicious fraction, aggregation rule, and tuning budget, following BackFed's standardized configuration to avoid the evaluation inconsistencies it documented.
Baselines
The "do nothing" reference point is the poisoned trained system deployed as-is to unseen clients. It anchors both sides of the trade: on CIFAR-10 the clean FedAvg global model reaches only 40.41% zero-shot accuracy on unseen clients versus 52.40% for HyperFedZero (reported in Deploying Models to Non-participating Clients in Federated Learning without Fine-tuning), and poisoned FedAvg suffers above 90% attack success under BadNet/Blended on seen clients (reported in Revisiting Personalized Federated Learning: Robustess Against Backdoor Attacks); measuring its unseen-client attack success is itself a contribution of phase one. The strongest existing defense is Lockdown (Lockdown: Backdoor Defense for Federated Learning with Isolated Subspace Training), which reports up to 90% attack-success reduction versus undefended FedAvg and, under extreme non-IID, an 83% reduction with only a 2.7% clean-accuracy drop; we run Lockdown during training and then apply hypernetwork personalization on top with the same compute and tuning budget as our defense, since the combination is untested and Lockdown's authors never evaluated zero-shot generalization of sparse consensus models. Beating Lockdown means matching its relative attack-success reduction (within a few points) while keeping the personalization advantage — clean unseen-client accuracy within about two points of undefended HyperFedZero's 52.40% on CIFAR-10. The strongest inference-time competitor is STRIP (STRIP: A Defence Against Trojan Attacks on Deep Neural Networks), which reports 0% false acceptance and 0% false rejection on static triggers at 1.32x inference latency; we run it with the same number of perturbation copies as our $M$ regenerated heads so compute is equalized, and beating it means detecting Bad-PFL's natural-trigger inputs at a comparable false-flag rate. Two further comparisons bound the problem: a Simple-Tuning labeled oracle (reinitialize the head and briefly fine-tune on clean labeled data, which reduced BadNet/Blended attack success by an average 56.6% in the Revisiting-pFL study) run with a small synthetic labeling budget to upper-bound what any label-free defense could achieve, and an ablation of our own detector in which inputs rather than descriptors are perturbed at identical budget — this isolates whether weight-space churn, the proposal's key ingredient, is doing the work that input-space perturbation cannot.
Why not just…?
Why not just fine-tune the head on a bit of local data (Simple-Tuning)? This is the obvious move, and it is exactly what the unseen-client setting forbids: the motivating systems (Inference-Time Personalized Federated Learning, UPFL) exist because late-arriving edge clients have unlabeled data and cannot run multi-step supervised training. It is also not clearly sufficient even with labels: Bad-PFL's attack success barely decayed after 45 continuous clean fine-tuning steps (Bad-PFL). Still, we take the threat seriously and run the labeled-oracle Simple-Tuning baseline explicitly, so the proposal reports precisely how much labeling budget would be needed before the simpler route dominates ours.
Why not just filter malicious updates at the server (Median, Multi-Krum, Lockdown)? Robust aggregation is the standard answer, and the file's evidence says it leaks: Bad-PFL holds roughly 77% attack success against Median, and BapFL with projected gradient descent stays above 70% against Multi-Krum. Server-side anomaly detection is also costly — BackFed measured DeepSight at roughly 388x FedAvg's runtime. Lockdown is the genuine threat here, which is why it is our strongest baseline rather than something we argue around; the open questions are whether sparse subspaces even span a hypernetwork's generated weights and whether Lockdown-trained systems retain zero-shot generalization, and our experiments answer both directly. None of these defenses addresses a poisoned hypernetwork or descriptor extractor, which phase three shows is a distinct attack surface.
Why not just run STRIP on the device? STRIP is cheap and battle-tested on static triggers, but Bad-PFL explicitly verified that its sample-specific natural triggers evade STRIP and Neural Cleanse, and there is a structural concern: under per-batch weight generation, blending an input with clean backgrounds shifts the descriptor and thus the generated weights, potentially breaking STRIP's input-agnostic premise entirely. We test STRIP head-to-head with equalized compute, and if it turns out to survive under hypernetwork personalization, that is a cheap win we would report gladly — our claim is only that weight-space churn catches what input-space perturbation cannot, which the ablation settles.
Why not skip personalization and ship the FedAvg global model? This removes the head-mismatch problem but is the worst of both worlds: 40.41% versus 52.40% zero-shot accuracy on CIFAR-10 unseen clients, and above 90% attack success under BadNet/Blended poisoning — a less accurate model that is also less protected, since the firewall never applied to FedAvg in the first place.
Decisive Checks
Four results decide the proposal. First, the seen-versus-unseen attack-success gap under identical poisoning: if unseen-client attack success does not substantially exceed seen-client attack success through generated heads, the firewall-collapse claim is wrong and the project pivots to characterizing why. Second, the FedTTA trace: attack success rising across adaptation steps with triggered samples in the batch, alongside the entropy curve, would confirm that entropy-based early stopping is deceived; a flat or falling trace refutes it. Third, the descriptor-churn false-flag rate on clean non-IID unseen data: above roughly 2%, the defense is unusable regardless of detection power, so this is a hard gate. Fourth, the adaptive descriptor-conditioned Trojan: if descriptor churn fails against it while the server-side sweep catches it, we report the split honestly — a defense that covers encoder-borne backdoors plus a detection story for generator-borne ones, with the narrow-activation-region attack documented as the known limit.
References
- Revisiting Personalized Federated Learning: Robustness Against Backdoor Attacks
- Exploiting Shared Representations for Personalized Federated Learning
- You Can Backdoor Personalized Federated Learning
- Bad-PFL: Exploiting Backdoor Attacks against Personalized Federated Learning
- Lockdown: Backdoor Defense for Federated Learning with Isolated Subspace Training
- Deploying Models to Non-participating Clients in Federated Learning without Fine-tuning: A Hypernetwork-based Approach
- Inference-Time Personalized Federated Learning
- UPFL: Unsupervised Personalized Federated Learning towards New Clients
- PeFLL: Personalized Federated Learning by Learning to Learn
- STRIP: a defence against trojan attacks on deep neural networks
- Sniper Backdoor: Single Client Targeted Backdoor Attack in Federated Learning
- BackFed: An Efficient & Standardized Benchmark Suite for Backdoor Attacks in Federated Learning
- pFL-Bench: A Comprehensive Benchmark for Personalized Federated Learning