Steganography-Based Image File Encryption — Encrypt First, Hide Smart

1. Introduction

The Steganography-Based Image File Encryption project merges modern cryptography with image steganography to secure data by hiding it in plain sight. Messages or files are first encrypted (AES/RSA) and then embedded into cover images via Least Significant Bit (LSB) substitution, keeping the stego-image visually unchanged while making the payload invisible to casual inspection and difficult for attackers to extract.

2. Existing System vs Proposed System

3. Working

1. Input Selection: Choose cover image and secret text/file.
2. Encryption: Encrypt payload via AES-256 symmetric key or RSA public key.
3. Embedding: Insert encrypted bits into image pixels using LSB.
4. Output: Save stego-image visually indistinguishable from the original.
5. Extraction: Recipient extracts bits and decrypts with the correct key.
6. Verification: Check integrity and key validity; log events.

4. Technology Stack

• Language: Python
• Libraries: Pillow (PIL), OpenCV, NumPy, PyCryptodome, Flask/Tkinter, sqlite3
• Encryption: AES-256 (CBC/GCM) or RSA (2048/3072)
• Steganography: LSB substitution (RGB channels)
• Storage: SQLite3 for logs and key references
• Optional: QR for key sharing, checksum/CRC, capacity estimator

5. Modules

6. Advantages

• Double security: encryption + hidden channel.
• Minimal visual distortion using lossless formats.
• Supports text and arbitrary files.
• Great for secure comms, forensics, watermarking.
• Logs and verification for auditability.

7. Applications

• Confidential government/enterprise exchange.
• Secure document sharing & archival.
• Digital watermarking & copyright defense.
• Academic research in crypto & stego.
• Personal privacy for sensitive comms.

Python Integration Sketch (AES/RSA + LSB + Pillow)

# 1) Encrypt payload (text/file)
def encrypt_payload(bytes_in, mode="AES", key=None, rsa_pub=None):
    if mode == "AES":
        iv = os.urandom(16)
        cipher = AES.new(key, AES.MODE_CBC, iv)
        enc = iv + cipher.encrypt(pad(bytes_in, AES.block_size))
        return enc
    else: # RSA
        return PKCS1_OAEP.new(rsa_pub).encrypt(bytes_in)

# 2) LSB embed into cover (PNG/BMP)
def lsb_embed(cover_img_path, secret_bytes, out_path):
    img = Image.open(cover_img_path).convert("RGB")
    pixels = np.array(img)
    bitstream = np.unpackbits(np.frombuffer(secret_bytes, dtype=np.uint8))
    # Ensure capacity (H*W*3 bits)
    assert bitstream.size <= pixels.size, "Cover image too small"
    flat = pixels.flatten()
    flat[:bitstream.size] = (flat[:bitstream.size] & ~1) | bitstream
    Image.fromarray(flat.reshape(pixels.shape)).save(out_path)

# 3) Extract + decrypt
def lsb_extract(stego_path, n_bytes):
    img = Image.open(stego_path).convert("RGB")
    bits = (np.array(img).flatten() & 1)[: n_bytes*8]
    data = np.packbits(bits).tobytes()
    return data

# 4) Decode flow
enc = encrypt_payload(payload, "AES", key=key)
lsb_embed("cover.png", enc, "stego.png")
ex = lsb_extract("stego.png", n_bytes=len(enc))
plain = unpad(AES.new(key, AES.MODE_CBC, iv=ex[:16]).decrypt(ex[16:]), AES.block_size)
              

What You Get