s np

def text_to_bits(text): """Convert text to a binary string with a null terminator.""" bits = ''.join(format(ord(c), '08b') for c in text) bits += '00000000' # null terminator to mark end of message return bits

def hide_message(image_path, message, output_path): """Hide a message in the LSBs of an image.""" img = Image.open(image_path).convert('RGB') pixels = np.array(img) flat = pixels.flatten()

bits = text_to_bits(message)
if len(bits) > len(flat):
    raise ValueError(f"Message too long: need {len(bits)} bits, have {len(flat)}")

for i, bit in enumerate(bits):
    # Clear the LSB, then set it to our message bit
    flat[i] = (flat[i] & 0xFE) | int(bit)

stego = flat.reshape(pixels.shape)
Image.fromarray(stego.astype('uint8')).save(output_path, 'PNG')
print(f"Hidden {len(message)} chars in {len(bits)} bits ({len(bits)/len(flat)*100:.4f}% of capacity)")

def extract_message(image_path): """Extract a hidden message from the LSBs of an image.""" img = Image.open(image_path).convert('RGB') flat = np.array(img).flatten()

bits = ''.join(str(b & 1) for b in flat)
chars = []
for i in range(0, len(bits), 8):
    byte = bits[i:i+8]
    if byte == '00000000':
        break
    chars.append(chr(int(byte, 2)))
return ''.join(chars)

Usage

hide_message('cat.png', 'The flag is CTF{hidden_in_plain_sight}', 'stego_cat.png') print(extract_message('stego_cat.png'))

**Architecture Decisions:**
- **Bitwise Operation:** `(flat[i] & 0xFE) | int(bit)` clears the LSB via AND masking (`11111110`) and injects the payload bit via OR. This is O(1) per pixel and preserves all higher-order bits.
- **Null Termination:** Appending `00000000` enables deterministic extraction without external length metadata.
- **Capacity Math:** A 1920×1080 RGB image provides 6,220,800 bits (760 KB). Operational safety dictates capping usage at 10–15% (~76–114 KB) to avoid statistical anomalies.
- **Defense-in-Depth Workflow:** Encrypt payload (AES-256) → Randomize pixel indices (password-seeded PRNG) → Embed LSBs → Strip EXIF/IPTC → Distribute carrier → Share decryption key via out-of-band channel.

## Pitfall Guide
1. **Using Lossy Carriers (JPEG/WebP):** Lossy compression applies DCT quantization and chroma subsampling, which irreversibly alters pixel values. LSB payloads are destroyed during the encoding pipeline. Always use PNG, BMP, or TIFF for lossless preservation.
2. **Sequential Pixel Traversal:** Writing bits linearly from coordinate (0,0) creates predictable histogram pair distributions. Steganalysis tools detect this via chi-squared tests. Use a cryptographically secure pseudorandom permutation seeded by a shared password to scatter modifications.
3. **Exceeding 20% Embedding Capacity:** High embedding rates flatten adjacent pixel value pairs, triggering RS analysis and chi-squared anomalies. Maintain ≤15% capacity utilization to keep statistical signatures within natural image variance.
4. **Neglecting Pre-Encryption:** LSB extraction yields plaintext if the payload is unencrypted. Always apply symmetric encryption (AES-256-GCM or ChaCha20-Poly1305) before embedding. Ciphertext indistinguishability ensures extracted bits appear as random noise.
5. **Metadata Leakage:** EXIF, IPTC, and XMP data often contain software fingerprints, timestamps, or GPS coordinates. Strip all metadata before distribution to prevent tool attribution and forensic correlation.
6. **Choosing Low-Texture Carriers:** Smooth gradients, solid colors, or heavily compressed images lack natural high-frequency noise. LSB modifications in these regions create stark statistical deviations. Select high-complexity carriers (forests, crowds, film grain, or cryptographic noise) to mask alterations.

## Deliverables
**📐 Secure LSB Steganography Blueprint**
A reference architecture for production-grade image steganography covering: carrier validation pipeline, AES-256 pre-encryption module, password-seeded pixel permutation engine, LSB embedding/extraction core, metadata sanitization layer, and steganalysis validation checkpoint. Includes capacity calculation formulas and threshold configurations.

**✅ Operational Checklist**
- [ ] Verify carrier format is lossless (PNG/BMP/TIFF)
- [ ] Calculate theoretical capacity and cap at ≤15%
- [ ] Encrypt payload with AES-256-GCM; generate random IV/nonce
- [ ] Seed PRNG with shared password; generate pixel permutation map
- [ ] Execute LSB embedding with null-terminated bitstream
- [ ] Strip all EXIF/IPTC/XMP metadata
- [ ] Run chi-squared and RS analysis validation
- [ ] Distribute carrier publicly; exchange decryption key via out-of-band channel

**⚙️ Configuration Templates**
- `stego_config.yaml`: Capacity thresholds, PRNG algorithm selection, encryption parameters, metadata stripping rules, and validation tolerance levels.
- `bitwise_ops_reference.md`: Quick-reference for `& 0xFE` masking, `| bit` injection, and null-termination handling across Python, C++, and WebAssembly implementations.