Adaptive Weights as a Leakage Channel in Secure Federated Learning

Federated learning lets many data holders train one model together by sending updates to a server instead of sharing raw data. Two features are usually sold as independent add-ons. Adaptive client weighting scores each participant's update for how much it helps — its loss improvement, its loss-landscape flatness, its validation slope — and scales its contribution to the global model accordingly, which matters a lot when some clients hold corrupted or unrepresentative data. Secure aggregation then cryptographically masks individual updates so the server only ever decrypts the sum. The natural assumption is that combining the two is safe: after all, the individual updates stay hidden.

This proposal argues that assumption is wrong, and that the point where the two features meet is a genuine, uncharacterized privacy hole. Under the semi-honest adversary model — a server that faithfully follows the protocol but records everything it sees — adaptive weighting necessarily publishes, every round, a small per-client signal: the weight itself, or the scalar (loss, sharpness) the weight is computed from. No existing work has asked what that signal leaks. Worse, once the weights are known, the server's multi-round "disaggregation" problem — recovering individual clients' updates from a long sequence of sums — changes character entirely, and possibly in the attacker's favor. We propose to characterize this weight channel, demonstrate attacks through it, and design a defense that keeps most of the utility benefit of adaptive weighting while closing the hole.

Core Claim

Three connected claims, none tested in the literature. First, the scalar trajectories that adaptive weighting exposes (the sharpness value $\xi_{k,t}$ in FedISM, or the local test loss used for inverse-loss weighting in When Less is More) are themselves a property-inference channel: a semi-honest server watching one number per client per round can infer private dataset attributes — corruption level, label skew, hardware quality — without ever attempting full gradient inversion. This extends the property-inference logic of PROLIN, which already breaks secure aggregation using only low-dimensional linear features (membership inference at roughly 79% F1 on CIFAR-10), but where the features must be extracted from aggregated gradients; here the protocol hands the adversary a per-client feature stream for free.

Second, when aggregation weights are continuous and adaptive, the multi-round disaggregation attack of Gradient Disaggregation breaks — its mixed-integer solver assumes a binary participation matrix $P$ — but only if the weights are hidden. If the server computes the weights (or learns the scalars they derive from), the system flips from an NP-hard matrix-factorization problem to an ordinary linear least-squares problem. Writing the observed aggregate update at round $t$ as

$$g_t \;=\; \sum_{k=1}^{K} \alpha_{k,t}\, \Delta_{k,t},$$

stacking $T$ rounds gives $g = A(\alpha)\,\Delta$, where $\Delta$ collects all individual updates and $A(\alpha)$ is a sparse matrix of coefficients. In Gradient Disaggregation, $A$ is unknown and binary, forcing a Gurobi mixed-integer solve. With visible adaptive weights, $A$ is known, and the adversary solves for $\Delta$ directly — then feeds the recovered updates into standard gradient inversion with a generative image prior Gradient Inversion with Generative Image Prior. The provocative hypothesis: adaptive weighting does not defend against a semi-honest disaggregator; it may enable clean disaggregation where the static-weight attack would fail.

Third, there is a cheap defense in the same setting. Replace each weight with a noisy version $\tilde\alpha_{k,t} = \alpha_{k,t} + \varepsilon_{k,t}$, where $\varepsilon$ is zero-mean noise calibrated per round. The expected aggregate is unchanged, so convergence is preserved up to a variance penalty, but the adversary's coefficient matrix becomes an estimate rather than a fact, degrading the conditioning of $A(\tilde\alpha)$ and the informativeness of the weight trajectory. Weight jitter is to the weight channel what randomized response is to a survey: honest in aggregate, unreliable per respondent.

Research Program

The work has three parts. The first is an attack study characterizing the weight channel. We take two concrete adaptive-weighting systems — FedISM-style sharpness weighting FedISM and inverse-loss weighting When Less is More — running on top of standard secure aggregation, with a strictly semi-honest server. (Note that under secure aggregation the server cannot apply weights to updates it cannot see, so clients must self-scale their masked updates; this means the weight or its generating scalar is broadcast either way — the channel exists in every natural deployment.) The adversary runs two attacks. A trajectory attack trains a classifier on shadow clients' scalar series $(\xi_{k,1},\dots,\xi_{k,T})$ to predict private properties, in the spirit of PROLIN's auxiliary-data approach PROLIN. A weight-informed disaggregation attack replaces the binary $P$ in the public codebase of Gradient Disaggregation (gdisag/gradient_disaggregation) with the known coefficient matrix and solves by non-negative least squares with a smoothness prior on individual updates across rounds, followed by gradient inversion using a generative prior Gradient Inversion with Generative Image Prior. A companion theory piece analyzes the condition number of $A(\tilde\alpha)$ as a function of weight entropy, quantization level, and jitter variance, giving the number of observed rounds needed for reliable recovery.

The second part is the defense: the weight-jitter mechanism above, plus weight coarsening (restricting $\alpha$ to a small shared codebook so individual trajectories are less identifying), evaluated for both privacy and utility. The design question is the jitter-vs-utility trade: too little noise leaves the channel open, too much turns adaptive weighting into random weighting and erodes its benefit. We will bound the effective-learning-rate variance introduced by jitter and measure where the utility curve actually breaks.

The third part is a honest boundary study: characterizing when the channel does and does not matter. The semi-honest setting deliberately excludes active attacks — so LIA-SA's fishing-model label extraction and CGI's camouflaged client-side poisoning are out of scope, and we say so explicitly rather than claiming our defense handles them. Relatedly, we leave the question of whether sharpness-aware weighting neutralizes CGI (the file's Gap 5) open; it requires a malicious client, not a curious server.

Baselines

The do-nothing reference point is standard FedAvg under secure aggregation, with no adaptive weighting. This is the privacy configuration the whole field implicitly assumes is safe, and it is already broken: Gradient Disaggregation reports recovering the participant matrix with 100% accuracy for settings with over 1,000 users, lifting reconstructed-image PSNR from a useless 6.1 dB (aggregated) to 36.5 dB (disaggregated) on CIFAR, and sustaining face-attribute inference on LFW at AUC 0.9+ regardless of user count. Its utility cost is equally documented: on the corrupted RSNA ICH medical benchmark, plain FedAvg trails sharpness-based weighting by 10.85% FedISM. We will run this baseline ourselves on identical partitions, compute, and tuning budgets so the trade-off is measured, not cited.

The strongest existing system at this intersection, and the one our proposal both attacks and must preserve the utility of, is FedISM FedISM: clients compute a scalar sharpness value via sharpness-aware minimization and the server weights aggregation by it. It reports beating FedAvg by 10.85% on corrupted RSNA ICH images and the best prior fair-FL method (FedGA) by 3.78%, across corruption ratios of 10% to 30%, and its stated privacy position is that sharing a single scalar is harmless. That claim is exactly what we test. The fair comparison gives FedISM its published hyperparameters and tuning budget, and asks two numbers of our attack: property-inference AUC and post-disaggregation reconstruction PSNR from its scalar channel, versus FedVal-style plaintext inspection as the ceiling.

The strongest attack-side competitor is vanilla Gradient Disaggregation Gradient Disaggregation, run on its public codebase against our adaptive-weighted runs. The decisive question is whether it genuinely fails under continuous weights (confirming the file's Gap 1) and whether our weight-informed variant recovers its full power — its published numbers (100% matrix recovery for over 1,000 users; PSNR 36.5 after disaggregation) are the bar. For property inference, PROLIN PROLIN is the comparator, with its reported stable membership-inference F1 of approximately 79% on CIFAR-10 up to 200 clients; our trajectory attack beats it only if it reaches comparable F1 from the scalar stream alone, with less auxiliary data.

The key ablation isolates the defense's ingredient: identical adaptive weighting, identical noise budgets, run three ways — unperturbed weights (the vulnerable system), weights hidden from the server by client-side self-scoring, and weight jitter at matched effective-aggregation variance. If the hidden-weights arm matches jitter's privacy at equal utility, the simpler design wins and we will say so. We will also report an ISIC 2019 run for external validity, noting that no reported result found on Lacuna for ISIC 2019 prevents a cited comparison there.

Why not just…?

Why not just drop adaptive weighting and use plain secure aggregation? This is the cleanest alternative and we take it seriously. The documented utility cost is real: 10.85% on corrupted medical imaging FedISM, and fairness failures that adaptive scoring fixes — minority-label accuracy rising from 32% to 53% on FEMNIST and minority recall from 19% to 50% on PUMS ACSIncome under FedVal. And dropping weighting does not even buy privacy: plain SecAgg is exactly the configuration that Gradient Disaggregation breaks (PSNR 36.5; LFW AUC 0.9+). So the do-nothing arm loses on both axes by the literature's own numbers; our experiments quantify this directly rather than assume it.

Why not just add differential-privacy noise to the updates or the scalars? DP is the field's default answer, and the file's evidence is unfavorable but incomplete. OASIS notes DP "often degrades model performance to gain privacy," and LIA-SA reports its label recovery resilient to DP noise whenever the model stays useful. Noise also corrupts the fine-grained signals adaptive aggregators consume — the normalized loss slopes of FedVal and the alignment measures of MOTION — so the defense damages the very mechanism it protects. Still, DP on the scalar channel is mathematically close to our jitter, so we run it as a head-to-head ablation at matched utility; if calibrated DP matches jitter, that is the honest result and the simpler method stands.

Why not just compute the weights under cryptography so the server never sees them? This exists in miniature: Secure Weighted Aggregation in Federated Learning does exactly this with Paillier homomorphic encryption and zero-knowledge proofs of plaintext knowledge, at 1.2x runtime and 1.3x communication overhead over SecAgg+ — but only for logistic regression, because the loss must be approximated by cubics, and the authors themselves flag deep networks and model inversion as open problems. Full ZK proofs over millions of weights are, per Helen and the verifiable-FL literature cited in the file, prohibitively expensive at edge scale. The cheaper version — clients self-score locally and self-scale their masked updates, so no scalar ever leaves the device — is a genuine threat to our approach, and we test it as the hidden-weights ablation. Its weakness is trust: self-reported scores are unverifiable, so it works in the semi-honest setting we study but forfeits the Byzantine robustness that motivates server-side scoring like FedVal's (which withstands 80% malicious clients). That trade-off is the real finding the ablation will settle.

Proposed Experiments and Decisive Checks

We simulate federations of 50–200 clients on CIFAR-10 and CIFAR-100 with Dirichlet label skew plus injected corruption at the 10–30% ratios used by FedISM, on RSNA ICH for the quality-shifted medical setting, on FEMNIST via LEAF for demographic skew, and on LFW-style attribute inference where the property target is the client's attribute distribution. Metrics split into privacy (property-inference AUC/F1, membership-inference F1, reconstruction PSNR/SSIM after disaggregation, participant-matrix recovery accuracy) and utility (global test accuracy, worst-client accuracy, minority-label accuracy). Every attack is run by a strictly semi-honest server: no parameter tampering, no protocol deviation, passive observation only.

The decisive checks are four. First, does the trajectory attack on sharpness or loss scalars alone reach property-inference performance near PROLIN's 79% F1 membership bar, from a channel the field treats as privacy-neutral? Second, does weight-informed disaggregation under continuous adaptive weights recover the attack effectiveness that vanilla Gradient Disaggregation loses — approaching its PSNR 36.5 / 100% matrix-recovery numbers — confirming that visible weights convert the NP-hard problem into tractable least squares? Third, does weight jitter at a variance budget that costs less than one fifth of FedISM's 10.85% utility gain push both inference channels toward chance? Fourth, the boundary check: the theory's condition-number predictions for required observation rounds should match the empirical disaggregation success curve, giving the community a usable design rule — how much weight entropy and jitter a deployment needs for a chosen leakage tolerance, rather than another all-or-nothing privacy argument.