Infinite Noise puts a thermal noise source in a USB key

A USB key whose randomness is thermal noise

The Infinite Noise TRNG is a USB key hardware true random number generator, and the claim in the project description is blunt: it is the world's easiest TRNG to get right. The mechanism behind that claim is the architecture. The design uses what the author calls a Modular Entropy Multiplier, previously named the Infinite Noise Multiplier or FireBug. In short, a tiny noise signal is amplified by a gain stage and then sampled by a comparator, and the sampling outcome is the random bit. The README is explicit that speed is limited by the gain stage and the comparator, and that modular entropy multipliers are suitable both for board level implementation and for ASIC implementation.

Entropy per bit you can measure rather than trust

The distinguishing claim is that the entropy is not a marketing number but a computed and checkable one. Modular entropy multipliers produce a provable and easily measured level of entropy based on thermal noise, approximately equal to log2(K) per output bit, where K is a gain between 1 and 2 set by two resistors around an op-amp. For the device described, the expected value is within 2% of log2(1.82). A health monitor tracks this and verifies that the output entropy stays inside the expected range. The measured numbers in the README are concrete: the first three boards from OSH Park generate 300,000 bits per second and produce a measured 259,000 bits of entropy per second, which is within 0.5% of the predicted value, with the three boards at 0.867, 0.868 and 0.867 bits of entropy per bit against a design value of 0.864.

Whitening is not optional, and the choice is Keccak-1600

Here is the constraint that shapes everything downstream. Adjacent bits from a modular entropy multiplier are correlated, so whitening is required before the output is used in cryptography. The README prescribes the method: continually reseed a cryptographically secure hash function such as SHA-512, Blake2b or Keccak-1600, or use a stream cipher such as ChaCha. This implementation uses Keccak-1600 with cryptographically secure reseeding of more than 400 bits of entropy at a time, which the author says overcomes the trickle in and out problem present in the GNU/Linux `/dev/random` system. There is also a throughput lever. Users who need many megabytes per second can set the outputMultiplier as high as they like, which makes Keccak generate outputMultiplier*256 bits per reseeding by the device.

Why the architecture resists outside influence

True random number generators are hard to build well, and the README explains why in the section it titles the problem. The usual approach amplifies a tiny noise signal, perhaps only a microvolt in amplitude, by a factor of millions or billions until it becomes an unpredictable digital signal, which is then sampled to see whether it is a 0 or a 1. The failure mode is that the weak noise source can be influenced by other nearby signals, which may be under the control of an attacker, or perhaps observable by an attacker. The modular entropy multiplier is presented as naturally defending against influence from outside signals such as radio interference and power supply noise, which is what makes it simple to build securely without requiring an expert in analog design. The cost of that simplicity is throughput, which the README puts at 8 Mbit per second with cheap CMOS quad op-amps.

The bill of parts is small and the boards are cheap

Building your own is presented as a matter of ordering a few boards and buying parts. Three boards from OSH Park cost $3.25, and the parts are listed in a BOM spreadsheet in the Eagle directory, with links to Digikey and Mouser. The total for all the parts including the boards is $5.69 each in 1,000 unit quantities, and that cost is dominated by the USB related parts, particularly the FT240X chip, the USB connector and the USB stick enclosure. The components for the modular entropy multiplier alone come to $0.97. There is an honesty in the assembly note as well: the board was designed to be cheap, not easy to assemble by hand, and it uses 2 QFN parts and three with 0.5mm lead pitch, so the author points to using a solder paste stencil from OSH Stencils and a stencil order, linking his own SparkFun tutorial for the process.

Three hardware variants and a software sub-directory

The repository holds more than one board. There is `infnoise_cmos/` for the cheap CMOS quad op-amp version, `infnoise_fast/` for the faster build, and `infnoise_small/` for the variant with the more expensive op-amp from TI. The Eagle directory holds the original design files including `infnoise.brd` and the BOM, and a `kicad/` directory holds a KiCad version of the design. The `tests/` directory contains the entropy test data, including colour and scatter plots of the raw output, and `hashlet_data/` holds data used in testing. The driver is not in the root. The README says that instructions for compiling and using the Infinite Noise TRNG driver are in the `software` sub-directory, in the README there, and that both Linux and Windows are supported.

A design with a documented lineage

The architecture is not new, and the project says so. The modular entropy multiplier architecture was invented by Peter Allan in 1999, which he called Firebug, and the author notes that he reinvented it in 2013, adding that most of his good ideas are rediscoveries of existing ideas. Peter Allan has his own version called the Redoubler, which the README calls awesome and the right way to generate random bits, whether on a board with standard parts or on a custom chip. The hardware history is documented too. The first completed Infinite Noise USB key was offered on Tindie to spread the concept, the first three boards from OSH Park worked exactly as predicted, and a breadboard version proved out much of the theory of operation, with an estimated 0.81 bits of entropy per bit against a design value of 0.80.

CC0 licensing, a crowdfunding campaign, and no tagged releases

The licence is CC0-1.0, which is about as permissive as a licence gets, and it suits a hardware project where the design files and the software are meant to be copied and rebuilt by anyone. The commercial side of the story is a Crowd Supply campaign, driven by Manuel Domke, the founder of a new electronics manufacturing company called 13-37.org electronics, with the campaign page linked for the latest updates. The repository has no GitHub releases, so there is no tagged version to point at, and the last push was on 2026-05-16, so a checkout of the default branch is the only way to get the current sources. The `CHANGELOG.md` at the root is where the history of the driver lives, and the repository also carries a `.gitmodules` file, which points to the design files being consumed as submodules rather than copied in.

Editorial conclusion

Adopt infnoise if you want randomness from a physical source you can measure, and are prepared to assemble hardware or buy a kit, because the health monitor reports the entropy rate and the repository ships schematics, board files and a bill of parts. Do not adopt it if you need megabytes per second of random data on a server, since a USB key at 300,000 bits per second cannot supply that, and the source itself is only a 256 kbit stream after whitening. Verify first that the health monitor output for your unit sits near the expected 0.864 bits of entropy per bit, and remember the software lives in the `software/` sub-directory with its own README.

Frequently asked questions

Official sources

1. Issues
2. License: CC0-1.0
3. README
4. waywardgeek/infnoise on GitHub