Entropy Bootstrapping for Wireless Embedded Systems

Technical Summary: Entropy Bootstrapping for Wireless Embedded Systems

Problem Statement
The paper addresses the critical vulnerability of "boot entropy starvation" in wireless embedded systems, particularly headless IoT devices like ESP32-class boards. Cryptographic security relies on unpredictable random values generated at the very start of a device's lifecycle. However, historical failures (e.g., Debian OpenSSL, shared RSA keys in headless devices) demonstrate that weak randomness at boot compromises the entire security posture.

The specific challenge identified is that many embedded devices operate in highly deterministic conditions (identical firmware, silicon, and reset vectors) and rely on Random Number Generators (RNGs) that may be pseudorandom by specification even when their physical entropy sources are inactive. The authors note that on ESP32 boards, the Wireless Device (WDEV) RNG register continues to output bytes even when the documented analog entropy inputs are disabled. Crucially, these "rejected" pseudorandom states pass standard statistical tests (such as Rabbit and SP 800-90B batteries) indistinguishably from active true-entropy states. Consequently, output testing alone cannot verify the health of the entropy source; a system cannot trust the output without verifying the source state.

Methodology and Architecture
The authors propose a defense-in-depth boot path that combines multiple entropy roots under an explicit source-state admission policy. Rather than relying on a single source, the system mixes material from three distinct roots, crediting only those where the required source state and protocol checks are verified. The final seed is derived via HKDF, but the security credit is assigned based on the single best-supported root, not the sum of all roots, to avoid independence assumptions between different physical noise sources.

The three proposed roots are:

1. SRAM Startup State (PUF): The system reads uninitialized SRAM immediately after a cold power-up. The stable bits provide a device-bound secret, while noisy bits contribute per-boot variability. The authors treat this as auxiliary material in their current implementation, pending further cold-power studies.
2. Radio Burst Extraction: A trusted node (e.g., a gateway) sends a public packet burst. The client sensor samples its local WDEV RNG output and packet timing deltas during this window. The client derives a seed locally. The trusted node receives no entropy credit; the security relies on the unpredictability of the client's analog response and timing to a public stimulus.
3. Asymmetric Entropy Capsules: A fallback mechanism for cold starts where local sources are unavailable. A trusted node encrypts fresh seed material to the client's pre-provisioned public key (using post-quantum primitives like ML-KEM) and signs the capsule. The client performs deterministic verification, decapsulation, and hashing to derive the seed.

Implementation and Evaluation
The system was implemented as open Zephyr artifacts for the ESP32-DevKitC V4. The evaluation involved:

• RNG State Analysis: Capturing 256 MB streams from ESP32 WDEV under various conditions (RF-disabled, Wi-Fi idle, Wi-Fi scan, and deterministic UDP bursts).
• Radio Burst Testing: Executing 127 trials with a fixed public burst plan (64 packets, 1000 µs spacing) to measure local response variability.
• Capsule Latency: Benchmarking the time required for a client to receive and process a capsule using ML-KEM-512 and ML-DSA-44.
• SRAM Analysis: Preliminary readings of SRAM reset states to assess stability and min-entropy.

Key Results

• Source-State vs. Output Tests: The study confirmed that RF-disabled ESP32 WDEV output is statistically indistinguishable from RF-active output in standard test batteries (ENT, SP 800-90B, Rabbit, etc.), despite being documented as pseudorandom. This validates the paper's core thesis: output tests cannot replace source-state admission.
• Radio Burst Entropy: Under the RF-active source-state model, a 64-packet burst window yielded approximately 59.0 kbit of conservative raw-source min-entropy (based on a lower bound of ~7.2 bits/byte) before extraction into a 256-bit seed. All WDEV windows produced distinct hashes.
• Capsule Performance: The asymmetric capsule path successfully seeded 10/10 boots. The deterministic client-side cryptographic work (verification, decapsulation, hashing) took approximately 18.7 ms. The total time to the first credited seed was dominated by network stack initialization (median ~9.7 seconds), not the cryptographic operations.
• SRAM: Preliminary reset measurements showed 87.47% stable bits and a pairwise Hamming distance of 6.10%. However, the authors classify this as auxiliary material, noting that full cold-power evidence requires more rigorous testing across boards and power-off durations.

Significance and Claims
The paper claims to offer a practical, defense-in-depth architecture for bootstrapping entropy in constrained wireless devices without certifying any single source. Its primary contribution is the source-state admission policy, which enforces that entropy credit is granted only when the firmware verifies the physical state of the source (e.g., ensuring the radio is active to enable the analog entropy path).

The authors modestly state that their measurements support the stance that "a documented pseudorandom RNG state can be statistically indistinguishable from a true-entropy state," necessitating policy-based gating. They demonstrate that:

1. Identical public bursts produce distinct local responses, providing a viable entropy source.
2. A capsule fallback is viable for cold starts, incurring only deterministic computational costs.
3. Security is maintained as long as at least one credited root remains unpredictable to the adversary.

The work does not claim to solve the entropy problem for all platforms or certify the ESP32 RNG by construction; rather, it provides a measurement path and a fail-safe policy that prevents the system from trusting a source that has failed its state checks. The authors acknowledge limitations, including the need for multi-board replication, the unexplained Rabbit flags in large ESP32 streams, and the current lack of low-level metrics (like CSI or hardware timestamps) in their implementation.