Fixed-Pattern Noise Is Not Privacy: Modeling Attacks on Hardware-Noised Federated Clients

Federated learning trains one model across many devices. Each device computes an update on its own data and sends only that update to a server, which averages the updates. The updates still leak the data, so the usual remedy is to add random noise to each one (differential privacy, a guarantee that any single training record barely changes what the server sees). That noise costs accuracy. A tempting shortcut for low-power edge chips is to count the chip's own physical randomness as the privacy noise. Analog compute-in-memory chips, which do matrix multiplication directly inside a grid of memory cells, are already imprecise, and the imprecision seems to come free. This note argues that most of that imprecision is the wrong kind of randomness. A large part of it is a fixed fingerprint of the individual chip, the same physics that makes a physically unclonable function (a PUF) work. Hardware-security research has shown repeatedly that such fingerprints can be learned by machine learning from enough observed input-output pairs.

The core idea is to treat a curious federated server as a PUF modeling attacker. The server broadcasts the global weights each round, which play the role of the "challenge." It then receives the device's distorted update, which plays the role of the "response." Over many rounds it can fit a model of that device's persistent distortion, subtract it, and leave only the small fresh, per-use noise as real protection. We propose to build this attack, to measure how much of a device's apparent noise survives it, and to turn that measurement into a privacy accounting rule that credits only the part an attacker cannot model.

Core Claim

The distortion that an analog edge client adds to its update can be split into three parts:

$$u_t = g(w_t; D) + h_\theta(w_t, D) + \xi_t,$$

Here $u_t$ is the update the server receives in round $t$, $g(w_t; D)$ is the ideal gradient of the broadcast weights $w_t$ on the private data $D$, $h_\theta$ is a deterministic distortion governed by device-specific parameters $\theta$ such as per-cell threshold-voltage offsets, and $\xi_t$ is fresh cycle-to-cycle noise that is independent across rounds.

The claim has two parts. First, a server that sees enough rounds can estimate $\theta$ well enough that $h_\theta$ provides essentially no privacy. Second, a sound accounting of differential privacy must therefore use only the variance of $\xi_t$, measured conditional on the attacker's best estimate of $\theta$. If the claim holds, "hardware-intrinsic privacy" designs that count total device variance overstate their guarantee, and the overstatement can be quantified. If it fails, because $h_\theta$ cannot be modeled at realistic round counts, that is equally useful: it would be the first evidence that persistent analog variation adds real privacy in federated settings.

Why This Is Different From the Closest Work

The nearest neighbors fall into three groups, and each leaves out the piece we study.

The first group uses fresh physical noise for privacy. Over-the-Air Federated Adaptive Data Analysis uses additive wireless-channel noise as "free" differential privacy, and Certified Characterization of Privacy, Participation, and Convergence in Over-the-Air Federated Learning certifies privacy for over-the-air aggregation. Both rely on noise that is fresh on every use. The danger we study is the opposite case, randomness that repeats.

The second group gets privacy from structured, non-additive mechanisms. Randomized Quantization is All You Need for Differential Privacy in Federated Learning obtains privacy from randomized rounding of gradients, but its proofs cover scalar inputs, and its multi-device behavior is only tested empirically.

The third group is the hardware side, which supplies both the motivation and the attack method. Physically unclonable memristor-based compute-in-memory chip for secure AI shows that fixed threshold-voltage variation can act as an analog key, keeping an extracted model below 40% accuracy. That result concerns one-shot extraction of a static model, not a server observing hundreds of training rounds. The modeling-attack literature tells us what a patient observer can do. A logistic-regression model reaches 98% accuracy on a 64-bit arbiter PUF from 2,000 pairs (A Challenge Obfuscation Method for Thwarting Model Building Attacks on PUFs). Chosen challenges break noise-free 16-XOR arbiter PUFs at 93.6–94.8% accuracy (Breaking XOR Arbiter PUFs With Chosen Challenge Attack). Sensor fingerprints of the PRNU type (photo-response non-uniformity, a fixed per-sensor pixel pattern) can be estimated and forged (Spoofing PRNU Patterns of Iris Sensors while Preserving Iris Recognition).

Our contribution is to transfer that attack logic onto federated updates. The server controls the "challenge" because it chooses the broadcast weights. That makes a malicious server a chosen-challenge attacker in exactly the sense of the XOR-PUF work.

Research Program

Client simulator. We first build a calibrated simulator of an analog in-memory training client. Weights are stored as cell conductances. Each cell carries a fixed multiplicative offset (the $\theta$ component) and slow drift, and each read adds fresh cycle-to-cycle noise. Device statistics will be set from the published characterizations of the memristor chip and the FeFET PUF (Demonstration of high-reconfigurability and low-power strong physical unclonable function). Where those papers do not report a quantity we need, such as the fresh-noise variance during training reads, we sweep it rather than guess. Gradients are computed through the distorted forward and backward passes, so $h_\theta$ depends on both the weights and the data, as it would on silicon.

Three attackers of increasing strength. The weakest is a passive averaging attacker. It estimates the persistent offset by regressing updates on the known broadcast weights, in the same way PRNU patterns are estimated by averaging many images. The second is a model-based attacker. It fits $\theta$ by maximum likelihood or with CMA-ES (covariance matrix adaptation evolution strategy, a derivative-free optimizer), using the known structure of the distortion. The third is an active, chosen-challenge attacker. It perturbs the broadcast weights in a few coordinates each round, borrowing the single-bit perturbation strategy from the XOR-PUF attack, to isolate individual cells' offsets.

What we measure. For each attacker we track three things as a function of rounds observed: how accurately it recovers $\theta$, how well a standard gradient-inversion attack (A Survey on Gradient Inversion) reconstructs private inputs after the modeled component is subtracted, and the conditional variance of what remains.

Accounting rule. The residual variance feeds a conservative rule that grants a Gaussian-mechanism privacy budget only for the residual. Where the residual is too small for the target budget, the client adds software noise to make up the difference. The output is a hybrid client that uses whatever hardware noise is genuinely fresh, and no more.

Baselines

No defense. The naive reference point is plain federated averaging with ideal digital clients. It fixes the ceilings: full utility and maximal leakage under gradient inversion.

Naive hardware accounting. This is the configuration the proposal attacks. The same analog clients are used, and privacy is credited for the total observed device variance, as an opportunistic-privacy argument in the style of Over-the-Air Federated Adaptive Data Analysis would suggest. We beat it in the sense that matters if our attacker drives reconstruction quality back near the no-defense level at a round count within a normal training run, despite the claimed budget.

Software Gaussian noise. The strongest competitor on utility is standard clipping plus Gaussian noise on ideal digital clients, which The Federation Strikes Back documents as the default and as costly in accuracy. For a numeric anchor from a related private federated setting, Fed-SB reports 70.33% SNLI accuracy at $\epsilon=1$, against 49.57% for standard federated LoRA. That is a language-model fine-tuning result and is not directly comparable to our edge tasks. No reported result was found on Lacuna for DP federated training on MIT-BIH or for Gaussian noise on EMNIST with a matched budget, so we will run it ourselves. The hybrid client beats this baseline if it reaches higher accuracy at the same honestly accounted $\epsilon$ and the same empirical attack resistance, because fresh hardware noise lets it inject less software noise.

Randomized quantization. RQM is the strongest noise-free alternative. We will run it on the same EMNIST split, client count, rounds, and tuning budget as every other method. Every method gets an equal hyperparameter grid, and each is evaluated at three target budgets.

Ablations. Two ablations isolate the key ingredient. One simulates clients with only persistent variation, which should give zero residual privacy under our attacker. The other uses only fresh variation, which should behave like additive Gaussian noise and match its accounting. Together they show that the persistent/fresh split, not analog distortion in general, drives the result.

Why not just…?

Why not just use software Gaussian noise and ignore the hardware? This is a real threat to any claim of a utility gain. If measured fresh cycle-to-cycle variance turns out to be tiny, the hybrid client collapses into software differential privacy, and the only contribution left is the negative result about naive accounting. We accept that outcome. The attack and the accounting rule stand regardless, and the residual-variance curve in our experiments states directly how much software noise the hardware can replace.

Why not just assume device noise is fresh, as over-the-air work does for channel noise? Channel noise is fresh by construction. Threshold-voltage offsets are fixed for the life of a chip; that fixity is exactly why they can serve as a PUF key. The modeling-attack results, from a 98% logistic-regression clone (A Challenge Obfuscation Method) to chosen-challenge breaks of designs built to resist it (Breaking XOR Arbiter PUFs), say that fixed physical structure should be presumed learnable. The passive-attacker experiment tests whether this holds for federated updates.

Why not just use secure aggregation so the server never sees individual updates? Secure aggregation hides individual updates within a round. However, The Federation Strikes Back notes that it remains exposed to multi-round attacks, and Panning for Gold in Federated Learning extracts targeted text even under arbitrarily large aggregation. The persistent offsets of all clients sum to a persistent aggregate distortion, which our regression attacker can model from the aggregates. We will run the attacker on aggregated updates to test whether this holds.

Why not just run more local steps before each upload? Ten local iterations cut recovery success by over 60% (A Survey on Gradient Inversion), but this gives no formal guarantee and does not remove a persistent fingerprint. We include local steps as a factor in the experiment grid, not as a substitute for accounting.

Proposed Experiments

The edge task is MIT-BIH arrhythmia classification with the two-layer network from the memristor chip study, which reported 94.4% on-chip and 95.2% in software. That task is partitioned non-IID across simulated clients. Reconstruction is evaluated on federated EMNIST and on CIFAR-10, using cosine-similarity gradient inversion with label extraction.

The decisive check is a curve of attacker-recovered reconstruction quality against rounds observed, for each attacker. We measure PSNR (peak signal-to-noise ratio, a pixel-level fidelity score) and label-recovery rate. Naive accounting fails if those curves return to no-defense levels before training converges. Our accounting is validated if empirical privacy auditing, which plants marked "canary" records and tests whether the server can detect them, stays within the residual-based budget while it exceeds the total-variance budget. The second check is utility: accuracy of the hybrid client against software-only Gaussian noise and randomized quantization, at matched accounted $\epsilon$. A third check sweeps drift rate and temperature to find whether drift makes $\theta$ effectively fresh. If it does, that would mark the regime in which hardware noise legitimately earns privacy credit.