⚛️ quantum physics

An Ideal Random Number Generator Based on Quantum Fluctuations and Rotating Wheel for Secure Image Encryption

This paper proposes a hybrid random number generator that combines quantum fluctuations from a kicked rotor model with a dynamically rotating wheel to produce high-entropy sequences for secure image encryption, demonstrating robust cryptographic performance suitable for consumer applications like mobile healthcare and biometric authentication.

Original authors: Subhadip Rana, Sanku Paul, Mrinal Kanti Mandal

Published 2026-03-17

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Subhadip Rana, Sanku Paul, Mrinal Kanti Mandal

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you have a very secret photo that you want to send to a friend, but you're worried that hackers might steal it or peek at it while it's traveling across the internet. To keep it safe, you need to lock it in a digital vault. The key to this vault isn't just a simple password; it's a perfectly random sequence of numbers that changes every single time you use it.

This paper introduces a new, super-secure way to generate those random numbers and lock your photos. Here is how it works, explained simply:

1. The Problem: Why "Random" is Hard

In the digital world, computers are actually terrible at being truly random. They usually follow strict rules (like a recipe), which means if a hacker knows the recipe, they can guess the next number. This is like a magician who always pulls the same rabbit out of the same hat. If the "random" numbers used to lock your photo aren't truly random, the lock is weak.

2. The Solution: A Quantum Roulette Wheel

The authors built a hybrid machine that combines two things: Quantum Physics (the weird, unpredictable world of tiny particles) and a Rotating Wheel (like a carnival game).

Step A: The Quantum Shuffle (The Magic Dice)

First, they use a model from quantum physics called the "kicked rotor." Think of this as a tiny particle spinning on a ring and getting kicked at random times. Because quantum physics is inherently chaotic and unpredictable, the energy of this particle creates a stream of numbers that no computer can predict.

The Analogy: Imagine rolling a die that is made of pure chaos. It doesn't follow physics like a normal die; it just is random. They use this chaos to shuffle a deck of cards (numbers 0 to 255).

Step B: The Rotating Wheel (The Carnival Game)

Now, imagine a giant wheel with numbers 0 through 255 painted on it.

Shuffling: Before the game starts, they use those "quantum chaos" numbers to shuffle the order of the numbers on the wheel.
The Tapping: Instead of spinning the wheel once and picking one number, they have four secret "tappers" (like four people tapping the wheel at specific spots).
The Secret Key: Where these four tappers stand is determined by your secret password (a 32-character key). If you change just one letter in your password, the tappers move to completely different spots.
The Spin: Every time they collect four numbers from the tappers, the wheel spins. But here's the trick: the speed of the spin changes slightly every time. It doesn't spin at a constant speed; it speeds up or slows down based on the numbers just collected.

3. Why This is a Big Deal

This method creates a "perfect storm" of randomness:

The Quantum Part: Ensures the starting point is truly unpredictable (no computer can guess it).
The Wheel Part: Ensures that even if someone guesses the starting point, they can't predict the future because the wheel's speed is constantly changing in a complex way.
The Tappers: By taking four numbers at once from different spots, they get a lot of data very quickly.

4. Locking the Image

Once they have this stream of perfect random numbers, they use it to scramble the image:

Shuffling: They rearrange the pixels of the image (like shuffling a deck of cards) so the picture looks like static noise.
Mixing: They mix the pixel values with the random numbers (like adding invisible ink).
Result: The final image looks like a completely random mess of colors. Even if a hacker has a supercomputer, they can't figure out the original picture without the exact secret key.

5. The Results: Unbreakable?

The authors tested this on all kinds of images: medical scans, satellite photos, fingerprints, and even QR codes.

Entropy (Randomness): The scrambled images were as random as mathematically possible (a score of nearly 8 out of 8).
Resilience: They tried to break the lock by adding noise (like static on a TV) or cutting parts of the image out. The system was very robust; even if the image was damaged, the original could still be recovered mostly intact.
Speed: Because they used simple math (integers) instead of complex floating-point math, it runs fast on regular computers.

The Bottom Line

Think of this system as a digital safe where:

The combination is generated by the chaos of the universe (Quantum).
The safe's tumblers are arranged on a spinning wheel that changes speed every time you turn the dial.
You need the exact right key to know where to stand and how fast to spin to open it.

This makes it incredibly difficult for hackers to crack, making it perfect for protecting sensitive things like your medical records, biometric data (fingerprints), or private photos on your phone.

1. Problem Statement

The rapid digitization of images for applications like telemedicine, biometric authentication, and cloud storage has created a critical need for secure image transmission. Traditional text-oriented cryptographic algorithms (e.g., AES) are inefficient for images due to the high redundancy, large data volume, and strong correlation between adjacent pixels in digital images.

Furthermore, existing random number generators (RNGs) used for encryption keys have limitations:

Pseudo-RNGs (PRNGs): Based on deterministic mathematical models, making them vulnerable to statistical and side-channel attacks.
Chaos-based RNGs: Often rely on floating-point arithmetic, leading to CPU-dependent behavior, precision inconsistencies, and reduced security across different platforms.
Hardware-based Quantum RNGs: While physically random, they often suffer from high correlation, limited availability, and sensitivity to environmental noise.

The paper addresses the need for a platform-independent, high-entropy, and computationally efficient random number generator that avoids floating-point operations while maintaining strong unpredictability for image encryption.

2. Methodology

The authors propose a Hybrid Random Number Generator (HRNG) that combines quantum physics principles with a mechanical "rotating wheel" simulation. The system operates in two main phases:

A. Quantum Fluctuation Generation

The system utilizes the Quantum Kicked Rotor (QKR) model, a paradigmatic system in quantum chaos.

Mechanism: A particle on a ring receives time-periodic kicks. The Hamiltonian involves position ( $\hat{x}$ ) and momentum ( $\hat{p}$ ) operators with a kick strength $K$ .
Dynamics: The system is evolved using the time-evolution operator $\hat{U}$ . The energy fluctuations in momentum space are calculated.
Index Generation: The energy values ( $E_i$ ) are converted into integer indices ($0-255$) using the formula: $P(i) = \lfloor E_i \times 10^4 \rfloor \mod 256$ . These indices serve as the seed for shuffling the wheel.

B. Rotating Wheel Mechanism

A virtual wheel containing integer values from 0 to 255 is initialized and manipulated as follows:

Wheel Initialization: The wheel elements are permuted (shuffled) using the index array $P$ derived from the quantum fluctuations.
Multi-Tap Sampling: Instead of reading sequentially, the system extracts four random numbers simultaneously from four fixed "tap positions" on the wheel.
- These positions are determined by a 32-byte secret key ( $k$ ).
- The tap positions ( $x_0, y_0, z_0, w_0$ ) are calculated using summation and modular product operations on segments of the ASCII values of the key.
Dynamic Rotation: After each sampling iteration, the wheel rotates counter-clockwise. The rotation speed ( $\delta$ ) is dynamically varied based on the key-derived parameters ( $\delta = \text{int}(x_0 \oplus y_0) / |x_0 - y_0|$ ). This ensures that the alignment between the wheel contents and the fixed tap positions changes constantly, enhancing temporal randomness without altering the wheel's internal content.
Sequence Generation: The sampled values are concatenated and further shuffled using permutation matrices derived from the quantum energy sequence to match the target image dimensions.

C. Image Encryption Algorithm

The generated keystream is applied to a grayscale image ( $M \times N$ ) via a two-step process:

Permutation (Confusion): The pixel positions of the plaintext image are shuffled using the quantum-derived permutation matrices.
Diffusion: The permuted image is XORed with the shuffled keystream to produce the ciphertext.

3. Key Contributions

Hybrid Architecture: A novel framework combining quantum fluctuation-driven randomness with a mechanical rotating wheel simulation, avoiding floating-point operations for platform independence.
Key-Dependent Multi-Tap Sampling: A mechanism that extracts four random values per iteration from positions determined by a 32-byte secret key, increasing the key space and reducing correlation.
Dynamic Rotation Strategy: An incremental speed variation mechanism that introduces temporal randomness, ensuring that the same wheel configuration yields different outputs over time.
Integer-Only Operations: The entire process relies on integer arithmetic, eliminating the precision issues associated with floating-point chaos systems.

4. Experimental Results

The system was tested on various images (Medical, Satellite, Fingerprint, QR Code, Panda) using Python on a standard desktop.

Entropy: The encrypted images achieved an entropy of 7.997 (close to the ideal maximum of 8), indicating high randomness.
NPCR (Number of Pixel Change Rate): Achieved 99.60%, demonstrating high sensitivity to plaintext changes (resistance to differential attacks).
UACI (Unified Average Changing Intensity): Values ranged from 31.75% to 41.80%, approaching the theoretical ideal of ~50% for images with significant black/white content.
Correlation Coefficients: Adjacent pixel correlations (horizontal, vertical, diagonal) were reduced to nearly zero (e.g., -0.002 to 0.003) in encrypted images, compared to >0.8 in original images.
Statistical Tests: The generated sequences passed all 15 NIST SP 800-22 statistical tests for randomness.
Robustness:
- Key Sensitivity: Changing a single character in the 32-byte key resulted in an SSIM of 0.020 between encrypted outputs.
- Attack Resistance: The scheme withstood brute-force attacks (key space $\approx 1.5 \times 10^{63}$ ), chosen-plaintext attacks, and noise/cropping attacks (partial image recovery was possible).
Ablation Study: Removing any component (shuffling, quantum fluctuations, dynamic rotation, or multi-tap sampling) significantly degraded security metrics (increased correlation, reduced entropy), proving the necessity of the full hybrid design.

5. Significance

This research presents a robust solution for secure image transmission in consumer and specialized applications (e.g., mobile healthcare, biometrics). By leveraging quantum fluctuations for initialization and a dynamic mechanical model for generation, the authors created an RNG that is:

High-Security: Exhibits ideal statistical properties and resists various cryptanalytic attacks.
Platform Independent: Uses integer operations, ensuring consistent performance across different hardware architectures.
Efficient: Suitable for real-time applications where computational resources may be limited compared to high-end servers.

The work bridges the gap between theoretical quantum randomness and practical, efficient cryptographic implementation, offering a viable alternative to traditional PRNGs and floating-point chaos-based systems.