Implement LSB Image Steganography in Python

The immediate answer

Least significant bit image steganography hides a payload by replacing the lowest-order bits of pixel channel values with message bits. A Python implementation typically opens an uncompressed or lossless image, flattens its pixel array, overwrites one or more least significant bits per byte, and saves the result. The receiver reads the same pixel array and extracts those bits in the same order.

The term steganography describes concealment of the existence of a message, not protection of its contents. Substituting the least significant bits of red, green, blue, or alpha values usually produces a visually similar image because changing a channel value from 125 to 124 is nearly imperceptible. That visual similarity is not the same as resistance to statistical detection.

Which image formats fit LSB substitution

The payload must survive the file-writing process exactly. A format that recomputes pixel values with lossy compression can alter or discard the embedded bits, so the safe choices are formats that preserve the decoded pixels.

• PNG is a natural fit because it stores decoded pixels losslessly.
• BMP stores pixels without lossy compression and is workable when handled as raw pixel data.
• TIFF can work when using a lossless pixel layout.
• JPEG is unsuitable for simple LSB replacement because its compression changes pixel values and therefore destroys the hidden bits; JPEG steganography requires different methods.

The embedding workflow

A minimal implementation has three stages: read a cover image into a form that exposes individual byte values, write message bits into selected channel bytes, and save the changed image without lossy recompression.

from PIL import Image

def load_pixels(path):
    image = Image.open(path)
    image = image.convert("RGBA")
    return bytearray(image.tobytes())

The bytearray exposes the image as a mutable sequence of channel values. Because the alpha channel is included, the receiver must use the same conversion and channel order, or every decoded message will be corrupted.

def embed_lsb(pixels, payload_bytes):
    bits = "".join(format(byte, "08b") for byte in payload_bytes)
    if len(bits) > len(pixels):
        raise ValueError("Payload does not fit in the available pixels")

    for index, bit in enumerate(bits):
        pixels[index] = (pixels[index] & 0xFE) | int(bit)

    return bytes(pixels)

The mask 0xFE clears the least significant bit without touching the other seven bits. The bit value is then ORed into place. This modifies one bit per channel byte. The same technique can be extended to two or more least significant bits, increasing capacity while increasing the visual and statistical footprint.

Writing the modified image

def save_embedded_image(modified_pixels, size, output_path):
    image = Image.frombytes("RGBA", size, modified_pixels)
    image.convert("RGB").save(output_path, "PNG")

Saving as RGB before writing as PNG avoids storing a non-informative alpha channel in the final file. The important requirement is that the output encoder does not introduce lossy changes. PNG fits that requirement.

Extraction

Extraction reverses the process. The receiver reads the first N least significant bits from the same channel sequence and reassembles them into bytes. The receiver must know how many bytes to read, either from a fixed-length header, an agreed length convention, or by reading until a terminator.

def extract_lsb(pixels, bit_count):
    bits = [str(pixels[index] & 1) for index in range(bit_count)]
    bit_string = "".join(bits)

    return bytes(
        int(bit_string[offset:offset + 8], 2)
        for offset in range(0, bit_count, 8)
    )

If the payload length is not a multiple of eight bits, the final byte may contain padding. A practical design must define that padding unambiguously, or extraction will return trailing garbage that looks like data.

Capacity and limits

Capacity depends on the number of available channel bytes and the number of bits replaced in each byte. An image with width W and height H has W times H pixels. With three color channels and one embedded bit per channel, three bits are available per pixel, so the ceiling is W times H times 3 divided by 8 payload bytes.

That figure assumes every channel byte is usable and no overhead is needed for a length field. A real implementation using all bytes should still reserve space for the receiver to know the payload size. Without a declared size or fixed message length, the receiver cannot distinguish the end of a message from the remaining image noise.

Important caveats

• LSB substitution hides a payload; it does not encrypt it. If the payload is sensitive, encryption should be applied before embedding.
• Visual similarity does not imply resistance to steganalysis. Replacing least significant bits alters statistical properties of an image, and detectors can compare expected and observed noise patterns.
• Modified or re-saved images generally destroy the message. Cropping, resizing, JPEG conversion, or any operation that changes pixel values can remove the least significant bits.
• Working with alpha channels introduces a hidden dependency. The embedder and extractor must use exactly the same pixel format, otherwise the bit stream is misaligned.

Evidence gaps and unverified behavior

This guide describes the algorithm and its format constraints from documented behavior, but does not claim independent test results for payload capacity, detection rates, or compression resilience. Any chosen detector or steganalysis tool should be tested against the exact image set and embedding settings before relying on its resistance. Capacity formulas here are theoretical ceilings based on pixel geometry, not measurements from a benchmark.