Quantum Gatekeeper: Multi-Factor Context-Bound Image Steganography with VQC Based Key Derivation on Quantum Hardware

This paper introduces "Quantum Gatekeeper," a multi-factor context-bound image steganography framework that ensures secure payload recovery only when four specific factors (password, shared secret, context string, and reference image) align to reconstruct a deterministic extraction path derived from a variational quantum circuit, while utilizing both statevector simulation and IBM quantum hardware to validate its noise-resilient, silent-rejection security model.

The Gist

Imagine you have a secret message hidden inside a regular photo. In the old days of digital hiding, if someone found the right "key" (like a password), they could unlock the photo and read your message. But what if the key wasn't just a password? What if the key was a complex combination of things that only you knew, and even if someone guessed the password, they still couldn't get in without the other pieces?

This paper introduces "Quantum Gatekeeper," a new way to hide secrets in images that acts like a high-security vault with four different locks. You can't open it unless you have the right key for every single lock at the exact same time.

Here is how it works, broken down into simple concepts:

1. The Four Keys to the Vault

In most secret-keeping systems, you just need a password. In this system, to recover the hidden message, you need four things to match perfectly:

• The Password: A secret phrase you know.
• The Shared Secret: A code you and the sender agreed on beforehand.
• The Context String: A specific phrase or sentence you both decided to use for this specific message.
• The Image Signature: A digital "fingerprint" of the exact photo used to hide the message.

The Analogy: Imagine trying to open a safe. Usually, you just turn a dial (the password). In this system, you have to turn the dial, insert a specific key, whisper a secret phrase, and hold the safe up to a specific light source (the image). If you get any one of these wrong, the safe doesn't just give you a "wrong password" error; it simply stays locked, and you get nothing. The system is designed to fail silently so no one learns anything about the secret.

2. The "Quantum" Magic Trick

The paper uses a Variational Quantum Circuit (VQC). Don't let the fancy name scare you. Think of this as a very complex, multi-layered maze.

• How it works: The four keys (password, secret, context, image) are mixed together to create a unique "seed." This seed is fed into a quantum computer simulation to generate a specific map.
• The Map: This map tells the computer exactly which pixels in the image to look at and in what order to read them. It's like a treasure map that says, "Go to pixel 45, then jump to pixel 902, then skip to pixel 12."
• The Twist: If you use the wrong keys, the quantum computer generates a completely different map. You might end up reading the pixels in a random order, which results in gibberish.

3. The "Two-Part" Puzzle (Dual-Region)

There was a tricky problem the authors had to solve: How do you tell the computer where to start looking for the secret if the map itself is hidden inside the secret area?

• The Solution: They split the image into two separate zones.
  • Zone A (The Header): This holds the basic instructions (like "the message is 500 bytes long"). This zone uses a simple, separate key.
  • Zone B (The Payload): This holds the actual secret message. This zone uses the complex "Quantum Map" described above.
• Why it matters: You unlock Zone A first to get the instructions. Then, you use the instructions and the Quantum Map to unlock Zone B. This prevents a "chicken and egg" problem where you can't start because you don't have the instructions to start.

4. The "Silent Failure" Rule

This is a crucial safety feature. In many systems, if you guess the password wrong, the system might show you a scrambled version of the message, giving you a hint.

• Quantum Gatekeeper's Rule: If your four keys don't match perfectly, the system doesn't just show you garbage; it fails completely. It produces zero partial information. It's like trying to open a door with the wrong key—the door doesn't creak or show you the inside; it just stays shut.

5. The Quantum Computer Test

The authors tested this on two things:

1. A Perfect Simulator: A computer program that acts like a perfect, noise-free quantum computer.
2. Real IBM Quantum Hardware: A real, physical quantum computer that has "noise" (glitches and errors) because it's a physical machine.

The Result: Even though the real hardware had some "noise" (like static on a radio), the most important part of the map (the "dominant bitstring") stayed the same. This means the system is robust enough to work even if the quantum hardware isn't perfect. The real hardware produced slightly different statistical "fingerprints" than the simulator, but the actual secret message was still recovered perfectly.

Summary

Quantum Gatekeeper is a system that hides secrets in photos by locking them behind four different doors. It uses a quantum computer to create a unique, complex path to find the hidden data.

• If you have all four keys: You get the perfect, original secret (whether it's text or another image).
• If you miss even one key: You get nothing. No hints, no partial data, just silence.

The paper proves that this works perfectly on images, hides the secret so well you can't tell the photo was altered, and remains stable even when tested on real, imperfect quantum hardware.

Technical Summary

1. Problem Statement

Traditional image steganography primarily focuses on content confidentiality (encrypting the payload) but often lacks robust extraction-path control. In conventional systems, once an adversary obtains the correct encryption key or embedding pattern, the hidden data can be extracted deterministically. Furthermore, most systems are limited to text or binary payloads and struggle with embedding entire images without compromising fidelity or capacity.

The authors identify a critical gap: existing methods do not sufficiently guard the mechanism of extraction. If the extraction path (pixel traversal order) is predictable or relies solely on a single key, the system remains vulnerable. Additionally, there is a lack of frameworks that leverage the physical noise characteristics of Noisy Intermediate-Scale Quantum (NISQ) hardware to create unique, device-specific signatures while maintaining deterministic recovery for legitimate users.

2. Methodology: The Quantum Gatekeeper Framework

The proposed system, Quantum Gatekeeper, is a hybrid quantum-classical framework that shifts the security paradigm from "hiding data" to "controlling the extraction path." Recovery is only possible when four specific factors are simultaneously correct.

A. Multi-Factor Context Binding

Successful payload recovery requires the simultaneous reconstruction of:

1. Password ($P$): Strengthened via PBKDF2.
2. Shared Secret ($S$): A pre-shared cryptographic secret.
3. Context String ($C$): A user-defined string.
4. Reference Image Signature ($R_I$): A hash derived from the original cover image buffer before embedding.

If any single factor is incorrect, the system fails to reconstruct the correct pixel traversal order or the decryption key, resulting in silent failure (no partial data leakage).

B. Dual-Region Embedding Architecture

To resolve the "bootstrapping problem" (where the nonce needed to decrypt the payload is stored inside the payload itself), the authors introduced a dual-region layout:

• Header Region ($\Omega_H$): Keyed by a separate seed ($\sigma_h$). Contains the Nonce ($N$) and payload length ($|M|$).
• Payload Region ($\Omega_P$): Keyed by a combined seed ($\sigma_p \parallel K_Q$). Contains the encrypted ciphertext.
  This separation allows the decoder to first recover the metadata required to access the main payload without circular dependencies.

C. Variational Quantum Circuit (VQC) for Key Derivation

The core innovation is the use of a Deterministic VQC to generate the Gate Key ($K_Q$):

• Parameterization: Circuit parameters are derived deterministically from the context-bound seed via cryptographic hash expansion.
• Execution Strategy:
  • Encoding/Decoding: Uses exact statevector simulation (not hardware sampling) to ensure the key $K_Q$ is reproducible and deterministic. This prevents the stochastic nature of quantum measurements from breaking the recovery process.
  • Validation: The same circuit is run on IBM Quantum hardware (e.g., ibm_pittsburgh) to measure statistical divergence (noise) and validate that the dominant output state remains stable despite physical noise.
• Function: $K_Q$ does not encrypt the data directly; it dictates the shuffled pixel access order (permutation) for the Least Significant Bit (LSB) embedding.

D. Cryptographic Pipeline

• Encryption: Payloads (text or images) are processed via AES-GCM (Authenticated Encryption with Associated Data).
• Image Handling: Secret images are resized to $512 \times 512$, PNG-compressed, and Base64-encoded before encryption to ensure deterministic capacity.
• Embedding: Uses lossless LSB substitution on RGB channels based on the quantum-derived permutation.

3. Key Contributions

1. Context-Bound Extraction Control: A novel framework where payload recovery depends on reconstructing a precise extraction path derived from four multi-factor inputs, rather than just decrypting a ciphertext.
2. Deterministic Quantum Key Derivation: A mechanism using VQCs to generate traversal keys via exact simulation, ensuring reliability while leveraging quantum circuit structures.
3. Dual-Region Architecture: A design pattern that decouples metadata (header) recovery from payload recovery, solving nonce bootstrapping issues in steganography.
4. Hybrid Execution Model: A split architecture that uses classical simulation for deterministic logic and real quantum hardware for statistical validation and device fingerprinting.
5. Silent Failure Mechanism: The system is designed to reject incorrect inputs entirely, preventing partial payload disclosure.

4. Experimental Results

The framework was evaluated on DIV2K, COCO, and ImageNet datasets using both local simulators and IBM Quantum hardware.

• Imperceptibility: The proposed method achieved superior visual quality compared to baselines (4bit-LSB, CAIS, HiNet, GAN-based).
  • SSIM: ~0.9998 (DIV2K)
  • PSNR: ~64.25 dB (DIV2K)
• Recovery Fidelity:
  • Text: 100% exact recovery or authenticated rejection.
  • Images: Pixel-perfect recovery (SSIM = 1.000, PSNR = $\infty$) for $512 \times 512$ secret images.
• Quantum Consistency:
  • Dominant State Stability: Both the simulator and IBM hardware produced the same dominant bitstring (e.g., $|1000\rangle$), confirming that the quantum control signal is robust against NISQ noise.
  • Statistical Divergence: Measurable differences were observed in Shannon Entropy and Total Variation Distance (TVD ~0.0566), proving the hardware produces a unique physical signature while maintaining functional stability.
  • Runtime: Simulator execution took ~0.0127s; IBM hardware took ~7.81s for 2048 shots.

5. Significance and Implications

• Paradigm Shift: Moves steganography security from "hiding the existence of data" to "controlling the access path." Even if an attacker finds the hidden bits, they cannot reconstruct the payload without the specific quantum-derived permutation and multi-factor context.
• NISQ Utilization: Demonstrates that current noisy quantum hardware can be used for cryptographic control mechanisms without requiring error correction, provided the system relies on the dominant state rather than stochastic sampling for critical keys.
• Physical Unclonable Function (PUF) Analogy: The system leverages the unique noise profile of specific quantum chips as a form of physical fingerprinting, adding a layer of hardware-bound security.
• Robustness: The "all-or-nothing" failure model ensures that partial information leakage is impossible, a significant improvement over many existing steganographic systems that may leak fragments of data upon incorrect key entry.

In conclusion, Quantum Gatekeeper successfully integrates quantum computing concepts into practical image steganography, offering a highly secure, context-aware, and visually imperceptible method for hiding complex payloads (including images) with rigorous access control.