Skip to main content
Be Bitwise

Physically Unclonable Functions

Hardware Security Architecture · Hardware Foundations track

12 min read

In this module

Silicon Fingerprints

No two silicon chips are identical. Sub-lithographic variations in dopant concentration, oxide thickness, and gate length nudge transistor behaviour by tiny amounts, even on chips from the same wafer cut from the same masks. The differences are far too small to break the chip's logic (a NAND gate still computes NAND) but they show up as measurable analogue variation in timing, voltage thresholds, and power-up behaviour.

A Physically Unclonable Function (PUF) harnesses those variations to give each chip a unique identity. Think of it as a silicon fingerprint: the response is baked into the physical device, reproducible (with some noise), and practically impossible to clone. Even the manufacturer can't spin a second chip with the same PUF response.

PUFs solve a fundamental hardware-security problem. How do you give a chip a unique identity without parking a secret key in non-volatile memory — flash, fuses, EEPROM — where an attacker can prise it out? With a PUF, the key never exists in stored form. It gets regenerated from the silicon's physics each time it's needed.

Physically Unclonable Function

A PUF is a hardware primitive that maps challenges (inputs) to responses (outputs) based on the unique physical characteristics of a specific chip. The challenge-response behaviour is determined by uncontrollable manufacturing variations, making each chip's PUF unique and unclonable. PUFs enable key generation, device authentication, and anti-counterfeiting without storing secret keys in non-volatile memory.

SRAM PUF

The most widely deployed PUF type is the SRAM PUF, which exploits the power-up behaviour of standard SRAM cells.

An SRAM cell is a cross-coupled pair of inverters forming a bistable latch. Power up the cell and it settles into one of two stable states (0 or 1). Which state wins depends on the relative strength of the two inverters, which depends on the transistor threshold voltages. Manufacturing variation guarantees one inverter is always a touch stronger.

The trick to seize on: those tiny asymmetries are

  • Unique per cell: The direction of asymmetry varies randomly from cell to cell.
  • Unique per chip: The pattern across thousands of cells forms a unique fingerprint.
  • Reproducible: The same cell tends to power up to the same state on each boot (typically 90-95% of bits are perfectly stable).
  • Unclonable: The asymmetries are determined by atomic-scale variations that cannot be controlled during manufacturing.

To use an SRAM PUF, the system reads the power-up values of a designated SRAM block before any software writes to it. The block might be 256 bytes (2048 bits) of SRAM, producing a unique bit pattern at every power-on.

Noisy Bits

Not every SRAM cell is stable. Roughly 5-10% have inverters too closely balanced and may flip between boots, and the error rate creeps up as the chip ages, since transistor ageing (NBTI) slowly shifts the balance. Products counter this by reading the array several times and taking a majority vote, masking out known-flaky cells, and sizing the error-correcting code for end-of-life noise rather than day-one noise. These noisy bits mean the raw PUF response can't be used directly as a cryptographic key (a key that drifts by even one bit is useless). Enter fuzzy extraction.

Ring Oscillator PUF

A ring oscillator PUF stands up pairs of identically designed ring oscillators and compares their frequencies. A ring oscillator is a chain of an odd number of inverters wired in a loop, oscillating at a frequency set by the inverter gate delays.

Two "identical" ring oscillators won't actually run at the same speed — manufacturing variation makes sure of that. Count each ring's oscillations over a fixed window and compare to see which won; out pops a single bit:

  • If oscillator A is faster than oscillator B: output 1
  • If oscillator B is faster than oscillator A: output 0

With N ring oscillators you can form C(N, 2) = N(N-1)/2 comparisons, so 128 oscillators give 8128 pairs. That doesn't mean 8128 bits of entropy, though. The comparisons aren't independent: if A beats B and B beats C, then A beats C. Everything the pairs can tell you is captured by the ordering of the N frequencies, so the entropy is at most log2(N!), about 716 bits for 128 oscillators. Designs usually compare disjoint pairs, or derive bits from the ordering directly, to avoid handing out correlated bits.

Ring oscillator PUFs are attractive because:

  • They use standard digital logic (no analogue circuits or special SRAM).
  • The frequency difference between paired oscillators is relatively large and stable.
  • They can be instantiated on FPGAs as well as ASICs.

The catch: ring oscillators burn power the whole time they're running, and their frequencies wobble with temperature and voltage.

Key Concept
Ring Oscillator PUF

A ring oscillator PUF exploits frequency variations between identically designed oscillators. Manufacturing variations cause each oscillator to run at a slightly different speed. Comparing frequencies between pairs produces bits that form a unique device fingerprint. The approach uses only standard digital logic and works on both ASICs and FPGAs.

Arbiter PUF

An arbiter PUF races two nominally identical-delay signal paths. A challenge bit at each stage decides whether paths are swapped or pass straight through. At the end, an arbiter (a D flip-flop) decides which path arrived first. The winner depends on the accumulated delay differences from transistor variation along each path.

The challenge is an N-bit input configuring N switching stages. Different challenges select different path combinations and produce different responses. N stages yield 2^N possible challenges, each giving a 1-bit response. The compact circuit ends up with an exponentially large challenge-response pair (CRP) space.

Arbiter PUFs offer juicy CRP spaces — handy for authentication protocols that hunger for unique challenges — but they fold under machine learning modelling attacks because the response is a linear function of the individual stage delays. Collect enough CRPs and an attacker can train a model that predicts the response to any challenge.

XOR Arbiter PUF

To beat back modelling attacks, XOR arbiter PUFs XOR the outputs of several independent arbiter PUF instances. XOR turns the combined response into a non-linear function of the individual PUF responses, kicking up the difficulty of ML attacks sharply. The price: XOR arbiter PUFs are noisier and need more challenge-response pairs to operate reliably.

Fuzzy Extraction: From Noisy Responses to Stable Keys

Raw PUF responses are noisy. They drift by a few bits each time. A cryptographic key has to be byte-for-byte identical on every read. Fuzzy extraction is the bridge.

A fuzzy extractor has two phases:

Enrolment (One-Time Setup)

  1. Read the PUF response R.
  2. Generate a random cryptographic key K.
  3. Compute helper data W = R XOR C, where C is a codeword from an error-correcting code that encodes K.
  4. Store W in non-volatile memory (it is public and does not reveal K).

Reconstruction (Every Subsequent Use)

  1. Read the PUF response R' (noisy version of R, differing in a few bits).
  2. Compute C' = R' XOR W. Since W = R XOR C, we get C' = R' XOR R XOR C = C XOR (R XOR R'). The term (R XOR R') is the noise vector.
  3. Apply error-correcting decoding to C'. If the noise is within the code's correction capacity, this recovers the original codeword C.
  4. Extract K from C.

Real designs add one more step: they run the recovered value through a hash or other randomness extractor to produce the final key. PUF responses are never perfectly uniform, and the hash squeezes the entropy that's actually there into a key that looks uniformly random.

The helper data W gets stored in the clear. It can't reveal K on its own, because without R an attacker can't tease the key apart from the noise. It isn't free, though: W always leaks some information about R (at least the code's redundancy), and if the PUF response is biased, for example more 1s than 0s, that leak can grow enough to shrink the effective key strength or, with a weak code choice, give the key away. That's why the response's entropy is measured carefully and the code is chosen with this loss in mind.

Try it on a toy extractor small enough to do by hand. The key is two bits, K = 10, and the code repeats each key bit four times, so C = 1111 0000. At enrolment the chip read R = 1011 0110, which makes the stored helper data W = R XOR C = 0100 0110 (decimal 70). Today's power-up gives R' = 1011 0111, with the last bit flipped by noise. Turn R' into the noisy codeword C':

Bit Manipulation Puzzle

1 steps left
Current
1
0
1
1
0
1
1
1
1830xB7
Target
1
1
1
1
0
0
0
1
2410xF1

You should land on C' = 1111 0001. Decode each four-bit group by majority vote: 1111 gives 1, 0001 gives 0, and K = 10 comes back intact. Now picture a second flip in the right-hand group. 0011 is a tie, and with three flips (0111) the vote picks 1 and hands back the wrong key without complaint. A repetition code of length four corrects one bad bit per group, which is why real designs use stronger codes (BCH, Reed-Muller, or a concatenation of the two) sized for the measured noise rate.

Fuzzy Extraction

A fuzzy extractor converts a noisy PUF response into a stable cryptographic key using helper data and error-correcting codes. The helper data is public and can be stored in insecure memory, provided the PUF's entropy covers what the helper data leaks. This is the critical bridge between the analogue reality of PUFs (noisy, approximate) and the digital requirement of cryptography (exact, deterministic).

PUF Applications

Device Authentication

During enrolment, a verifier hits the PUF with a set of inputs and records the responses. Later, to authenticate the device, the verifier picks a random subset of challenges. The device has to produce the right responses. An attacker who clones the device's digital state (firmware, stored keys) still can't clone the PUF responses — they're rooted in the physical silicon.

Key Generation Without Key Storage

Traditional hardware tucks secret keys into OTP fuses or flash memory. Both fall to invasive attacks: decapping the chip to probe metal layers, electron microscopy, focused ion beam editing. A PUF-based key lives only transiently — reconstructed from silicon physics when needed, destroyed once the computation finishes. Nothing sits in non-volatile memory waiting to be extracted.

Anti-Counterfeiting

Every genuine chip has its unique PUF fingerprint enrolled in a database. To check authenticity, the chip gets challenged with a known input. A counterfeit (even one fabricated on the same process with the same design) yields a different response because its manufacturing variations are its own.

IP Protection on FPGAs

FPGA bitstreams are routinely encrypted to fend off design theft. The encryption key can be derived from an on-chip PUF instead of being parked in battery-backed SRAM or OTP fuses. That removes the key-extraction risk and welds the bitstream to one specific FPGA chip.

PUF Attacks

PUFs aren't invulnerable. Several attack classes go after them:

Machine Learning Modelling Attacks

For strong PUFs with hefty challenge-response spaces, arbiter PUFs above all, an attacker who scrapes enough CRPs can train an ML model — logistic regression, neural network, evolution strategies — to predict any future response. Simple arbiter PUFs have fallen to better than 99% accuracy via logistic regression on a few thousand CRPs. XOR arbiter PUFs and feed-forward variants resist more, but advanced techniques still chip away at them.

Environmental Manipulation

PUF responses bend under operating conditions. An attacker who can drive temperature, supply voltage, or the EM environment may:

  • Push noisy bits in a desired direction.
  • Increase the overall bit error rate beyond the fuzzy extractor's correction capacity, causing a denial of service.
  • Observe how the response changes with environmental conditions to gain information about the underlying physical parameters.

Invasive Physical Attacks

Advanced attackers wielding failure-analysis kit (focused ion beam, scanning electron microscope) might:

  • Edit the PUF circuit to shift its response.
  • Probe individual transistors and measure the threshold-voltage differences directly.
  • Run photon emission microscopy to watch switching behaviour.

These attacks need pricey equipment and serious expertise, parking them in nation-state territory rather than the average attacker's reach.

Semi-Invasive Attacks

Laser fault injection and electromagnetic fault injection can flip individual PUF bits without full invasive surgery. Targeting a specific PUF cell is fiddly in practice, but on older or larger process nodes it's far from impossible.

Key Concept
PUF Security Margin

PUFs derive their security from the physical unclonable nature of manufacturing variations. However, machine learning can model some PUF types from observed challenge-response pairs, environmental changes can shift responses, and invasive attacks can probe the underlying physics. The security margin depends on the PUF type, the number of exposed CRPs, and the attacker's physical access and resources.

The Future of PUFs

PUF technology continues to evolve. Current research focuses on:

  • Strong PUFs with exponentially large CRP spaces that resist machine learning modelling.
  • Controlled PUFs that restrict access to the PUF interface, preventing attackers from collecting arbitrary CRPs.
  • PUF-based secure boot: Using PUF-derived keys to encrypt and authenticate firmware, eliminating stored root keys entirely.
  • PUFs at advanced process nodes: As transistors shrink, manufacturing variations increase in relative magnitude, potentially making PUFs more reliable and harder to attack.

PUFs are already in products you can buy. NXP's LPC55S6x microcontrollers and Microchip's PolarFire FPGAs use SRAM PUFs (Intrinsic ID's technology) to protect their key stores, and AMD/Xilinx Zynq UltraScale+ devices offer a PUF for wrapping the bitstream encryption key. PUF-derived secrets also make a natural Unique Device Secret for the Trusted Computing Group's DICE architecture, which derives a chain of identities from it at each boot stage.

PUFs flip the script on hardware security. Instead of fighting manufacturing randomness, they harvest it as raw material.