text-image-simple.py

#!/usr/bin/env python3
import sys
import os
import zlib
import hashlib
from struct import pack, unpack

PNG_MAGIC = b"\x89PNG\r\n\x1a\n"
JPEG_SOI = b"\xff\xd8"
JPEG_EOI = b"\xff\xd9"
JPEG_COM = b"\xff\xfe"


class SimpleSteg:
    MAX_CHARS = 500
    MARKER = b'\xDE\xAD\xBE\xEF'

    def __init__(self, password: str):
        self.password = password
        self.salt_size = 16
        self.key_iterations = 100000

    def _derive_key(self, salt: bytes) -> bytes:
        return hashlib.pbkdf2_hmac('sha256', self.password.encode(), salt, self.key_iterations, 32)

    def _encrypt(self, data: bytes) -> tuple[bytes, bytes]:
        salt = os.urandom(self.salt_size)
        key = self._derive_key(salt)
        encrypted = bytes([data[i] ^ key[i % 32] for i in range(len(data))])
        return salt, encrypted

    def _decrypt(self, salt: bytes, encrypted: bytes) -> bytes:
        key = self._derive_key(salt)
        return bytes([encrypted[i] ^ key[i % 32] for i in range(len(encrypted))])

    def _create_payload(self, text: str) -> bytes:
        text_bytes = text.encode('utf-8')
        crc = zlib.crc32(text_bytes) & 0xFFFFFFFF
        salt, encrypted = self._encrypt(text_bytes)
        length = len(text_bytes)
        payload = pack(">I", length) + salt + encrypted + pack(">I", crc)
        return payload

    def _extract_payload(self, data: bytes) -> str | None:
        try:
            if len(data) < 24:
                return None
            length = unpack(">I", data[:4])[0]
            if length > 10000 or length == 0:
                return None
            salt = data[4:20]
            encrypted = data[20:20 + length]
            stored_crc = unpack(">I", data[20 + length:24 + length])[0]
            decrypted = self._decrypt(salt, encrypted)
            if zlib.crc32(decrypted) & 0xFFFFFFFF != stored_crc:
                return None
            return decrypted.decode('utf-8')
        except:
            return None

    def hide(self, text: str, input_path: str, output_path: str) -> bool:
        if len(text) > self.MAX_CHARS:
            print(f"Error: Maximum {self.MAX_CHARS} characters allowed")
            return False

        with open(input_path, 'rb') as f:
            data = f.read()

        if data[:8] == PNG_MAGIC:
            return self._hide_png(text, data, output_path)
        elif data[:2] == JPEG_SOI:
            return self._hide_jpeg(text, data, output_path)
        else:
            print("Error: Unsupported format. Use PNG or JPEG.")
            return False

    def _hide_png(self, text: str, png_data: bytes, output_path: str) -> bool:
        payload = self._create_payload(text)
        trailing_data = self.MARKER + pack(">I", len(payload)) + payload

        chunks = []
        pos = 8
        width, height = 0, 0
        idat_bodies = []

        while pos < len(png_data):
            chunk_len = unpack(">I", png_data[pos:pos + 4])[0]
            chunk_type = png_data[pos + 4:pos + 8]
            chunk_body = png_data[pos + 8:pos + 8 + chunk_len]
            pos += 12 + chunk_len

            if chunk_type == b"IHDR":
                width, height = unpack(">II", chunk_body[:8])
                chunks.append((chunk_type, chunk_body))
            elif chunk_type == b"IDAT":
                idat_bodies.append(chunk_body)
            elif chunk_type == b"IEND":
                combined_idat = b"".join(idat_bodies) + trailing_data
                chunks.append((b"IDAT", combined_idat))
                chunks.append((b"IEND", b""))
                break
            elif chunk_type[0:1].islower():
                continue
            else:
                chunks.append((chunk_type, chunk_body))

        output = PNG_MAGIC
        for chunk_type, chunk_body in chunks:
            length = pack(">I", len(chunk_body))
            crc = pack(">I", zlib.crc32(chunk_type + chunk_body) & 0xFFFFFFFF)
            output += length + chunk_type + chunk_body + crc

        with open(output_path, 'wb') as f:
            f.write(output)

        file_size = os.path.getsize(output_path)
        max_for_xcom = width * height
        print(f"\nPNG DEFLATE Steganography")
        print(f"  Hidden: {len(text)} characters")
        print(f"  File size: {file_size/1024:.1f} KB")
        if file_size < max_for_xcom:
            print(f"  X.com: Compatible (size < {max_for_xcom})")
        else:
            print(f"  X.com: May re-encode (size > width*height)")
        print(f"  Send as: DOCUMENT (WhatsApp/Telegram)")
        return True

    def _hide_jpeg(self, text: str, jpeg_data: bytes, output_path: str) -> bool:
        payload = self._create_payload(text)
        marked_payload = self.MARKER + pack(">I", len(payload)) + payload

        comment_segment = JPEG_COM + pack(">H", len(marked_payload) + 2) + marked_payload

        insert_pos = 2
        while insert_pos < len(jpeg_data) - 1:
            if jpeg_data[insert_pos] == 0xFF and jpeg_data[insert_pos + 1] not in [0x00, 0xD8]:
                break
            insert_pos += 1

        output = jpeg_data[:insert_pos] + comment_segment + jpeg_data[insert_pos:]

        with open(output_path, 'wb') as f:
            f.write(output)

        file_size = os.path.getsize(output_path)
        print(f"\nJPEG Comment Steganography")
        print(f"  Hidden: {len(text)} characters")
        print(f"  File size: {file_size/1024:.1f} KB")
        print(f"  Send as: DOCUMENT (WhatsApp/Telegram)")
        print(f"  Warning: Will NOT survive recompression or photo upload")
        return True

    def reveal(self, input_path: str) -> str | None:
        with open(input_path, 'rb') as f:
            data = f.read()

        if data[:8] == PNG_MAGIC:
            return self._reveal_png(data)
        elif data[:2] == JPEG_SOI:
            return self._reveal_jpeg(data)
        return None

    def _reveal_png(self, png_data: bytes) -> str | None:
        pos = 8
        while pos < len(png_data):
            chunk_len = unpack(">I", png_data[pos:pos + 4])[0]
            chunk_type = png_data[pos + 4:pos + 8]
            chunk_body = png_data[pos + 8:pos + 8 + chunk_len]
            pos += 12 + chunk_len

            if chunk_type == b"IDAT":
                marker_pos = chunk_body.find(self.MARKER)
                if marker_pos != -1:
                    payload_len = unpack(">I", chunk_body[marker_pos + 4:marker_pos + 8])[0]
                    payload = chunk_body[marker_pos + 8:marker_pos + 8 + payload_len]
                    result = self._extract_payload(payload)
                    if result:
                        return result
        return None

    def _reveal_jpeg(self, jpeg_data: bytes) -> str | None:
        pos = 2
        while pos < len(jpeg_data) - 1:
            if jpeg_data[pos] != 0xFF:
                pos += 1
                continue

            marker = jpeg_data[pos:pos + 2]
            if marker == JPEG_EOI:
                break

            if marker == JPEG_COM:
                seg_len = unpack(">H", jpeg_data[pos + 2:pos + 4])[0]
                segment_data = jpeg_data[pos + 4:pos + 2 + seg_len]
                marker_pos = segment_data.find(self.MARKER)
                if marker_pos != -1:
                    payload_len = unpack(">I", segment_data[marker_pos + 4:marker_pos + 8])[0]
                    payload = segment_data[marker_pos + 8:marker_pos + 8 + payload_len]
                    result = self._extract_payload(payload)
                    if result:
                        return result
                pos += 2 + seg_len
            elif jpeg_data[pos + 1] in [0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0x01]:
                pos += 2
            else:
                if pos + 4 <= len(jpeg_data):
                    seg_len = unpack(">H", jpeg_data[pos + 2:pos + 4])[0]
                    pos += 2 + seg_len
                else:
                    break
        return None


def print_usage():
    print("Simple Image Steganography Tool")
    print("================================")
    print()
    print("Hides text in image file structure (no pixel modification).")
    print("Best for sending images as DOCUMENTS via messaging apps.")
    print()
    print("Supported formats:")
    print("  PNG  - Data hidden in DEFLATE stream (IDAT chunk)")
    print("  JPEG - Data hidden in comment marker (COM segment)")
    print()
    print("Usage:")
    print(f"  {sys.argv[0]} hide <text> <password> <input> <output>")
    print(f"  {sys.argv[0]} show <password> <image>")
    print()
    print("Examples:")
    print(f"  {sys.argv[0]} hide \"Secret message\" mypass photo.png stego.png")
    print(f"  {sys.argv[0]} hide \"Secret message\" mypass photo.jpg stego.jpg")
    print(f"  {sys.argv[0]} show mypass stego.png")
    print()
    print("Platform compatibility:")
    print("  X.com (PNG)     - Survives if filesize < width*height")
    print("  WhatsApp        - Send as DOCUMENT only")
    print("  Telegram        - Send as DOCUMENT only")
    print()
    print("Note: Does NOT survive photo uploads or recompression.")
    print("      For photo sharing, use text-image-advance.py with ROBUST method.")


if __name__ == "__main__":
    if len(sys.argv) < 2:
        print_usage()
        sys.exit(0)

    cmd = sys.argv[1].lower()

    if cmd == "hide":
        if len(sys.argv) < 6:
            print("Usage: hide <text> <password> <input> <output>")
            sys.exit(1)

        text = sys.argv[2]
        password = sys.argv[3]
        input_path = sys.argv[4]
        output_path = sys.argv[5]

        steg = SimpleSteg(password)
        if steg.hide(text, input_path, output_path):
            print("\nSuccess!")
        else:
            print("Failed to hide message")
            sys.exit(1)

    elif cmd == "show":
        if len(sys.argv) < 4:
            print("Usage: show <password> <image>")
            sys.exit(1)

        password = sys.argv[2]
        input_path = sys.argv[3]

        steg = SimpleSteg(password)
        result = steg.reveal(input_path)

        if result:
            print(f"Message: {result}")
        else:
            print("No hidden message found or wrong password")
            sys.exit(1)

    else:
        print_usage()