A physically unclonable function (PUF) is a small circuit whose output depends on tiny manufacturing differences in the silicon. It acts as a hardware fingerprint that low-power sensors can use to authenticate themselves without storing a secret key in memory. PUFs are noisy, though: temperature and voltage flip some of their output bits. Recent key-exchange protocols absorb this noise by asking many redundant questions and taking a majority vote. That creates a problem these protocols do not examine. Any responder that answers correctly more than about half the time passes the vote, and the same papers report that a neural network can predict PUF answers with 89–99% accuracy. In the regime these protocols are designed for, a genuine device with 10% bit noise and a good software clone produce similar numbers of errors.
This proposal treats the authentication server's decision as a rare-event physics problem. Rare-event physics separates a true signal from a background that has the same energy by using the shape of each event, not only its size. Here the "event" is a session of answers, and the question is whether the errors look like physical noise or like a learned model's mistakes. A real PUF errs randomly, and only on challenges whose internal delay race is close to a tie. A software clone errs deterministically, on challenges that are hard to learn. The server already enrolls a model of each device. We propose that it also enroll which challenges are physically marginal and how often each one flips. During the handshake it would then ask a few chosen challenges, some of them repeated, and accept or reject using a likelihood-ratio test on the error pattern rather than on the error count.
Core Claim
At an equal number of challenges per session, a server that chooses challenges interactively and scores responses by their error structure will accept far fewer machine-learned clones than majority-vote or error-count acceptance. It will do this without rejecting more genuine devices, specifically when clone accuracy and genuine device reliability overlap. The claim is narrow on purpose. When clones are much worse than the device, simple counting already works, and we expect no gain there.
Where This Sits in Prior Work
Three PUF key-agreement papers motivate the gap. Secure PUF-based Authentication and Key Exchange Protocol using Machine Learning trains a multilayer perceptron "digital twin" of an XOR arbiter PUF at the server. The server uses the twin to assemble "challenge packs" that are all predicted to give the same bit, and the device majority-decodes them. The paper reports 0% key failure at repetition length 10 or more, even at 10% bit noise, and 89–99% twin accuracy. We reuse its architecture and its simulation setting. The difference is the question asked: that paper asks whether the genuine device recovers the key, and we ask whether a clone with twin-level accuracy would also recover it.
Harmonizing PUFs for Forward Secure Authenticated Key Exchange with Symmetric Primitives aligns noisy outputs from two PUFs with public harmonizing vectors and runs a 2-message, 1216-bit exchange. It states that a formal account of resistance to learning attacks is open. Lightweight and Robust Key Agreement for Securing IIoT-Driven Flexible Manufacturing Systems treats the PUF as an ideal black box and lists environmental instability as future work. Both treat noise as something to erase. We treat it as evidence of physical presence.
The method comes from rare-event physics. In α-event characterization and rejection in point-contact HPGe detectors, surface alpha events land at the same energy as the signal. They are rejected by a second feature, the slow tail of trapped charge (delayed charge recovery), and this removes all alphas beyond 3 mm while losing 0.2% of bulk events. Our "repeat a marginal challenge and check for inconsistency" probe plays the same role: a second feature that separates populations which look identical on the primary count.
Machine learning-powered data cleaning for LEGEND: a semi-supervised approach using affinity propagation and support vector machines reports results as two numbers, physics-event sacrifice and anomalous-event leakage. Its high-rate leakage of 15.034% next to a 0.024% sacrifice shows how a filter tuned for low sacrifice can let background through. We adopt the same two-number reporting: genuine sessions rejected, and clone sessions accepted.
Isolating Unisolated Upsilons with Anomaly Detection in CMS Open Data supplies two ideas. The first is likelihood-ratio classification, which took a 1.6σ cut-and-count significance to 6.4σ. The second is a constraint: learned discriminators can manufacture a signal, so the paper validates on a same-sign control channel where no signal should exist. We build the analogous control. Genuine devices measured at a shifted temperature must not be flagged as clones.
Research Program
At enrollment, the server measures each challenge several times, not once. From these repeats it estimates a flip probability $p_c$ for each challenge $c$, which reflects how close that challenge's delay race is to a tie. It also keeps the bit-predicting twin from Pour et al.
The server additionally trains a set of "adversary twins." These are clones fitted to the challenge–response leakage an attacker might plausibly have, for example eavesdropped packs or $k$ leaked pairs. From the disagreement among them, the server estimates $q_c$, the probability that a realistic clone answers challenge $c$ wrongly.
During a session the server mixes three kinds of challenge. Stable-but-hard-to-learn challenges have small $p_c$ and large $q_c$, so a clone misses them while the device does not. Marginal challenges have moderate $p_c$, and some of them are sent twice in one session. A physical device should answer these inconsistently at a rate near $2p_c(1-p_c)$, while a deterministic clone answers consistently. The third kind is the ordinary key-bearing packs.
The server accepts when the log-likelihood ratio exceeds a threshold $\tau$:
$$ \Lambda = \sum_{c} \log \frac{P(r_c \mid \text{genuine}, p_c)}{P(r_c \mid \text{clone}, q_c)} > \tau . $$
Here $r_c$ is the observed response, or the observed pair of responses for repeated challenges. $\tau$ is set to hit a target genuine-rejection rate.
The key bits are still derived exactly as in Pour et al., so the key-agreement layer and its proof are unchanged. Only the acceptance rule and the choice of non-key challenges change. Challenge selection is a greedy expected-information criterion. Its cost is server-side computation plus a small number of extra challenges, which we report in bits.
The main threat is an adaptive attacker who randomizes its answers to imitate physical noise. To do this convincingly it must know which challenges are marginal, which means learning $p_c$ and not only the bit. We evaluate attackers who are given increasing numbers of repeated queries to the real device, and we report where the advantage disappears. That crossover point is a result in its own right, not a footnote.
Baselines
The naive reference is the unchanged protocol of Secure PUF-based Authentication and Key Exchange Protocol using Machine Learning. It accepts whenever majority decoding recovers the key. The paper reports 0% key failure for genuine devices at repetition length 10 or more with 10% noise. For clone acceptance under this rule there is no reported result found on Lacuna. Measuring it is our first experiment, and we expect it to be high once clone accuracy exceeds roughly 90%.
The strongest simple competitor is a cut-and-count Hamming test. The server sends the same number of random challenges and accepts if the error fraction falls below a threshold. This threshold is tuned on held-out sessions for the best clone rejection at matched genuine rejection.
A second strong competitor is a stability-filtered Hamming test. The server sends only the most stable enrolled challenges, those with smallest $p_c$, and counts errors. This captures most of what "use reliability information" offers without any interactive structure.
We run two ablations. The first keeps the likelihood-ratio scoring but selects challenges at random, which isolates the value of interactive selection. The second removes repeated marginal challenges, which isolates the value of the inconsistency signal.
For fairness, all methods use the same simulated PUF instances, the same total challenge budget per session, the same enrollment budget, and the same attacker clones. The tuning budget for thresholds is equal across methods. Beating the strongest baseline means a lower clone-acceptance rate at genuine-rejection rates of 1% and 0.1%, with non-overlapping bootstrap intervals across PUF instances, in the overlap regime where clone accuracy is between 88% and 95% and device noise is between 5% and 10%.
Why not just…?
Why not just raise the majority-vote or Hamming threshold? If clone accuracy is below device reliability, this works, and we expect to match rather than beat it there. In the overlap regime that the cited 89–99% twin accuracy and 10% noise imply, the two error-count distributions overlap. Any count threshold then trades sacrifice for leakage, in the same way LEGEND's filter trades 0.024% sacrifice for 15% leakage. The Hamming baseline measures this directly. If it closes the gap, the proposal's main claim fails.
Why not just send only the most stable challenges? This is the real threat. Stable challenges are also the easiest for a clone to learn, so filtering for stability may help the attacker as much as the defender. The stability-filtered baseline settles the question. If it equals our method, the structured test adds nothing and we would recommend the simpler rule.
Why not just add a standard fuzzy extractor or a separate anomaly detector beside the AKE? Error correction removes noise, and noise is the very evidence that a device is physical. Helper data also creates the leakage that Secure PUF-based Authentication and Key Exchange Protocol using Machine Learning designs against. A detached detector that never chooses challenges is our random-selection ablation. If that ablation matches the full method, interactivity is unnecessary.
Proposed Experiments
We simulate 4-, 5-, 6-, and 7-XOR arbiter PUFs with 64-bit challenges, matching Pour et al. Noise is modeled as additive Gaussian delay noise whose variance depends on temperature, calibrated so that bit-error rates span 2–10%.
Attackers are multilayer perceptron clones trained on 10³ to 10⁶ leaked pairs. Adaptive attackers additionally receive repeated queries to the device so they can estimate reliability.
We report clone-acceptance and genuine-rejection curves for every method, per session challenge budget. We also report extra communication bits relative to the 1216-bit exchange of H-AKE and the 1632-bit exchange of the IIoT scheme.
Three checks decide the outcome. The first is whether clone acceptance drops by an order of magnitude against the stability-filtered Hamming baseline at matched 1% genuine rejection in the overlap regime. The second is the temperature control channel. Genuine devices enrolled at one temperature and tested at another must not show inflated rejection, and we would handle shift by rescaling $p_c$ rather than by re-enrolling. The third is the adaptive-attacker crossover: how many repeated device queries an attacker needs before the structured test's advantage disappears. A small crossover number means the idea fails and we report it as such. A large number means the defense raises the attacker's cost from passive eavesdropping to sustained physical access.
References
- Secure PUF-based Authentication and Key Exchange Protocol using Machine Learning
- Harmonizing PUFs for Forward Secure Authenticated Key Exchange with Symmetric Primitives
- Lightweight and Robust Key Agreement for Securing IIoT-Driven Flexible Manufacturing Systems
- $$\alpha $$-event characterization and rejection in point-contact HPGe detectors
- Machine learning-powered data cleaning for LEGEND: a semi-supervised approach using affinity propagation and support vector machines
- Isolating Unisolated Upsilons with Anomaly Detection in CMS Open Data