Recovering a Secret Image from LSBs in Python (Pillow Tutorial)

[Rajeev Bagra]

📌 Context (Initial Code)

In this discussion, we explore how to recover a hidden black-and-white image stored inside another image using LSB steganography (Least Significant Bit).

Here is the core code:

from PIL import Image

def extract_end_bits(num_end_bits, pixel):
    return pixel % (2 ** num_end_bits)

def reveal_bw_image(filename):
    img = Image.open(filename)
    width, height = img.size
    pixels = img.load()

    secret_img = Image.new("L", (width, height))
    secret_pixels = secret_img.load()

    for x in range(width):
        for y in range(height):
            hidden_bit = extract_end_bits(1, pixels[x, y])
            secret_pixels[x, y] = hidden_bit * 255

    return secret_img

This program opens a “carrier image”, extracts the LSB bit from every pixel, and builds a new secret image from those bits.

---

✅ Q&A: Recovering a Hidden Black & White Image Using LSB

---

❓ Q1: What is Image in Python?

✅ Answer:
Image comes from the Pillow library:

from PIL import Image

It is used to open, create, manipulate, and save images.

---

❓ Q2: What does img = Image.open(filename) do?

✅ Answer:
It opens the image file given by filename and returns a PIL image object.

Example:

img = Image.open("hidden1.bmp")

---

❓ Q3: Does width, height = img.size refer to the image passed as the filename?

✅ Answer:
Yes ✅
It reads the width and height of the exact image file opened using filename.

---

❓ Q4: What does pixels = img.load() do?

✅ Answer:
It loads pixel data and gives a pixel-access object, allowing pixel reading like:

pixels[x, y]

For grayscale images, this returns an integer from 0 to 255.

---

❓ Q5: Where does the pixel value come from in extract_end_bits(1, pixel)?

✅ Answer:
The pixel value comes from the image at a specific coordinate:

pixel_value = pixels[x, y]

So this line:

extract_end_bits(1, pixels[x, y])

means:

“Extract the last bit from the pixel value at (x, y).”

---

❓ Q6: Does extract_end_bits(1, pixel) return only 0 or 1?

✅ Answer:
Yes ✅
Because only 1 bit is extracted, the output can only be:

• 0 or 1

---

❓ Q7: Why multiply by 255?

✅ Answer:
Because if the new image contains only pixel values 0 and 1, it will look almost completely black.

In grayscale "L" mode:

• 0 = black
• 1 = almost black
• 255 = white

So scaling improves visibility:

hidden_bit * 255

This converts:

• 0 → 0 (black)
• 1 → 255 (white)

---

❓ Q8: Can this be written in one line?

✅ Answer:
Yes ✅ this is equivalent:

secret_pixels[x, y] = 255 * extract_end_bits(1, pixels[x, y])

---

❓ Q9: What are pixel values immediately after Image.new() creates the image?

✅ Answer:
When the new image is created:

secret_img = Image.new("L", (width, height))

All pixels are initialized to:

✅ 0 (black)

So it starts as a fully black image until pixels are updated in the loop.

---

❓ Q10: Why is the hidden image the same size as the original image?

✅ Answer:
Because one hidden bit is extracted from every pixel of the carrier image.

Each pixel maps directly:

secret_pixels[x, y]  ← derived from  pixels[x, y]

So the recovered secret image uses the same width and height.

---

❓ Q11: If the secret image contains only 0 and 1, do its dimensions change?

✅ Answer:
No ✅
Dimensions depend on the number of pixels (width × height), not the pixel values.

Whether the pixel values are:

• 0/1 or 0/255

the size remains the same.

---

❓ Q12: Can a black-and-white secret image still show objects like a dog?

✅ Answer:
Yes ✅
Images can be formed using only black and white pixels through pixel patterns (silhouettes, outlines, shapes, text, logos, etc.).

---

❓ Q13: Why loop through x first instead of y?

✅ Answer:
It is mainly a style choice. Both orders work correctly as long as all pixels are visited.

These both work:

for x in range(width):
    for y in range(height):

and

for y in range(height):
    for x in range(width):

---

❓ Q14: What is happening in LSB steganography at a high level?

✅ Answer:
A hidden black-and-white image is stored by replacing the least significant bit of each pixel in the carrier image. The carrier looks almost identical to humans, but the hidden image can be recovered by extracting and rescaling those bits.

---

✅ Final Takeaway

LSB steganography hides a black-and-white secret image by storing one bit inside the least significant bit of every pixel in a normal image. The secret image is recovered by extracting those bits and scaling them to full black/white for visibility.

[Author]

Posts