DEV Community: Anjasfedo

Perfect Pixel Recovery: Implementing Bayesian Neural Networks for Reversible Steganography 🕵️‍♂️

Anjasfedo — Tue, 19 May 2026 18:23:55 +0000

Imagine hiding a secret message inside an image, transmitting it, and then extracting that exact message without losing a single bit. Now, imagine being able to restore the original cover image to its exact mathematical state, pixel for pixel. 🧩

In this article, I will walk through my implementation of a research-backed architecture that uses Bayesian Neural Networks and Modulo-256 arithmetic to achieve 100% reversible steganography.

📜 Academic Attribution

First and foremost, this work is an implementation and exploration of the research paper:

"Bayesian Neural Networks for Reversible Steganography"
Author: Ching-Chun Chang
Journal: IEEE Access, 2022
DOI: 10.1109/ACCESS.2022.3159911

All architectural foundations for the uncertainty-driven embedding, including the Bayesian Neural Network predictor and the variance-sorted difference expansion, are attributed to the original author.

📌 The Challenge: The Reversibility Problem

Most traditional steganography permanently alters the cover image. Reversible steganography aims to fix this, but it faces a massive enemy: pixel overflow and underflow (clipping).

If a pixel is purely white (255) and you add 1 to hide a secret bit, the image format clips it back to 255. When the receiver tries to read it, the math is broken, the secret bit is corrupted, and the image cannot be restored. 💥

🧬 Why Bayesian Neural Networks?

The core innovation here is uncertainty estimation. Instead of just guessing pixel values, the network outputs two things: the predicted pixel intensity and its own uncertainty (variance).

By predicting which pixels it is highly confident about, the network creates a variance map. We can then hide our secret message exclusively in the areas where the network is most certain. This ensures the visual distortion is kept to an absolute minimum. 🧠

🔄 The Modulo-256 Magic

To completely defeat the clipping problem, this implementation uses Modulo-256 arithmetic. If a pixel at 255 gets a +1 modification, it rolls over to 0 instead of clipping.

Because the receiver uses a checkerboard pattern to share the exact same neural network context, they can calculate the modulo difference and perfectly restore both the secret bit and the original pixel.

🧮 The Mathematical Framework

The system optimizes a custom uncertainty-weighted loss function. Instead of standard mean squared error, the loss penalizes errors based on the model's confidence:

Loss=1N∑((y−y^)2σ2+λlog⁡(σ2)) Loss = \frac{1}{N} \sum \left( \frac{(y - \hat{y})^2}{\sigma^2} + \lambda \log(\sigma^2) \right)

For the embedding process, the residual \epsilon (the difference between the true pixel and the prediction) is modulated with the secret bit m:

\epsilon^{\prime} = (2 \times \epsilon) + m \pmod{256}

📊 Experimental Results (The Trial Run)

I trained the Bayesian predictor for 200 epochs on a dataset of standard test images. The payload size was set to approximately 0.3 bits per pixel (bpp).

1. Visual Performance & Reversibility

The system achieved 100% extraction success. Every single bit was recovered, and the images were restored flawlessly. For smooth images like Lena and Sailboat, the PSNR reached above 50 dB, meaning the stego image is visually indistinguishable from the original.

Below are the visual results across different textures, demonstrating the system's ability to maintain imperceptibility (ranked from highest to lowest PSNR):

1. Sailboat

MSE: 0.5237
PSNR: 50.94 dB

2. Lena

MSE: 0.6204
PSNR: 50.20 dB

3. Airplane

MSE: 0.7910
PSNR: 49.15 dB

4. Baboon

MSE: 1.7721
PSNR: 45.65 dB

5. Splash

MSE: 1.9156
PSNR: 45.31 dB

6. Peppers

MSE: 7.5769
PSNR: 39.34 dB

2. Training Convergence

The training curve shows the stabilization of the Bayesian loss across the 200 epochs.

The loss function descends smoothly without exploding gradients, indicating that the model successfully learns to predict pixel values while accurately estimating its uncertainty bounds. 📉

🏁 Conclusion

Reversible steganography is a fascinating intersection of deep learning and cryptography. By combining Bayesian uncertainty with clever modular arithmetic, we can achieve high-capacity hiding with zero data loss. 🛡️

Check out the repository here: Anjasfedo/bayesian_neural_network_reversible_steganography

The repository is structured cleanly in PyTorch, allowing you to train the network on your own datasets and test the limits of reversible embedding. 💻

Have you ever worked with Bayesian Networks for tasks outside of standard classification? Let me know in the comments! 👇

Hiding in the Bits: Mastering AMBTC Steganography with Combination Theory

Anjasfedo — Sun, 17 May 2026 04:56:55 +0000

In our previous explorations, we looked at Coverless Steganography—a method where we don't change a single pixel, but instead find images that already "look" like our data.

Today, we are shifting gears into the Compressed Domain. We are going to hide secret messages inside the mathematics of image compression: Absolute Moment Block Truncation Coding (AMBTC).

However, simple bit-swapping in a compressed file often leaves messy visual artifacts. This is why we add Combination Theory. By using a pseudo-random Matrix P to map our message to a block's parity, we can hide 4 bits of data by flipping at most one single bit. This allows us to achieve high capacity while keeping the changes virtually invisible to the human eye.

Academic Attribution 📚
This implementation is based on the 2023 research paper:
"High Imperceptible Data Hiding Method for AMBTC Compressed Images Based on Combination Theory" by Kurnia Anggriani, Shu-Fen Chiou, Nan-I Wu, and Min-Shiang Hwang.
DOI: 10.20944/preprints202304.0341.v1

🖼️ What is AMBTC?

Before we hide data, we have to compress the image. AMBTC works by dividing an image into 4x4 blocks. For each block, it calculates:

High Quantizer (hq): The average value of "bright" pixels.
Low Quantizer (lq): The average value of "dark" pixels.
Bitmap: A 16-bit grid of 0s and 1s telling the computer which pixel gets which color.

This reduces a 16-pixel block (128 bits) down to just two 8-bit values and a 16-bit map (32 bits). It’s efficient, fast, and—most importantly—the perfect place to hide secrets.

🎲 The Secret Sauce: Combination Theory

The "magic" happens in the bitmap. Standard steganography might just flip bits randomly, but that creates "salt and pepper" noise that's easy to spot. Combination Theory uses a Pseudo-Random Matrix P.

How it works:

Generate Matrix P: Using a secret Seed (our key), we create a 4x4 matrix filled with numbers 0–15 in a random order.
Calculate Parity: We look at the current bitmap and check the "features" based on Matrix P.
The Flip: If the parity doesn't match our secret message bits, we flip exactly one bit in the bitmap.

Because we only change one pixel in a 16-pixel block, the human eye (and even most statistical tools) can't tell anything has changed.

🧪 Benchmark: Performance Results

I tested this "Base Implementation" on several standard 512x512 grayscale images. Each image was embedded with a full payload of 65,536 bits.

Image	MSE	PSNR (dB)	Capacity
Splash	14.6467	36.4734	65,536 bits
Lena	33.3143	32.9045	65,536 bits
Peppers	34.9454	32.6969	65,536 bits
Airplane	44.6739	31.6303	65,536 bits
Sailboat	76.0594	29.3193	65,536 bits
Baboon	142.7971	26.5836	65,536 bits

Observations:

The Complexity Trade-off: Images with smooth surfaces (like Splash) achieve a much higher PSNR. Complex textures (like Baboon's fur) are harder to compress via AMBTC, which naturally lowers the baseline quality.
Capacity is King: Regardless of the image, we maintained a rock-solid capacity of 65,536 bits. This is far superior to most basic LSB methods when considering the file size.

🔍 Why Hide in the Compressed Domain?

Smaller Footprint: You aren't sending a massive raw PNG; you're sending compressed data that already looks "efficient."
Bit-Level Security: Without the correct Seed, Matrix P is impossible to reconstruct. An attacker might see the modified bitmap, but they won't know which bits represent the message and which are just image data.
Minimal Distortion: Since we only flip a maximum of 1 bit per block, the visual integrity remains nearly perfect.

🎯 Conclusion

AMBTC with Combination Theory represents a sophisticated balance between compression and secrecy. It proves that we don't need to choose between a small file size and a large hidden message—we can have both.

If you want to dive into the code, check out the full Python implementation (including the performance test suite) on my GitHub:

🚀 GitHub Repository: AMBTC Steganography

What do you think? Is compressed-domain steganography the future, or do you prefer the "zero-touch" approach of coverless methods?

Hidden in Plain Sight: Implementing StegoPNet for Deep Image Steganography 🚀

Anjasfedo — Sat, 16 May 2026 04:51:33 +0000

Imagine being able to hide a high-resolution photo of a baboon inside a photo of Lena, where the resulting image looks absolutely identical to the original to the naked eye. This isn't just a classic spy trope; it is a complex Deep Learning challenge. 🧬

In this article, I will walk through my implementation and evaluation of StegoPNet, a research-backed architecture that uses Pyramid Pooling to achieve high-capacity image steganography.

📜 Academic Attribution

First and foremost, this work is an implementation and exploration of the research paper:

"StegoPNet: Image Steganography With Generalization Ability Based on Pyramid Pooling Module"
Authors: X. Duan, K. Jia, B. Li, D. Guo, Z. Zhang, and E. Sun
Journal: IEEE Access, 2020
DOI: 10.1109/ACCESS.2020.3033895

All architectural foundations, specifically the integration of the Pyramid Pooling Module (PPM) for multi-scale feature extraction, are attributed to the original authors.

📌 The Challenge: High-Capacity Hiding

Most traditional steganography methods hide tiny amounts of data, like text or small watermarks. StegoPNet aims for a 1:1 ratio: hiding a full-sized 256 x 256 RGB secret image inside a 256 x 256 RGB cover image. 🖼️

Standard CNNs often struggle with this because they process images locally. When you hide a high-entropy image (like a Baboon with complex textures) inside a smooth image (like Lena's face), a standard CNN often leaves visible ghosts or artifacts.

🧬 Why Pyramid Pooling?

The core innovation here is the Pyramid Pooling Module (PPM). Unlike standard layers that focus on small pixel neighborhoods, the PPM captures features at five different scales (32 x 32 down to 2 x 2).

By understanding the global context of the image, the network can:

Identify high-texture areas (like hair or fabric) where changes are harder to see. 🕵️
Spread the secret data across different frequency bands to avoid statistical anomalies.

🧮 The Mathematical Framework

The system optimizes a weighted Mean Squared Error (MSE) to balance invisibility with reconstruction accuracy:

$$Loss = L_{h} + \alpha L_{r}$$

Where $L_{h}$ is the Hiding Loss, $L_{r}$ is the Reveal Loss, and alpha is set to 0.6. This ensures the model prioritizes making the cover look clean while still allowing for perfect secret extraction. ⚖️

📊 Experimental Results (The Trial Run)

I conducted a trial run using a Tesla T4 GPU on Google Colab, training the models on the classic Lena and Baboon pair for 3,000 iterations.

1. Visual Performance & Error Analysis

When we look at the Error Maps (the pixel difference between original and stego multiplied by 10), the difference is staggering.

No PPM (Baseline): Shows noticeable distortion. The error is scattered and creates hotspots that are easy for steganalysis tools to detect.
With PPM (Proposed): The stego image is visually indistinguishable. The error is intelligently concentrated in textured areas, significantly improving imperceptibility. 🌈

2. Training Convergence

The training curves show how much more stable the PPM architecture is compared to a standard baseline.

PPM (Orange): Exhibits a smoother, faster descent. It achieves a much lower loss, proving it solves the hiding/revealing task more effectively.
No PPM (Blue): Displayed high volatility and sharp spikes, indicating the network struggled to pack high-entropy data without ruining the cover image. 📉

🏁 Conclusion

Global context matters in image steganography. By using multi-scale features, StegoPNet proves that we can achieve massive payload capacity without sacrificing security. 🛡️

Check out the full repository here: [https://github.com/Anjasfedo/stegopnet]
The repository is structured to allow for easy ablation studies, so you can test exactly what happens when you toggle the PPM module on or off. 💻

Do you think Deep Learning will eventually make traditional statistical steganalysis obsolete? Let me know in the comments! 👇

Scaling Stealth: Massive Capacity Upgrades for Coverless Steganography with E-CIHMSB and CB-CIHMSB 🕵️‍♂️📈

Anjasfedo — Sat, 16 May 2026 04:11:03 +0000

In our journey through coverless steganography, we first explored CIHMSB —a method that hides data by matching message bits to the average intensity of image fragments. While perfect in its invisibility, CIHMSB faces a significant hurdle: capacity. Using only one bit per fragment limits how much data we can hide in a single image.

Today, we are looking at two advanced extensions that shatter these capacity limits: E-CIHMSB and CB-CIHMSB. By applying matrix extensions and combination theory, we can pack significantly more data into the same carrier while actually improving robustness against image attacks.

Academic Attribution 📚
This implementation and analysis are based on the 2023 research paper:
"A Robust and High-Capacity Coverless Information Hiding Based on Combination Theory" by Kurnia Anggriani, Shu-Fen Chiou, Nan-I Wu, and Min-Shiang Hwang.
DOI: https://doi.org/10.15388/23-INFOR521.

🚀 The Next Evolution: Two Powerful Extensions

The researchers identified that the original CIHMSB only embeds one bit per segment, making it inefficient for large messages. They proposed two solutions:

1. E-CIHMSB (Extended CIHMSB)

This scheme builds an "Extended Matrix". After calculating the average pixel values for all fragments in a group, it adds one extra value: the average of all those averages. This simple mathematical addition increases the bit pool for every image carrier.

2. CB-CIHMSB (Combination Theory-Based)

This is the true heavy-lifter. Instead of just adding one value, it uses combination theory to create a "Combined Matrix". If you have a group of n fragments, it calculates the averages for every possible combination of those fragments (choosing 1, 2, 3, or all n).
The capacity growth is exponential: EC = 2^n - 1. For a group of 4 fragments, you generate 15 feature values instead of just 4!

🧪 Benchmark: Performance Comparison

To see these algorithms in action, I ran a full experimental benchmark on a 512x512 carrier image using 8x8 fragments. Here are the real-world results:

1. Image Quality Assessment

As these are coverless methods, the image itself is never modified.

SSIM: 1.0 (Perfect match)
Qi: 1.0 (Optimal quality)

2. Hiding Capacity (512x512 Carrier)

Method	Bits per Carrier	Improvement
Original CIHMSB	16,384 bits	Baseline
E-CIHMSB	20,480 bits	+25%
CB-CIHMSB	61,440 bits	+275%

3. Robustness Analysis (BER)

Bit Error Rate (BER) measures how many bits were lost during a transmission attack. Lower is better.

Attack Type	E-CIHMSB BER	CB-CIHMSB BER
AGWN (Var 0.1)	16.07%	7.14%
SPN (Dens 0.005)	5.36%	1.79%
AF (3x3 Window)	12.50%	8.93%
JPEG (Quality 50-90)	1.79% - 5.36%	0.00% (Perfect)

🔍 Why is CB-CIHMSB the Clear Winner?

Looking at the benchmark data, CB-CIHMSB is superior for two main reasons:

Massive Capacity: It offers 275% more capacity than the original method. You can hide an entire secret document where you previously could only hide a short paragraph.
Superior Robustness: Notice the JPEG compression results. While E-CIHMSB suffered some errors, CB-CIHMSB achieved a 0.00% Bit Error Rate. Because it averages multiple combinations of fragments, the secret features become more "stable" and resistant to pixel-level distortions like JPEG artifacts or blurring.

🎯 Conclusion

The research by Anggriani et al. proves that coverless steganography does not have to be low-capacity. By shifting from linear fragment matching to combinatorial logic, we can hide massive amounts of data with zero pixel manipulation. This makes it impossible for standard steganalysis tools to detect anything—because mathematically, there is nothing "embedded" in the pixels.

Check out the full modular Python implementation on my GitHub! https://github.com/Anjasfedo/ecihmsb_cbcihmsb

Tripling Data Capacity: Implementing CIHLHF Coverless Steganography in Python 🕵️‍♂️🚀

Anjasfedo — Sat, 16 May 2026 03:26:12 +0000

In my previous post, we explored CIHMSB, a way to hide data in images without changing a single pixel by using the average value of image fragments. While it offers perfect invisibility, the main challenge is hiding capacity.

Today, we are looking at the next evolution: CIHLHF. By targeting the "Extremes"—the lowest and highest pixel values in a fragment—we can pack three times more information into the same image while maintaining uncrackable security.

Academic Attribution 📚
This article is based on the 2023 research paper:
"A High-Capacity Coverless Information Hiding Based on the Lowest and Highest Image Fragments" by Kurnia Anggriani, Shu-Fen Chiou, Nan-I Wu, and Min-Shiang Hwang.
Published in Electronics 2023, 12, 395.
DOI: 10.3390/electronics12020395

It also references the foundational CIHMSB method:
"A Novel Coverless Information Hiding Method Based on the Most Significant Bit of the Cover Image" by Lina Yang, Haiyu Deng, and Xiaocui Dang (IEEE Access, 2020).
DOI: 10.1109/ACCESS.2020.3000993

🧠 Why CIHLHF?

The original CIHMSB method maps bits to the Average Intensity of a fragment. CIHLHF introduces two major upgrades:

Dual-Value Mapping: Instead of a single average, it extracts the Minimum (L) and Maximum (H) values from each fragment.
Increased Payload: By extracting multiple MSB bits from both the L and H values, the total bit pool per image is significantly larger.
The Z-Key (Secret Mapping): Both the sender and receiver use a shared secret key (Z) to randomize the fragment sequence, ensuring that even if an attacker intercepts the image, the data remains scrambled.

Like its predecessor, it remains Coverless, meaning the stego image is identical to the cover image.

💻 The Implementation

This Python implementation handles the extraction of extreme values and the random Z-key permutation logic.

import numpy as np

class CIHLHF:
    def __init__(self, fragment_size=8, first_msb_bits=1, second_msb_bits=1, seed=None):
        self.fragment_size = fragment_size
        self.first_msb_bits = first_msb_bits
        self.second_msb_bits = second_msb_bits
        self.seed = seed

    def _text_to_bin(self, text):
        binary_list = []
        for char in text:
            bin_char = format(ord(char), '07b')
            for bit in bin_char:
                binary_list.append(int(bit))
        return binary_list

    def _bin_to_text(self, binary_list):
        text = ""
        for i in range(0, len(binary_list), 7):
            chunk = binary_list[i:i+7]
            if len(chunk) < 7: break
            chunk_str = "".join(map(str, chunk))
            text += chr(int(chunk_str, 2))
        return text

    def _extract_min_max_msbs(self, image_array):
        h, w = image_array.shape
        h_trunc = h - (h % self.fragment_size)
        w_trunc = w - (w % self.fragment_size)

        msb_pool = []
        for i in range(0, h_trunc, self.fragment_size):
            for j in range(0, w_trunc, self.fragment_size):
                fragment = image_array[i:i+self.fragment_size, j:j+self.fragment_size]
                min_val = int(np.min(fragment)) 
                max_val = int(np.max(fragment)) 

                bin_min = format(min_val, '08b')
                for b in range(self.first_msb_bits):
                    msb_pool.append(int(bin_min[b]))

                bin_max = format(max_val, '08b')
                for b in range(self.second_msb_bits):
                    msb_pool.append(int(bin_max[b]))
        return msb_pool

    def _generate_z_key(self, capacity):
        if self.seed is None: return list(range(1, capacity + 1))
        state = np.random.get_state()
        np.random.seed(self.seed)
        z_key = np.random.permutation(np.arange(1, capacity + 1))
        np.random.set_state(state)
        return z_key.tolist()

    def embed(self, image_array, secret_text):
        secret_bits = self._text_to_bin(secret_text)
        msb_pool = self._extract_min_max_msbs(image_array)
        if len(secret_bits) > len(msb_pool):
            raise ValueError(f"Capacity {len(msb_pool)} bits is not enough.")

        z_key = self._generate_z_key(len(msb_pool))
        mapping_flag = [0] * len(secret_bits)
        for i in range(len(secret_bits)):
            target_index = z_key[i] - 1
            mapping_flag[i] = 1 if secret_bits[i] == msb_pool[target_index] else 0
        return mapping_flag

    def extract(self, image_array, mapping_flag):
        msb_pool = self._extract_min_max_msbs(image_array)
        z_key = self._generate_z_key(len(msb_pool))
        secret_bits = []
        for i in range(len(mapping_flag)):
            target_index = z_key[i] - 1
            t_i = 1 if mapping_flag[i] == msb_pool[target_index] else 0
            secret_bits.append(t_i)
        return self._bin_to_text(secret_bits)

🧪 Replicating the Paper: Benchmark Results

To verify the effectiveness of CIHLHF, I ran a full replication suite based on the experiments conducted by Anggriani et al. Here are the results from the Python test suite:

[1] CIHLHF EXPERIMENT DEMO
Original Message: CIHLHF_REPLICATION_2026
Extraction Match: True

[2] HIDING CAPACITY ANALYSIS
Total Fragments   : 4096
CIHMSB Capacity   : 16384 bits
CIHLHF Capacity   : 49152 bits
Improvement Factor: 3.0x

[3] SECURITY ANALYSIS (Brute-Force Complexity)
Total Fragments (Ci) : 4096
Secret Bits (Ti)     : 49152
Complexity (Years)   : 2.69 x 10^209255

[4] IMAGE QUALITY ASSESSMENT (IQA)
MSE  : 0.0
PSNR : inf dB
SSIM : 1.0
Qi   : 1.0

Analysis of Results:

3.0x Capacity Leap: By utilizing 12 bits per fragment (6 from the minimum value and 6 from the maximum), the capacity jumps from 16,384 bits to a massive 49,152 bits for a 512 x 512 carrier image.
Optimal Visual Quality: Since no pixels are modified, the PSNR remains infinite and the SSIM is a perfect 1.0. The image is mathematically identical to the original.
Extreme Security: The brute-force complexity for a 512x512 image reaches an astronomical 10^209255 combinations, making it physically impossible to crack without the secret mapping key Z.

🎯 Conclusion

CIHLHF proves that we don't have to sacrifice capacity for security. By shifting the mapping logic from the fragment's average value to its extreme values, we can hide massive amounts of data in plain sight—unseen by both the human eye and digital steganalysis tools.

Source code and replication scripts are available on my GitHub! ⭐

https://github.com/Anjasfedo/cihlhf

Hiding in Plain Sight: Building Coverless Steganography (CIHMSB) with Python 🕵️‍♂️🐍

Anjasfedo — Fri, 15 May 2026 18:06:00 +0000

If you have ever explored cybersecurity, you probably know about Steganography—the art of hiding secret messages inside an image.

The most popular approach is usually the LSB (Least Significant Bit) method, where we slightly alter the pixel colors to embed text. The problem? Modern detection tools (steganalysis) are incredibly smart. Altering even a single bit can trigger an alert that the image has been manipulated.

So, what if we could hide data without changing a single pixel of the original image?

Welcome to the world of Coverless Steganography.

Academic Attribution 📚
The article and code below are the result of my independent breakdown and implementation based on an excellent academic paper titled:
"A Novel Coverless Information Hiding Method Based on the Most Significant Bit of the Cover Image" by Lina Yang, Haiyu Deng, and Xiaocui Dang (IEEE Access, 2020).
DOI: 10.1109/ACCESS.2020.3000993

Let us break down how it works and write the code in Python!

🧠 Core Concept of CIHMSB

CIHMSB stands for Coverless Information Hiding Method based on Most Significant Bit. It relies on logic matching rather than physical embedding. Here is the simple workflow based on the original paper:

Convert Message to Binary: Change your secret message into a sequence of 0s and 1s using a 7-bit ASCII format.
Divide the Image: Cut the original grayscale image matrix into small grids or fragments, for example, 8x8 or 5x5 pixels.
Calculate Average and Extract MSB: Instead of looking at a single random pixel, calculate the average pixel value of the entire fragment. Then, extract the Most Significant Bits from that average value.
The Magic Matching: Compare your message bits with the extracted image MSBs. If they match, we record a 1 in a separate ledger. If they do not match, we record a 0. This ledger is called the Mapping Flag.
Transmission: You send the 100% unaltered original image and the Mapping Flag file to your receiver.

Because the original image is completely untouched, error detection metrics return an Infinite value. Zero pixels are damaged!

💻 Let's Write the Code

We will use the numpy library to manipulate the image matrices. Notice how the class allows us to extract multiple MSB bits per fragment to increase the hiding capacity.

import numpy as np

class CIHMSB:
    def __init__(self, fragment_size=8, msb_bits=1):
        self.fragment_size = fragment_size
        self.msb_bits = msb_bits 

    def _text_to_bin(self, text):
        binary_list = []
        for char in text:
            bin_char = format(ord(char), '07b')
            for bit in bin_char:
                binary_list.append(int(bit))
        return binary_list

    def _bin_to_text(self, binary_list):
        text = ""
        for i in range(0, len(binary_list), 7):
            chunk = binary_list[i:i+7]
            if len(chunk) < 7: break
            chunk_str = "".join(map(str, chunk))
            text += chr(int(chunk_str, 2))
        return text

    def _extract_image_msb(self, image_array):
        h, w = image_array.shape
        h_trunc = h - (h % self.fragment_size)
        w_trunc = w - (w % self.fragment_size)

        msb_pool = []
        for i in range(0, h_trunc, self.fragment_size):
            for j in range(0, w_trunc, self.fragment_size):
                fragment = image_array[i:i+self.fragment_size, j:j+self.fragment_size]
                avg_val = int(np.mean(fragment))

                bin_avg = format(avg_val, '08b')
                for b in range(self.msb_bits):
                    msb_pool.append(int(bin_avg[b]))
        return msb_pool

    def embed(self, image_array, secret_text):
        secret_bits = self._text_to_bin(secret_text)
        msb_pool = self._extract_image_msb(image_array)
        if len(secret_bits) > len(msb_pool):
            raise ValueError("Kapasitas tidak cukup.")
        return [1 if secret_bits[i] == msb_pool[i] else 0 for i in range(len(secret_bits))]

    def extract(self, image_array, mapping_flag):
        msb_pool = self._extract_image_msb(image_array)
        secret_bits = [1 if mapping_flag[i] == msb_pool[i] else 0 for i in range(len(mapping_flag))]
        return self._bin_to_text(secret_bits)

How to Run It

Now, let us test the code above. You will need a grayscale image loaded into a numpy array (named img_array in this example). We will configure it to use 4 bits per fragment to simulate a high-capacity scenario.

img_pil = Image.open('assets/cover.png').convert('L')
img_array = np.array(img_pil)

cihmsb = CIHMSB(fragment_size=8, msb_bits=4)

secret_message = "SECRET MESSAGE"
print(f"Original Message: {secret_message}")

mapping_flag = cihmsb.embed(img_array, secret_message)
print(f"Transmitted Mapping Flag: {mapping_flag[:10]}... (Total {len(mapping_flag)} bits)")

extracted_message = cihmsb.extract(img_array, mapping_flag)
print(f"Extracted Message: {extracted_message}")

🧪 Replicating the Paper's Experiments

To prove that this method works exactly as the IEEE paper claims, I built a complete test suite to replicate their Image Quality Assessment (IQA), Security Analysis, and Robustness parameters.

Here is the terminal output from running the master test script on a 256x256 image with 5x5 fragments:

[1] EXPERIMENT DEMO
Secret message length : 160 characters
Binary bit length     : 1120 bits
Extraction Match      : True

[2] HIDING CAPACITY ANALYSIS
Image Size          : 256x256
Fragment Size       : 5x5
Max Hiding Capacity : 2601 bits per carrier

[3] SECURITY ANALYSIS (Violent Attack)
Total Image Fragments (Fm) : 2601
Secret Bits (Cn)           : 1120
Possible Attack Combos (U) : 10^3701 combinations

[4] IMAGE QUALITY ASSESSMENT (IQA)
Mean Square Error (MSE) : 0.0
PSNR (dB)               : inf
SSIM                    : 1.0
Universal Quality (Qi)  : 1.0

[5] ROBUSTNESS ANALYSIS: AWGN & JPEG
--- AWGN (Gaussian Noise) ---
Variance 0.1 -> BER: 9.73%
Variance 0.5 -> BER: 33.04%
Variance 1.0 -> BER: 45.36%

--- JPEG Compression ---
Quality 90   -> BER: 1.16%
Quality 70   -> BER: 1.96%
Quality 50   -> BER: 3.12%

Key Takeaways from the Benchmark:

Perfect Image Quality: Notice the PSNR is inf (Infinite) and SSIM is 1.0. Because we don't manipulate pixels, the stego image is mathematically identical to the cover image.
Unbreakable Brute-Force: Without the Mapping Flag, an attacker trying a violent brute-force attack would face 10^3701 combinations to extract just 1120 bits.
Robustness: Even if the image is compressed and loses quality (JPEG Quality 50), the Bit Error Rate (BER) remains remarkably low at just 3.12%, meaning most of the secret text is still perfectly readable!

🎯 Conclusion

The main advantage of this Coverless method is: Your original image does not change at all. If a hacker or analyst intercepts the image and checks its MD5 hash or color histogram, they will find absolutely nothing suspicious. It is just a normal image.

The secret data will only materialize if that specific original image is paired with the Mapping Flag file we send separately. By averaging the fragment values instead of picking a single pixel, this specific algorithm also ensures better robustness against minor image distortions like JPEG compression.

I have uploaded the full source code and the complete test replication suite to my GitHub repository. Feel free to check it out, run the tests yourself, and give it a star! ⭐

👉 https://github.com/Anjasfedo/cihmsb

What do you think? Will this zero-pixel manipulation method become the data security standard of the future? Let me know in the comments below!