LSB Steganography in RGB Images: Recovering Hidden Color Images Step by Step

[Rajeev Bagra]

📌 Context (Initial Code)

In this discussion, we focus on how to recover a hidden color image from an RGB carrier image using LSB steganography, where multiple least significant bits are used.

Below is a simplified version of the recovery code:

from PIL import Image

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

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

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

    scale = 255 // 7   # ≈ 36 (for 3 bits)

    for x in range(width):
        for y in range(height):
            r, g, b = pixels[x, y]

            secret_r = extract_end_bits(3, r) * scale
            secret_g = extract_end_bits(3, g) * scale
            secret_b = extract_end_bits(3, b) * scale

            secret_pixels[x, y] = (secret_r, secret_g, secret_b)

    return secret_img

This code extracts three least significant bits from each RGB channel, rescales them, and rebuilds the hidden color image.

---

✅ Q&A: Recovering Hidden Color Images Using LSB Steganography

---

❓ Q1: What does “three least significant bits of each channel” mean?

✅ Answer:
It means that from each color channel (Red, Green, Blue), we extract the last three binary bits.

So for every pixel, we extract:

• 3 bits from Red
• 3 bits from Green
• 3 bits from Blue

That gives 9 hidden bits per pixel.

---

❓ Q2: Is taking 1 bit from R, G, and B the same as taking 3 bits?

✅ Answer:
No ❌

Taking 1 bit from each channel gives only 3 bits per pixel, while the assignment requires 3 bits from each channel, giving 9 bits per pixel.

They are completely different methods.

---

❓ Q3: Why do extracted values range from 0 to 7?

✅ Answer:
Because 3 bits can represent:

2³ = 8 values → 0 to 7

So after extraction, each channel can only have values between 0 and 7.

---

❓ Q4: Why is rescaling needed after extracting bits?

✅ Answer:
RGB images require pixel values between 0 and 255.

If we keep values at 0–7, the image will look almost completely black.

So we must stretch (rescale) them to the full range.

---

❓ Q5: Why do we multiply by about 36?

✅ Answer:
To map the range 0–7 into 0–255.

We compute:

255 / 7 ≈ 36

So multiplying by about 36 spreads values evenly:

• 0 → 0
• 7 → ~252

Which is close to white.

---

❓ Q6: Why not multiply by 255 directly?

✅ Answer:
Because that would create invalid values:

Example:

2 × 255 = 510 ❌

RGB pixels must stay within 0–255.

So direct multiplication by 255 does not work.

---

❓ Q7: What does r, g, b = pixels[x, y] do?

✅ Answer:
It reads one pixel from the RGB image and splits it into:

• Red value (r)
• Green value (g)
• Blue value (b)

Each value is between 0 and 255.

---

❓ Q8: Why do we need secret_pixels = secret_img.load()?

✅ Answer:
Because .load() gives a writable pixel-access object.

Without it, we cannot efficiently write:

secret_pixels[x, y] = (r, g, b)

---

❓ Q9: What are the pixel values in the new image at creation time?

✅ Answer:
When we create:

Image.new("RGB", (width, height))

All pixels are initially set to:

(0, 0, 0)  → black

They are overwritten later in the loop.

---

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

✅ Answer:
Because each carrier pixel stores hidden bits for exactly one secret pixel.

So extraction rebuilds the image in the same grid.

---

❓ Q11: What is the main advantage of using 3 bits per channel?

✅ Answer:
It allows the hidden image to have:

• more color levels
• smoother shading
• better visual quality

compared to using only 1 bit per channel.

---

❓ Q12: How does this relate to real-world applications?

✅ Answer:
This technique is used in:

• digital watermarking
• copyright protection
• data integrity checking
• secure communication
• media authentication

It also builds strong foundations for computer vision and cybersecurity.

---

✅ Final Takeaway

Recovering a hidden color image using LSB steganography involves extracting three least significant bits from each RGB channel, rescaling them to 0–255, and rebuilding a full-color image. This provides higher-quality recovery while keeping the carrier image visually unchanged.

[Author]

Posts