The French Fridge Hack and the Illusion of Randomness: Where Does True Randomness Begin?

AI Generated image
AI Generated image

In October 2026, hundreds of supermarkets across France found their refrigeration systems hijacked. Attackers remotely forced freezers and coolers to run continuous defrost cycles, pushing temperatures as high as 50°C (122°F), spoiling tons of perishable food and in some cases sparking electrical fires. The estimated toll: tens to hundreds of millions of euros across an estimated 700 stores.

The attack was not sophisticated. It exploited something far more mundane: a password that changed every day but was, in reality, entirely predictable. The administrative username was “admin,” and the daily password was simply the current date. The authentication mechanism, known as check_code_of_day, generated an access code from the date itself. Anyone who understood the algorithm could calculate the password for any day, on any device, in any store. The password rotated daily, but rotation without randomness is merely the illusion of security.

This incident is not just a story about lax industrial security. It is a window into a deeper question that sits at the heart of cybersecurity: what does it actually mean for a password to be random, and where does true randomness come from?

The Entropy Problem: When “Random” Isn’t Random

In information security, randomness is measured in bits of entropy. A password with 128 bits of entropy is exponentially harder to guess than one with 20 bits. But entropy is only as good as its source. If the source is predictable—a date, a timestamp, a known algorithm—the effective entropy collapses to nearly zero, regardless of how long the password string appears.

The French fridge controllers illustrate this perfectly. A password like 20261012 might look like a meaningless string to a casual observer, but it contains almost no entropy from an attacker’s perspective. The search space is tiny: one guess per day, and the attacker knows the algorithm.

This is a classic failure mode in cryptographic systems. RFC 4086, the Internet Engineering Task Force’s seminal document on randomness requirements for security, warns explicitly against relying on “poor entropy sources or traditional pseudo-random number generation techniques” for generating passwords and cryptographic keys. The document recommends “truly random hardware techniques” and shows that existing hardware on many systems can be used for this purpose.

Where Does True Randomness Begin?

The honest answer is that true randomness—in the strict mathematical sense—is extraordinarily difficult to achieve on a deterministic machine. A computer, by design, executes instructions predictably. Given the same input and state, it will always produce the same output. So where can genuine unpredictability come from?

1. Physical Processes: The Hardware Entropy Source

The gold standard for randomness is the physical world. Modern CPUs often include dedicated hardware random number generators (HRNGs) that harvest entropy from physical phenomena: thermal noise, shot noise in semiconductors, or quantum effects. These are processes that, as far as we know, are fundamentally non-deterministic.

Recent research has pushed this further. Scientists have demonstrated true random number generators based on magnetic tunnel junctions, chaotic oscillators, and even quantum mechanical processes. A 2026 study in Scientific Reports described a coupled-oscillator chip that serves as a physical entropy source for hybrid true random number generation. Another team achieved true random bit generation at five million bits per second using a magnetic tunnel junction controlled by an FPGA.

NIST itself has developed a quantum-based random number generator called CURBy, described as “the world’s truest random number generator”. These systems extract randomness from the laws of physics rather than from algorithmic computation.

2. Environmental Noise: The Operating System Entropy Pool

Not every system has a dedicated quantum random number generator. Most operating systems—Linux, Windows, macOS—maintain what is called an entropy pool: a reservoir of unpredictable data collected from hardware events. These include keyboard timings, mouse movements, disk I/O fluctuations, network packet arrival times, and interrupt timings.

In Unix-like systems, /dev/random and /dev/urandom are special device files that serve as cryptographically secure pseudorandom number generators, drawing from this entropy pool. The kernel continuously estimates how many bits of true noise have been collected. When the pool is empty, reads from /dev/random will block until more environmental noise is gathered.

This is the randomness that most password managers and cryptographic libraries rely on. When you move your mouse to “collect entropy” in KeePass, you are literally feeding environmental noise into the entropy pool to seed the generator.

3. CPU Jitter: The Non-Physical True Random Number Generator

A fascinating development in recent years is the CPU jitter random number generator. This approach harvests entropy not from external hardware events but from tiny, unpredictable variations in the execution time of the same piece of code. CPU pipeline timing divergences, DRAM refresh cycle perturbations, and other system-level jitters create a source of randomness that is, in principle, non-deterministic.

The CPU Jitter RNG, developed by Stephan Müller, is designed to meet the requirements of a true random number generator without requiring specialized hardware. It runs as pure algorithmic code, harvesting jitter from all active subsystems. NIST has evaluated versions of this entropy source, and it is now used in production systems including cloud infrastructure.

Pseudorandomness: The Practical Compromise

For most applications, true randomness is either unavailable, too slow, or too expensive. The practical solution is the cryptographically secure pseudorandom number generator (CSPRNG). A CSPRNG takes a small amount of true randomness—a seed—and expands it into a long, unpredictable-looking sequence.

The security of a CSPRNG depends entirely on two things: the quality of the seed and the cryptographic strength of the algorithm. If the seed is predictable, the entire sequence is predictable. This is exactly what happened with the Danfoss controllers. The seed was the date, and the algorithm was publicly available in the firmware. An attacker who analyzed the code could generate the same “daily password” on any unpatched device.

Password managers typically use CSPRNGs. Some, like Pass, use Unix /dev/urandom as their entropy source. Others, like Random.org, offer true randomness as a service, harvesting entropy from atmospheric noise. The practical difference for password generation is often marginal, provided the seed is strong and the algorithm is cryptographically sound.

Lessons from the Fridge Hack

The French supermarket incident is a case study in what happens when the gap between the appearance of security and the reality of entropy is ignored. Four failures compounded:

  1. Predictable credentials: The password was derived from the date, a value any attacker could compute.
  2. Internet-exposed controllers: Thousands of Danfoss AK-SM 800A controllers were directly accessible from the internet without VPNs or IP allowlists.
  3. Unpatched firmware: Updates that fixed the authentication flaw had been available for over a year, but many systems remained unupdated.
  4. Lack of network segmentation: Industrial control systems shared networks with other infrastructure, allowing lateral movement.

Each of these failures is individually serious. Together, they turned a predictable password into a weapon capable of destroying inventory, damaging equipment, and causing fires.

The Beginning of Randomness

So where does true randomness actually begin? It begins at the boundary between the deterministic world of computation and the probabilistic world of physics. It begins in the thermal noise of a semiconductor, the quantum uncertainty of a photon, the jitter of a CPU pipeline, the timing of a keystroke. It begins wherever the universe refuses to be predictable.

The challenge for cybersecurity is not just to find these sources of randomness, but to ensure that they are used correctly. A password that changes daily is not secure if its change is predictable. A random number generator is not trustworthy if its seed is known. True randomness is a precious resource, and like any precious resource, it must be harvested, protected, and—above all—understood.

The French supermarkets learned this lesson at a cost of millions. The rest of us would do well to learn it before our own refrigerators start running hot.