True Random Number Generator (TRNG)

The foundational characteristic of a TRNG is its reliance on a fundamentally unpredictable physical phenomenon to seed randomness. This is in stark contrast to software-based Pseudorandom Number Generators (PRNGs). Common entropy sources include:

• Thermal noise (Johnson–Nyquist noise) in a resistor.
• Quantum effects like shot noise in a semiconductor or photon arrival times.
• Metastability in digital circuits (e.g., ring oscillators).
• Radioactive decay (less common in commercial devices). The quality of the entropy source directly determines the statistical randomness and unpredictability of the output.

A TRNG's output sequence is inherently unpredictable and cannot be reproduced, even with complete knowledge of the device's initial state and design. This non-determinism arises from the analog, chaotic nature of the underlying physical process. It provides a critical security property: forward and backward secrecy. If an attacker captures a sequence of random numbers, they cannot computationally derive past or future numbers from the generator. This makes TRNGs essential for creating cryptographic keys, nonces, and initialization vectors where predictability would be catastrophic.

By definition, a TRNG is a hardware component, either a discrete chip or a module integrated into a System-on-Chip (SoC) or microcontroller. This hardware-centric design is necessary to directly interface with and sample the analog entropy source. Implementation styles vary:

• Discrete analog circuits with amplifiers and comparators.
• Digital circuits exploiting metastability (e.g., ring oscillators feeding a flip-flop).
• Dedicated peripheral within a secure microcontroller or Hardware Security Module (HSM). This hardware isolation helps protect the entropy generation process from software-based attacks and contamination.

Raw analog noise is often biased or correlated. Therefore, a TRNG includes post-processing circuitry or firmware to 'condition' the raw bits. This typically involves:

• A digital conditioner like a cryptographic hash function (e.g., SHA-256) or a randomness extractor (e.g., a von Neumann corrector).
• Continuous health tests that run in real-time to detect failures, such as a stuck output or a significant statistical deviation (e.g., monobit test, poker test). If a failure is detected, the generator must halt output to prevent the use of compromised randomness. Standards like NIST SP 800-90B define rigorous health testing requirements.

A TRNG for security applications must meet two key performance metrics:

• Cryptographic Security: The output must pass stringent statistical test suites for randomness (e.g., NIST STS, Dieharder) and be suitable for generating cryptographic key material. Its design must resist environmental manipulation (e.g., voltage, temperature) aimed at influencing the entropy source.
• Bit Generation Rate: The speed at which it produces conditioned random bits, measured in bits per second (bps). Rates vary from kilobits/sec for simple microcontroller TRNGs to gigabits/sec for high-performance HSMs. The rate is limited by the entropy source's inherent noise bandwidth and the conditioning logic. For many TinyML security tasks (e.g., key generation), a slow but secure TRNG is sufficient.

In practical systems, a TRNG is rarely used directly to output a long stream of random numbers. Instead, it seeds a Cryptographically Secure Pseudorandom Number Generator (CSPRNG). The architecture follows this pattern:

1. The TRNG generates a high-entropy seed.
2. This seed initializes a deterministic CSPRNG algorithm (e.g., CTR_DRBG, Hash_DRBG).
3. The CSPRNG produces a high-speed stream of pseudorandom numbers. This hybrid approach combines the unpredictability of the TRNG with the high performance and deterministic reproducibility (if seeded identically for testing) of the CSPRNG. The TRNG periodically reseeds the CSPRNG to maintain long-term security.

The most common digital TRNG implementation in microcontrollers and FPGAs. It exploits timing jitter—the inherent, unpredictable variations in the propagation delay of logic gates within a free-running oscillator loop.

• Mechanism: Multiple inverter gates are connected in a loop. The unstable oscillation frequency is sampled at a rate derived from a second, stable clock.
• Key Advantage: Can be implemented entirely in digital logic, making it suitable for integration into System-on-Chip (SoC) designs.
• Challenge: Requires careful design to ensure sufficient entropy and to be resilient against environmental changes like temperature and voltage fluctuations.

This method leverages the unpredictable power-up state of bi-stable circuits. When SRAM cells are first powered, inherent transistor mismatches cause each cell to settle into a random 0 or 1 state.

• Dual-Use: The initial pattern acts as a Physical Unclonable Function (PUF) for device fingerprinting. The noise around the settling point provides entropy for a TRNG.
• Process: The unstable startup values are harvested, whitened (using a cryptographic hash like SHA-256), and output as random bits.
• Use Case: Found in many secure microcontrollers as a low-area entropy source that requires no dedicated analog components.

These TRNGs sample fundamental analog noise phenomena, considered among the highest-quality entropy sources.

• Thermal (Johnson-Nyquist) Noise: The random motion of electrons in a resistor, present in all conductors above absolute zero. Amplified and sampled to generate bits.
• Shot Noise: Results from the discrete nature of electrical current (individual electrons flowing). Prevalent in semiconductor junctions like diodes and transistors.
• Avalanche Noise: Generated by a semiconductor junction (e.g., a Zener diode) operated in reverse breakdown. Produces a broad-spectrum, high-amplitude noise signal.
• Implementation: Requires precision analog circuitry (amplifiers, comparators) and is sensitive to power supply noise, making integration more complex than digital methods.

Represents the gold standard for high-assurance randomness, leveraging the intrinsic probabilistic nature of quantum mechanics.

• Photon Detection: A beam splitter directs single photons randomly to one of two detectors. The path choice is fundamentally unpredictable.
• Vacuum Fluctuations: Quantum fluctuations in a vacuum state are measured to produce randomness.
• Use Case: Primarily used in high-security applications like quantum key distribution (QKD) systems, cryptographic key generation for national security, and fundamental physics research. These are typically external, laboratory-grade devices, not integrated into microcontrollers.

The paramount use case for TRNGs. Cryptographic security is entirely dependent on the unpredictability of keys.

• Process: The raw entropy from a TRNG is fed into a Deterministic Random Bit Generator (DRBG), also known as a Pseudorandom Number Generator (PRNG), which expands the seed to generate long key streams.
• Standards: NIST SP 800-90A/B/C specify approved DRBG mechanisms (e.g., CTR_DRBG, Hash_DRBG) and entropy source requirements.
• Impact: A weak or predictable TRNG compromises all encryption (AES), digital signatures (ECDSA), and key exchange protocols (Diffie-Hellman) on the device.

TRNGs provide the essential randomness for foundational device security operations.

• Nonce Generation: Creates unique cryptographic nonces ('number used once') to prevent replay attacks in authentication protocols.
• Secure Boot Seeds: Provides randomness for generating the unique device keys used in firmware attestation and establishing a hardware root of trust.
• PUF Helper Data: Used to generate the error-correcting helper data for Physical Unclonable Functions (PUFs), ensuring reliable key reconstruction without storing the key itself.
• Secure Session Initialization: Generates random salts and initialization vectors (IVs) for secure communication sessions.

A Physical Unclonable Function (PUF) is a hardware security primitive that exploits inherent, microscopic manufacturing variations in silicon to generate a unique, device-specific digital fingerprint. Unlike a TRNG which produces a continuous stream of random bits, a PUF generates a static, unique response when challenged. Key applications include:

• Device Authentication: Proving hardware identity without storing secrets in non-volatile memory.
• Key Generation: The PUF response can be used with a Fuzzy Extractor to derive a stable cryptographic key, which is then protected by the TRNG-seeded system.
• Anti-Counterfeiting: Providing an unclonable hardware identity.

PUFs and TRNGs are complementary; a PUF provides a unique identity, while a TRNG provides ongoing entropy for session keys and nonces.

A Secure Element is a certified, tamper-resistant hardware chip (often integrated into a microcontroller package) designed to securely host applications, store cryptographic keys, and perform sensitive operations in an isolated environment. It is a common implementation of an HSM for constrained devices. Its integration with a TRNG is fundamental:

• The on-chip TRNG provides the entropy for all key generation within the secure boundary.
• It executes cryptographic algorithms, protecting against side-channel attacks.
• It provides secure storage, isolating keys from the main application processor.

Examples include the ATECC608A or integrated secure cores in modern MCUs like the STM32U5. For TinyML, a Secure Element enables secure model updates, attestation, and inference result signing.

An Entropy Source is the underlying physical phenomenon that provides the non-deterministic, unpredictable data required for random number generation. A TRNG is the hardware device that harvests and digitizes this entropy. Common entropy sources in microcontrollers include:

• Thermal Noise (Johnson-Nyquist noise) in resistors.
• Avalanche Noise in reverse-biased semiconductor junctions.
• Ring Oscillator Jitter, where phase noise in free-running oscillators is sampled.
• Quantum Effects such as shot noise.

The quality of a TRNG is directly dependent on the min-entropy of its source. For cryptographic use, the raw entropy must be processed by a deterministic random bit generator (DRBG) or conditioning algorithm to remove any bias and ensure statistical randomness, as defined by standards like NIST SP 800-90B.

A Pseudorandom Number Generator (PRNG) is an algorithm that generates a sequence of numbers whose properties approximate those of true random sequences. It is deterministic, meaning it produces the same sequence from a given initial value, or seed. Critical contrasts with a TRNG:

• Seed Dependency: A PRNG requires a high-entropy seed, ideally from a TRNG. A weak seed compromises all output.
• Speed & Efficiency: PRNGs (e.g., AES-CTR DRBG, ChaCha20) are fast and suitable for generating large volumes of random data for simulations.
• Cryptographic Security: A Cryptographically Secure PRNG (CSPRNG) is designed such that predicting future output is computationally infeasible, even if many previous outputs are known.

In secure systems, a TRNG seeds a CSPRNG, combining guaranteed entropy with high-performance generation for operational use.