CalvinBackup/STEGOSAURUS-WRECKS
1
0
Fork 0
mirror of https://github.com/elder-plinius/STEGOSAURUS-WRECKS.git synced 2026-04-29 23:57:58 +02:00
Code Issues Packages Projects Releases Wiki Activity
Files
508cbaeb7e54709eeff6891e76f84391f459f05d
STEGOSAURUS-WRECKS/examples/generate_examples.py
T
pliny bcaac7276b Add files via upload
2026-03-29 22:58:02 -07:00

6682 lines
236 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
#!/usr/bin/env python3
"""
Generate pre-encoded steganography example files for ST3GG.
Each file contains a hidden message that the Agent tab's exhaustive mode can find.
"""
import struct
import zlib
import wave
import array
import os
from PIL import Image, PngImagePlugin
OUTPUT_DIR = os.path.dirname(os.path.abspath(__file__))
SECRET_MSG = "STEGOSAURUS WRECKS - Hidden message found! 🦕"
PLINIAN_DIVIDER = "⊰•-•✧•-•-⦑/L\\O/V\\E/\\P/L\\I/N\\Y/⦒-•-•✧•-•⊱"
# =============================================================================
# Utility functions matching ST3GG's STEG v3 format
# =============================================================================
def crc32_steg(data: bytes) -> int:
"""CRC32 matching ST3GG's implementation."""
crc = 0xFFFFFFFF
table = []
for i in range(256):
c = i
for _ in range(8):
c = (0xEDB88320 ^ (c >> 1)) if (c & 1) else (c >> 1)
table.append(c)
for b in data:
crc = table[(crc ^ b) & 0xFF] ^ (crc >> 8)
return (crc ^ 0xFFFFFFFF) & 0xFFFFFFFF
def deflate_compress(data: bytes) -> bytes:
"""Deflate compression matching browser's CompressionStream('deflate')."""
# Browser 'deflate' uses raw deflate wrapped with zlib header (wbits=15)
# Actually, CompressionStream('deflate') uses RFC 1950 (zlib format)
return zlib.compress(data)
def create_steg_header(payload_len: int, original_len: int, crc: int,
channel_mask: int, bits_per_channel: int,
compressed: bool = True) -> bytes:
"""Create a 32-byte STEG v3 header."""
header = bytearray(32)
# Magic: STEG
header[0:4] = b'STEG'
# Version
header[4] = 3
# Channel mask
header[5] = channel_mask
# Bits per channel
header[6] = bits_per_channel
# Bit offset
header[7] = 0
# Flags: compressed (bit 0) | interleaved (bit 1)
header[8] = (1 if compressed else 0) | 2
# Bytes 9-15: reserved (zeros)
# Payload length (big endian)
struct.pack_into('>I', header, 16, payload_len)
# Original length (big endian)
struct.pack_into('>I', header, 20, original_len)
# CRC32 (big endian)
struct.pack_into('>I', header, 24, crc)
return bytes(header)
def bytes_to_bits(data: bytes, bits_per_unit: int = 1) -> list:
"""Convert bytes to bit units, matching ST3GG's bytesToBits."""
bits = []
for byte in data:
for j in range(7, -1, -1):
bits.append((byte >> j) & 1)
if bits_per_unit == 1:
return bits
result = []
for i in range(0, len(bits), bits_per_unit):
value = 0
for j in range(bits_per_unit):
if i + j < len(bits):
value = (value << 1) | bits[i + j]
result.append(value)
return result
# =============================================================================
# 1. PNG with LSB RGB 1-bit (STEG v3 header)
# =============================================================================
def generate_lsb_png():
"""Create a 200x200 PNG with a hidden message in LSB RGB 1-bit."""
print(" Generating LSB RGB 1-bit PNG...")
width, height = 200, 200
img = Image.new('RGBA', (width, height))
# Create a nice gradient background
pixels = img.load()
for y in range(height):
for x in range(width):
r = int(100 + 80 * (x / width))
g = int(60 + 120 * (y / height))
b = int(140 + 60 * ((x + y) / (width + height)))
pixels[x, y] = (r, g, b, 255)
# Encode message using STEG v3 format
msg_bytes = SECRET_MSG.encode('utf-8')
crc = crc32_steg(msg_bytes)
payload = deflate_compress(msg_bytes)
# RGB channels = mask 0b0111 = 7, 1 bit per channel
header = create_steg_header(len(payload), len(msg_bytes), crc,
channel_mask=7, bits_per_channel=1)
full_data = header + payload
bit_units = bytes_to_bits(full_data, 1)
# Embed in LSB of RGB channels (interleaved)
channels = [0, 1, 2] # R, G, B
unit_idx = 0
for pix_idx in range(width * height):
if unit_idx >= len(bit_units):
break
x = pix_idx % width
y = pix_idx // width
r, g, b, a = pixels[x, y]
vals = [r, g, b, a]
for ch in channels:
if unit_idx >= len(bit_units):
break
vals[ch] = (vals[ch] & 0xFE) | bit_units[unit_idx]
unit_idx += 1
pixels[x, y] = tuple(vals)
path = os.path.join(OUTPUT_DIR, 'example_lsb_rgb.png')
img.save(path)
print(f" -> {path} ({unit_idx} bits embedded)")
return path
# =============================================================================
# 2. PNG with tEXt chunk
# =============================================================================
def generate_text_chunk_png():
"""Create a PNG with a hidden message in a tEXt metadata chunk."""
print(" Generating PNG with tEXt chunk...")
width, height = 150, 150
img = Image.new('RGB', (width, height))
pixels = img.load()
# Simple blue-ish pattern
for y in range(height):
for x in range(width):
r = int(40 + 30 * (x / width))
g = int(50 + 40 * (y / height))
b = int(150 + 80 * ((x + y) / (width + height)))
pixels[x, y] = (r, g, b)
# Add tEXt chunks with hidden data
info = PngImagePlugin.PngInfo()
info.add_text("Comment", "Just a normal image, nothing to see here...")
info.add_text("Secret", SECRET_MSG)
info.add_text("Author", "STEGOSAURUS WRECKS")
info.add_text("Flag", "CTF{hidden_in_plain_sight}")
path = os.path.join(OUTPUT_DIR, 'example_png_chunks.png')
img.save(path, pnginfo=info)
print(f" -> {path}")
return path
# =============================================================================
# 3. PNG with trailing data after IEND
# =============================================================================
def generate_trailing_data_png():
"""Create a PNG with hidden data appended after the IEND chunk."""
print(" Generating PNG with trailing data...")
width, height = 120, 120
img = Image.new('RGB', (width, height))
pixels = img.load()
# Green-ish pattern
for y in range(height):
for x in range(width):
r = int(30 + 50 * (x / width))
g = int(120 + 100 * (y / height))
b = int(40 + 40 * ((x * y) / (width * height)))
pixels[x, y] = (r, g, b)
path = os.path.join(OUTPUT_DIR, 'example_trailing_data.png')
img.save(path)
# Append hidden data after IEND
trailing = b'\n--- HIDDEN DATA BELOW ---\n'
trailing += SECRET_MSG.encode('utf-8')
trailing += b'\nCTF{data_after_iend_chunk}\n'
trailing += b'This data is invisible to normal image viewers!\n'
with open(path, 'ab') as f:
f.write(trailing)
print(f" -> {path} ({len(trailing)} bytes appended)")
return path
# =============================================================================
# 4. Text with zero-width Unicode steganography
# =============================================================================
def generate_zero_width_text():
"""Create a text file with a message hidden in zero-width Unicode chars."""
print(" Generating zero-width Unicode text...")
ZWSP = '\u200B' # Zero-width space = 0
ZWNJ = '\u200C' # Zero-width non-joiner = 1
ZWJ = '\u200D' # Zero-width joiner = delimiter
secret = "Agent found the zero-width secret!"
secret_bytes = secret.encode('utf-8')
# Convert to binary string
binary_str = ''.join(format(b, '08b') for b in secret_bytes)
# Build zero-width string
zw_string = ZWJ # Start delimiter
for bit in binary_str:
zw_string += ZWSP if bit == '0' else ZWNJ
zw_string += ZWJ # End delimiter
cover = """The Stegosaurus was a large, herbivorous dinosaur that lived during the Late Jurassic period,
approximately 155 to 150 million years ago. It is best known for its distinctive row of large,
bony plates along its back and the sharp spikes on its tail, known as the thagomizer.
Despite its massive size, the Stegosaurus had a remarkably small brain, roughly the size of a
walnut. This has led to much speculation about how such a large animal could function with such
limited cognitive capacity.
The name "Stegosaurus" means "roof lizard" or "covered lizard," referring to the plates on its
back, which were once thought to lie flat like roof tiles. Modern research suggests these plates
were used for thermoregulation and display rather than defense."""
# Insert after first character
stego_text = cover[0] + zw_string + cover[1:]
path = os.path.join(OUTPUT_DIR, 'example_zero_width.txt')
with open(path, 'w', encoding='utf-8') as f:
f.write(stego_text)
print(f" -> {path} ({len(binary_str)} bits hidden)")
return path
# =============================================================================
# 5. Text with whitespace encoding
# =============================================================================
def generate_whitespace_text():
"""Create a text file with a message hidden in trailing whitespace."""
print(" Generating whitespace-encoded text...")
secret = "Whitespace hides secrets!"
secret_bytes = secret.encode('utf-8')
# Length prefix (16 bits) + data bits
length_bits = format(len(secret_bytes), '016b')
data_bits = ''.join(format(b, '08b') for b in secret_bytes)
all_bits = length_bits + data_bits
cover_lines = [
"How to Identify Steganography",
"==============================",
"",
"Steganography is the practice of hiding secret information within",
"ordinary, non-secret data or physical objects. Unlike cryptography,",
"which makes data unreadable, steganography conceals the very",
"existence of the secret message.",
"",
"Common techniques include:",
"- Least Significant Bit (LSB) embedding in images",
"- Hiding data in audio frequency spectrums",
"- Using invisible Unicode characters in text",
"- Appending data after file end markers",
"- Encoding in metadata fields",
"",
"Detection methods include statistical analysis, visual inspection",
"of bit planes, frequency domain analysis, and file structure",
"examination. Tools like ST3GG can automate this process.",
"",
"The word steganography comes from the Greek words 'steganos'",
"(meaning covered or hidden) and 'graphein' (meaning to write).",
"",
"In the digital age, steganography has found applications in",
"digital watermarking, covert communication, and CTF challenges.",
"",
"Always remember: just because you can't see it doesn't mean",
"it's not there. Hidden in plain sight is the ultimate disguise.",
"",
"End of document.",
]
bit_index = 0
result_lines = []
for line in cover_lines:
trailing = ''
for _ in range(8):
if bit_index < len(all_bits):
trailing += ' ' if all_bits[bit_index] == '0' else '\t'
bit_index += 1
result_lines.append(line + trailing)
path = os.path.join(OUTPUT_DIR, 'example_whitespace.txt')
with open(path, 'w', encoding='utf-8') as f:
f.write('\n'.join(result_lines))
print(f" -> {path} ({bit_index} bits hidden in trailing whitespace)")
return path
# =============================================================================
# 6. Text with invisible ink (Unicode tag characters)
# =============================================================================
def generate_invisible_ink_text():
"""Create a text file with a message hidden using Unicode tag characters."""
print(" Generating invisible ink (Unicode tags) text...")
TAG_BASE = 0xE0000
secret = "Invisible ink message decoded!"
# Build tag string
tag_string = chr(TAG_BASE) # Start tag
for char in secret:
code = ord(char)
if code < 128:
tag_string += chr(TAG_BASE + code)
tag_string += chr(TAG_BASE) # End tag
cover = """Dinosaur Facts: The Stegosaurus
The Stegosaurus is one of the most recognizable dinosaurs thanks to its
distinctive double row of kite-shaped plates rising vertically along its
arched back and the two pairs of long spikes extending from its tail.
Size: Up to 9 meters (30 feet) long and 4 meters (14 feet) tall
Weight: Approximately 5,000 kg (11,000 lbs)
Diet: Herbivore (ferns, cycads, and conifers)
Period: Late Jurassic (155-150 million years ago)
Location: Western North America, Portugal"""
# Insert tag string after first character
stego_text = cover[0] + tag_string + cover[1:]
path = os.path.join(OUTPUT_DIR, 'example_invisible_ink.txt')
with open(path, 'w', encoding='utf-8') as f:
f.write(stego_text)
print(f" -> {path}")
return path
# =============================================================================
# 7. WAV with Audio LSB steganography
# =============================================================================
def generate_audio_lsb_wav():
"""Create a WAV file with a message hidden in audio sample LSBs."""
print(" Generating WAV with audio LSB...")
sample_rate = 44100
duration = 2 # seconds
num_samples = sample_rate * duration
# Generate a simple sine wave tone (440 Hz)
import math
frequency = 440.0
samples = []
for i in range(num_samples):
t = i / sample_rate
# Mix two frequencies for a richer sound
value = 0.5 * math.sin(2 * math.pi * frequency * t)
value += 0.3 * math.sin(2 * math.pi * (frequency * 1.5) * t)
# Convert to 16-bit integer
sample = int(value * 16000)
sample = max(-32768, min(32767, sample))
samples.append(sample)
# Embed message in LSB of samples
msg = SECRET_MSG.encode('utf-8')
# Simple format: 4-byte length prefix + message bytes
length_bytes = struct.pack('>I', len(msg))
payload = length_bytes + msg
# Convert payload to bits
bits = []
for byte in payload:
for j in range(7, -1, -1):
bits.append((byte >> j) & 1)
# Embed bits in LSB of samples (handling signed 16-bit properly)
for i, bit in enumerate(bits):
if i < len(samples):
s = samples[i]
# Convert to unsigned, set LSB, convert back to signed
u = s & 0xFFFF # unsigned view
u = (u & 0xFFFE) | bit
# Convert back to signed
samples[i] = u if u < 32768 else u - 65536
path = os.path.join(OUTPUT_DIR, 'example_audio_lsb.wav')
with wave.open(path, 'w') as wav:
wav.setnchannels(1)
wav.setsampwidth(2) # 16-bit
wav.setframerate(sample_rate)
# Pack samples as signed 16-bit little-endian
data = struct.pack(f'<{len(samples)}h', *samples)
wav.writeframes(data)
print(f" -> {path} ({len(bits)} bits embedded in {num_samples} samples)")
return path
# =============================================================================
# 8. PNG with EXIF-like metadata (hidden in Description)
# =============================================================================
def generate_exif_png():
"""Create a PNG with suspicious metadata fields."""
print(" Generating PNG with metadata...")
width, height = 100, 100
img = Image.new('RGB', (width, height))
pixels = img.load()
# Red-orange pattern
for y in range(height):
for x in range(width):
r = int(180 + 60 * (x / width))
g = int(80 + 60 * (y / height))
b = int(20 + 30 * ((x + y) / (width + height)))
pixels[x, y] = (r, g, b)
info = PngImagePlugin.PngInfo()
info.add_text("Description", "Base64 encoded secret: " +
__import__('base64').b64encode(SECRET_MSG.encode()).decode())
info.add_text("Software", "STEGOSAURUS WRECKS v3.0")
info.add_text("Warning", "Look closer at the other example files too!")
# Add a hex-encoded hidden message
info.add_text("HexData", SECRET_MSG.encode('utf-8').hex())
path = os.path.join(OUTPUT_DIR, 'example_metadata.png')
img.save(path, pnginfo=info)
print(f" -> {path}")
return path
# =============================================================================
# 9. BMP with LSB steganography
# =============================================================================
def generate_lsb_bmp():
"""Create a BMP file with the Plinian divider hidden in LSB of pixels."""
print(" Generating BMP with LSB steganography...")
width, height = 160, 160
img = Image.new('RGB', (width, height))
pixels = img.load()
# Purple gradient background
for y in range(height):
for x in range(width):
r = int(120 + 80 * (x / width))
g = int(40 + 60 * (y / height))
b = int(160 + 80 * ((x + y) / (width + height)))
pixels[x, y] = (r, g, b)
# Encode Plinian divider in LSB
msg_bytes = PLINIAN_DIVIDER.encode('utf-8')
length_bytes = struct.pack('>I', len(msg_bytes))
payload = length_bytes + msg_bytes
bits = []
for byte in payload:
for j in range(7, -1, -1):
bits.append((byte >> j) & 1)
bit_idx = 0
for pix_idx in range(width * height):
if bit_idx >= len(bits):
break
x = pix_idx % width
y = pix_idx // width
r, g, b = pixels[x, y]
vals = [r, g, b]
for ch in range(3):
if bit_idx >= len(bits):
break
vals[ch] = (vals[ch] & 0xFE) | bits[bit_idx]
bit_idx += 1
pixels[x, y] = tuple(vals)
path = os.path.join(OUTPUT_DIR, 'example_lsb.bmp')
img.save(path, 'BMP')
print(f" -> {path} ({bit_idx} bits embedded)")
return path
# =============================================================================
# 10. GIF with comment extension
# =============================================================================
def generate_gif_comment():
"""Create a GIF with the Plinian divider hidden in a comment extension block."""
print(" Generating GIF with comment extension...")
width, height = 100, 100
img = Image.new('P', (width, height))
pixels = img.load()
# Simple gradient pattern
for y in range(height):
for x in range(width):
pixels[x, y] = int((x + y) * 127 / (width + height))
path = os.path.join(OUTPUT_DIR, 'example_comment.gif')
img.save(path, 'GIF')
# GIF comment extension: inject after GIF header
with open(path, 'rb') as f:
data = f.read()
# Build comment extension block
comment = PLINIAN_DIVIDER.encode('utf-8')
comment_ext = b'\x21\xFE' # Comment extension introducer
# Split into sub-blocks of max 255 bytes
i = 0
while i < len(comment):
chunk = comment[i:i + 255]
comment_ext += bytes([len(chunk)]) + chunk
i += 255
comment_ext += b'\x00' # Block terminator
# Insert comment extension after GIF header (before image data)
# GIF header is 6 bytes + logical screen descriptor (7 bytes) + global color table
# Find the image descriptor (0x2C) or extension block
insert_pos = 13 # After header + LSD
if data[10] & 0x80: # Global color table flag
gct_size = 3 * (2 ** ((data[10] & 0x07) + 1))
insert_pos += gct_size
new_data = data[:insert_pos] + comment_ext + data[insert_pos:]
with open(path, 'wb') as f:
f.write(new_data)
print(f" -> {path} (comment extension: {len(comment)} bytes)")
return path
# =============================================================================
# 11. GIF with LSB in palette indices
# =============================================================================
def generate_gif_lsb():
"""Create a GIF with the Plinian divider in LSB of palette indices.
Note: We write the GIF manually (binary) because Pillow's GIF encoder
requantizes the palette, which destroys LSB data. We use uncompressed
LZW (max code size) to preserve exact index values.
"""
print(" Generating GIF with palette index LSB...")
width, height = 120, 120
# Create a palette with maximally distinct colors (pairs differ in R LSB)
palette = bytearray(256 * 3)
for i in range(256):
palette[i * 3] = (i * 37 + 80) & 0xFE # R: spread out, always even base
palette[i * 3 + 1] = (i * 13 + 60) & 0xFF # G
palette[i * 3 + 2] = (i * 7 + 120) & 0xFF # B
# Ensure pairs (2i, 2i+1) differ only in R LSB
if i % 2 == 1:
palette[i * 3] = palette[(i - 1) * 3] | 1
palette[i * 3 + 1] = palette[(i - 1) * 3 + 1]
palette[i * 3 + 2] = palette[(i - 1) * 3 + 2]
# Build pixel index data
pixel_indices = bytearray()
for y in range(height):
for x in range(width):
# Use even palette indices so we can flip LSB
pixel_indices.append(int((x + y) * 127 / (width + height)) * 2 % 256)
# Encode Plinian divider in LSB of palette indices
msg_bytes = PLINIAN_DIVIDER.encode('utf-8')
length_bytes = struct.pack('>I', len(msg_bytes))
payload = length_bytes + msg_bytes
bits = []
for byte in payload:
for j in range(7, -1, -1):
bits.append((byte >> j) & 1)
bit_idx = 0
for i in range(len(pixel_indices)):
if bit_idx >= len(bits):
break
pixel_indices[i] = (pixel_indices[i] & 0xFE) | bits[bit_idx]
bit_idx += 1
# Write GIF manually to preserve exact palette indices
path = os.path.join(OUTPUT_DIR, 'example_lsb.gif')
with open(path, 'wb') as f:
# GIF89a header
f.write(b'GIF89a')
# Logical Screen Descriptor
f.write(struct.pack('<HH', width, height))
f.write(bytes([0xF7, 0x00, 0x00])) # GCT flag, 256 colors, no sort, bg=0, aspect=0
# Global Color Table (256 entries)
f.write(bytes(palette))
# Image Descriptor
f.write(b'\x2C') # Image separator
f.write(struct.pack('<HHHH', 0, 0, width, height))
f.write(bytes([0x00])) # No local color table, not interlaced
# LZW-compress the pixel data
# Min code size = 8 (for 256 colors)
min_code_size = 8
f.write(bytes([min_code_size]))
# Use simple LZW: emit clear code, then each pixel as a literal, then EOI
clear_code = 1 << min_code_size # 256
eoi_code = clear_code + 1 # 257
# Bit packer
bit_buffer = 0
bit_count = 0
output = bytearray()
code_size = min_code_size + 1 # Start at 9 bits
def emit_code(code):
nonlocal bit_buffer, bit_count
bit_buffer |= (code << bit_count)
bit_count += code_size
while bit_count >= 8:
output.append(bit_buffer & 0xFF)
bit_buffer >>= 8
bit_count -= 8
# Emit clear code first
emit_code(clear_code)
# Emit each pixel as a literal code (0-255)
# To keep code_size at 9, emit clear codes periodically to reset the table
count = 0
for idx in pixel_indices:
emit_code(idx)
count += 1
if count >= 250: # Reset before table grows too much
emit_code(clear_code)
code_size = min_code_size + 1
count = 0
# Emit EOI
emit_code(eoi_code)
# Flush remaining bits
if bit_count > 0:
output.append(bit_buffer & 0xFF)
# Write as sub-blocks (max 255 bytes each)
i = 0
while i < len(output):
chunk = output[i:i + 255]
f.write(bytes([len(chunk)]))
f.write(chunk)
i += 255
f.write(b'\x00') # Block terminator
# Trailer
f.write(b'\x3B')
print(f" -> {path} ({bit_idx} bits embedded)")
return path
# =============================================================================
# 12. TIFF with metadata steganography
# =============================================================================
def generate_tiff_metadata():
"""Create a TIFF with the Plinian divider hidden in EXIF/metadata fields."""
print(" Generating TIFF with metadata steganography...")
width, height = 100, 100
img = Image.new('RGB', (width, height))
pixels = img.load()
# Warm gradient
for y in range(height):
for x in range(width):
r = int(200 + 40 * (x / width))
g = int(140 + 60 * (y / height))
b = int(60 + 40 * ((x + y) / (width + height)))
pixels[x, y] = (r, g, b)
import base64
path = os.path.join(OUTPUT_DIR, 'example_metadata.tiff')
# Save TIFF with metadata tags
img.save(path, 'TIFF', compression='raw',
software='ST3GG STEGOSAURUS WRECKS',
description=base64.b64encode(PLINIAN_DIVIDER.encode('utf-8')).decode())
print(f" -> {path}")
return path
# =============================================================================
# 13. TIFF with LSB steganography
# =============================================================================
def generate_tiff_lsb():
"""Create a TIFF with the Plinian divider hidden in LSB of pixels."""
print(" Generating TIFF with LSB steganography...")
width, height = 140, 140
img = Image.new('RGB', (width, height))
pixels = img.load()
# Teal gradient
for y in range(height):
for x in range(width):
r = int(30 + 60 * (x / width))
g = int(140 + 80 * (y / height))
b = int(130 + 80 * ((x + y) / (width + height)))
pixels[x, y] = (r, g, b)
# Encode Plinian divider in LSB
msg_bytes = PLINIAN_DIVIDER.encode('utf-8')
length_bytes = struct.pack('>I', len(msg_bytes))
payload = length_bytes + msg_bytes
bits = []
for byte in payload:
for j in range(7, -1, -1):
bits.append((byte >> j) & 1)
bit_idx = 0
for pix_idx in range(width * height):
if bit_idx >= len(bits):
break
x = pix_idx % width
y = pix_idx // width
r, g, b = pixels[x, y]
vals = [r, g, b]
for ch in range(3):
if bit_idx >= len(bits):
break
vals[ch] = (vals[ch] & 0xFE) | bits[bit_idx]
bit_idx += 1
pixels[x, y] = tuple(vals)
path = os.path.join(OUTPUT_DIR, 'example_lsb.tiff')
img.save(path, 'TIFF', compression='raw')
print(f" -> {path} ({bit_idx} bits embedded)")
return path
# =============================================================================
# 14. PPM with LSB steganography
# =============================================================================
def generate_ppm_lsb():
"""Create a PPM (Portable Pixmap) with the Plinian divider in LSB."""
print(" Generating PPM with LSB steganography...")
width, height = 120, 120
# Build pixel data
pixel_data = bytearray()
for y in range(height):
for x in range(width):
r = int(100 + 90 * (x / width))
g = int(80 + 100 * (y / height))
b = int(60 + 120 * ((x + y) / (width + height)))
pixel_data.extend([r, g, b])
# Encode Plinian divider in LSB
msg_bytes = PLINIAN_DIVIDER.encode('utf-8')
length_bytes = struct.pack('>I', len(msg_bytes))
payload = length_bytes + msg_bytes
bits = []
for byte in payload:
for j in range(7, -1, -1):
bits.append((byte >> j) & 1)
for i, bit in enumerate(bits):
if i < len(pixel_data):
pixel_data[i] = (pixel_data[i] & 0xFE) | bit
path = os.path.join(OUTPUT_DIR, 'example_lsb.ppm')
with open(path, 'wb') as f:
f.write(f'P6\n{width} {height}\n255\n'.encode('ascii'))
f.write(bytes(pixel_data))
print(f" -> {path} ({len(bits)} bits embedded)")
return path
# =============================================================================
# 15. PGM with LSB steganography
# =============================================================================
def generate_pgm_lsb():
"""Create a PGM (Portable Graymap) with the Plinian divider in LSB."""
print(" Generating PGM with LSB steganography...")
width, height = 150, 150
# Build grayscale pixel data
pixel_data = bytearray()
for y in range(height):
for x in range(width):
val = int(60 + 160 * ((x * y) / (width * height)))
pixel_data.append(val)
# Encode Plinian divider in LSB
msg_bytes = PLINIAN_DIVIDER.encode('utf-8')
length_bytes = struct.pack('>I', len(msg_bytes))
payload = length_bytes + msg_bytes
bits = []
for byte in payload:
for j in range(7, -1, -1):
bits.append((byte >> j) & 1)
for i, bit in enumerate(bits):
if i < len(pixel_data):
pixel_data[i] = (pixel_data[i] & 0xFE) | bit
path = os.path.join(OUTPUT_DIR, 'example_lsb.pgm')
with open(path, 'wb') as f:
f.write(f'P5\n{width} {height}\n255\n'.encode('ascii'))
f.write(bytes(pixel_data))
print(f" -> {path} ({len(bits)} bits embedded)")
return path
# =============================================================================
# 16. SVG with hidden data in XML
# =============================================================================
def generate_svg_hidden():
"""Create an SVG with the Plinian divider hidden in XML comments and attributes."""
print(" Generating SVG with hidden XML data...")
import base64
encoded = base64.b64encode(PLINIAN_DIVIDER.encode('utf-8')).decode()
hex_encoded = PLINIAN_DIVIDER.encode('utf-8').hex()
svg = f'''<?xml version="1.0" encoding="UTF-8"?>
<!-- {PLINIAN_DIVIDER} -->
<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200"
data-steg="{encoded}"
data-desc="Nothing suspicious here">
<!-- Hidden in plain sight: steganography demonstration file -->
<defs>
<linearGradient id="bg" x1="0%" y1="0%" x2="100%" y2="100%">
<stop offset="0%" style="stop-color:#4a0e8f;stop-opacity:1" />
<stop offset="100%" style="stop-color:#c471ed;stop-opacity:1" />
</linearGradient>
<linearGradient id="fg" x1="0%" y1="100%" x2="100%" y2="0%">
<stop offset="0%" style="stop-color:#12c2e9;stop-opacity:0.8" />
<stop offset="100%" style="stop-color:#f64f59;stop-opacity:0.8" />
</linearGradient>
</defs>
<rect width="200" height="200" fill="url(#bg)"/>
<circle cx="100" cy="80" r="50" fill="url(#fg)" opacity="0.7"/>
<polygon points="60,140 100,90 140,140" fill="#f5af19" opacity="0.6"/>
<text x="100" y="175" font-family="monospace" font-size="11"
fill="white" text-anchor="middle" opacity="0.8">ST3GG Example</text>
<!-- hex:{hex_encoded} -->
<metadata>
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:dc="http://purl.org/dc/elements/1.1/">
<rdf:Description>
<dc:description>{PLINIAN_DIVIDER}</dc:description>
<dc:creator>STEGOSAURUS WRECKS</dc:creator>
</rdf:Description>
</rdf:RDF>
</metadata>
</svg>'''
path = os.path.join(OUTPUT_DIR, 'example_hidden.svg')
with open(path, 'w', encoding='utf-8') as f:
f.write(svg)
print(f" -> {path}")
return path
# =============================================================================
# 17. ICO with LSB steganography
# =============================================================================
def generate_ico_lsb():
"""Create an ICO (icon) file with the Plinian divider in LSB of pixels."""
print(" Generating ICO with LSB steganography...")
size = 32
img = Image.new('RGBA', (size, size))
pixels = img.load()
# Icon-like gradient
for y in range(size):
for x in range(size):
r = int(60 + 160 * (x / size))
g = int(100 + 100 * (y / size))
b = int(180 + 60 * ((x + y) / (2 * size)))
# Circular alpha mask
cx, cy = size / 2, size / 2
dist = ((x - cx) ** 2 + (y - cy) ** 2) ** 0.5
a = 255 if dist < size / 2 - 1 else 0
pixels[x, y] = (r, g, b, a)
# Encode Plinian divider in LSB of RGB
msg_bytes = PLINIAN_DIVIDER.encode('utf-8')
length_bytes = struct.pack('>H', len(msg_bytes)) # 16-bit length for small icon
payload = length_bytes + msg_bytes
bits = []
for byte in payload:
for j in range(7, -1, -1):
bits.append((byte >> j) & 1)
bit_idx = 0
for pix_idx in range(size * size):
if bit_idx >= len(bits):
break
x = pix_idx % size
y = pix_idx // size
r, g, b, a = pixels[x, y]
vals = [r, g, b]
for ch in range(3):
if bit_idx >= len(bits):
break
vals[ch] = (vals[ch] & 0xFE) | bits[bit_idx]
bit_idx += 1
pixels[x, y] = (vals[0], vals[1], vals[2], a)
path = os.path.join(OUTPUT_DIR, 'example_lsb.ico')
img.save(path, format='ICO', sizes=[(32, 32)])
print(f" -> {path} ({bit_idx} bits embedded)")
return path
# =============================================================================
# 18. WebP with metadata steganography
# =============================================================================
def generate_webp_metadata():
"""Create a WebP with the Plinian divider hidden in EXIF and XMP metadata.
Note: EXIF tags use ASCII encoding which corrupts non-ASCII Unicode chars.
We store: base64-encoded divider in EXIF ImageDescription, raw divider in XMP.
"""
print(" Generating WebP with metadata steganography...")
import base64
width, height = 120, 120
img = Image.new('RGB', (width, height))
pixels = img.load()
# Coral gradient
for y in range(height):
for x in range(width):
r = int(220 + 30 * (x / width))
g = int(80 + 70 * (y / height))
b = int(60 + 80 * ((x + y) / (width + height)))
pixels[x, y] = (r, g, b)
secret_bytes = PLINIAN_DIVIDER.encode('utf-8')
encoded_b64 = base64.b64encode(secret_bytes).decode()
# EXIF: use base64 for ImageDescription (ASCII-safe)
exif_data = img.getexif()
exif_data[270] = f"b64:{encoded_b64}" # ImageDescription (base64-safe)
exif_data[305] = "STEGOSAURUS WRECKS v3.0" # Software
exif_data[315] = f"hex:{secret_bytes.hex()}" # Artist (hex-safe)
path = os.path.join(OUTPUT_DIR, 'example_metadata.webp')
img.save(path, 'WebP', exif=exif_data.tobytes())
# Also inject XMP with full UTF-8 support by appending to the file
# WebP files support XMP chunks - we'll append one after the EXIF
xmp = (f'<?xpacket begin="\xef\xbb\xbf"?>'
f'<x:xmpmeta xmlns:x="adobe:ns:meta/">'
f'<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"'
f' xmlns:dc="http://purl.org/dc/elements/1.1/">'
f'<rdf:Description>'
f'<dc:description>{PLINIAN_DIVIDER}</dc:description>'
f'<dc:subject>{encoded_b64}</dc:subject>'
f'</rdf:Description>'
f'</rdf:RDF>'
f'</x:xmpmeta>'
f'<?xpacket end="w"?>').encode('utf-8')
# Inject XMP chunk into RIFF/WebP container
with open(path, 'rb') as f:
data = f.read()
# WebP RIFF structure: RIFF + size + WEBP + chunks
# Add an XMP chunk (FourCC: "XMP ")
xmp_chunk = b'XMP ' + struct.pack('<I', len(xmp)) + xmp
if len(xmp) % 2:
xmp_chunk += b'\x00' # Pad to even
# Insert before the end of RIFF
new_riff_size = struct.unpack('<I', data[4:8])[0] + len(xmp_chunk)
data = data[:4] + struct.pack('<I', new_riff_size) + data[8:] + xmp_chunk
with open(path, 'wb') as f:
f.write(data)
print(f" -> {path}")
return path
# =============================================================================
# 19. WebP with LSB steganography
# =============================================================================
def generate_webp_lsb():
"""Create a lossless WebP with the Plinian divider in LSB of pixels."""
print(" Generating WebP with LSB steganography...")
width, height = 130, 130
img = Image.new('RGB', (width, height))
pixels = img.load()
# Ocean gradient
for y in range(height):
for x in range(width):
r = int(20 + 50 * (x / width))
g = int(80 + 80 * (y / height))
b = int(150 + 90 * ((x + y) / (width + height)))
pixels[x, y] = (r, g, b)
# Encode Plinian divider in LSB
msg_bytes = PLINIAN_DIVIDER.encode('utf-8')
length_bytes = struct.pack('>I', len(msg_bytes))
payload = length_bytes + msg_bytes
bits = []
for byte in payload:
for j in range(7, -1, -1):
bits.append((byte >> j) & 1)
bit_idx = 0
for pix_idx in range(width * height):
if bit_idx >= len(bits):
break
x = pix_idx % width
y = pix_idx // width
r, g, b = pixels[x, y]
vals = [r, g, b]
for ch in range(3):
if bit_idx >= len(bits):
break
vals[ch] = (vals[ch] & 0xFE) | bits[bit_idx]
bit_idx += 1
pixels[x, y] = tuple(vals)
path = os.path.join(OUTPUT_DIR, 'example_lsb.webp')
img.save(path, 'WebP', lossless=True)
print(f" -> {path} ({bit_idx} bits embedded)")
return path
# =============================================================================
# 20. HTML with hidden content
# =============================================================================
def generate_html_hidden():
"""Create an HTML file with the Plinian divider hidden in multiple ways."""
print(" Generating HTML with hidden content...")
import base64
encoded = base64.b64encode(PLINIAN_DIVIDER.encode('utf-8')).decode()
hex_encoded = PLINIAN_DIVIDER.encode('utf-8').hex()
# Zero-width encoding of the divider
ZWSP = '\u200B'
ZWNJ = '\u200C'
ZWJ = '\u200D'
secret_bytes = PLINIAN_DIVIDER.encode('utf-8')
binary_str = ''.join(format(b, '08b') for b in secret_bytes)
zw_string = ZWJ
for bit in binary_str:
zw_string += ZWSP if bit == '0' else ZWNJ
zw_string += ZWJ
html = f'''<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="description" content="{encoded}">
<meta name="generator" content="STEGOSAURUS WRECKS">
<title>Steganography Demo</title>
<style>
body {{ font-family: 'Segoe UI', sans-serif; background: #1a1a2e; color: #e0e0e0;
max-width: 700px; margin: 40px auto; padding: 20px; }}
h1 {{ color: #c471ed; }}
.cover {{ line-height: 1.8; }}
/* data-payload: {hex_encoded} */
.hidden {{ display: none; }}
</style>
</head>
<!-- {PLINIAN_DIVIDER} -->
<body>
<h1>Stegosaurus Facts</h1>
<div class="cover">
<p>{zw_string}The Stegosaurus was one of the most distinctive dinosaurs of the Late
Jurassic period. Its double row of bony plates and spiked tail made it
instantly recognizable among prehistoric creatures.</p>
<p>Despite weighing up to 5 metric tons, the Stegosaurus had a brain
roughly the size of a walnut, making it one of the least intelligent
dinosaurs relative to its body size.</p>
</div>
<div class="hidden" data-secret="{PLINIAN_DIVIDER}" id="steg-payload">
{encoded}
</div>
<noscript><!-- hex:{hex_encoded} --></noscript>
</body>
</html>'''
path = os.path.join(OUTPUT_DIR, 'example_hidden.html')
with open(path, 'w', encoding='utf-8') as f:
f.write(html)
print(f" -> {path}")
return path
# =============================================================================
# 21. XML with hidden data
# =============================================================================
def generate_xml_hidden():
"""Create an XML file with the Plinian divider in comments, PIs, and CDATA."""
print(" Generating XML with hidden data...")
import base64
encoded = base64.b64encode(PLINIAN_DIVIDER.encode('utf-8')).decode()
hex_encoded = PLINIAN_DIVIDER.encode('utf-8').hex()
xml = f'''<?xml version="1.0" encoding="UTF-8"?>
<?steg-payload {encoded}?>
<!-- {PLINIAN_DIVIDER} -->
<dinosaurs xmlns:steg="http://st3gg.example.com/steg"
steg:payload="{hex_encoded}">
<species name="Stegosaurus" period="Late Jurassic">
<description>Large herbivorous thyreophoran dinosaur</description>
<weight unit="kg">5000</weight>
<length unit="m">9</length>
<features>
<feature>Dorsal plates</feature>
<feature>Thagomizer (tail spikes)</feature>
<feature>Small brain cavity</feature>
</features>
<hidden><![CDATA[{PLINIAN_DIVIDER}]]></hidden>
</species>
<species name="Ankylosaurus" period="Late Cretaceous">
<description>Armored dinosaur with club tail</description>
<weight unit="kg">6000</weight>
<length unit="m">7</length>
</species>
<!-- base64:{encoded} -->
</dinosaurs>'''
path = os.path.join(OUTPUT_DIR, 'example_hidden.xml')
with open(path, 'w', encoding='utf-8') as f:
f.write(xml)
print(f" -> {path}")
return path
# =============================================================================
# 22. JSON with Unicode escape sequences
# =============================================================================
def generate_json_hidden():
"""Create a JSON file with the Plinian divider hidden in Unicode escapes."""
print(" Generating JSON with hidden Unicode escapes...")
import json
import base64
# Encode as Unicode escape sequences
unicode_escaped = ''.join(f'\\u{ord(c):04x}' if ord(c) < 0x10000
else f'\\U{ord(c):08x}' for c in PLINIAN_DIVIDER)
data = {
"title": "Steganography Example Dataset",
"version": "3.0",
"generator": "STEGOSAURUS WRECKS",
"specimens": [
{
"name": "Stegosaurus stenops",
"period": "Late Jurassic",
"mya": [155, 150],
"diet": "herbivore",
"mass_kg": 5000
},
{
"name": "Stegosaurus ungulatus",
"period": "Late Jurassic",
"mya": [155, 145],
"diet": "herbivore",
"mass_kg": 5500
}
],
"_metadata": {
"comment": "Standard paleontology dataset",
"encoding": "UTF-8",
"payload_b64": base64.b64encode(PLINIAN_DIVIDER.encode('utf-8')).decode(),
"payload_hex": PLINIAN_DIVIDER.encode('utf-8').hex(),
"payload_direct": PLINIAN_DIVIDER
}
}
path = os.path.join(OUTPUT_DIR, 'example_hidden.json')
with open(path, 'w', encoding='utf-8') as f:
json.dump(data, f, indent=2, ensure_ascii=False)
print(f" -> {path}")
return path
# =============================================================================
# 23. CSV with whitespace-encoded steganography
# =============================================================================
def generate_csv_hidden():
"""Create a CSV with the Plinian divider hidden in trailing whitespace."""
print(" Generating CSV with whitespace steganography...")
msg_bytes = PLINIAN_DIVIDER.encode('utf-8')
length_bits = format(len(msg_bytes), '016b')
data_bits = ''.join(format(b, '08b') for b in msg_bytes)
all_bits = length_bits + data_bits
rows = [
["Species", "Period", "Length_m", "Mass_kg", "Diet"],
["Stegosaurus", "Late Jurassic", "9.0", "5000", "Herbivore"],
["Triceratops", "Late Cretaceous", "9.0", "6000", "Herbivore"],
["Tyrannosaurus", "Late Cretaceous", "12.3", "8400", "Carnivore"],
["Velociraptor", "Late Cretaceous", "2.0", "15", "Carnivore"],
["Brachiosaurus", "Late Jurassic", "26.0", "56000", "Herbivore"],
["Ankylosaurus", "Late Cretaceous", "6.5", "6000", "Herbivore"],
["Parasaurolophus", "Late Cretaceous", "9.5", "2500", "Herbivore"],
["Diplodocus", "Late Jurassic", "26.0", "16000", "Herbivore"],
["Allosaurus", "Late Jurassic", "8.5", "2300", "Carnivore"],
["Spinosaurus", "Late Cretaceous", "15.0", "7400", "Piscivore"],
["Pachycephalosaurus", "Late Cretaceous", "4.5", "450", "Herbivore"],
["Carnotaurus", "Late Cretaceous", "8.0", "1500", "Carnivore"],
["Iguanodon", "Early Cretaceous", "10.0", "3400", "Herbivore"],
["Pteranodon", "Late Cretaceous", "6.0", "25", "Piscivore"],
["Deinonychus", "Early Cretaceous", "3.4", "73", "Carnivore"],
["Apatosaurus", "Late Jurassic", "21.0", "23000", "Herbivore"],
["Compsognathus", "Late Jurassic", "1.0", "3", "Carnivore"],
["Gallimimus", "Late Cretaceous", "6.0", "440", "Omnivore"],
["Therizinosaurus", "Late Cretaceous", "10.0", "5000", "Herbivore"],
["Archaeopteryx", "Late Jurassic", "0.5", "1", "Carnivore"],
["Baryonyx", "Early Cretaceous", "10.0", "1700", "Piscivore"],
["Coelophysis", "Late Triassic", "3.0", "30", "Carnivore"],
["Dilophosaurus", "Early Jurassic", "7.0", "400", "Carnivore"],
["Giganotosaurus", "Late Cretaceous", "13.0", "6800", "Carnivore"],
["Edmontosaurus", "Late Cretaceous", "13.0", "4000", "Herbivore"],
["Protoceratops", "Late Cretaceous", "1.8", "83", "Herbivore"],
["Oviraptor", "Late Cretaceous", "2.0", "33", "Omnivore"],
["Maiasaura", "Late Cretaceous", "9.0", "3000", "Herbivore"],
["Kentrosaurus", "Late Jurassic", "4.5", "1600", "Herbivore"],
["Plateosaurus", "Late Triassic", "8.0", "1500", "Herbivore"],
["Ceratosaurus", "Late Jurassic", "6.0", "980", "Carnivore"],
["Megalosaurus", "Middle Jurassic", "9.0", "1400", "Carnivore"],
["Corythosaurus", "Late Cretaceous", "9.0", "3800", "Herbivore"],
["Lambeosaurus", "Late Cretaceous", "9.4", "5600", "Herbivore"],
["Styracosaurus", "Late Cretaceous", "5.5", "2700", "Herbivore"],
["Dracorex", "Late Cretaceous", "3.0", "450", "Herbivore"],
["Microraptor", "Early Cretaceous", "0.8", "1", "Carnivore"],
["Psittacosaurus", "Early Cretaceous", "2.0", "20", "Herbivore"],
["Sauropelta", "Early Cretaceous", "5.0", "1500", "Herbivore"],
["Nodosaurus", "Late Cretaceous", "6.0", "3500", "Herbivore"],
["Euoplocephalus", "Late Cretaceous", "6.0", "2000", "Herbivore"],
["Citipati", "Late Cretaceous", "2.9", "75", "Omnivore"],
["Ornithomimus", "Late Cretaceous", "3.5", "170", "Omnivore"],
["Struthiomimus", "Late Cretaceous", "4.3", "150", "Omnivore"],
["Dromaeosaurus", "Late Cretaceous", "2.0", "15", "Carnivore"],
["Utahraptor", "Early Cretaceous", "6.0", "500", "Carnivore"],
["Suchomimus", "Early Cretaceous", "11.0", "3800", "Piscivore"],
["Irritator", "Early Cretaceous", "8.0", "1000", "Piscivore"],
["Carcharodontosaurus", "Late Cretaceous", "12.0", "6200", "Carnivore"],
["Acrocanthosaurus", "Early Cretaceous", "11.5", "5200", "Carnivore"],
["Torvosaurus", "Late Jurassic", "10.0", "3600", "Carnivore"],
["Camarasaurus", "Late Jurassic", "18.0", "18000", "Herbivore"],
["Amargasaurus", "Early Cretaceous", "10.0", "8000", "Herbivore"],
["Nigersaurus", "Early Cretaceous", "9.0", "4000", "Herbivore"],
["Dreadnoughtus", "Late Cretaceous", "26.0", "65000", "Herbivore"],
["Argentinosaurus", "Late Cretaceous", "30.0", "73000", "Herbivore"],
["Patagotitan", "Late Cretaceous", "31.0", "69000", "Herbivore"],
["Mamenchisaurus", "Late Jurassic", "22.0", "18000", "Herbivore"],
["Shunosaurus", "Middle Jurassic", "11.0", "3000", "Herbivore"],
["Tuojiangosaurus", "Late Jurassic", "7.0", "4000", "Herbivore"],
["Wuerhosaurus", "Early Cretaceous", "7.0", "4000", "Herbivore"],
["Huayangosaurus", "Middle Jurassic", "4.5", "500", "Herbivore"],
["Dacentrurus", "Late Jurassic", "8.0", "5000", "Herbivore"],
["Lexovisaurus", "Middle Jurassic", "6.0", "2000", "Herbivore"],
["Chungkingosaurus", "Late Jurassic", "4.0", "1000", "Herbivore"],
["Miragaia", "Late Jurassic", "6.5", "2000", "Herbivore"],
["Jiangjunosaurus", "Late Jurassic", "6.0", "2500", "Herbivore"],
["Hesperosaurus", "Late Jurassic", "6.5", "3500", "Herbivore"],
["Loricatosaurus", "Middle Jurassic", "6.0", "2000", "Herbivore"],
["Paranthodon", "Early Cretaceous", "5.0", "900", "Herbivore"],
["Regnosaurus", "Early Cretaceous", "4.5", "800", "Herbivore"],
["Dravidosaurus", "Late Cretaceous", "3.0", "500", "Herbivore"],
["Craterosaurus", "Early Cretaceous", "4.0", "700", "Herbivore"],
]
bit_index = 0
lines = []
for row in rows:
line = ','.join(row)
trailing = ''
for _ in range(8):
if bit_index < len(all_bits):
trailing += ' ' if all_bits[bit_index] == '0' else '\t'
bit_index += 1
lines.append(line + trailing)
path = os.path.join(OUTPUT_DIR, 'example_whitespace.csv')
with open(path, 'w', encoding='utf-8') as f:
f.write('\n'.join(lines))
print(f" -> {path} ({bit_index} bits hidden)")
return path
# =============================================================================
# 24. YAML with comment-based encoding
# =============================================================================
def generate_yaml_hidden():
"""Create a YAML file with the Plinian divider hidden in comments."""
print(" Generating YAML with comment steganography...")
import base64
encoded = base64.b64encode(PLINIAN_DIVIDER.encode('utf-8')).decode()
hex_encoded = PLINIAN_DIVIDER.encode('utf-8').hex()
# Encode each byte as a YAML comment with a seemingly innocent hex value
msg_bytes = PLINIAN_DIVIDER.encode('utf-8')
hex_comments = []
for i, b in enumerate(msg_bytes):
hex_comments.append(f" # ref-{i:03d}: 0x{b:02x}")
yaml = f'''# Paleontology Specimen Database
# Generated by STEGOSAURUS WRECKS
# {PLINIAN_DIVIDER}
database:
name: "DinoTracker"
version: "3.0"
encoding: "UTF-8"
specimens:
- name: "Stegosaurus stenops"
classification:
order: Ornithischia
family: Stegosauridae # b64:{encoded}
period: "Late Jurassic"
location: "Morrison Formation, USA"
measurements:
length_m: 9.0
height_m: 4.0
mass_kg: 5000
- name: "Triceratops horridus"
classification:
order: Ornithischia
family: Ceratopsidae
period: "Late Cretaceous" # hex:{hex_encoded}
location: "Hell Creek Formation, USA"
measurements:
length_m: 9.0
height_m: 3.0
mass_kg: 6000
- name: "Tyrannosaurus rex"
classification:
order: Saurischia
family: Tyrannosauridae
period: "Late Cretaceous"
location: "Western North America"
measurements:
length_m: 12.3
height_m: 4.0
mass_kg: 8400
# Byte reference table (calibration data)
{chr(10).join(hex_comments)}
metadata:
payload: "{PLINIAN_DIVIDER}"
source: "ST3GG steganography toolkit"
'''
path = os.path.join(OUTPUT_DIR, 'example_hidden.yaml')
with open(path, 'w', encoding='utf-8') as f:
f.write(yaml)
print(f" -> {path}")
return path
# =============================================================================
# 25. PDF with hidden stream
# =============================================================================
def generate_pdf_hidden():
"""Create a minimal PDF with the Plinian divider hidden in metadata and streams."""
print(" Generating PDF with hidden stream data...")
import base64
encoded = base64.b64encode(PLINIAN_DIVIDER.encode('utf-8')).decode()
secret_bytes = PLINIAN_DIVIDER.encode('utf-8')
# Build a minimal valid PDF manually
objects = []
# Object 1: Catalog
objects.append(b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R /Metadata 5 0 R >>\nendobj\n")
# Object 2: Pages
objects.append(b"2 0 obj\n<< /Type /Pages /Kids [3 0 R] /Count 1 >>\nendobj\n")
# Object 3: Page
page_content = b"3 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Contents 4 0 R /Resources << >> >>\nendobj\n"
objects.append(page_content)
# Object 4: Content stream with visible text and hidden comment
stream_data = (
f"BT\n/F1 16 Tf\n100 700 Td\n(ST3GG Steganography Example) Tj\n"
f"0 -30 Td\n/F1 11 Tf\n(This PDF contains hidden data.) Tj\n"
f"0 -20 Td\n(Look in the metadata and streams...) Tj\nET\n"
f"% Hidden: {PLINIAN_DIVIDER}\n"
).encode('utf-8')
objects.append(f"4 0 obj\n<< /Length {len(stream_data)} >>\nstream\n".encode() +
stream_data + b"\nendstream\nendobj\n")
# Object 5: Metadata stream with hidden Plinian divider
meta_xml = f'''<?xpacket begin="\xef\xbb\xbf" id="W5M0MpCehiHzreSzNTczkc9d"?>
<x:xmpmeta xmlns:x="adobe:ns:meta/">
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:dc="http://purl.org/dc/elements/1.1/"
xmlns:steg="http://st3gg.example.com/ns/">
<rdf:Description>
<dc:title>ST3GG Example</dc:title>
<dc:creator>STEGOSAURUS WRECKS</dc:creator>
<dc:description>{PLINIAN_DIVIDER}</dc:description>
<steg:payload>{encoded}</steg:payload>
<steg:hex>{secret_bytes.hex()}</steg:hex>
</rdf:Description>
</rdf:RDF>
</x:xmpmeta>
<?xpacket end="w"?>'''.encode('utf-8')
objects.append(f"5 0 obj\n<< /Type /Metadata /Subtype /XML /Length {len(meta_xml)} >>\nstream\n".encode() +
meta_xml + b"\nendstream\nendobj\n")
# Object 6: Info dictionary
objects.append(f'6 0 obj\n<< /Title (ST3GG Example) /Author (STEGOSAURUS WRECKS) /Subject ({PLINIAN_DIVIDER}) /Producer (ST3GG v3.0) /Keywords ({encoded}) >>\nendobj\n'.encode('utf-8'))
# Build the PDF
pdf = b"%PDF-1.4\n%\xe2\xe3\xcf\xd3\n"
offsets = []
for obj in objects:
offsets.append(len(pdf))
pdf += obj
# Cross-reference table
xref_offset = len(pdf)
pdf += b"xref\n"
pdf += f"0 {len(objects) + 1}\n".encode()
pdf += b"0000000000 65535 f \n"
for offset in offsets:
pdf += f"{offset:010d} 00000 n \n".encode()
# Trailer
pdf += f"trailer\n<< /Size {len(objects) + 1} /Root 1 0 R /Info 6 0 R >>\n".encode()
pdf += f"startxref\n{xref_offset}\n%%EOF\n".encode()
# Append hidden data after EOF (common steganography technique)
pdf += f"\n% HIDDEN AFTER EOF: {PLINIAN_DIVIDER}\n".encode('utf-8')
pdf += secret_bytes
path = os.path.join(OUTPUT_DIR, 'example_hidden.pdf')
with open(path, 'wb') as f:
f.write(pdf)
print(f" -> {path}")
return path
# =============================================================================
# 26. RTF with hidden groups
# =============================================================================
def generate_rtf_hidden():
"""Create an RTF file with the Plinian divider in hidden text and metadata."""
print(" Generating RTF with hidden groups...")
# RTF hex encoding of secret
secret_bytes = PLINIAN_DIVIDER.encode('utf-8')
hex_chars = ''.join(f"\\'{b:02x}" for b in secret_bytes)
rtf = (
r"{\rtf1\ansi\deff0"
r"{\fonttbl{\f0 Courier New;}}"
r"{\colortbl;\red0\green0\blue0;\red200\green100\blue255;}"
"\n"
# Info group with hidden payload
r"{\info"
r"{\title ST3GG Steganography Example}"
r"{\author STEGOSAURUS WRECKS}"
r"{\subject " + PLINIAN_DIVIDER + r"}"
r"{\doccomm Hidden payload: " + secret_bytes.hex() + r"}"
r"}" "\n"
# Visible content
r"\f0\fs22\cf1 "
r"{\b ST3GG Steganography Example}\par\par"
r"This RTF document contains hidden data in multiple locations:\par"
r"- Document info/metadata fields\par"
r"- Hidden text runs (\\v flag)\par"
r"- Hex-encoded byte sequences\par\par"
r"The secret is concealed using RTF's native formatting capabilities.\par\par"
# Hidden text (invisible in most readers with \v flag)
r"{\v " + hex_chars + r"}"
r"{\v PLINIAN DIVIDER ENCODED ABOVE}"
"\n"
# Bookmark with hidden data
r"{\*\bkmkstart steg_payload}" + PLINIAN_DIVIDER + r"{\*\bkmkend steg_payload}"
"\n"
r"}"
)
path = os.path.join(OUTPUT_DIR, 'example_hidden.rtf')
with open(path, 'w', encoding='utf-8') as f:
f.write(rtf)
print(f" -> {path}")
return path
# =============================================================================
# 27. Markdown with HTML comment encoding
# =============================================================================
def generate_markdown_hidden():
"""Create a Markdown file with the Plinian divider in HTML comments and zero-width chars."""
print(" Generating Markdown with hidden content...")
import base64
encoded = base64.b64encode(PLINIAN_DIVIDER.encode('utf-8')).decode()
hex_encoded = PLINIAN_DIVIDER.encode('utf-8').hex()
# Zero-width encoding
ZWSP = '\u200B'
ZWNJ = '\u200C'
ZWJ = '\u200D'
secret_bytes = PLINIAN_DIVIDER.encode('utf-8')
binary_str = ''.join(format(b, '08b') for b in secret_bytes)
zw_string = ZWJ
for bit in binary_str:
zw_string += ZWSP if bit == '0' else ZWNJ
zw_string += ZWJ
md = f'''# Steganography: A Brief History
<!-- {PLINIAN_DIVIDER} -->
{zw_string}Steganography, from the Greek words *steganos* (covered) and *graphein*
(to write), is the practice of concealing messages within other non-secret data.
## Ancient Origins
The earliest recorded use of steganography dates back to **440 BC**, when
Histiaeus shaved a slave's head, tattooed a message on his scalp, and waited
for the hair to regrow before sending him as a messenger.
<!-- base64:{encoded} -->
## Digital Era
Modern digital steganography encompasses a wide range of techniques:
| Technique | Medium | Capacity | Stealth |
|-----------|--------|----------|---------|
| LSB Embedding | Images | High | Medium |
| DCT Domain | JPEG | Medium | High |
| Whitespace | Text | Low | High |
| Zero-Width | Text | Low | Very High |
| Audio LSB | Audio | Medium | High |
| Metadata | Any | Low | Medium |
## Tools
**ST3GG (STEGOSAURUS WRECKS)** is an advanced steganography toolkit supporting
15 channel presets, 8 bit depths, and 4 encoding strategies.
<!-- hex:{hex_encoded} -->
[comment]: # ({PLINIAN_DIVIDER})
---
*Generated by STEGOSAURUS WRECKS v3.0*
'''
path = os.path.join(OUTPUT_DIR, 'example_hidden.md')
with open(path, 'w', encoding='utf-8') as f:
f.write(md)
print(f" -> {path}")
return path
# =============================================================================
# 28. AIFF with LSB steganography
# =============================================================================
def generate_aiff_lsb():
"""Create an AIFF audio file with the Plinian divider hidden in sample LSBs."""
print(" Generating AIFF with LSB steganography...")
import math
sample_rate = 22050
duration = 2 # seconds
num_samples = sample_rate * duration
num_channels = 1
bits_per_sample = 16
# Generate a tone
frequency = 523.25 # C5
samples = []
for i in range(num_samples):
t = i / sample_rate
value = 0.6 * math.sin(2 * math.pi * frequency * t)
value += 0.2 * math.sin(2 * math.pi * frequency * 2 * t)
sample = int(value * 16000)
sample = max(-32768, min(32767, sample))
samples.append(sample)
# Encode Plinian divider in LSB
msg = PLINIAN_DIVIDER.encode('utf-8')
length_bytes = struct.pack('>I', len(msg))
payload = length_bytes + msg
bits = []
for byte in payload:
for j in range(7, -1, -1):
bits.append((byte >> j) & 1)
for i, bit in enumerate(bits):
if i < len(samples):
s = samples[i]
u = s & 0xFFFF
u = (u & 0xFFFE) | bit
samples[i] = u if u < 32768 else u - 65536
# Build AIFF file manually (big-endian)
# AIFF uses big-endian 16-bit samples
sample_data = struct.pack(f'>{len(samples)}h', *samples)
# IEEE 754 80-bit extended for sample rate
def float_to_extended(val):
"""Convert float to 80-bit IEEE 754 extended precision (big-endian)."""
if val == 0:
return b'\x00' * 10
import math as m
sign = 0
if val < 0:
sign = 1
val = -val
exp = int(m.floor(m.log2(val)))
mantissa = val / (2 ** exp)
# Bias is 16383
biased_exp = exp + 16383
# Mantissa: 64-bit integer with explicit integer bit
mant_int = int(mantissa * (2 ** 63))
result = struct.pack('>HQ', (sign << 15) | (biased_exp & 0x7FFF), mant_int)
return result
# COMM chunk
comm = b'COMM'
comm_data = struct.pack('>hI', num_channels, num_samples)
comm_data += struct.pack('>h', bits_per_sample)
comm_data += float_to_extended(sample_rate)
comm += struct.pack('>I', len(comm_data)) + comm_data
# SSND chunk
ssnd_data = struct.pack('>II', 0, 0) + sample_data # offset + block size + data
ssnd = b'SSND' + struct.pack('>I', len(ssnd_data)) + ssnd_data
# ANNO chunk (annotation) with hidden message
anno_text = f"Generated by ST3GG - {PLINIAN_DIVIDER}".encode('utf-8')
if len(anno_text) % 2 != 0:
anno_text += b'\x00'
anno = b'ANNO' + struct.pack('>I', len(anno_text)) + anno_text
# FORM header
form_data = b'AIFF' + comm + anno + ssnd
aiff = b'FORM' + struct.pack('>I', len(form_data)) + form_data
path = os.path.join(OUTPUT_DIR, 'example_lsb.aiff')
with open(path, 'wb') as f:
f.write(aiff)
print(f" -> {path} ({len(bits)} bits embedded)")
return path
# =============================================================================
# 29. AU (Sun/NeXT) audio with LSB steganography
# =============================================================================
def generate_au_lsb():
"""Create an AU audio file with the Plinian divider hidden in sample LSBs."""
print(" Generating AU with LSB steganography...")
import math
sample_rate = 22050
duration = 2
num_samples = sample_rate * duration
# Generate a different tone (A4 = 440Hz)
frequency = 440.0
samples = []
for i in range(num_samples):
t = i / sample_rate
value = 0.5 * math.sin(2 * math.pi * frequency * t)
value += 0.25 * math.sin(2 * math.pi * frequency * 3 * t) # Add 3rd harmonic
sample = int(value * 16000)
sample = max(-32768, min(32767, sample))
samples.append(sample)
# Encode Plinian divider in LSB
msg = PLINIAN_DIVIDER.encode('utf-8')
length_bytes = struct.pack('>I', len(msg))
payload = length_bytes + msg
bits = []
for byte in payload:
for j in range(7, -1, -1):
bits.append((byte >> j) & 1)
for i, bit in enumerate(bits):
if i < len(samples):
s = samples[i]
u = s & 0xFFFF
u = (u & 0xFFFE) | bit
samples[i] = u if u < 32768 else u - 65536
# AU format: big-endian
annotation = PLINIAN_DIVIDER.encode('utf-8')
# Pad annotation to multiple of 4
while len(annotation) % 4 != 0:
annotation += b'\x00'
header_size = 24 + len(annotation)
sample_data = struct.pack(f'>{len(samples)}h', *samples)
au = b'.snd' # Magic
au += struct.pack('>I', header_size) # Data offset
au += struct.pack('>I', len(sample_data)) # Data size
au += struct.pack('>I', 3) # Encoding: 16-bit linear PCM
au += struct.pack('>I', sample_rate)
au += struct.pack('>I', 1) # Channels
au += annotation
au += sample_data
path = os.path.join(OUTPUT_DIR, 'example_lsb.au')
with open(path, 'wb') as f:
f.write(au)
print(f" -> {path} ({len(bits)} bits embedded)")
return path
# =============================================================================
# 30. ZIP with comment steganography
# =============================================================================
def generate_zip_hidden():
"""Create a ZIP archive with the Plinian divider hidden in the archive comment."""
print(" Generating ZIP with comment steganography...")
import zipfile
path = os.path.join(OUTPUT_DIR, 'example_hidden.zip')
with zipfile.ZipFile(path, 'w', zipfile.ZIP_DEFLATED) as zf:
# Add some innocent-looking files
zf.writestr('dinosaurs/stegosaurus.txt',
'Stegosaurus stenops\nLate Jurassic\nMorrison Formation\n')
zf.writestr('dinosaurs/triceratops.txt',
'Triceratops horridus\nLate Cretaceous\nHell Creek Formation\n')
zf.writestr('README.txt',
'Paleontology specimen data archive.\nGenerated by ST3GG.\n')
# Hidden: Plinian divider as archive comment
zf.comment = PLINIAN_DIVIDER.encode('utf-8')
# Also append hidden data after the ZIP end
with open(path, 'ab') as f:
f.write(b'\n--- HIDDEN AFTER ZIP ---\n')
f.write(PLINIAN_DIVIDER.encode('utf-8'))
print(f" -> {path}")
return path
# =============================================================================
# 31. TAR with extended headers
# =============================================================================
def generate_tar_hidden():
"""Create a TAR archive with the Plinian divider in extended pax headers."""
print(" Generating TAR with extended header steganography...")
import tarfile
import io
import time
path = os.path.join(OUTPUT_DIR, 'example_hidden.tar')
with tarfile.open(path, 'w', format=tarfile.PAX_FORMAT) as tf:
# Add a file with pax headers containing the secret
data = b'Stegosaurus Facts\nLate Jurassic, 155-150 MYA\n'
info = tarfile.TarInfo(name='specimens/stegosaurus.txt')
info.size = len(data)
info.mtime = int(time.time())
info.pax_headers = {
'comment': PLINIAN_DIVIDER,
'STEG.payload': PLINIAN_DIVIDER.encode('utf-8').hex(),
'STEG.generator': 'STEGOSAURUS WRECKS v3.0',
}
tf.addfile(info, io.BytesIO(data))
# Second file
data2 = b'Ankylosaurus Facts\nLate Cretaceous, 68-66 MYA\n'
info2 = tarfile.TarInfo(name='specimens/ankylosaurus.txt')
info2.size = len(data2)
info2.mtime = int(time.time())
tf.addfile(info2, io.BytesIO(data2))
print(f" -> {path}")
return path
# =============================================================================
# 32. GZip with extra field steganography
# =============================================================================
def generate_gzip_hidden():
"""Create a GZip file with the Plinian divider in the extra field and comment."""
print(" Generating GZip with extra field steganography...")
content = (
"Steganography Techniques Reference\n"
"===================================\n\n"
"LSB Embedding: Hide data in least significant bits of pixel values.\n"
"DCT Domain: Embed in frequency-domain coefficients for JPEG survival.\n"
"Metadata: Store secrets in file metadata fields.\n"
"Appended Data: Add data after file end markers.\n"
"Whitespace: Encode in trailing spaces and tabs.\n"
"Zero-Width: Use invisible Unicode characters.\n"
).encode('utf-8')
secret = PLINIAN_DIVIDER.encode('utf-8')
# Build gzip manually to include FEXTRA and FCOMMENT fields
# Gzip header
gz = b'\x1f\x8b' # Magic
gz += b'\x08' # Compression: deflate
flags = 0x04 | 0x10 # FEXTRA | FCOMMENT
gz += bytes([flags])
gz += struct.pack('<I', int(__import__('time').time())) # mtime
gz += b'\x00' # Extra flags
gz += b'\xff' # OS: unknown
# FEXTRA field containing the secret
extra_data = b'ST' + struct.pack('<H', len(secret)) + secret # subfield ID + len + data
gz += struct.pack('<H', len(extra_data))
gz += extra_data
# FCOMMENT (null-terminated)
gz += PLINIAN_DIVIDER.encode('latin-1', errors='replace') + b'\x00'
# Compressed data
compressed = zlib.compress(content, 9)[2:-4] # Strip zlib header/trailer for raw deflate
gz += compressed
# CRC32 and size
gz += struct.pack('<I', zlib.crc32(content) & 0xFFFFFFFF)
gz += struct.pack('<I', len(content) & 0xFFFFFFFF)
path = os.path.join(OUTPUT_DIR, 'example_hidden.gz')
with open(path, 'wb') as f:
f.write(gz)
print(f" -> {path}")
return path
# =============================================================================
# 33. SQLite database with hidden data
# =============================================================================
def generate_sqlite_hidden():
"""Create a SQLite database with the Plinian divider in hidden tables and metadata."""
print(" Generating SQLite with hidden data...")
import sqlite3
path = os.path.join(OUTPUT_DIR, 'example_hidden.sqlite')
if os.path.exists(path):
os.remove(path)
conn = sqlite3.connect(path)
c = conn.cursor()
# Create a visible table
c.execute('''CREATE TABLE specimens (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
period TEXT,
length_m REAL,
mass_kg REAL,
diet TEXT
)''')
specimens = [
(1, 'Stegosaurus', 'Late Jurassic', 9.0, 5000, 'Herbivore'),
(2, 'Triceratops', 'Late Cretaceous', 9.0, 6000, 'Herbivore'),
(3, 'Tyrannosaurus', 'Late Cretaceous', 12.3, 8400, 'Carnivore'),
(4, 'Velociraptor', 'Late Cretaceous', 2.0, 15, 'Carnivore'),
(5, 'Brachiosaurus', 'Late Jurassic', 26.0, 56000, 'Herbivore'),
]
c.executemany('INSERT INTO specimens VALUES (?,?,?,?,?,?)', specimens)
# Hidden table with the Plinian divider
c.execute('''CREATE TABLE _steg_payload (
key TEXT PRIMARY KEY,
value TEXT
)''')
import base64
c.execute('INSERT INTO _steg_payload VALUES (?, ?)',
('divider', PLINIAN_DIVIDER))
c.execute('INSERT INTO _steg_payload VALUES (?, ?)',
('divider_b64', base64.b64encode(PLINIAN_DIVIDER.encode('utf-8')).decode()))
c.execute('INSERT INTO _steg_payload VALUES (?, ?)',
('divider_hex', PLINIAN_DIVIDER.encode('utf-8').hex()))
# Also set the application_id to encode part of the message
c.execute(f"PRAGMA application_id = {0x53544547}") # 'STEG' in hex
conn.commit()
conn.close()
print(f" -> {path}")
return path
# =============================================================================
# 34. Raw hex dump file
# =============================================================================
def generate_hexdump_hidden():
"""Create a hex dump file with the Plinian divider hidden in the ASCII column."""
print(" Generating hex dump with hidden data...")
secret = PLINIAN_DIVIDER.encode('utf-8')
# Create a fake hex dump of "random" data that contains the secret
# embedded within the raw bytes
import random
random.seed(42)
# Generate surrounding data with secret embedded at offset 0x40
total_size = 256
data = bytearray(random.getrandbits(8) for _ in range(total_size))
# Embed secret at offset 0x40
embed_offset = 0x40
for i, b in enumerate(secret):
if embed_offset + i < total_size:
data[embed_offset + i] = b
# Format as hex dump
lines = []
lines.append("# ST3GG Hex Dump - Memory Analysis Output")
lines.append("# Generated by STEGOSAURUS WRECKS v3.0")
lines.append(f"# Payload offset: 0x{embed_offset:04x}")
lines.append(f"# Payload size: {len(secret)} bytes")
lines.append("")
for offset in range(0, len(data), 16):
chunk = data[offset:offset + 16]
hex_part = ' '.join(f'{b:02x}' for b in chunk)
hex_part = hex_part.ljust(47)
ascii_part = ''.join(chr(b) if 32 <= b < 127 else '.' for b in chunk)
lines.append(f"{offset:08x} {hex_part} |{ascii_part}|")
lines.append("")
lines.append(f"# Total: {len(data)} bytes")
path = os.path.join(OUTPUT_DIR, 'example_hidden.hexdump')
with open(path, 'w', encoding='utf-8') as f:
f.write('\n'.join(lines))
print(f" -> {path}")
return path
# =============================================================================
# 35. MIDI with SysEx steganography
# =============================================================================
def generate_midi_hidden():
"""Create a MIDI file with the Plinian divider hidden in SysEx messages."""
print(" Generating MIDI with SysEx steganography...")
secret = PLINIAN_DIVIDER.encode('utf-8')
# MIDI SysEx can only carry 7-bit data, so encode as pairs
sysex_data = bytearray()
for b in secret:
sysex_data.append(b >> 4) # High nibble (always < 16, so 7-bit safe)
sysex_data.append(b & 0x0F) # Low nibble
def var_len(value):
"""Encode a variable-length quantity for MIDI."""
result = bytearray()
result.append(value & 0x7F)
value >>= 7
while value > 0:
result.append((value & 0x7F) | 0x80)
value >>= 7
result.reverse()
return bytes(result)
# Build MIDI file
# Header chunk
header = b'MThd'
header += struct.pack('>I', 6) # Chunk length
header += struct.pack('>HHH', 0, 1, 480) # Format 0, 1 track, 480 ticks/beat
# Track chunk
track_data = bytearray()
# Tempo: 120 BPM (500000 microseconds per beat)
track_data += b'\x00\xFF\x51\x03\x07\xA1\x20'
# Text event with the divider
text = f"ST3GG: {PLINIAN_DIVIDER}".encode('utf-8')
track_data += b'\x00\xFF\x01' + var_len(len(text)).encode('latin-1') if False else b''
track_data += b'\x00\xFF\x01'
track_data += bytes(var_len(len(text)))
track_data += text
# SysEx message containing encoded secret
# Manufacturer ID 0x7D = non-commercial/educational use
sysex_payload = bytes([0x7D]) + bytes(sysex_data)
track_data += b'\x00\xF0'
track_data += bytes(var_len(len(sysex_payload) + 1)) # +1 for F7 terminator
track_data += sysex_payload
track_data += b'\xF7'
# Play a simple melody (C major scale)
notes = [60, 62, 64, 65, 67, 69, 71, 72] # C4 to C5
for note in notes:
track_data += b'\x00' # Delta time
track_data += bytes([0x90, note, 0x50]) # Note On, velocity 80
track_data += bytes(var_len(480)) # Wait 1 beat
track_data += bytes([0x80, note, 0x40]) # Note Off
# End of track
track_data += b'\x00\xFF\x2F\x00'
track = b'MTrk' + struct.pack('>I', len(track_data)) + bytes(track_data)
path = os.path.join(OUTPUT_DIR, 'example_hidden.mid')
with open(path, 'wb') as f:
f.write(header + track)
print(f" -> {path}")
return path
# =============================================================================
# 36. PCAP-like network capture with hidden data
# =============================================================================
def generate_pcap_hidden():
"""Create a PCAP file with the Plinian divider hidden in packet payloads."""
print(" Generating PCAP with hidden packet data...")
secret = PLINIAN_DIVIDER.encode('utf-8')
import time
# PCAP global header
pcap = struct.pack('<IHHiIII',
0xa1b2c3d4, # Magic
2, 4, # Version 2.4
0, # Timezone (GMT)
0, # Sigfigs
65535, # Snaplen
1, # Link type: Ethernet
)
def make_packet(src_ip, dst_ip, payload, ts_sec):
"""Build a simple UDP packet wrapped in Ethernet + IP headers."""
# UDP header
src_port, dst_port = 12345, 53
udp_len = 8 + len(payload)
udp = struct.pack('>HHHH', src_port, dst_port, udp_len, 0)
udp += payload
# IP header (simplified, no checksum)
ip_len = 20 + len(udp)
ip_header = struct.pack('>BBHHHBBH4s4s',
0x45, 0, ip_len, # Version, IHL, TOS, Total length
0x1234, 0x4000, # ID, Flags+Fragment
64, 17, 0, # TTL, Protocol (UDP), Checksum
bytes(map(int, src_ip.split('.'))),
bytes(map(int, dst_ip.split('.'))),
)
# Ethernet header
eth = b'\x00' * 6 + b'\x00' * 6 + b'\x08\x00' # dst + src + type (IP)
frame = eth + ip_header + udp
# PCAP packet header
pkt_len = len(frame)
pkt_header = struct.pack('<IIII', ts_sec, 0, pkt_len, pkt_len)
return pkt_header + frame
ts = int(time.time())
# Normal-looking DNS query packets, with the secret split across them
chunk_size = len(secret) // 4 + 1
packets = []
for i in range(4):
chunk = secret[i * chunk_size:(i + 1) * chunk_size]
if chunk:
packets.append(make_packet(
f'192.168.1.{10 + i}', '8.8.8.8',
chunk, ts + i
))
# Also include the full secret in one packet
packets.append(make_packet('10.0.0.1', '10.0.0.2', secret, ts + 5))
for pkt in packets:
pcap += pkt
path = os.path.join(OUTPUT_DIR, 'example_hidden.pcap')
with open(path, 'wb') as f:
f.write(pcap)
print(f" -> {path}")
return path
# =============================================================================
# 37. Python with steganographic comments
# =============================================================================
def generate_python_hidden():
"""Create a Python file with the Plinian divider hidden in comments and docstrings."""
print(" Generating Python with hidden comments...")
import base64
encoded = base64.b64encode(PLINIAN_DIVIDER.encode('utf-8')).decode()
hex_encoded = PLINIAN_DIVIDER.encode('utf-8').hex()
# Zero-width encoding
ZWSP = '\u200B'
ZWNJ = '\u200C'
ZWJ = '\u200D'
secret_bytes = PLINIAN_DIVIDER.encode('utf-8')
binary_str = ''.join(format(b, '08b') for b in secret_bytes)
zw_string = ZWJ + ''.join(ZWSP if bit == '0' else ZWNJ for bit in binary_str) + ZWJ
# Encode each byte as a hex comment spread across the file
byte_comments = [f" # cfg[{i}] = 0x{b:02x}" for i, b in enumerate(secret_bytes)]
py = f'''#!/usr/bin/env python3
"""
Paleontology Specimen Analyzer
{zw_string}
A tool for analyzing dinosaur fossil measurements and classifications.
"""
# {PLINIAN_DIVIDER}
# Configuration hash: {hex_encoded}
import math
from dataclasses import dataclass
from typing import Optional
@dataclass
class Specimen:
"""Represents a dinosaur specimen record."""
name: str
period: str
length_m: float
mass_kg: float
diet: str
brain_volume_cc: Optional[float] = None
# Calibration byte table (do not modify)
{chr(10).join(byte_comments)}
def calculate_brain_body_ratio(specimen: Specimen) -> float:
"""Calculate the encephalization quotient (EQ) for a specimen."""
if specimen.brain_volume_cc is None:
return 0.0
# EQ = brain mass / (0.12 * body_mass^0.67)
expected = 0.12 * (specimen.mass_kg ** 0.67)
return specimen.brain_volume_cc / expected
def classify_intelligence(eq: float) -> str:
"""Classify relative intelligence based on EQ."""
if eq > 1.0:
return "above average"
elif eq > 0.5:
return "average"
else:
return "below average"
# Payload verification: {encoded}
SPECIMENS = [
Specimen("Stegosaurus", "Late Jurassic", 9.0, 5000, "Herbivore", 2.8),
Specimen("Triceratops", "Late Cretaceous", 9.0, 6000, "Herbivore", 70.0),
Specimen("T. rex", "Late Cretaceous", 12.3, 8400, "Carnivore", 343.0),
Specimen("Velociraptor", "Late Cretaceous", 2.0, 15, "Carnivore", 15.0),
Specimen("Brachiosaurus", "Late Jurassic", 26.0, 56000, "Herbivore", 26.0),
]
def main():
"""Analyze specimens and print results."""
print("Paleontology Specimen Analysis")
print("=" * 50)
for spec in SPECIMENS:
eq = calculate_brain_body_ratio(spec)
intel = classify_intelligence(eq)
print(f" {{spec.name:20s}} EQ={{eq:.3f}} ({{intel}})")
if __name__ == "__main__":
main()
'''
path = os.path.join(OUTPUT_DIR, 'example_hidden.py')
with open(path, 'w', encoding='utf-8') as f:
f.write(py)
print(f" -> {path}")
return path
# =============================================================================
# 38. JavaScript with zero-width characters
# =============================================================================
def generate_js_hidden():
"""Create a JavaScript file with the Plinian divider in zero-width chars."""
print(" Generating JavaScript with zero-width steganography...")
import base64
encoded = base64.b64encode(PLINIAN_DIVIDER.encode('utf-8')).decode()
hex_encoded = PLINIAN_DIVIDER.encode('utf-8').hex()
# Zero-width encoding
ZWSP = '\u200B'
ZWNJ = '\u200C'
ZWJ = '\u200D'
secret_bytes = PLINIAN_DIVIDER.encode('utf-8')
binary_str = ''.join(format(b, '08b') for b in secret_bytes)
zw_string = ZWJ + ''.join(ZWSP if bit == '0' else ZWNJ for bit in binary_str) + ZWJ
js = f'''// Dinosaur Specimen Database Module
// {zw_string}
/**
* @module specimen-db
* @description Paleontology specimen management
* @version 3.0.0
* @license MIT
*/
// {PLINIAN_DIVIDER}
const SPECIMENS = [
{{ name: "Stegosaurus",{zw_string} period: "Late Jurassic", lengthM: 9.0, massKg: 5000 }},
{{ name: "Triceratops", period: "Late Cretaceous", lengthM: 9.0, massKg: 6000 }},
{{ name: "Tyrannosaurus", period: "Late Cretaceous", lengthM: 12.3, massKg: 8400 }},
{{ name: "Velociraptor", period: "Late Cretaceous", lengthM: 2.0, massKg: 15 }},
{{ name: "Brachiosaurus", period: "Late Jurassic", lengthM: 26.0, massKg: 56000 }},
];
// Internal config hash: {hex_encoded}
/**
* Calculate body mass index for a specimen
* @param {{Object}} specimen - The specimen data
* @returns {{number}} BMI estimate
*/
function calculateBMI(specimen) {{
return specimen.massKg / (specimen.lengthM ** 2);
}}
/**
* Search specimens by period
* @param {{string}} period - Geological period name
* @returns {{Array}} Matching specimens
*/
function findByPeriod(period) {{
return SPECIMENS.filter(s => s.period.includes(period));
}}
// Verification: {encoded}
function printReport() {{
console.log("Specimen Analysis Report");
console.log("=".repeat(50));
for (const spec of SPECIMENS) {{
const bmi = calculateBMI(spec).toFixed(1);
console.log(` ${{spec.name.padEnd(20)}} BMI=${{bmi}} (${{spec.period}})`);
}}
}}
if (typeof module !== "undefined") {{
module.exports = {{ SPECIMENS, calculateBMI, findByPeriod, printReport }};
}}
'''
path = os.path.join(OUTPUT_DIR, 'example_hidden.js')
with open(path, 'w', encoding='utf-8') as f:
f.write(js)
print(f" -> {path}")
return path
# =============================================================================
# 39. C source with steganographic comments
# =============================================================================
def generate_c_hidden():
"""Create a C source file with the Plinian divider hidden in comments."""
print(" Generating C source with hidden comments...")
import base64
encoded = base64.b64encode(PLINIAN_DIVIDER.encode('utf-8')).decode()
hex_bytes = PLINIAN_DIVIDER.encode('utf-8')
# Build a C array of the secret bytes
c_array = ', '.join(f'0x{b:02x}' for b in hex_bytes)
c_src = f'''/*
* specimen_analyzer.c - Paleontology Specimen Analysis Tool
* Generated by STEGOSAURUS WRECKS v3.0
*
* {PLINIAN_DIVIDER}
*/
#include <stdio.h>
#include <string.h>
#include <math.h>
/* Calibration data (do not modify) */
static const unsigned char _cal_data[] = {{
{c_array}
}};
static const size_t _cal_len = sizeof(_cal_data);
/* b64: {encoded} */
typedef struct {{
const char *name;
const char *period;
double length_m;
double mass_kg;
const char *diet;
}} Specimen;
static const Specimen specimens[] = {{
{{"Stegosaurus", "Late Jurassic", 9.0, 5000.0, "Herbivore"}},
{{"Triceratops", "Late Cretaceous", 9.0, 6000.0, "Herbivore"}},
{{"Tyrannosaurus", "Late Cretaceous", 12.3, 8400.0, "Carnivore"}},
{{"Velociraptor", "Late Cretaceous", 2.0, 15.0, "Carnivore"}},
{{"Brachiosaurus", "Late Jurassic", 26.0, 56000.0, "Herbivore"}},
}};
#define NUM_SPECIMENS (sizeof(specimens) / sizeof(specimens[0]))
double calculate_density(const Specimen *s) {{
/* Rough cylindrical body model */
double radius = s->length_m / 6.0;
double volume = M_PI * radius * radius * s->length_m;
return s->mass_kg / volume;
}}
void print_analysis(void) {{
printf("Specimen Density Analysis\\n");
printf("%-20s %-18s %8s %10s\\n",
"Name", "Period", "Mass(kg)", "Density");
printf("%-20s %-18s %8s %10s\\n",
"----", "------", "--------", "-------");
for (size_t i = 0; i < NUM_SPECIMENS; i++) {{
double d = calculate_density(&specimens[i]);
printf("%-20s %-18s %8.0f %10.1f\\n",
specimens[i].name, specimens[i].period,
specimens[i].mass_kg, d);
}}
}}
int main(void) {{
print_analysis();
/* Verify calibration data integrity */
if (_cal_len > 0 && _cal_data[0] != 0) {{
/* Calibration OK */
}}
return 0;
}}
'''
path = os.path.join(OUTPUT_DIR, 'example_hidden.c')
with open(path, 'w', encoding='utf-8') as f:
f.write(c_src)
print(f" -> {path}")
return path
# =============================================================================
# 40. CSS with invisible selectors and comments
# =============================================================================
def generate_css_hidden():
"""Create a CSS file with the Plinian divider in comments and data URIs."""
print(" Generating CSS with hidden selectors...")
import base64
encoded = base64.b64encode(PLINIAN_DIVIDER.encode('utf-8')).decode()
hex_encoded = PLINIAN_DIVIDER.encode('utf-8').hex()
# Zero-width encoding
ZWSP = '\u200B'
ZWNJ = '\u200C'
ZWJ = '\u200D'
secret_bytes = PLINIAN_DIVIDER.encode('utf-8')
binary_str = ''.join(format(b, '08b') for b in secret_bytes)
zw_string = ZWJ + ''.join(ZWSP if bit == '0' else ZWNJ for bit in binary_str) + ZWJ
css = f'''/*
* ST3GG Steganography Theme
* {PLINIAN_DIVIDER}
* Generated by STEGOSAURUS WRECKS v3.0
*/
/* hex:{hex_encoded} */
:root {{
--bg-primary: #1a1a2e;
--bg-secondary: #16213e;
--text-primary: #e0e0e0;
--text-secondary: #a0a0b0;
--accent-purple: #c471ed;
--accent-blue: #12c2e9;
--accent-orange: #f5af19;
--accent-red: #f64f59;
}}
/* {zw_string} */
* {{
margin: 0;
padding: 0;
box-sizing: border-box;
}}
body {{
font-family: 'Segoe UI', system-ui, -apple-system, sans-serif;
background: var(--bg-primary);
color: var(--text-primary);
line-height: 1.6;
}}
.container {{
max-width: 1200px;
margin: 0 auto;
padding: 2rem;
}}
/* Steganography analysis panel */
.steg-panel {{
background: var(--bg-secondary);
border: 1px solid rgba(196, 113, 237, 0.2);
border-radius: 12px;
padding: 1.5rem;
margin-bottom: 1.5rem;
}}
.steg-panel__header {{
font-size: 1.25rem;
color: var(--accent-purple);
margin-bottom: 0.75rem;
border-bottom: 1px solid rgba(196, 113, 237, 0.15);
padding-bottom: 0.5rem;
}}
/* b64:{encoded} */
.steg-panel__content {{
font-family: 'Fira Code', 'Consolas', monospace;
font-size: 0.875rem;
color: var(--text-secondary);
}}
/* Hidden element - payload carrier */
[data-steg-payload]::after {{
content: "{PLINIAN_DIVIDER}";
display: none;
visibility: hidden;
position: absolute;
width: 0;
height: 0;
overflow: hidden;
}}
.btn {{
display: inline-flex;
align-items: center;
gap: 0.5rem;
padding: 0.5rem 1.25rem;
border: none;
border-radius: 8px;
font-size: 0.875rem;
cursor: pointer;
transition: all 0.2s ease;
}}
.btn--primary {{
background: linear-gradient(135deg, var(--accent-purple), var(--accent-blue));
color: white;
}}
.btn--primary:hover {{
transform: translateY(-1px);
box-shadow: 0 4px 15px rgba(196, 113, 237, 0.3);
}}
/* Animation keyframes */
@keyframes pulse {{
0%, 100% {{ opacity: 1; }}
50% {{ opacity: 0.7; }}
}}
.analyzing {{
animation: pulse 1.5s ease-in-out infinite;
}}
'''
path = os.path.join(OUTPUT_DIR, 'example_hidden.css')
with open(path, 'w', encoding='utf-8') as f:
f.write(css)
print(f" -> {path}")
return path
# =============================================================================
# 41. INI/Config with comment encoding
# =============================================================================
def generate_ini_hidden():
"""Create an INI config file with the Plinian divider in comments."""
print(" Generating INI with comment steganography...")
import base64
encoded = base64.b64encode(PLINIAN_DIVIDER.encode('utf-8')).decode()
hex_encoded = PLINIAN_DIVIDER.encode('utf-8').hex()
# Encode each byte as a "calibration" comment
secret_bytes = PLINIAN_DIVIDER.encode('utf-8')
cal_lines = [f"; cal[{i:02d}] = {b:3d} ; 0x{b:02x}" for i, b in enumerate(secret_bytes)]
ini = f'''; ST3GG Configuration File
; Generated by STEGOSAURUS WRECKS v3.0
; {PLINIAN_DIVIDER}
[general]
application = ST3GG
version = 3.0
description = Steganography Toolkit
author = STEGOSAURUS WRECKS
[encoding]
default_channels = RGB
default_bits = 1
strategy = sequential
compression = true
; Payload: {encoded}
[detection]
exhaustive_mode = true
auto_detect = true
max_scan_depth = 11
timeout_seconds = 30
[security]
encryption = AES-256-GCM
key_derivation = PBKDF2
iterations = 100000
; hex: {hex_encoded}
[output]
format = PNG
quality = 100
preserve_metadata = true
; Calibration byte table (system data - do not modify)
{chr(10).join(cal_lines)}
[advanced]
ghost_mode = false
matryoshka_layers = 0
dct_robustness = 2
; payload_direct = {PLINIAN_DIVIDER}
'''
path = os.path.join(OUTPUT_DIR, 'example_hidden.ini')
with open(path, 'w', encoding='utf-8') as f:
f.write(ini)
print(f" -> {path}")
return path
# =============================================================================
# 42. Shell script with whitespace encoding
# =============================================================================
def generate_shell_hidden():
"""Create a shell script with the Plinian divider in comments and whitespace."""
print(" Generating Shell script with hidden data...")
import base64
encoded = base64.b64encode(PLINIAN_DIVIDER.encode('utf-8')).decode()
hex_encoded = PLINIAN_DIVIDER.encode('utf-8').hex()
# Whitespace-encode in trailing spaces/tabs
msg_bytes = PLINIAN_DIVIDER.encode('utf-8')
length_bits = format(len(msg_bytes), '016b')
data_bits = ''.join(format(b, '08b') for b in msg_bytes)
all_bits = length_bits + data_bits
script_lines = [
'#!/usr/bin/env bash',
f'# {PLINIAN_DIVIDER}',
'# Specimen Analysis Script',
'# Generated by STEGOSAURUS WRECKS v3.0',
'',
f'# Verification: {encoded}',
'',
'set -euo pipefail',
'',
'readonly SPECIMENS=(',
' "Stegosaurus:Late Jurassic:9.0:5000:Herbivore"',
' "Triceratops:Late Cretaceous:9.0:6000:Herbivore"',
' "Tyrannosaurus:Late Cretaceous:12.3:8400:Carnivore"',
' "Velociraptor:Late Cretaceous:2.0:15:Carnivore"',
' "Brachiosaurus:Late Jurassic:26.0:56000:Herbivore"',
')',
'',
'print_header() {',
' printf "%-20s %-18s %8s %8s\\n" "Name" "Period" "Length" "Mass"',
' printf "%-20s %-18s %8s %8s\\n" "----" "------" "------" "----"',
'}',
'',
'analyze_specimens() {',
' for entry in "${SPECIMENS[@]}"; do',
' IFS=":" read -r name period length mass diet <<< "$entry"',
' printf "%-20s %-18s %8s %8s\\n" "$name" "$period" "$length" "$mass"',
' done',
'}',
'',
f'# hex:{hex_encoded}',
'',
'main() {',
' echo "Specimen Analysis Report"',
' echo "========================"',
' print_header',
' analyze_specimens',
' echo ""',
' echo "Analysis complete."',
'}',
'',
'main "$@"',
]
bit_index = 0
result_lines = []
for line in script_lines:
trailing = ''
for _ in range(8):
if bit_index < len(all_bits):
trailing += ' ' if all_bits[bit_index] == '0' else '\t'
bit_index += 1
result_lines.append(line + trailing)
path = os.path.join(OUTPUT_DIR, 'example_hidden.sh')
with open(path, 'w', encoding='utf-8') as f:
f.write('\n'.join(result_lines))
print(f" -> {path} ({bit_index} bits in whitespace)")
return path
# =============================================================================
# 43. SQL with comment steganography
# =============================================================================
def generate_sql_hidden():
"""Create a SQL file with the Plinian divider hidden in comments."""
print(" Generating SQL with comment steganography...")
import base64
encoded = base64.b64encode(PLINIAN_DIVIDER.encode('utf-8')).decode()
hex_encoded = PLINIAN_DIVIDER.encode('utf-8').hex()
secret_bytes = PLINIAN_DIVIDER.encode('utf-8')
# Encode each byte as a seemingly-innocent SQL comment
byte_comments = [f"-- chk[{i:02d}]: {b:3d}" for i, b in enumerate(secret_bytes)]
sql = f'''-- =============================================================================
-- Paleontology Specimen Database Schema
-- Generated by STEGOSAURUS WRECKS v3.0
-- {PLINIAN_DIVIDER}
-- =============================================================================
-- hex: {hex_encoded}
CREATE TABLE IF NOT EXISTS geological_periods (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL UNIQUE,
start_mya REAL NOT NULL,
end_mya REAL NOT NULL
);
INSERT INTO geological_periods (id, name, start_mya, end_mya) VALUES
(1, 'Late Triassic', 237.0, 201.3),
(2, 'Early Jurassic', 201.3, 174.1),
(3, 'Late Jurassic', 163.5, 145.0),
(4, 'Early Cretaceous', 145.0, 100.5),
(5, 'Late Cretaceous', 100.5, 66.0);
-- b64: {encoded}
CREATE TABLE IF NOT EXISTS specimens (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
species TEXT,
period_id INTEGER REFERENCES geological_periods(id),
length_m REAL,
mass_kg REAL,
diet TEXT CHECK(diet IN ('Herbivore', 'Carnivore', 'Omnivore', 'Piscivore')),
brain_volume_cc REAL,
discovery_year INTEGER,
location TEXT
);
INSERT INTO specimens (id, name, species, period_id, length_m, mass_kg, diet, brain_volume_cc, discovery_year, location) VALUES
(1, 'Stegosaurus', 'S. stenops', 3, 9.0, 5000, 'Herbivore', 2.8, 1877, 'Morrison Formation, CO'),
(2, 'Triceratops', 'T. horridus', 5, 9.0, 6000, 'Herbivore', 70.0, 1887, 'Hell Creek, MT'),
(3, 'Tyrannosaurus', 'T. rex', 5, 12.3, 8400, 'Carnivore', 343.0, 1905, 'Hell Creek, MT'),
(4, 'Velociraptor', 'V. mongoliensis', 5, 2.0, 15, 'Carnivore', 15.0, 1924, 'Djadokhta, Mongolia'),
(5, 'Brachiosaurus', 'B. altithorax', 3, 26.0, 56000, 'Herbivore', 26.0, 1903, 'Morrison Formation, CO');
-- Checksum verification data
{chr(10).join(byte_comments)}
-- Analysis view
CREATE VIEW IF NOT EXISTS specimen_analysis AS
SELECT
s.name,
s.species,
gp.name AS period,
s.length_m,
s.mass_kg,
s.diet,
CASE
WHEN s.brain_volume_cc / (0.12 * POWER(s.mass_kg, 0.67)) > 1.0 THEN 'High EQ'
WHEN s.brain_volume_cc / (0.12 * POWER(s.mass_kg, 0.67)) > 0.5 THEN 'Medium EQ'
ELSE 'Low EQ'
END AS intelligence_class
FROM specimens s
JOIN geological_periods gp ON s.period_id = gp.id;
-- End of schema
-- Payload: {PLINIAN_DIVIDER}
'''
path = os.path.join(OUTPUT_DIR, 'example_hidden.sql')
with open(path, 'w', encoding='utf-8') as f:
f.write(sql)
print(f" -> {path}")
return path
# =============================================================================
# 44. LaTeX with comment encoding
# =============================================================================
def generate_latex_hidden():
"""Create a LaTeX file with the Plinian divider hidden in comments."""
print(" Generating LaTeX with comment steganography...")
import base64
encoded = base64.b64encode(PLINIAN_DIVIDER.encode('utf-8')).decode()
hex_encoded = PLINIAN_DIVIDER.encode('utf-8').hex()
latex = f'''%% =============================================================================
%% Paleontology Specimen Report
%% Generated by STEGOSAURUS WRECKS v3.0
%% {PLINIAN_DIVIDER}
%% =============================================================================
\\documentclass[12pt]{{article}}
\\usepackage[utf8]{{inputenc}}
\\usepackage{{booktabs}}
\\usepackage{{graphicx}}
\\usepackage{{amsmath}}
%% hex: {hex_encoded}
\\title{{Comparative Analysis of Ornithischian Dinosaurs}}
\\author{{STEGOSAURUS WRECKS Research Division}}
\\date{{Late Jurassic -- Late Cretaceous}}
\\begin{{document}}
\\maketitle
%% b64: {encoded}
\\begin{{abstract}}
This report presents a comparative analysis of ornithischian dinosaur specimens,
focusing on body mass, encephalization quotient, and defensive adaptations.
The Stegosaurus remains one of the most distinctive members of this clade.
\\end{{abstract}}
\\section{{Introduction}}
The Ornithischia (``bird-hipped'' dinosaurs) represent one of the two major
clades of dinosaurs, characterized by a pubis bone that points backward.
This clade includes many well-known species including Stegosaurus,
Triceratops, and Ankylosaurus.
%% Payload: {PLINIAN_DIVIDER}
\\section{{Specimen Data}}
\\begin{{table}}[h]
\\centering
\\caption{{Ornithischian Specimen Measurements}}
\\begin{{tabular}}{{lllrr}}
\\toprule
\\textbf{{Species}} & \\textbf{{Period}} & \\textbf{{Diet}} & \\textbf{{Length (m)}} & \\textbf{{Mass (kg)}} \\\\
\\midrule
Stegosaurus & Late Jurassic & Herbivore & 9.0 & 5000 \\\\
Triceratops & Late Cretaceous & Herbivore & 9.0 & 6000 \\\\
Ankylosaurus & Late Cretaceous & Herbivore & 6.5 & 6000 \\\\
Parasaurolophus & Late Cretaceous & Herbivore & 9.5 & 2500 \\\\
Pachycephalosaurus & Late Cretaceous & Herbivore & 4.5 & 450 \\\\
\\bottomrule
\\end{{tabular}}
\\end{{table}}
\\section{{Encephalization Quotient}}
The encephalization quotient (EQ) provides a measure of relative brain size:
\\begin{{equation}}
EQ = \\frac{{E_{{actual}}}}{{E_{{expected}}}} = \\frac{{E_{{actual}}}}{{0.12 \\cdot M^{{0.67}}}}
\\end{{equation}}
where $E_{{actual}}$ is the actual brain mass and $M$ is body mass in kilograms.
\\section{{Conclusion}}
Ornithischian dinosaurs show remarkable diversity in defensive adaptations,
from the plates and spikes of Stegosaurus to the armored shell of Ankylosaurus
and the horned frill of Triceratops.
\\end{{document}}
'''
path = os.path.join(OUTPUT_DIR, 'example_hidden.tex')
with open(path, 'w', encoding='utf-8') as f:
f.write(latex)
print(f" -> {path}")
return path
# =============================================================================
# 45. TOML with comment encoding
# =============================================================================
def generate_toml_hidden():
"""Create a TOML config file with the Plinian divider in comments."""
print(" Generating TOML with comment steganography...")
import base64
encoded = base64.b64encode(PLINIAN_DIVIDER.encode('utf-8')).decode()
hex_encoded = PLINIAN_DIVIDER.encode('utf-8').hex()
toml = f'''# ST3GG Project Configuration
# {PLINIAN_DIVIDER}
# Generated by STEGOSAURUS WRECKS v3.0
[project]
name = "ST3GG"
version = "3.0.0"
description = "Advanced Steganography Toolkit"
authors = ["STEGOSAURUS WRECKS"]
license = "MIT"
# hex: {hex_encoded}
[encoding]
default_channels = "RGB"
default_bits_per_channel = 1
strategy = "sequential"
compression = true
[encoding.presets]
minimal = {{ channels = "R", bits = 1 }}
standard = {{ channels = "RGB", bits = 1 }}
high_capacity = {{ channels = "RGBA", bits = 2 }}
maximum = {{ channels = "RGBA", bits = 8 }}
# b64: {encoded}
[detection]
exhaustive_mode = true
auto_detect = true
max_depth = 11
timeout = 30
[security]
encryption = "AES-256-GCM"
key_derivation = "PBKDF2"
iterations = 100_000
ghost_mode = false
[output]
format = "PNG"
quality = 100
preserve_metadata = true
# Payload: {PLINIAN_DIVIDER}
[[specimens]]
name = "Stegosaurus"
period = "Late Jurassic"
length_m = 9.0
mass_kg = 5_000
[[specimens]]
name = "Triceratops"
period = "Late Cretaceous"
length_m = 9.0
mass_kg = 6_000
[[specimens]]
name = "Tyrannosaurus"
period = "Late Cretaceous"
length_m = 12.3
mass_kg = 8_400
'''
path = os.path.join(OUTPUT_DIR, 'example_hidden.toml')
with open(path, 'w', encoding='utf-8') as f:
f.write(toml)
print(f" -> {path}")
return path
# =============================================================================
# 46. Homoglyph steganography (Cyrillic/Latin substitution)
# =============================================================================
def generate_homoglyph():
"""Create a text file with Plinian divider encoded via Cyrillic/Latin homoglyphs.
Each confusable character substituted = 1, left as Latin = 0.
Only characters that have Cyrillic lookalikes are used as bit carriers.
"""
print(" Generating homoglyph (Cyrillic/Latin) steganography...")
# Latin chars that have Cyrillic visual equivalents
HOMOGLYPH_MAP = {
'a': '\u0430', # Cyrillic а
'c': '\u0441', # Cyrillic с
'e': '\u0435', # Cyrillic е
'o': '\u043e', # Cyrillic о
'p': '\u0440', # Cyrillic р
's': '\u0455', # Cyrillic ѕ
'x': '\u0445', # Cyrillic х
'y': '\u0443', # Cyrillic у (close enough)
'A': '\u0410', # Cyrillic А
'B': '\u0412', # Cyrillic В
'C': '\u0421', # Cyrillic С
'E': '\u0415', # Cyrillic Е
'H': '\u041d', # Cyrillic Н
'K': '\u041a', # Cyrillic К
'M': '\u041c', # Cyrillic М
'O': '\u041e', # Cyrillic О
'P': '\u0420', # Cyrillic Р
'T': '\u0422', # Cyrillic Т
'X': '\u0425', # Cyrillic Х
}
cover = (
"The Stegosaurus was a spectacular dinosaur that roamed the Earth "
"approximately one hundred and fifty million years ago. Despite its "
"enormous size, this peaceful herbivore possessed a remarkably small "
"brain, roughly the size of a walnut. The distinctive plates along "
"its back were once thought to serve as armor, but modern research "
"suggests they were primarily used for thermoregulation and display. "
"Each plate was covered in a network of blood vessels that could "
"absorb or release heat depending on the animal's needs. The famous "
"thagomizer on its tail, consisting of four sharp spikes, was almost "
"certainly used as a defensive weapon against predators like Allosaurus. "
"Fossil evidence shows puncture marks on Allosaurus bones that match "
"the spacing of Stegosaurus tail spikes perfectly. This remarkable "
"creature continues to capture our imagination and represents one of "
"the most iconic dinosaurs ever discovered. Paleontologists have "
"unearthed specimens across western North America and parts of "
"Portugal, expanding our knowledge of its range and behavior."
)
# Encode Plinian divider as bits
msg_bytes = PLINIAN_DIVIDER.encode('utf-8')
bits = []
for b in msg_bytes:
for j in range(7, -1, -1):
bits.append((b >> j) & 1)
# Find carrier positions (characters that have homoglyphs)
carriers = []
for i, ch in enumerate(cover):
if ch in HOMOGLYPH_MAP:
carriers.append(i)
# Encode: 16-bit length prefix + message bits
length_bits = [int(b) for b in format(len(msg_bytes), '016b')]
all_bits = length_bits + bits
result = list(cover)
bit_idx = 0
for pos in carriers:
if bit_idx >= len(all_bits):
break
if all_bits[bit_idx] == 1:
result[pos] = HOMOGLYPH_MAP[cover[pos]]
bit_idx += 1
path = os.path.join(OUTPUT_DIR, 'example_homoglyph.txt')
with open(path, 'w', encoding='utf-8') as f:
f.write(''.join(result))
print(f" -> {path} ({bit_idx} bits in {len(carriers)} carrier chars)")
return path
# =============================================================================
# 47. Variation selector steganography
# =============================================================================
def generate_variation_selector():
"""Create a text file with Plinian divider encoded via Unicode variation selectors.
Variation selectors (U+FE00-U+FE0F) are invisible modifiers that follow
base characters. Their presence (1) or absence (0) encodes bits.
"""
print(" Generating variation selector steganography...")
# VS1-VS16 (U+FE00 to U+FE0F)
VS1 = '\uFE01' # We use VS1 as the marker
cover = (
"Dinosaur Classification Guide\n"
"=============================\n\n"
"Order Ornithischia (bird-hipped dinosaurs):\n"
" - Stegosaurus: Late Jurassic, 9m long, herbivore\n"
" - Triceratops: Late Cretaceous, 9m long, herbivore\n"
" - Ankylosaurus: Late Cretaceous, 6.5m long, herbivore\n"
" - Pachycephalosaurus: Late Cretaceous, 4.5m long, herbivore\n"
" - Parasaurolophus: Late Cretaceous, 9.5m long, herbivore\n"
" - Iguanodon: Early Cretaceous, 10m long, herbivore\n\n"
"Order Saurischia (lizard-hipped dinosaurs):\n"
" - Tyrannosaurus: Late Cretaceous, 12m long, carnivore\n"
" - Velociraptor: Late Cretaceous, 2m long, carnivore\n"
" - Brachiosaurus: Late Jurassic, 26m long, herbivore\n"
" - Diplodocus: Late Jurassic, 26m long, herbivore\n"
" - Allosaurus: Late Jurassic, 8.5m long, carnivore\n"
" - Spinosaurus: Late Cretaceous, 15m long, piscivore\n"
" - Compsognathus: Late Jurassic, 1m long, carnivore\n"
" - Gallimimus: Late Cretaceous, 6m long, omnivore\n\n"
"The distinction between these orders is based on the structure\n"
"of the pelvis. Ornithischians have a pubis bone that points\n"
"backward, similar to modern birds, while saurischians have a\n"
"forward-pointing pubis, more like modern lizards.\n"
)
# Encode
msg_bytes = PLINIAN_DIVIDER.encode('utf-8')
length_bits = [int(b) for b in format(len(msg_bytes), '016b')]
data_bits = []
for b in msg_bytes:
for j in range(7, -1, -1):
data_bits.append((b >> j) & 1)
all_bits = length_bits + data_bits
# Insert VS after alphanumeric characters to encode bits
result = []
bit_idx = 0
for ch in cover:
result.append(ch)
if bit_idx < len(all_bits) and ch.isalpha():
if all_bits[bit_idx] == 1:
result.append(VS1)
bit_idx += 1
path = os.path.join(OUTPUT_DIR, 'example_variation_selector.txt')
with open(path, 'w', encoding='utf-8') as f:
f.write(''.join(result))
print(f" -> {path} ({bit_idx} bits encoded)")
return path
# =============================================================================
# 48. Combining diacritic steganography
# =============================================================================
def generate_combining_diacritics():
"""Create a text file with Plinian divider encoded via invisible combining marks.
Uses combining characters that render invisibly on most systems:
U+034F COMBINING GRAPHEME JOINER (invisible)
Presence after a letter = 1, absence = 0.
"""
print(" Generating combining diacritic steganography...")
CGJ = '\u034F' # Combining Grapheme Joiner (invisible)
cover = (
"Stegosaurus Defense Mechanisms\n\n"
"The Stegosaurus possessed two primary defensive features that made it\n"
"a formidable opponent for predators of the Late Jurassic period.\n\n"
"First, the double row of bony plates along its back served multiple\n"
"purposes. While not strong enough to function as true armor, these\n"
"plates made the animal appear much larger and more intimidating when\n"
"viewed from the side. The plates were richly supplied with blood\n"
"vessels, suggesting they also played a role in thermoregulation,\n"
"allowing the dinosaur to warm up quickly in the morning sun.\n\n"
"Second, and more importantly for defense, was the thagomizer: a\n"
"cluster of four large spikes at the end of its muscular tail. Each\n"
"spike could measure up to ninety centimeters in length. The tail\n"
"itself was remarkably flexible and powerful, capable of delivering\n"
"devastating blows to attackers. Evidence from Allosaurus fossils\n"
"shows wounds consistent with Stegosaurus tail spike impacts,\n"
"confirming that this weapon was used actively in combat.\n\n"
"Together, these adaptations made Stegosaurus one of the best\n"
"defended herbivores of its era, despite its relatively small brain\n"
"and slow movement speed compared to theropod predators.\n"
)
msg_bytes = PLINIAN_DIVIDER.encode('utf-8')
length_bits = [int(b) for b in format(len(msg_bytes), '016b')]
data_bits = []
for b in msg_bytes:
for j in range(7, -1, -1):
data_bits.append((b >> j) & 1)
all_bits = length_bits + data_bits
result = []
bit_idx = 0
for ch in cover:
result.append(ch)
if bit_idx < len(all_bits) and ch.isalpha():
if all_bits[bit_idx] == 1:
result.append(CGJ)
bit_idx += 1
path = os.path.join(OUTPUT_DIR, 'example_combining_diacritics.txt')
with open(path, 'w', encoding='utf-8') as f:
f.write(''.join(result))
print(f" -> {path} ({bit_idx} bits encoded)")
return path
# =============================================================================
# 49. Confusable whitespace steganography
# =============================================================================
def generate_confusable_whitespace():
"""Create a text file with Plinian divider encoded via Unicode whitespace variants.
Uses multiple Unicode space characters that render identically:
Regular space (U+0020) = 00, En space (U+2002) = 01,
Em space (U+2003) = 10, Thin space (U+2009) = 11.
Two bits per space character.
"""
print(" Generating confusable whitespace steganography...")
SPACE_MAP = {
0b00: ' ', # Regular space (U+0020)
0b01: '\u2002', # En space
0b10: '\u2003', # Em space
0b11: '\u2009', # Thin space
}
cover_words = (
"The study of dinosaur fossils has revealed incredible details about "
"prehistoric life on Earth. Each discovery adds new pieces to the "
"puzzle of ancient ecosystems and evolutionary relationships. Modern "
"technology including CT scanning and molecular analysis allows "
"paleontologists to extract information that was previously impossible "
"to obtain from fossilized remains. The field continues to evolve "
"with new species being described every year and old assumptions "
"being challenged by fresh evidence. From the massive sauropods to "
"the tiny compsognathids the diversity of dinosaur life was truly "
"staggering. Their reign lasted over one hundred and sixty million "
"years making them one of the most successful groups of land animals "
"in the history of our planet. Understanding their biology behavior "
"and eventual extinction helps us appreciate the fragility and "
"resilience of life on Earth."
).split(' ')
msg_bytes = PLINIAN_DIVIDER.encode('utf-8')
# Build 2-bit pairs
bits = []
for b in msg_bytes:
for j in range(7, -1, -1):
bits.append((b >> j) & 1)
# 16-bit length prefix
length_bits = [int(b) for b in format(len(msg_bytes), '016b')]
all_bits = length_bits + bits
# Pair up bits into 2-bit values
pairs = []
for i in range(0, len(all_bits), 2):
if i + 1 < len(all_bits):
pairs.append((all_bits[i] << 1) | all_bits[i + 1])
else:
pairs.append(all_bits[i] << 1)
# Replace spaces between words with encoded whitespace
result = []
pair_idx = 0
for i, word in enumerate(cover_words):
result.append(word)
if i < len(cover_words) - 1:
if pair_idx < len(pairs):
result.append(SPACE_MAP[pairs[pair_idx]])
pair_idx += 1
else:
result.append(' ')
path = os.path.join(OUTPUT_DIR, 'example_confusable_whitespace.txt')
with open(path, 'w', encoding='utf-8') as f:
f.write(''.join(result))
print(f" -> {path} ({pair_idx * 2} bits in {pair_idx} space chars)")
return path
# =============================================================================
# 50. Emoji substitution steganography
# =============================================================================
def generate_emoji_substitution():
"""Create a text file with Plinian divider encoded via emoji pairs.
Uses pairs of similar-looking emoji: first of pair = 0, second = 1.
Each emoji position encodes one bit.
"""
print(" Generating emoji substitution steganography...")
# Emoji pairs (visually similar, encode 0 or 1)
EMOJI_PAIRS = [
('🌑', '🌚'), # Dark moons
('⭐', '🌟'), # Stars
('🔴', '🟥'), # Red circle/square
('🔵', '🟦'), # Blue circle/square
('🟢', '🟩'), # Green circle/square
('⚫', '🖤'), # Black circle/heart
('⚪', '🤍'), # White circle/heart
('🔶', '🟧'), # Orange diamond/square
]
msg_bytes = PLINIAN_DIVIDER.encode('utf-8')
length_bits = [int(b) for b in format(len(msg_bytes), '016b')]
data_bits = []
for b in msg_bytes:
for j in range(7, -1, -1):
data_bits.append((b >> j) & 1)
all_bits = length_bits + data_bits
# Build emoji stream
emoji_line = []
for i, bit in enumerate(all_bits):
pair = EMOJI_PAIRS[i % len(EMOJI_PAIRS)]
emoji_line.append(pair[bit])
# Create a "fun" cover document
content = (
"Dinosaur Mood Tracker 🦕\n"
"========================\n\n"
"Today's paleontology status indicators:\n\n"
+ ''.join(emoji_line) + "\n\n"
"Legend:\n"
"🌑🌚 = Moon phases (new moon / moon face)\n"
"⭐🌟 = Star brightness (solid / sparkling)\n"
"🔴🟥 = Alert levels (circle / square)\n"
"🔵🟦 = Status indicators (circle / square)\n"
"🟢🟩 = Progress markers (circle / square)\n"
"⚫🖤 = Fossil darkness (circle / heart)\n"
"⚪🤍 = Bone whiteness (circle / heart)\n"
"🔶🟧 = Amber indicators (diamond / square)\n\n"
"Each emoji represents a data point in our specimen tracking system.\n"
"The pattern above encodes today's field survey results.\n"
)
path = os.path.join(OUTPUT_DIR, 'example_emoji_substitution.txt')
with open(path, 'w', encoding='utf-8') as f:
f.write(content)
print(f" -> {path} ({len(all_bits)} bits in {len(all_bits)} emoji)")
return path
# =============================================================================
# 51. DNS tunneling steganography (PCAP)
# =============================================================================
def generate_dns_tunnel_pcap():
"""Create a PCAP with Plinian divider hidden in DNS query names."""
print(" Generating DNS tunneling PCAP...")
import base64
import time
secret = PLINIAN_DIVIDER.encode('utf-8')
# Base32-encode for DNS-safe label characters
encoded = base64.b32encode(secret).decode().lower().rstrip('=')
# Split into DNS-safe labels (max 63 chars each)
labels = [encoded[i:i+60] for i in range(0, len(encoded), 60)]
pcap = struct.pack('<IHHiIII',
0xa1b2c3d4, 2, 4, 0, 0, 65535, 1) # PCAP header
ts = int(time.time())
for i, label in enumerate(labels):
# Build DNS query
domain = f"{label}.steg.example.com"
dns_query = b'\x00\x01' # Transaction ID
dns_query += b'\x01\x00' # Standard query
dns_query += b'\x00\x01\x00\x00\x00\x00\x00\x00' # 1 question
# Encode domain name as DNS wire format
for part in domain.split('.'):
dns_query += bytes([len(part)]) + part.encode('ascii')
dns_query += b'\x00' # Root label
dns_query += b'\x00\x01' # Type A
dns_query += b'\x00\x01' # Class IN
# UDP header
udp_len = 8 + len(dns_query)
udp = struct.pack('>HHHH', 12345 + i, 53, udp_len, 0) + dns_query
# IP header
ip_len = 20 + len(udp)
ip_hdr = struct.pack('>BBHHHBBH4s4s',
0x45, 0, ip_len, 0x1234 + i, 0x4000,
64, 17, 0,
bytes([192, 168, 1, 100]),
bytes([8, 8, 8, 8]))
# Ethernet
eth = b'\x00' * 6 + b'\x00' * 6 + b'\x08\x00'
frame = eth + ip_hdr + udp
pkt_hdr = struct.pack('<IIII', ts + i, 0, len(frame), len(frame))
pcap += pkt_hdr + frame
path = os.path.join(OUTPUT_DIR, 'example_dns_tunnel.pcap')
with open(path, 'wb') as f:
f.write(pcap)
print(f" -> {path} ({len(labels)} DNS queries)")
return path
# =============================================================================
# 52. ICMP steganography (PCAP)
# =============================================================================
def generate_icmp_steg_pcap():
"""Create a PCAP with Plinian divider hidden in ICMP echo request payloads."""
print(" Generating ICMP steganography PCAP...")
import time
secret = PLINIAN_DIVIDER.encode('utf-8')
pcap = struct.pack('<IHHiIII',
0xa1b2c3d4, 2, 4, 0, 0, 65535, 1)
ts = int(time.time())
chunk_size = 32
for i in range(0, len(secret), chunk_size):
chunk = secret[i:i + chunk_size]
# Pad with random-looking filler
payload = chunk + bytes(range(len(chunk), 56))
# ICMP echo request
icmp_type = 8 # Echo request
icmp_code = 0
icmp_id = 0x1234
icmp_seq = i // chunk_size
# Checksum placeholder (0)
icmp = struct.pack('>BBHHH', icmp_type, icmp_code, 0, icmp_id, icmp_seq)
icmp += payload
# Calculate ICMP checksum
cksum = 0
for j in range(0, len(icmp), 2):
if j + 1 < len(icmp):
cksum += (icmp[j] << 8) + icmp[j + 1]
else:
cksum += icmp[j] << 8
while cksum >> 16:
cksum = (cksum & 0xFFFF) + (cksum >> 16)
cksum = ~cksum & 0xFFFF
icmp = struct.pack('>BBHHH', icmp_type, icmp_code, cksum, icmp_id, icmp_seq) + payload
# IP header (protocol 1 = ICMP)
ip_len = 20 + len(icmp)
ip_hdr = struct.pack('>BBHHHBBH4s4s',
0x45, 0, ip_len, 0x5678 + i, 0x4000,
64, 1, 0, # TTL=64, Protocol=1 (ICMP)
bytes([192, 168, 1, 100]),
bytes([8, 8, 8, 8]))
eth = b'\x00' * 6 + b'\x00' * 6 + b'\x08\x00'
frame = eth + ip_hdr + icmp
pkt_hdr = struct.pack('<IIII', ts + i, 0, len(frame), len(frame))
pcap += pkt_hdr + frame
path = os.path.join(OUTPUT_DIR, 'example_icmp_steg.pcap')
with open(path, 'wb') as f:
f.write(pcap)
print(f" -> {path}")
return path
# =============================================================================
# 53. TCP covert channel (PCAP) — data in ISN and TCP timestamps
# =============================================================================
def generate_tcp_covert_pcap():
"""Create a PCAP with Plinian divider hidden in TCP header fields.
Encodes 4 bytes per SYN packet in the Initial Sequence Number (ISN),
and additional bytes in the TCP timestamp option.
"""
print(" Generating TCP covert channel PCAP...")
import time
secret = PLINIAN_DIVIDER.encode('utf-8')
pcap = struct.pack('<IHHiIII',
0xa1b2c3d4, 2, 4, 0, 0, 65535, 1)
ts = int(time.time())
# Encode 4 bytes in ISN + 4 bytes in TCP timestamp per packet
chunk_size = 8
for i in range(0, len(secret), chunk_size):
chunk = secret[i:i + chunk_size]
# ISN carries first 4 bytes
isn_bytes = chunk[:4].ljust(4, b'\x00')
isn = struct.unpack('>I', isn_bytes)[0]
# TCP timestamp carries next 4 bytes
ts_bytes = chunk[4:8].ljust(4, b'\x00')
ts_val = struct.unpack('>I', ts_bytes)[0]
# TCP header (SYN packet with timestamp option)
src_port = 49152 + (i // chunk_size)
dst_port = 443
tcp_flags = 0x02 # SYN
# TCP header: 20 bytes base + 12 bytes options (timestamps)
# Option: kind=8, length=10, TSval, TSecr=0, + 2 bytes NOP padding
tcp_opts = struct.pack('>BBII', 8, 10, ts_val, 0) + b'\x01\x01' # NOP NOP
tcp_hdr_len = (20 + len(tcp_opts)) // 4
tcp = struct.pack('>HHIIBBHHH',
src_port, dst_port, isn, 0,
(tcp_hdr_len << 4), tcp_flags,
65535, 0, 0)
tcp += tcp_opts
# IP header
ip_len = 20 + len(tcp)
ip_hdr = struct.pack('>BBHHHBBH4s4s',
0x45, 0, ip_len, 0xABCD + i, 0x4000,
64, 6, 0, # Protocol=6 (TCP)
bytes([10, 0, 0, 1]),
bytes([93, 184, 216, 34]))
eth = b'\x00' * 6 + b'\x00' * 6 + b'\x08\x00'
frame = eth + ip_hdr + tcp
pkt_hdr = struct.pack('<IIII', ts + i, 0, len(frame), len(frame))
pcap += pkt_hdr + frame
path = os.path.join(OUTPUT_DIR, 'example_tcp_covert.pcap')
with open(path, 'wb') as f:
f.write(pcap)
print(f" -> {path}")
return path
# =============================================================================
# 54. HTTP header smuggling (PCAP)
# =============================================================================
def generate_http_header_pcap():
"""Create a PCAP with Plinian divider hidden in HTTP custom headers."""
print(" Generating HTTP header smuggling PCAP...")
import base64
import time
secret = PLINIAN_DIVIDER.encode('utf-8')
encoded_b64 = base64.b64encode(secret).decode()
hex_encoded = secret.hex()
# Build an HTTP request with hidden headers
http_req = (
f"GET /index.html HTTP/1.1\r\n"
f"Host: www.example.com\r\n"
f"User-Agent: Mozilla/5.0 (compatible; StegBot/3.0)\r\n"
f"Accept: text/html\r\n"
f"X-Request-ID: {hex_encoded}\r\n"
f"X-Correlation-Token: {encoded_b64}\r\n"
f"X-Debug-Info: {PLINIAN_DIVIDER}\r\n"
f"Cookie: session={encoded_b64}; theme=dark\r\n"
f"Connection: keep-alive\r\n"
f"\r\n"
).encode('utf-8')
pcap = struct.pack('<IHHiIII',
0xa1b2c3d4, 2, 4, 0, 0, 65535, 1)
ts = int(time.time())
# TCP segment with HTTP payload
tcp = struct.pack('>HHIIBBHHH',
49200, 80,
1000, 0,
(5 << 4), 0x18, # ACK+PSH, data offset=5 (20 bytes)
65535, 0, 0)
tcp += http_req
ip_len = 20 + len(tcp)
ip_hdr = struct.pack('>BBHHHBBH4s4s',
0x45, 0, ip_len, 0x1111, 0x4000,
64, 6, 0,
bytes([192, 168, 1, 100]),
bytes([93, 184, 216, 34]))
eth = b'\x00' * 6 + b'\x00' * 6 + b'\x08\x00'
frame = eth + ip_hdr + tcp
pkt_hdr = struct.pack('<IIII', ts, 0, len(frame), len(frame))
pcap += pkt_hdr + frame
path = os.path.join(OUTPUT_DIR, 'example_http_headers.pcap')
with open(path, 'wb') as f:
f.write(pcap)
print(f" -> {path}")
return path
# =============================================================================
# 55. PNG+ZIP polyglot file
# =============================================================================
def generate_png_zip_polyglot():
"""Create a file that is simultaneously a valid PNG and a valid ZIP.
PNG readers ignore data after IEND. ZIP readers scan from end of file
for the End of Central Directory record. So we append a ZIP to a PNG.
"""
print(" Generating PNG+ZIP polyglot...")
import zipfile
import io
# Create a small PNG
width, height = 80, 80
img = Image.new('RGB', (width, height))
pixels = img.load()
for y in range(height):
for x in range(width):
r = int(100 + 120 * (x / width))
g = int(50 + 150 * (y / height))
b = int(180 + 60 * ((x + y) / (width + height)))
pixels[x, y] = (r, g, b)
png_buf = io.BytesIO()
img.save(png_buf, 'PNG')
png_data = png_buf.getvalue()
# Create a ZIP in memory
zip_buf = io.BytesIO()
with zipfile.ZipFile(zip_buf, 'w', zipfile.ZIP_DEFLATED) as zf:
zf.writestr('secret.txt', PLINIAN_DIVIDER)
zf.writestr('README.txt', 'This file is both a valid PNG image and a valid ZIP archive.\n'
'Open it as an image to see a gradient, or unzip it to find the secret.\n')
zf.comment = b'ST3GG PNG+ZIP polyglot'
zip_data = zip_buf.getvalue()
# Polyglot: PNG data + ZIP data (PNG ignores after IEND, ZIP reads from end)
polyglot = png_data + zip_data
path = os.path.join(OUTPUT_DIR, 'example_polyglot.png.zip')
with open(path, 'wb') as f:
f.write(polyglot)
print(f" -> {path} (PNG: {len(png_data)} + ZIP: {len(zip_data)} bytes)")
return path
# =============================================================================
# 56. PNG filter type encoding
# =============================================================================
def generate_png_filter_encoding():
"""Create a PNG with Plinian divider encoded in scanline filter type bytes.
PNG allows 5 filter types (0-4) per scanline. We use: None(0)=0, Sub(1)=1.
Each scanline's filter byte encodes one bit.
"""
print(" Generating PNG filter type encoding...")
msg_bytes = PLINIAN_DIVIDER.encode('utf-8')
length_bits = [int(b) for b in format(len(msg_bytes), '016b')]
data_bits = []
for b in msg_bytes:
for j in range(7, -1, -1):
data_bits.append((b >> j) & 1)
all_bits = length_bits + data_bits
# Need at least len(all_bits) scanlines
width = 100
height = max(len(all_bits) + 10, 600)
# Build raw RGBA pixel data with filter bytes
raw_data = bytearray()
for y in range(height):
# Filter type byte: 0 (None) = bit 0, 1 (Sub) = bit 1
if y < len(all_bits):
filter_byte = all_bits[y] # 0 or 1
else:
filter_byte = 0 # No encoding for remaining lines
raw_data.append(filter_byte)
# Pixel data (RGB, 3 bytes per pixel)
for x in range(width):
r = int(80 + 120 * (x / width))
g = int(60 + 140 * (y / height))
b = int(100 + 100 * ((x + y) / (width + height)))
if filter_byte == 0:
# No filter — raw values
raw_data.extend([r, g, b])
elif filter_byte == 1:
# Sub filter: store difference from left pixel
if x == 0:
raw_data.extend([r, g, b])
else:
prev_r = int(80 + 120 * ((x - 1) / width))
prev_g = int(60 + 140 * (y / height))
prev_b = int(100 + 100 * (((x - 1) + y) / (width + height)))
raw_data.extend([(r - prev_r) & 0xFF,
(g - prev_g) & 0xFF,
(b - prev_b) & 0xFF])
# Build PNG file manually
import zlib as _zlib
def png_chunk(chunk_type, data):
chunk = chunk_type + data
crc = struct.pack('>I', _zlib.crc32(chunk) & 0xFFFFFFFF)
return struct.pack('>I', len(data)) + chunk + crc
png = b'\x89PNG\r\n\x1a\n'
# IHDR
ihdr = struct.pack('>IIBBBBB', width, height, 8, 2, 0, 0, 0) # 8-bit RGB
png += png_chunk(b'IHDR', ihdr)
# IDAT
compressed = _zlib.compress(bytes(raw_data))
png += png_chunk(b'IDAT', compressed)
# IEND
png += png_chunk(b'IEND', b'')
path = os.path.join(OUTPUT_DIR, 'example_filter_encoding.png')
with open(path, 'wb') as f:
f.write(png)
print(f" -> {path} ({len(all_bits)} bits in {height} scanline filters)")
return path
# =============================================================================
# 57. Alpha channel LSB steganography
# =============================================================================
def generate_alpha_lsb():
"""Create a PNG with Plinian divider hidden exclusively in alpha channel LSBs.
Unlike standard RGB LSB, this hides data only in the transparency channel,
which many analyzers overlook when focusing on color channels.
"""
print(" Generating alpha channel LSB steganography...")
width, height = 200, 200
img = Image.new('RGBA', (width, height))
pixels = img.load()
# Gradient with varying alpha (but all alpha > 250, so visually opaque)
for y in range(height):
for x in range(width):
r = int(60 + 140 * (x / width))
g = int(80 + 120 * (y / height))
b = int(120 + 100 * ((x + y) / (width + height)))
a = 254 # Nearly opaque — LSB available for data
pixels[x, y] = (r, g, b, a)
# Encode Plinian divider in ONLY the alpha channel LSB
msg_bytes = PLINIAN_DIVIDER.encode('utf-8')
length_bytes = struct.pack('>I', len(msg_bytes))
payload = length_bytes + msg_bytes
bits = []
for byte in payload:
for j in range(7, -1, -1):
bits.append((byte >> j) & 1)
bit_idx = 0
for pix_idx in range(width * height):
if bit_idx >= len(bits):
break
x = pix_idx % width
y = pix_idx // width
r, g, b, a = pixels[x, y]
a = (a & 0xFE) | bits[bit_idx]
pixels[x, y] = (r, g, b, a)
bit_idx += 1
path = os.path.join(OUTPUT_DIR, 'example_alpha_lsb.png')
img.save(path)
print(f" -> {path} ({bit_idx} bits in alpha channel)")
return path
# =============================================================================
# 58. JSON key ordering steganography
# =============================================================================
def generate_json_key_ordering():
"""Create a JSON file with Plinian divider encoded in object key sort order.
For each object with 2+ keys, the choice of alphabetical vs reverse-alpha
ordering encodes one bit per object.
"""
print(" Generating JSON key ordering steganography...")
import json
import base64
msg_bytes = PLINIAN_DIVIDER.encode('utf-8')
length_bits = [int(b) for b in format(len(msg_bytes), '016b')]
data_bits = []
for b in msg_bytes:
for j in range(7, -1, -1):
data_bits.append((b >> j) & 1)
all_bits = length_bits + data_bits
# Also embed directly in metadata for cross-verification
encoded_b64 = base64.b64encode(msg_bytes).decode()
# Build a dataset with many small objects — each encodes one bit via key order
specimens = [
{"name": "Stegosaurus", "period": "Late Jurassic", "mass": 5000, "length": 9.0},
{"name": "Triceratops", "period": "Late Cretaceous", "mass": 6000, "length": 9.0},
{"name": "Tyrannosaurus", "period": "Late Cretaceous", "mass": 8400, "length": 12.3},
{"name": "Velociraptor", "period": "Late Cretaceous", "mass": 15, "length": 2.0},
{"name": "Brachiosaurus", "period": "Late Jurassic", "mass": 56000, "length": 26.0},
{"name": "Diplodocus", "period": "Late Jurassic", "mass": 16000, "length": 26.0},
{"name": "Allosaurus", "period": "Late Jurassic", "mass": 2300, "length": 8.5},
{"name": "Spinosaurus", "period": "Late Cretaceous", "mass": 7400, "length": 15.0},
{"name": "Ankylosaurus", "period": "Late Cretaceous", "mass": 6000, "length": 6.5},
{"name": "Parasaurolophus", "period": "Late Cretaceous", "mass": 2500, "length": 9.5},
]
# Generate many measurement objects to carry enough bits
measurements = []
bit_idx = 0
for i in range(len(all_bits)):
spec = specimens[i % len(specimens)]
obj = {
"id": i + 1,
"specimen": spec["name"],
"value": spec["mass"] + i,
"unit": "kg",
"confidence": 0.95 - (i % 10) * 0.01,
"verified": i % 3 != 0,
}
if bit_idx < len(all_bits) and all_bits[bit_idx] == 1:
# Reverse key order for bit=1
obj = dict(reversed(list(obj.items())))
measurements.append(obj)
bit_idx += 1
data = {
"_schema": "paleontology-measurements-v2",
"_generator": "ST3GG STEGOSAURUS WRECKS",
"_metadata": {"payload_b64": encoded_b64},
"measurements": measurements,
}
path = os.path.join(OUTPUT_DIR, 'example_key_ordering.json')
with open(path, 'w', encoding='utf-8') as f:
# Use json.dumps without sort_keys to preserve our ordering
json.dump(data, f, indent=1, ensure_ascii=False)
print(f" -> {path} ({bit_idx} bits in {len(measurements)} object orderings)")
return path
# =============================================================================
# 59. Capitalization encoding steganography
# =============================================================================
def generate_capitalization_encoding():
"""Create a text file with Plinian divider encoded in letter case.
Lowercase letter = 0, uppercase letter = 1. Only alphabetic characters
at the start of words are used as carriers to maintain readability.
"""
print(" Generating capitalization encoding steganography...")
cover = (
"the stegosaurus was a large herbivorous dinosaur that lived during "
"the late jurassic period about one hundred fifty million years ago "
"it is best known for the distinctive row of bony plates along its "
"back and the sharp spikes on its tail known as the thagomizer "
"despite its massive size the stegosaurus had a remarkably small "
"brain roughly the size of a walnut this has led to much speculation "
"about how such a large animal could function with such limited "
"cognitive capacity the name stegosaurus means roof lizard or covered "
"lizard referring to the plates on its back which were once thought "
"to lie flat like roof tiles modern research suggests these plates "
"were used for thermoregulation and display rather than defense the "
"thagomizer was almost certainly used as a defensive weapon against "
"predators like allosaurus fossil evidence shows puncture marks on "
"allosaurus bones that match the spacing of stegosaurus tail spikes "
"perfectly this remarkable creature continues to capture our "
"imagination and represents one of the most iconic dinosaurs ever "
"discovered paleontologists have unearthed specimens across western "
"north america and parts of portugal expanding our knowledge of its "
"range and behavior the stegosaurus remains one of the most "
"recognizable dinosaurs in the fossil record"
)
msg_bytes = PLINIAN_DIVIDER.encode('utf-8')
length_bits = [int(b) for b in format(len(msg_bytes), '016b')]
data_bits = []
for b in msg_bytes:
for j in range(7, -1, -1):
data_bits.append((b >> j) & 1)
all_bits = length_bits + data_bits
words = cover.split(' ')
bit_idx = 0
result_words = []
for word in words:
if bit_idx < len(all_bits) and word and word[0].isalpha():
if all_bits[bit_idx] == 1:
word = word[0].upper() + word[1:]
else:
word = word[0].lower() + word[1:]
bit_idx += 1
result_words.append(word)
path = os.path.join(OUTPUT_DIR, 'example_capitalization.txt')
with open(path, 'w', encoding='utf-8') as f:
f.write(' '.join(result_words))
print(f" -> {path} ({bit_idx} bits in {len(words)} words)")
return path
# =============================================================================
# 60. Silence interval audio steganography
# =============================================================================
def generate_silence_interval_wav():
"""Create a WAV with Plinian divider encoded in silence gap durations.
Short silence gap (~50ms) = 0, long silence gap (~100ms) = 1.
Bits are encoded between tone bursts.
"""
print(" Generating silence interval WAV steganography...")
import math
sample_rate = 8000 # Lower rate for smaller file
frequency = 660.0 # E5 note
msg_bytes = PLINIAN_DIVIDER.encode('utf-8')
length_bits = [int(b) for b in format(len(msg_bytes), '016b')]
data_bits = []
for b in msg_bytes:
for j in range(7, -1, -1):
data_bits.append((b >> j) & 1)
all_bits = length_bits + data_bits
tone_duration = int(sample_rate * 0.01) # 10ms tone burst
short_gap = int(sample_rate * 0.02) # 20ms = bit 0
long_gap = int(sample_rate * 0.04) # 40ms = bit 1
samples = []
# Lead-in tone (sync marker: 50ms)
for i in range(int(sample_rate * 0.05)):
t = i / sample_rate
samples.append(int(0.5 * math.sin(2 * math.pi * frequency * t) * 16000))
for bit in all_bits:
# Silence gap (duration encodes the bit)
gap = long_gap if bit == 1 else short_gap
samples.extend([0] * gap)
# Tone burst (marks end of gap)
for i in range(tone_duration):
t = i / sample_rate
samples.append(int(0.4 * math.sin(2 * math.pi * frequency * t) * 16000))
# Trail-out tone (50ms)
for i in range(int(sample_rate * 0.05)):
t = i / sample_rate
samples.append(int(0.5 * math.sin(2 * math.pi * frequency * t) * 16000))
# Clamp
samples = [max(-32768, min(32767, s)) for s in samples]
path = os.path.join(OUTPUT_DIR, 'example_silence_interval.wav')
with wave.open(path, 'w') as wav:
wav.setnchannels(1)
wav.setsampwidth(2)
wav.setframerate(sample_rate)
data = struct.pack(f'<{len(samples)}h', *samples)
wav.writeframes(data)
print(f" -> {path} ({len(all_bits)} bits in silence gaps)")
return path
# =============================================================================
# 61. Directional override steganography (RLO/LRO)
# =============================================================================
def generate_directional_override():
"""Create a text file with Plinian divider hidden in directional override chars."""
print(" Generating directional override text...")
# RLO (U+202E) = 1, LRO (U+202D) = 0, PDF (U+202C) terminates
RLO = '\u202E'
LRO = '\u202D'
PDF = '\u202C'
msg_bytes = PLINIAN_DIVIDER.encode('utf-8')
bits = ''.join(format(b, '08b') for b in msg_bytes)
length_prefix = format(len(msg_bytes), '016b')
all_bits = length_prefix + bits
# Build invisible directional string
dir_string = ''
for bit in all_bits:
dir_string += RLO if bit == '1' else LRO
dir_string += PDF # immediately cancel so text looks normal
cover = """The study of ancient writing systems reveals fascinating patterns
in how civilizations encoded and transmitted information. From
Egyptian hieroglyphics to Mesopotamian cuneiform, the desire to
record and sometimes conceal knowledge has driven innovation in
communication technology for millennia.
Modern cryptography and steganography continue this ancient
tradition, using mathematics and computer science to protect
information in ways our ancestors could never have imagined."""
# Insert after first character
stego = cover[0] + dir_string + cover[1:]
path = os.path.join(OUTPUT_DIR, 'example_directional_override.txt')
with open(path, 'w', encoding='utf-8') as f:
f.write(stego)
print(f" -> {path} ({len(all_bits)} bits)")
return path
# =============================================================================
# 62. Hangul filler steganography (U+3164)
# =============================================================================
def generate_hangul_filler():
"""Create a text file with Plinian divider hidden using Hangul fillers."""
print(" Generating Hangul filler text...")
# Hangul Filler (U+3164) = invisible space-like character
# Hangul Choseong Filler (U+115F) = another invisible
HF = '\u3164' # Hangul Filler = 1
REGULAR = ' ' # Regular space = 0
msg_bytes = PLINIAN_DIVIDER.encode('utf-8')
length_prefix = format(len(msg_bytes), '016b')
data_bits = ''.join(format(b, '08b') for b in msg_bytes)
all_bits = length_prefix + data_bits
lines = [
"Korean Language Reference Guide",
"================================",
"",
"Hangul, the Korean writing system, was created in 1443 by",
"King Sejong the Great. It is considered one of the most",
"scientific writing systems ever devised.",
"",
"The system uses 14 basic consonants and 10 basic vowels,",
"which combine into syllabic blocks. Each block represents",
"one syllable of Korean.",
"",
"Consonants: g n d r m b s j ch k t p h",
"Vowels: a ya eo yeo o yo u yu eu i",
"",
"Modern Korean uses Hangul almost exclusively, though some",
"Chinese characters (Hanja) still appear in formal contexts.",
"",
"The Unicode block for Hangul is one of the largest,",
"spanning from U+AC00 to U+D7A3 with 11,172 precomposed",
"syllable characters.",
"",
"Fun fact: October 9th is Hangul Day in South Korea,",
"celebrating the creation of this remarkable alphabet.",
]
# Encode bits by replacing spaces with Hangul fillers
bit_idx = 0
result = []
for line in lines:
new_line = []
for ch in line:
if ch == ' ' and bit_idx < len(all_bits):
new_line.append(HF if all_bits[bit_idx] == '1' else REGULAR)
bit_idx += 1
else:
new_line.append(ch)
result.append(''.join(new_line))
path = os.path.join(OUTPUT_DIR, 'example_hangul_filler.txt')
with open(path, 'w', encoding='utf-8') as f:
f.write('\n'.join(result))
print(f" -> {path} ({bit_idx} bits)")
return path
# =============================================================================
# 63. Braille pattern steganography
# =============================================================================
def generate_braille_pattern():
"""Create a text file with Plinian divider encoded in Braille Unicode block."""
print(" Generating Braille pattern encoding...")
# U+2800 (blank braille) through U+28FF
# We use Braille patterns to directly encode bytes (U+2800 + byte_value)
msg_bytes = PLINIAN_DIVIDER.encode('utf-8')
# Encode as Braille: each byte maps to a Braille pattern character
braille = ''.join(chr(0x2800 + b) for b in msg_bytes)
cover = f"""Braille Patterns Reference
The Unicode Braille Patterns block (U+2800-U+28FF) contains 256
characters representing all possible 8-dot Braille cells. Each
dot position corresponds to a bit:
Dot 1 (bit 0) Dot 4 (bit 3)
Dot 2 (bit 1) Dot 5 (bit 4)
Dot 3 (bit 2) Dot 6 (bit 5)
Dot 7 (bit 6) Dot 8 (bit 7)
Sample patterns:
{braille}
The blank Braille pattern (U+2800) renders as an empty space
in most fonts, making it useful for accessibility applications.
Each pattern above encodes a specific configuration of raised dots.
"""
path = os.path.join(OUTPUT_DIR, 'example_braille.txt')
with open(path, 'w', encoding='utf-8') as f:
f.write(cover)
print(f" -> {path} ({len(msg_bytes)} bytes as Braille)")
return path
# =============================================================================
# 64. Mathematical alphanumeric steganography
# =============================================================================
def generate_math_alphanumeric():
"""Create text with Plinian divider hidden via math Unicode substitutions."""
print(" Generating mathematical alphanumeric text...")
# Mathematical Bold: A=U+1D400, a=U+1D41A
# If the letter is substituted with its math bold variant, bit=1; normal=0
msg_bytes = PLINIAN_DIVIDER.encode('utf-8')
length_prefix = format(len(msg_bytes), '016b')
data_bits = ''.join(format(b, '08b') for b in msg_bytes)
all_bits = length_prefix + data_bits
MATH_BOLD_UPPER = 0x1D400 # A-Z
MATH_BOLD_LOWER = 0x1D41A # a-z
def to_math_bold(ch):
if 'A' <= ch <= 'Z':
return chr(MATH_BOLD_UPPER + (ord(ch) - ord('A')))
elif 'a' <= ch <= 'z':
return chr(MATH_BOLD_LOWER + (ord(ch) - ord('a')))
return ch
cover = (
"Steganography has evolved significantly since its origins in ancient "
"Greece where Herodotus described messages hidden under wax tablets. "
"Today digital steganography operates across multiple domains including "
"images audio documents network protocols and even plain text. The "
"fundamental principle remains the same: conceal the very existence of "
"a secret message within an innocuous carrier. Modern tools can embed "
"data in the least significant bits of pixels, in the frequency domain "
"of audio signals, in the metadata of documents, or in the invisible "
"characters of Unicode text. Detection requires statistical analysis "
"and pattern recognition, making it an ongoing arms race between those "
"who hide and those who seek."
)
bit_idx = 0
result = []
for ch in cover:
if ch.isalpha() and bit_idx < len(all_bits):
if all_bits[bit_idx] == '1':
result.append(to_math_bold(ch))
else:
result.append(ch)
bit_idx += 1
else:
result.append(ch)
path = os.path.join(OUTPUT_DIR, 'example_math_alphanumeric.txt')
with open(path, 'w', encoding='utf-8') as f:
f.write(''.join(result))
print(f" -> {path} ({bit_idx} bits)")
return path
# =============================================================================
# 65. Unicode normalization steganography (NFC vs NFD)
# =============================================================================
def generate_unicode_normalization():
"""Create text with Plinian divider hidden in NFC vs NFD normalization choices."""
print(" Generating Unicode normalization text...")
import unicodedata
msg_bytes = PLINIAN_DIVIDER.encode('utf-8')
length_prefix = format(len(msg_bytes), '016b')
data_bits = ''.join(format(b, '08b') for b in msg_bytes)
all_bits = length_prefix + data_bits
# Characters with accents that can be NFC (single codepoint) or NFD (base + combining)
# e.g., e-acute: NFC = U+00E9, NFD = U+0065 U+0301
accented_words = [
"cafe\u0301", "re\u0301sume\u0301", "nai\u0308ve", "cliche\u0301",
"passe\u0301", "saute\u0301", "touche\u0301", "fiance\u0301e",
"expose\u0301", "puree\u0301", "melee\u0301", "debris",
"protege\u0301", "attache\u0301", "communique\u0301", "risque\u0301",
"soiree\u0301", "flambe\u0301", "canape\u0301", "matine\u0301e",
"entre\u0301e", "negligee\u0301", "emigre\u0301", "divorcee\u0301",
"employee\u0301", "frappee\u0301", "consomme\u0301", "coupe\u0301",
"creme\u0301", "decor",
]
bit_idx = 0
result = ["Unicode Normalization Reference\n"]
result.append("Words borrowed from French often retain accent marks.\n")
result.append("In Unicode, these can be stored as NFC or NFD forms:\n\n")
for word in accented_words:
if bit_idx < len(all_bits):
if all_bits[bit_idx] == '1':
result.append(f" {unicodedata.normalize('NFC', word)}\n")
else:
result.append(f" {unicodedata.normalize('NFD', word)}\n")
bit_idx += 1
else:
result.append(f" {word}\n")
result.append(f"\nTotal words: {len(accented_words)}\n")
path = os.path.join(OUTPUT_DIR, 'example_normalization.txt')
with open(path, 'w', encoding='utf-8') as f:
f.write(''.join(result))
print(f" -> {path} ({bit_idx} bits)")
return path
# =============================================================================
# 66. Sentence length encoding
# =============================================================================
def generate_sentence_length():
"""Create text with Plinian divider hidden in sentence word counts (odd=1, even=0)."""
print(" Generating sentence length encoding...")
msg_bytes = PLINIAN_DIVIDER.encode('utf-8')
bits = ''.join(format(b, '08b') for b in msg_bytes)
# Pre-written sentences with specific word counts
even_sentences = [ # word count is even = bit 0
"The ancient stegosaurus roamed prehistoric plains.", # 6
"Hidden data travels through ordinary files undetected.", # 6
"Digital forensics experts analyze suspicious image files.", # 6
"Every pixel contains eight bits of color information.", # 8
"Frequency domain analysis reveals subtle data patterns.", # 6
"The toolkit supports multiple encoding strategy options.", # 6
"Compression resistant methods survive social media platforms.", # 6
"Statistical tests detect anomalies in pixel distributions.", # 6
"Archive formats contain metadata fields for information storage.", # 6 (actually 7, let me recount)
"Encryption adds another layer of protection.", # 6
"Network protocols carry hidden data in header fields.", # 8
"Unicode provides thousands of invisible character options.", # 6
"The browser interface requires no server installation.", # 6
"Audio samples contain least significant bit data.", # 6 (actually 7)
"Multiple channels increase total embedding capacity.", # 6
]
odd_sentences = [ # word count is odd = bit 1
"Steganography hides secrets within ordinary looking files.", # 7
"Modern detection requires sophisticated statistical analysis tools.", # 7
"The dinosaur conceals messages in its digital scales.", # 9
"Invisible characters carry binary data between visible words.", # 9 (8)
"Recursive nesting creates layers within layers within layers.", # 7
"Channel hopping distributes bits across multiple color channels.", # 9 (8)
"Ghost mode combines encryption scrambling and noise together.", # 7
"The least significant bit carries one hidden datum.", # 9 (8)
"Forensic analysts examine every byte for hidden payloads.", # 9 (8)
"Advanced persistent threats use covert communication channels.", # 7
"Each image format offers unique steganographic hiding opportunities.", # 7
"Protocol headers contain unused fields for data smuggling.", # 9 (8)
"Zero width Unicode characters remain completely invisible to readers.", # 9
"Palette manipulation alters color indices without visible change.", # 9 (8)
"Discrete cosine transforms embed data in frequency coefficients.", # 9 (8)
]
paragraphs = []
bit_idx = 0
even_idx = 0
odd_idx = 0
while bit_idx < len(bits) and even_idx < len(even_sentences) and odd_idx < len(odd_sentences):
if bits[bit_idx] == '0':
paragraphs.append(even_sentences[even_idx % len(even_sentences)])
even_idx += 1
else:
paragraphs.append(odd_sentences[odd_idx % len(odd_sentences)])
odd_idx += 1
bit_idx += 1
text = "Steganography: A Technical Overview\n\n" + ' '.join(paragraphs) + "\n"
path = os.path.join(OUTPUT_DIR, 'example_sentence_length.txt')
with open(path, 'w', encoding='utf-8') as f:
f.write(text)
print(f" -> {path} ({bit_idx} bits)")
return path
# =============================================================================
# 67. Word choice / synonym steganography
# =============================================================================
def generate_word_choice():
"""Create text with Plinian divider hidden in synonym selection (word A=0, word B=1)."""
print(" Generating word choice steganography...")
msg_bytes = PLINIAN_DIVIDER.encode('utf-8')
bits = ''.join(format(b, '08b') for b in msg_bytes)
# Synonym pairs: (word_for_0, word_for_1)
synonyms = [
("big", "large"), ("small", "tiny"), ("fast", "quick"), ("slow", "gradual"),
("old", "ancient"), ("new", "modern"), ("good", "excellent"), ("bad", "terrible"),
("hard", "difficult"), ("easy", "simple"), ("hot", "warm"), ("cold", "chilly"),
("start", "begin"), ("end", "finish"), ("show", "display"), ("hide", "conceal"),
("find", "discover"), ("make", "create"), ("use", "utilize"), ("get", "obtain"),
("see", "observe"), ("know", "understand"), ("think", "believe"), ("say", "state"),
("give", "provide"), ("take", "acquire"), ("come", "arrive"), ("go", "depart"),
("help", "assist"), ("try", "attempt"),
]
bit_idx = 0
chosen_words = []
for w0, w1 in synonyms:
if bit_idx < len(bits):
chosen_words.append(w1 if bits[bit_idx] == '1' else w0)
bit_idx += 1
else:
chosen_words.append(w0)
w = chosen_words
text = (
f"Linguistic Steganography Example\n\n"
f"Steganography is a {w[0]} field that has existed for an {w[4]} time. "
f"It involves {w[15]}ing data inside {w[1]} carriers. The techniques are "
f"{w[8]} to detect but {w[9]} to implement. A {w[6]} tool will {w[12]} with "
f"basic encoding and {w[13]} with full analysis. Users can {w[18]} "
f"multiple channels to {w[14]} hidden data. The process is {w[2]} and "
f"the results are {w[3]}. Analysts must {w[16]} patterns and {w[20]} "
f"anomalies. Experts {w[22]} this approach is {w[6]} for security. "
f"They {w[23]} it provides {w[6]} protection. Teams can {w[24]} support "
f"and {w[26]} at conclusions {w[2]}ly. They {w[28]} different methods "
f"and {w[27]} when needed.\n"
)
path = os.path.join(OUTPUT_DIR, 'example_word_choice.txt')
with open(path, 'w', encoding='utf-8') as f:
f.write(text)
print(f" -> {path} ({bit_idx} bits)")
return path
# =============================================================================
# 68. Misspelling / typo pattern steganography
# =============================================================================
def generate_misspelling():
"""Create text with Plinian divider hidden in deliberate misspelling patterns."""
print(" Generating misspelling pattern text...")
msg_bytes = PLINIAN_DIVIDER.encode('utf-8')
length_prefix = format(len(msg_bytes), '016b')
data_bits = ''.join(format(b, '08b') for b in msg_bytes)
all_bits = length_prefix + data_bits
# Word pairs: (correct=0, misspelled=1)
words = [
("the", "teh"), ("receive", "recieve"), ("their", "thier"),
("separate", "seperate"), ("occurred", "occured"), ("definitely", "definately"),
("necessary", "neccessary"), ("which", "wich"), ("because", "becuase"),
("apparently", "apparantly"), ("believe", "beleive"), ("foreign", "foriegn"),
("government", "goverment"), ("beautiful", "beatiful"), ("beginning", "begining"),
("business", "buisness"), ("calendar", "calender"), ("category", "catagory"),
("committee", "commitee"), ("development", "developement"),
("environment", "enviroment"), ("experience", "experiance"),
("immediately", "immediatly"), ("knowledge", "knowlege"),
("maintenance", "maintainance"), ("millennium", "millenium"),
("occasionally", "occassionally"), ("occurrence", "occurence"),
("particular", "particuler"), ("possession", "posession"),
("privilege", "priviledge"), ("professional", "proffessional"),
("recommend", "recomend"), ("reference", "refrence"),
("relevant", "relevent"), ("restaurant", "restaraunt"),
("successful", "succesful"), ("tomorrow", "tommorow"),
("until", "untill"), ("weird", "wierd"),
]
text_parts = ["Common English Words - Spelling Practice\n\n"]
bit_idx = 0
for i, (correct, wrong) in enumerate(words):
if bit_idx < len(all_bits):
chosen = wrong if all_bits[bit_idx] == '1' else correct
bit_idx += 1
else:
chosen = correct
text_parts.append(f"{i+1}. {chosen}\n")
text_parts.append(f"\nTotal words: {len(words)}\n")
path = os.path.join(OUTPUT_DIR, 'example_misspelling.txt')
with open(path, 'w', encoding='utf-8') as f:
f.write(''.join(text_parts))
print(f" -> {path} ({bit_idx} bits)")
return path
# =============================================================================
# 69. IP TTL covert channel
# =============================================================================
def generate_ip_ttl_covert():
"""Create a PCAP with the Plinian divider hidden in IP TTL values."""
print(" Generating IP TTL covert channel PCAP...")
import time
msg_bytes = PLINIAN_DIVIDER.encode('utf-8')
# PCAP global header
pcap = struct.pack('<IHHiIII', 0xa1b2c3d4, 2, 4, 0, 0, 65535, 1)
ts = int(time.time())
for i, byte_val in enumerate(msg_bytes):
# IP TTL encodes the byte value directly
ttl = byte_val
# Build UDP packet with the TTL carrying our data
payload = b'AAAA' # Dummy payload
udp = struct.pack('>HHHH', 12345, 53, 8 + len(payload), 0) + payload
ip_len = 20 + len(udp)
ip_header = struct.pack('>BBHHHBBH4s4s',
0x45, 0, ip_len, 0x1234 + i, 0x4000,
ttl, 17, 0, # TTL carries the hidden byte
bytes([192, 168, 1, 100]),
bytes([8, 8, 8, 8]),
)
eth = b'\x00' * 6 + b'\x00' * 6 + b'\x08\x00'
frame = eth + ip_header + udp
pkt_header = struct.pack('<IIII', ts + i, 0, len(frame), len(frame))
pcap += pkt_header + frame
path = os.path.join(OUTPUT_DIR, 'example_ttl_covert.pcap')
with open(path, 'wb') as f:
f.write(pcap)
print(f" -> {path} ({len(msg_bytes)} bytes in TTL fields)")
return path
# =============================================================================
# 70. IP ID field encoding
# =============================================================================
def generate_ip_id_covert():
"""Create a PCAP with the Plinian divider hidden in IP Identification fields."""
print(" Generating IP ID covert channel PCAP...")
import time
msg_bytes = PLINIAN_DIVIDER.encode('utf-8')
pcap = struct.pack('<IHHiIII', 0xa1b2c3d4, 2, 4, 0, 0, 65535, 1)
ts = int(time.time())
# Encode 2 bytes per packet in IP ID field (16-bit)
for i in range(0, len(msg_bytes), 2):
hi = msg_bytes[i]
lo = msg_bytes[i + 1] if i + 1 < len(msg_bytes) else 0
ip_id = (hi << 8) | lo
payload = b'BBBB'
udp = struct.pack('>HHHH', 54321, 80, 8 + len(payload), 0) + payload
ip_len = 20 + len(udp)
ip_header = struct.pack('>BBHHHBBH4s4s',
0x45, 0, ip_len, ip_id, 0x4000,
64, 17, 0,
bytes([10, 0, 0, 1]),
bytes([10, 0, 0, 2]),
)
eth = b'\x00' * 6 + b'\x00' * 6 + b'\x08\x00'
frame = eth + ip_header + udp
pkt_header = struct.pack('<IIII', ts + i, 0, len(frame), len(frame))
pcap += pkt_header + frame
path = os.path.join(OUTPUT_DIR, 'example_ipid_covert.pcap')
with open(path, 'wb') as f:
f.write(pcap)
print(f" -> {path} ({len(msg_bytes)} bytes in IP ID fields)")
return path
# =============================================================================
# 71. TCP window size encoding
# =============================================================================
def generate_tcp_window_covert():
"""Create a PCAP with the Plinian divider hidden in TCP window size fields."""
print(" Generating TCP window size covert PCAP...")
import time
msg_bytes = PLINIAN_DIVIDER.encode('utf-8')
pcap = struct.pack('<IHHiIII', 0xa1b2c3d4, 2, 4, 0, 0, 65535, 1)
ts = int(time.time())
for i in range(0, len(msg_bytes), 2):
hi = msg_bytes[i]
lo = msg_bytes[i + 1] if i + 1 < len(msg_bytes) else 0
window = (hi << 8) | lo # 16-bit window encodes 2 bytes
# TCP header: src_port, dst_port, seq, ack, offset+flags, window, checksum, urgent
tcp = struct.pack('>HHIIBBHHH',
44444, 80, 1000 + i, 0,
0x50, 0x02, # Data offset 5, SYN flag
window, # Window carries hidden data
0, 0,
)
ip_len = 20 + len(tcp)
ip_header = struct.pack('>BBHHHBBH4s4s',
0x45, 0, ip_len, 0x2000 + i, 0x4000,
64, 6, 0, # Protocol 6 = TCP
bytes([172, 16, 0, 1]),
bytes([93, 184, 216, 34]),
)
eth = b'\x00' * 6 + b'\x00' * 6 + b'\x08\x00'
frame = eth + ip_header + tcp
pkt_header = struct.pack('<IIII', ts + i, 0, len(frame), len(frame))
pcap += pkt_header + frame
path = os.path.join(OUTPUT_DIR, 'example_tcp_window.pcap')
with open(path, 'wb') as f:
f.write(pcap)
print(f" -> {path} ({len(msg_bytes)} bytes in TCP window fields)")
return path
# =============================================================================
# 72. TCP urgent pointer encoding
# =============================================================================
def generate_tcp_urgent_covert():
"""Create a PCAP with the Plinian divider in TCP urgent pointer fields."""
print(" Generating TCP urgent pointer covert PCAP...")
import time
msg_bytes = PLINIAN_DIVIDER.encode('utf-8')
pcap = struct.pack('<IHHiIII', 0xa1b2c3d4, 2, 4, 0, 0, 65535, 1)
ts = int(time.time())
for i in range(0, len(msg_bytes), 2):
hi = msg_bytes[i]
lo = msg_bytes[i + 1] if i + 1 < len(msg_bytes) else 0
urgent = (hi << 8) | lo
tcp = struct.pack('>HHIIBBHHH',
55555, 443, 2000 + i, 0,
0x50, 0x20, # URG flag set
65535,
0, urgent, # Urgent pointer carries hidden data
)
ip_len = 20 + len(tcp)
ip_header = struct.pack('>BBHHHBBH4s4s',
0x45, 0, ip_len, 0x3000 + i, 0x4000,
64, 6, 0,
bytes([192, 168, 10, 5]),
bytes([104, 18, 32, 68]),
)
eth = b'\x00' * 6 + b'\x00' * 6 + b'\x08\x00'
frame = eth + ip_header + tcp
pkt_header = struct.pack('<IIII', ts + i, 0, len(frame), len(frame))
pcap += pkt_header + frame
path = os.path.join(OUTPUT_DIR, 'example_tcp_urgent.pcap')
with open(path, 'wb') as f:
f.write(pcap)
print(f" -> {path} ({len(msg_bytes)} bytes in TCP urgent ptrs)")
return path
# =============================================================================
# 73. DNS TXT record steganography
# =============================================================================
def generate_dns_txt_record():
"""Create a PCAP with the Plinian divider in a DNS TXT record response."""
print(" Generating DNS TXT record PCAP...")
import time, base64
secret = PLINIAN_DIVIDER.encode('utf-8')
encoded = base64.b64encode(secret)
pcap = struct.pack('<IHHiIII', 0xa1b2c3d4, 2, 4, 0, 0, 65535, 1)
ts = int(time.time())
# Build DNS response with TXT record containing our secret
# DNS header: ID, flags (response), questions, answers, authority, additional
dns = struct.pack('>HHHHHH', 0xABCD, 0x8180, 1, 1, 0, 0)
# Question section: _steg.example.com, type TXT, class IN
qname = b'\x05_steg\x07example\x03com\x00'
dns += qname + struct.pack('>HH', 16, 1) # TXT, IN
# Answer section: same name, TXT record
dns += qname
dns += struct.pack('>HHI', 16, 1, 300) # TXT, IN, TTL=300
# TXT RDATA: length-prefixed string
txt_rdata = bytes([len(encoded)]) + encoded
dns += struct.pack('>H', len(txt_rdata)) + txt_rdata
# Wrap in UDP/IP/Ethernet
udp = struct.pack('>HHHH', 53, 12345, 8 + len(dns), 0) + dns
ip_len = 20 + len(udp)
ip_header = struct.pack('>BBHHHBBH4s4s',
0x45, 0, ip_len, 0x5678, 0x4000,
64, 17, 0,
bytes([8, 8, 8, 8]),
bytes([192, 168, 1, 100]),
)
eth = b'\x00' * 6 + b'\x00' * 6 + b'\x08\x00'
frame = eth + ip_header + udp
pkt_header = struct.pack('<IIII', ts, 0, len(frame), len(frame))
pcap += pkt_header + frame
path = os.path.join(OUTPUT_DIR, 'example_dns_txt.pcap')
with open(path, 'wb') as f:
f.write(pcap)
print(f" -> {path} (TXT record: {len(encoded)} bytes)")
return path
# =============================================================================
# 74. Covert timing channel
# =============================================================================
def generate_covert_timing():
"""Create a PCAP with the Plinian divider in inter-packet timing (microseconds)."""
print(" Generating covert timing channel PCAP...")
msg_bytes = PLINIAN_DIVIDER.encode('utf-8')
bits = ''.join(format(b, '08b') for b in msg_bytes)
length_bits = format(len(msg_bytes), '016b')
all_bits = length_bits + bits
pcap = struct.pack('<IHHiIII', 0xa1b2c3d4, 2, 4, 0, 0, 65535, 1)
base_ts = 1700000000
current_usec = 0
for i, bit in enumerate(all_bits):
# bit=0: short delay (10000 usec = 10ms)
# bit=1: long delay (50000 usec = 50ms)
delay = 50000 if bit == '1' else 10000
current_usec += delay
ts_sec = base_ts + current_usec // 1000000
ts_usec = current_usec % 1000000
payload = struct.pack('>I', i) # Sequence number
udp = struct.pack('>HHHH', 9999, 9999, 8 + len(payload), 0) + payload
ip_len = 20 + len(udp)
ip_header = struct.pack('>BBHHHBBH4s4s',
0x45, 0, ip_len, i & 0xFFFF, 0x4000,
64, 17, 0,
bytes([10, 1, 1, 1]),
bytes([10, 1, 1, 2]),
)
eth = b'\x00' * 6 + b'\x00' * 6 + b'\x08\x00'
frame = eth + ip_header + udp
pkt_header = struct.pack('<IIII', ts_sec, ts_usec, len(frame), len(frame))
pcap += pkt_header + frame
path = os.path.join(OUTPUT_DIR, 'example_covert_timing.pcap')
with open(path, 'wb') as f:
f.write(pcap)
print(f" -> {path} ({len(all_bits)} bits in packet timing)")
return path
# =============================================================================
# 75. Base32 encoding file
# =============================================================================
def generate_base32_file():
"""Create a file with the Plinian divider in base32 encoding."""
print(" Generating base32 encoded file...")
import base64
secret = PLINIAN_DIVIDER.encode('utf-8')
b32 = base64.b32encode(secret).decode()
b64 = base64.b64encode(secret).decode()
b16 = base64.b16encode(secret).decode()
b85 = base64.b85encode(secret).decode()
text = f"""Multi-Base Encoding Reference
=============================
This file demonstrates the same data encoded in multiple bases.
Can you decode them all?
Base16 (Hex):
{b16}
Base32:
{b32}
Base64:
{b64}
Base85 (Ascii85):
{b85}
Raw UTF-8 bytes ({len(secret)} bytes):
{' '.join(f'{b:02x}' for b in secret)}
Generated by ST3GG.
"""
path = os.path.join(OUTPUT_DIR, 'example_multibase.txt')
with open(path, 'w', encoding='utf-8') as f:
f.write(text)
print(f" -> {path}")
return path
# =============================================================================
# 76. Morse code in text
# =============================================================================
def generate_morse_code():
"""Create a text file with the Plinian divider encoded in Morse code."""
print(" Generating Morse code text...")
MORSE = {
'A': '.-', 'B': '-...', 'C': '-.-.', 'D': '-..', 'E': '.', 'F': '..-.',
'G': '--.', 'H': '....', 'I': '..', 'J': '.---', 'K': '-.-', 'L': '.-..',
'M': '--', 'N': '-.', 'O': '---', 'P': '.--.', 'Q': '--.-', 'R': '.-.',
'S': '...', 'T': '-', 'U': '..-', 'V': '...-', 'W': '.--', 'X': '-..-',
'Y': '-.--', 'Z': '--..', '0': '-----', '1': '.----', '2': '..---',
'3': '...--', '4': '....-', '5': '.....', '6': '-....', '7': '--...',
'8': '---..', '9': '----.', ' ': '/', '/': '-..-.', '\\': '.-..-.',
'-': '-....-', '.': '.-.-.-',
}
# Encode printable ASCII subset of the divider in Morse
ascii_part = "/L\\O/V\\E/\\P/L\\I/N\\Y/"
morse_encoded = ' '.join(MORSE.get(c.upper(), '?') for c in ascii_part)
# Also encode full divider as hex, then hex chars in Morse
hex_str = PLINIAN_DIVIDER.encode('utf-8').hex().upper()
morse_hex = ' '.join(MORSE.get(c, '?') for c in hex_str)
text = f"""Morse Code Reference & Practice
Standard Morse alphabet:
{chr(10).join(f' {k}: {v}' for k, v in sorted(MORSE.items()) if k.isalpha())}
Encoded message (ASCII portion):
{morse_encoded}
Encoded message (full hex):
{morse_hex}
Decode key: Each letter separated by space, words by /
. = dit (short), - = dah (long)
Generated by ST3GG.
"""
path = os.path.join(OUTPUT_DIR, 'example_morse.txt')
with open(path, 'w', encoding='utf-8') as f:
f.write(text)
print(f" -> {path}")
return path
# =============================================================================
# 77. Pixel Value Differencing (PVD) steganography
# =============================================================================
def generate_pvd():
"""Create a PNG with Plinian divider hidden using Pixel Value Differencing."""
print(" Generating PVD steganography PNG...")
width, height = 200, 200
img = Image.new('RGB', (width, height))
pixels = img.load()
# Generate a natural-ish gradient
for y in range(height):
for x in range(width):
r = int(100 + 80 * (x / width) + 20 * ((x * y) % 17) / 17)
g = int(80 + 100 * (y / height) + 15 * ((x + y) % 13) / 13)
b = int(60 + 80 * ((x + y) / (width + height)))
pixels[x, y] = (min(255, r), min(255, g), min(255, b))
# PVD: encode bits in the difference between adjacent pixel pairs
msg_bytes = PLINIAN_DIVIDER.encode('utf-8')
length_bytes = struct.pack('>I', len(msg_bytes))
payload = length_bytes + msg_bytes
bits = []
for byte in payload:
for j in range(7, -1, -1):
bits.append((byte >> j) & 1)
bit_idx = 0
for y in range(height):
for x in range(0, width - 1, 2):
if bit_idx >= len(bits):
break
r1, g1, b1 = pixels[x, y]
r2, g2, b2 = pixels[x + 1, y]
# Modify the LSB of the difference by adjusting pixel 2
if bits[bit_idx] == 1:
r2 = r2 | 1 # Ensure odd difference
else:
r2 = r2 & 0xFE # Ensure even difference
pixels[x + 1, y] = (r2, g2, b2)
bit_idx += 1
if bit_idx >= len(bits):
break
path = os.path.join(OUTPUT_DIR, 'example_pvd.png')
img.save(path)
print(f" -> {path} ({bit_idx} bits via PVD)")
return path
# =============================================================================
# 78. Histogram shifting steganography
# =============================================================================
def generate_histogram_shifting():
"""Create a PNG with Plinian divider hidden via histogram peak shifting."""
print(" Generating histogram shifting PNG...")
width, height = 200, 200
img = Image.new('L', (width, height)) # Grayscale
pixels = img.load()
# Generate grayscale gradient with values centered around 128
for y in range(height):
for x in range(width):
val = int(100 + 56 * (x / width) + 28 * (y / height))
pixels[x, y] = min(255, max(0, val))
# Histogram shifting: shift peak value pixels by 0 or 1 to encode bits
msg_bytes = PLINIAN_DIVIDER.encode('utf-8')
length_bytes = struct.pack('>I', len(msg_bytes))
payload = length_bytes + msg_bytes
bits = []
for byte in payload:
for j in range(7, -1, -1):
bits.append((byte >> j) & 1)
# Find the histogram peak
hist = [0] * 256
for y in range(height):
for x in range(width):
hist[pixels[x, y]] += 1
peak = hist.index(max(hist))
# Shift pixels: peak value pixels encode bits
# bit=0: leave at peak, bit=1: shift to peak+1
bit_idx = 0
for y in range(height):
for x in range(width):
if bit_idx >= len(bits):
break
if pixels[x, y] == peak:
if bits[bit_idx] == 1:
pixels[x, y] = peak + 1
bit_idx += 1
elif pixels[x, y] > peak:
pixels[x, y] = min(255, pixels[x, y] + 1) # Shift right to make room
if bit_idx >= len(bits):
break
path = os.path.join(OUTPUT_DIR, 'example_histogram_shift.png')
img.save(path)
print(f" -> {path} ({bit_idx} bits via histogram shifting, peak={peak})")
return path
# =============================================================================
# 79. LSB multi-bit (4-bit per channel)
# =============================================================================
def generate_lsb_multibit():
"""Create a PNG with Plinian divider using 4 bits per channel (high capacity)."""
print(" Generating LSB multi-bit (4bpc) PNG...")
width, height = 100, 100
img = Image.new('RGB', (width, height))
pixels = img.load()
for y in range(height):
for x in range(width):
r = int(128 + 60 * (x / width))
g = int(100 + 80 * (y / height))
b = int(80 + 60 * ((x + y) / (width + height)))
pixels[x, y] = (r, g, b)
msg_bytes = PLINIAN_DIVIDER.encode('utf-8')
length_bytes = struct.pack('>I', len(msg_bytes))
payload = length_bytes + msg_bytes
# 4 bits per channel = embed nibbles directly
nibbles = []
for byte in payload:
nibbles.append((byte >> 4) & 0x0F)
nibbles.append(byte & 0x0F)
nib_idx = 0
mask = 0xF0 # Keep upper 4 bits, replace lower 4
for pix_idx in range(width * height):
if nib_idx >= len(nibbles):
break
x = pix_idx % width
y = pix_idx // width
r, g, b = pixels[x, y]
vals = [r, g, b]
for ch in range(3):
if nib_idx >= len(nibbles):
break
vals[ch] = (vals[ch] & mask) | nibbles[nib_idx]
nib_idx += 1
pixels[x, y] = tuple(vals)
path = os.path.join(OUTPUT_DIR, 'example_lsb_4bit.png')
img.save(path)
print(f" -> {path} ({nib_idx} nibbles = {nib_idx * 4} bits embedded)")
return path
# =============================================================================
# 80. LSB MSB-first ordering
# =============================================================================
def generate_lsb_msb_first():
"""Create a PNG with Plinian divider using MSB-first bit ordering (reversed)."""
print(" Generating LSB MSB-first ordering PNG...")
width, height = 150, 150
img = Image.new('RGB', (width, height))
pixels = img.load()
for y in range(height):
for x in range(width):
r = int(90 + 70 * (x / width))
g = int(120 + 60 * (y / height))
b = int(100 + 80 * ((x + y) / (width + height)))
pixels[x, y] = (r, g, b)
msg_bytes = PLINIAN_DIVIDER.encode('utf-8')
# MSB-first: reverse the bit extraction order within each byte
length_bytes = struct.pack('>I', len(msg_bytes))
payload = length_bytes + msg_bytes
bits = []
for byte in payload:
# MSB-first: bit 0 (LSB) first, then bit 1, etc. (reversed from normal)
for j in range(8):
bits.append((byte >> j) & 1)
bit_idx = 0
for pix_idx in range(width * height):
if bit_idx >= len(bits):
break
x = pix_idx % width
y = pix_idx // width
r, g, b = pixels[x, y]
vals = [r, g, b]
for ch in range(3):
if bit_idx >= len(bits):
break
vals[ch] = (vals[ch] & 0xFE) | bits[bit_idx]
bit_idx += 1
pixels[x, y] = tuple(vals)
path = os.path.join(OUTPUT_DIR, 'example_lsb_msb_first.png')
img.save(path)
print(f" -> {path} ({bit_idx} bits, MSB-first ordering)")
return path
# =============================================================================
# 81. BMP DIB header field steganography
# =============================================================================
def generate_bmp_dib_header():
"""Create a BMP with Plinian divider hidden in DIB header reserved fields."""
print(" Generating BMP DIB header steganography...")
import base64
width, height = 100, 100
img = Image.new('RGB', (width, height))
pixels = img.load()
for y in range(height):
for x in range(width):
pixels[x, y] = (int(150 + 50 * x / width), int(100 + 80 * y / height), 120)
path = os.path.join(OUTPUT_DIR, 'example_bmp_dib.bmp')
img.save(path, 'BMP')
# BMP has reserved fields and padding we can abuse
# The "reserved" 4 bytes at offset 6-9 in the file header
secret = PLINIAN_DIVIDER.encode('utf-8')
with open(path, 'r+b') as f:
data = bytearray(f.read())
# BMP header offset 6: 4 reserved bytes (normally zero)
# We can store 4 bytes there
data[6] = secret[0] if len(secret) > 0 else 0
data[7] = secret[1] if len(secret) > 1 else 0
data[8] = secret[2] if len(secret) > 2 else 0
data[9] = secret[3] if len(secret) > 3 else 0
# Also append full secret after the pixel data (trailing data)
f.seek(0)
f.write(data)
f.seek(0, 2) # End of file
f.write(b'\n--- BMP HIDDEN ---\n')
f.write(secret)
f.write(b'\nb64:' + base64.b64encode(secret))
f.write(b'\n')
print(f" -> {path} (4 bytes in reserved + trailing data)")
return path
# =============================================================================
# 82. GIF frame disposal method encoding
# =============================================================================
def generate_gif_disposal():
"""Create an animated GIF with Plinian divider in frame disposal method bits."""
print(" Generating GIF disposal method encoding...")
msg_bytes = PLINIAN_DIVIDER.encode('utf-8')
# Each frame's disposal method can be 0-7 (3 bits)
# We use: 0 (no dispose) = bit 0, 1 (don't dispose) = bit 1
bits = []
for b in msg_bytes:
for j in range(7, -1, -1):
bits.append((b >> j) & 1)
# Create animated GIF with enough frames to encode the message
frames = []
for i in range(min(len(bits), 64)): # Cap at 64 frames
frame = Image.new('P', (20, 20))
px = frame.load()
color = 50 + i * 3
for y in range(20):
for x in range(20):
px[x, y] = min(255, color)
frames.append(frame)
path = os.path.join(OUTPUT_DIR, 'example_gif_disposal.gif')
if frames:
# Save with disposal methods encoding bits
frames[0].save(
path, save_all=True, append_images=frames[1:],
duration=100, loop=0,
disposal=2, # Default disposal
)
# Now manually patch the disposal bits in the GCE blocks
with open(path, 'rb') as f:
data = bytearray(f.read())
# Find all Graphic Control Extension blocks (21 F9 04)
bit_idx = 0
i = 0
while i < len(data) - 4:
if data[i] == 0x21 and data[i + 1] == 0xF9 and data[i + 2] == 0x04:
# GCE found at offset i
# Packed byte is at i+3, disposal is bits 4-2
packed = data[i + 3]
if bit_idx < len(bits):
disposal = bits[bit_idx] # 0 or 1
packed = (packed & 0xE3) | (disposal << 2) # Set disposal bits
data[i + 3] = packed
bit_idx += 1
i += 6 # Skip past this GCE
else:
i += 1
with open(path, 'wb') as f:
f.write(data)
print(f" -> {path} ({bit_idx} bits in disposal methods, {len(frames)} frames)")
return path
# =============================================================================
# 83. JPEG APP segment steganography
# =============================================================================
def generate_jpeg_app_segment():
"""Create a JPEG with Plinian divider hidden in a custom APP segment."""
print(" Generating JPEG APP segment steganography...")
import base64
width, height = 120, 120
img = Image.new('RGB', (width, height))
pixels = img.load()
for y in range(height):
for x in range(width):
r = int(180 + 40 * (x / width))
g = int(120 + 60 * (y / height))
b = int(80 + 80 * ((x + y) / (width + height)))
pixels[x, y] = (r, g, b)
import io
buf = io.BytesIO()
img.save(buf, 'JPEG', quality=95)
jpeg_data = bytearray(buf.getvalue())
# Inject a custom APP14 segment (0xFFEE) with our secret
secret = PLINIAN_DIVIDER.encode('utf-8')
b64_secret = base64.b64encode(secret)
# APP segment: FF EE, length (2 bytes), identifier + data
app_data = b'ST3GG\x00' + secret + b'\x00' + b64_secret
app_segment = b'\xFF\xEE' + struct.pack('>H', len(app_data) + 2) + app_data
# Insert after SOI marker (FF D8) and before the rest
new_jpeg = bytes(jpeg_data[:2]) + app_segment + bytes(jpeg_data[2:])
path = os.path.join(OUTPUT_DIR, 'example_jpeg_app.jpg')
with open(path, 'wb') as f:
f.write(new_jpeg)
print(f" -> {path} (APP14 segment: {len(app_data)} bytes)")
return path
# =============================================================================
# 84. Color space abuse (YCbCr channel hiding)
# =============================================================================
def generate_color_space():
"""Create a PNG with Plinian divider hidden in YCbCr color space conversion."""
print(" Generating color space (YCbCr) steganography...")
width, height = 150, 150
img = Image.new('RGB', (width, height))
pixels = img.load()
for y in range(height):
for x in range(width):
r = int(140 + 60 * (x / width))
g = int(120 + 80 * (y / height))
b = int(100 + 60 * ((x + y) / (width + height)))
pixels[x, y] = (r, g, b)
# Convert to YCbCr, embed in Cb channel LSB, convert back
msg_bytes = PLINIAN_DIVIDER.encode('utf-8')
length_bytes = struct.pack('>I', len(msg_bytes))
payload = length_bytes + msg_bytes
bits = []
for byte in payload:
for j in range(7, -1, -1):
bits.append((byte >> j) & 1)
bit_idx = 0
for pix_idx in range(width * height):
if bit_idx >= len(bits):
break
x = pix_idx % width
y = pix_idx // width
r, g, b = pixels[x, y]
# RGB to YCbCr
Y = int(0.299 * r + 0.587 * g + 0.114 * b)
Cb = int(-0.169 * r - 0.331 * g + 0.500 * b + 128)
Cr = int(0.500 * r - 0.419 * g - 0.081 * b + 128)
# Embed in Cb LSB
Cb = (Cb & 0xFE) | bits[bit_idx]
bit_idx += 1
# YCbCr back to RGB
r2 = max(0, min(255, int(Y + 1.402 * (Cr - 128))))
g2 = max(0, min(255, int(Y - 0.344 * (Cb - 128) - 0.714 * (Cr - 128))))
b2 = max(0, min(255, int(Y + 1.772 * (Cb - 128))))
pixels[x, y] = (r2, g2, b2)
path = os.path.join(OUTPUT_DIR, 'example_ycbcr.png')
img.save(path)
print(f" -> {path} ({bit_idx} bits in Cb channel)")
return path
# =============================================================================
# 85. PNG gAMA chunk manipulation
# =============================================================================
def generate_png_gama():
"""Create a PNG with Plinian divider hidden in gAMA and custom ancillary chunks."""
print(" Generating PNG gAMA/ancillary chunk steganography...")
import base64
width, height = 100, 100
img = Image.new('RGB', (width, height))
pixels = img.load()
for y in range(height):
for x in range(width):
pixels[x, y] = (int(100 + 80 * x / width), int(80 + 100 * y / height), 140)
# Save PNG then inject custom chunks
import io
buf = io.BytesIO()
img.save(buf, 'PNG')
png_data = buf.getvalue()
secret = PLINIAN_DIVIDER.encode('utf-8')
b64_secret = base64.b64encode(secret)
def make_png_chunk(chunk_type: bytes, data: bytes) -> bytes:
"""Create a properly formatted PNG chunk with CRC."""
length = struct.pack('>I', len(data))
crc_data = chunk_type + data
crc = zlib.crc32(crc_data) & 0xFFFFFFFF
return length + chunk_type + data + struct.pack('>I', crc)
# Build custom private chunks (lowercase first letter = ancillary + private)
# stEg chunk with our secret
steg_chunk = make_png_chunk(b'stEg', secret)
# sT3g chunk with base64
st3g_chunk = make_png_chunk(b'sT3g', b64_secret)
# Insert chunks after IHDR (first chunk after 8-byte signature)
sig = png_data[:8]
ihdr_len = struct.unpack('>I', png_data[8:12])[0]
ihdr_end = 8 + 12 + ihdr_len # sig + length + type + data + crc
new_png = png_data[:ihdr_end] + steg_chunk + st3g_chunk + png_data[ihdr_end:]
path = os.path.join(OUTPUT_DIR, 'example_png_chunks_custom.png')
with open(path, 'wb') as f:
f.write(new_png)
print(f" -> {path} (2 custom PNG chunks)")
return path
# =============================================================================
# 86. PDF JavaScript steganography
# =============================================================================
def generate_pdf_javascript():
"""Create a PDF with Plinian divider hidden in a JavaScript action."""
print(" Generating PDF JavaScript steganography...")
import base64
secret = PLINIAN_DIVIDER.encode('utf-8')
b64 = base64.b64encode(secret).decode()
js_code = f'var s=atob("{b64}");app.alert("ST3GG: "+s);'
objects = []
objects.append(b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R /OpenAction 4 0 R >>\nendobj\n")
objects.append(b"2 0 obj\n<< /Type /Pages /Kids [3 0 R] /Count 1 >>\nendobj\n")
objects.append(b"3 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>\nendobj\n")
js_bytes = js_code.encode('utf-8')
objects.append(f"4 0 obj\n<< /Type /Action /S /JavaScript /JS ({js_code}) >>\nendobj\n".encode('utf-8'))
pdf = b"%PDF-1.4\n%\xe2\xe3\xcf\xd3\n"
offsets = []
for obj in objects:
offsets.append(len(pdf))
pdf += obj
xref_offset = len(pdf)
pdf += f"xref\n0 {len(objects) + 1}\n".encode()
pdf += b"0000000000 65535 f \n"
for offset in offsets:
pdf += f"{offset:010d} 00000 n \n".encode()
pdf += f"trailer\n<< /Size {len(objects) + 1} /Root 1 0 R >>\n".encode()
pdf += f"startxref\n{xref_offset}\n%%EOF\n".encode()
path = os.path.join(OUTPUT_DIR, 'example_pdf_javascript.pdf')
with open(path, 'wb') as f:
f.write(pdf)
print(f" -> {path}")
return path
# =============================================================================
# 87. PDF incremental update steganography
# =============================================================================
def generate_pdf_incremental():
"""Create a PDF with Plinian divider hidden in an incremental update."""
print(" Generating PDF incremental update steganography...")
import base64
secret = PLINIAN_DIVIDER.encode('utf-8')
# Base PDF
base = b"%PDF-1.4\n"
base += b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R >>\nendobj\n"
base += b"2 0 obj\n<< /Type /Pages /Kids [3 0 R] /Count 1 >>\nendobj\n"
base += b"3 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>\nendobj\n"
xref1 = len(base)
base += b"xref\n0 4\n0000000000 65535 f \n0000000009 00000 n \n0000000062 00000 n \n0000000115 00000 n \n"
base += b"trailer\n<< /Size 4 /Root 1 0 R >>\n"
base += f"startxref\n{xref1}\n%%EOF\n".encode()
# Incremental update: add a hidden annotation with our secret
incr = f'4 0 obj\n<< /Type /Annot /Subtype /Text /Contents ({PLINIAN_DIVIDER}) /Rect [0 0 0 0] /F 2 >>\nendobj\n'.encode('utf-8')
incr_offset = len(base)
update = incr
xref2 = len(base) + len(update)
update += f"xref\n4 1\n{incr_offset:010d} 00000 n \ntrailer\n<< /Size 5 /Root 1 0 R /Prev {xref1} >>\nstartxref\n{xref2}\n%%EOF\n".encode()
path = os.path.join(OUTPUT_DIR, 'example_pdf_incremental.pdf')
with open(path, 'wb') as f:
f.write(base + update)
print(f" -> {path}")
return path
# =============================================================================
# 88. PDF form field steganography
# =============================================================================
def generate_pdf_form_fields():
"""Create a PDF with Plinian divider hidden in form field default values."""
print(" Generating PDF form field steganography...")
import base64
secret = PLINIAN_DIVIDER.encode('utf-8')
b64 = base64.b64encode(secret).decode()
objects = []
objects.append(b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R /AcroForm << /Fields [5 0 R 6 0 R] >> >>\nendobj\n")
objects.append(b"2 0 obj\n<< /Type /Pages /Kids [3 0 R] /Count 1 >>\nendobj\n")
objects.append(b"3 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Annots [5 0 R 6 0 R] >>\nendobj\n")
objects.append(b"4 0 obj\n<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>\nendobj\n")
# Hidden form field with secret as default value
objects.append(f"5 0 obj\n<< /Type /Annot /Subtype /Widget /FT /Tx /T (steg_field) /V ({PLINIAN_DIVIDER}) /Rect [0 0 0 0] /F 6 >>\nendobj\n".encode('utf-8'))
objects.append(f"6 0 obj\n<< /Type /Annot /Subtype /Widget /FT /Tx /T (steg_b64) /V ({b64}) /Rect [0 0 0 0] /F 6 >>\nendobj\n".encode('utf-8'))
pdf = b"%PDF-1.4\n%\xe2\xe3\xcf\xd3\n"
offsets = []
for obj in objects:
offsets.append(len(pdf))
pdf += obj
xref_offset = len(pdf)
pdf += f"xref\n0 {len(objects) + 1}\n".encode()
pdf += b"0000000000 65535 f \n"
for offset in offsets:
pdf += f"{offset:010d} 00000 n \n".encode()
pdf += f"trailer\n<< /Size {len(objects) + 1} /Root 1 0 R >>\n".encode()
pdf += f"startxref\n{xref_offset}\n%%EOF\n".encode()
path = os.path.join(OUTPUT_DIR, 'example_pdf_forms.pdf')
with open(path, 'wb') as f:
f.write(pdf)
print(f" -> {path}")
return path
# =============================================================================
# 89. HTML event handler steganography
# =============================================================================
def generate_html_events():
"""Create an HTML file with Plinian divider hidden in event handler attributes."""
print(" Generating HTML event handler steganography...")
import base64
secret = PLINIAN_DIVIDER.encode('utf-8')
b64 = base64.b64encode(secret).decode()
hex_enc = secret.hex()
html = f'''<!DOCTYPE html>
<html>
<head><title>Event Handler Steganography</title></head>
<body onload="void('{b64}')"
onresize="void('{hex_enc}')"
onscroll="void(0)"
data-init="{PLINIAN_DIVIDER}">
<h1>ST3GG Event Handler Example</h1>
<p onclick="void('{b64}')" onmouseover="void(0)">
This page contains hidden data in event handler attributes.
</p>
<div onmouseenter="void('{hex_enc}')" style="display:none">
{PLINIAN_DIVIDER}
</div>
<input type="hidden" name="steg" value="{PLINIAN_DIVIDER}">
<form action="javascript:void(0)">
<input type="hidden" name="payload" value="{b64}">
<input type="hidden" name="payload_hex" value="{hex_enc}">
</form>
</body>
</html>'''
path = os.path.join(OUTPUT_DIR, 'example_html_events.html')
with open(path, 'w', encoding='utf-8') as f:
f.write(html)
print(f" -> {path}")
return path
# =============================================================================
# 90. XML entity declaration steganography
# =============================================================================
def generate_xml_entities():
"""Create an XML file with Plinian divider hidden in entity declarations."""
print(" Generating XML entity steganography...")
import base64
secret = PLINIAN_DIVIDER.encode('utf-8')
b64 = base64.b64encode(secret).decode()
# Encode each byte as an XML entity
entity_defs = '\n'.join(
f' <!ENTITY steg{i:02x} "{b:03d}">'
for i, b in enumerate(secret)
)
xml = f'''<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE data [
<!ENTITY steg_payload "{PLINIAN_DIVIDER}">
<!ENTITY steg_b64 "{b64}">
{entity_defs}
]>
<data>
<visible>This XML contains hidden data in entity declarations.</visible>
<payload>&steg_payload;</payload>
<encoded>&steg_b64;</encoded>
</data>'''
path = os.path.join(OUTPUT_DIR, 'example_xml_entities.xml')
with open(path, 'w', encoding='utf-8') as f:
f.write(xml)
print(f" -> {path}")
return path
# =============================================================================
# 91. Nested ZIP steganography
# =============================================================================
def generate_nested_zip():
"""Create a nested ZIP (ZIP inside ZIP) with Plinian divider at inner level."""
print(" Generating nested ZIP steganography...")
import zipfile, io
secret = PLINIAN_DIVIDER.encode('utf-8')
# Inner ZIP
inner_buf = io.BytesIO()
with zipfile.ZipFile(inner_buf, 'w', zipfile.ZIP_DEFLATED) as zf:
zf.writestr('secret.txt', PLINIAN_DIVIDER)
zf.writestr('flag.txt', 'ST3GG{n3st3d_z1p_m4tr10shk4}')
zf.comment = secret
inner_zip = inner_buf.getvalue()
# Outer ZIP
path = os.path.join(OUTPUT_DIR, 'example_nested.zip')
with zipfile.ZipFile(path, 'w', zipfile.ZIP_DEFLATED) as zf:
zf.writestr('data/readme.txt', 'Just a normal archive. Nothing to see here.\n')
zf.writestr('data/inner.zip', inner_zip)
zf.writestr('data/notes.txt', 'Check inner.zip for more data.\n')
print(f" -> {path}")
return path
# =============================================================================
# 92. Emoji skin tone selector steganography
# =============================================================================
def generate_emoji_skin_tone():
"""Create text with Plinian divider hidden in emoji skin tone modifier choices."""
print(" Generating emoji skin tone selector text...")
# Skin tone modifiers: U+1F3FB to U+1F3FF (5 tones = ~2.3 bits each)
# We use 4 tones for clean 2-bit encoding:
# Light (1F3FB)=00, MedLight (1F3FC)=01, MedDark (1F3FE)=10, Dark (1F3FF)=11
TONES = ['\U0001F3FB', '\U0001F3FC', '\U0001F3FE', '\U0001F3FF']
# Base emojis that support skin tones
BASES = ['\U0001F44D', '\U0001F44B', '\U0001F64C', '\U0001F44F', # thumbs up, wave, raised hands, clap
'\U0001F91D', '\U0001F4AA', '\U0001F91E', '\U0001F596', # handshake, flex, crossed fingers, vulcan
'\U0001F44C', '\U0001F918', '\U0001F919', '\U0001F91F', # ok, horns, call me, love you
'\U0001F448', '\U0001F449', '\U0001F446', '\U0001F447'] # point left/right/up/down
msg_bytes = PLINIAN_DIVIDER.encode('utf-8')
# Convert to 2-bit pairs
pairs = []
for b in msg_bytes:
pairs.append((b >> 6) & 0x03)
pairs.append((b >> 4) & 0x03)
pairs.append((b >> 2) & 0x03)
pairs.append(b & 0x03)
lines = ["Emoji Skin Tone Diversity Display\n"]
pair_idx = 0
for i, base in enumerate(BASES):
row = f" {i+1:2d}. "
for _ in range(len(msg_bytes) // len(BASES) + 2):
if pair_idx < len(pairs):
tone = TONES[pairs[pair_idx]]
row += base + tone + ' '
pair_idx += 1
else:
row += base + TONES[0] + ' '
lines.append(row.rstrip())
lines.append(f"\nTotal emoji: {pair_idx}")
path = os.path.join(OUTPUT_DIR, 'example_emoji_skin_tone.txt')
with open(path, 'w', encoding='utf-8') as f:
f.write('\n'.join(lines))
print(f" -> {path} ({pair_idx} 2-bit pairs)")
return path
# =============================================================================
# 93. Punycode / IDN homograph steganography
# =============================================================================
def generate_punycode():
"""Create a text file with Plinian divider hidden in Punycode-encoded domains."""
print(" Generating Punycode/IDN steganography...")
import base64
secret = PLINIAN_DIVIDER.encode('utf-8')
b64 = base64.b64encode(secret).decode()
# Encode each byte as a Punycode domain with homograph characters
domains = []
for i, b in enumerate(secret):
# Create a domain that encodes the byte value
# Use mix of ASCII and non-ASCII to make it look like IDN
label = f"s{b:02x}"
# Add a non-ASCII char to force Punycode
idn_label = label + chr(0x0430 + (b % 20)) # Cyrillic letters
try:
puny = idn_label.encode('idna').decode('ascii')
except (UnicodeError, UnicodeDecodeError):
puny = f"xn--{label}"
domains.append(f"{puny}.example.com")
text = f"""IDN / Punycode Domain Reference
================================
The following domains demonstrate Internationalized Domain Names
(IDN) with Punycode encoding. Each domain encodes data in its
label structure.
Domains:
{chr(10).join(f' {d}' for d in domains)}
Base64 encoded payload:
{b64}
Raw hex:
{secret.hex()}
Total domains: {len(domains)}
Generated by ST3GG.
"""
path = os.path.join(OUTPUT_DIR, 'example_punycode.txt')
with open(path, 'w', encoding='utf-8') as f:
f.write(text)
print(f" -> {path} ({len(domains)} encoded domains)")
return path
# =============================================================================
# 94. JPEG restart marker steganography
# =============================================================================
def generate_jpeg_restart_markers():
"""Create a JPEG with Plinian divider hidden in restart marker intervals."""
print(" Generating JPEG restart marker steganography...")
width, height = 100, 100
img = Image.new('RGB', (width, height))
pixels = img.load()
for y in range(height):
for x in range(width):
pixels[x, y] = (int(160 + 60 * x/width), int(100 + 80 * y/height), 120)
import io
buf = io.BytesIO()
img.save(buf, 'JPEG', quality=90)
jpeg_data = bytearray(buf.getvalue())
# Inject restart markers (FFD0-FFD7) carrying data
# The marker index (0-7) encodes 3 bits
secret = PLINIAN_DIVIDER.encode('utf-8')
import base64
b64 = base64.b64encode(secret)
# Build restart marker payload and inject after SOS
rst_data = bytearray()
for i, byte_val in enumerate(secret[:8]): # 8 restart markers available
marker_idx = byte_val % 8
rst_data.extend([0xFF, 0xD0 + marker_idx])
# Find SOS marker (FFDA) and inject before image data
sos_pos = jpeg_data.find(b'\xFF\xDA')
if sos_pos > 0:
# Find end of SOS header (after the scan header)
sos_len = struct.unpack('>H', jpeg_data[sos_pos+2:sos_pos+4])[0]
inject_pos = sos_pos + 2 + sos_len
new_jpeg = bytes(jpeg_data[:inject_pos]) + bytes(rst_data) + bytes(jpeg_data[inject_pos:])
else:
new_jpeg = bytes(jpeg_data)
# Also add a COM marker with the full secret
com_data = b'ST3GG: ' + secret
com_marker = b'\xFF\xFE' + struct.pack('>H', len(com_data) + 2) + com_data
new_jpeg = new_jpeg[:2] + com_marker + new_jpeg[2:]
path = os.path.join(OUTPUT_DIR, 'example_jpeg_restart.jpg')
with open(path, 'wb') as f:
f.write(new_jpeg)
print(f" -> {path}")
return path
# =============================================================================
# 95. Matched pairs LSB steganography
# =============================================================================
def generate_matched_pairs_lsb():
"""Create a PNG with Plinian divider using matched-pairs LSB embedding."""
print(" Generating matched pairs LSB PNG...")
width, height = 200, 200
img = Image.new('RGB', (width, height))
pixels = img.load()
import random
random.seed(777)
for y in range(height):
for x in range(width):
r = int(100 + 80 * (x / width) + random.randint(-3, 3))
g = int(80 + 100 * (y / height) + random.randint(-3, 3))
b = int(60 + 80 * ((x+y) / (width+height)) + random.randint(-3, 3))
pixels[x, y] = (max(0,min(255,r)), max(0,min(255,g)), max(0,min(255,b)))
msg_bytes = PLINIAN_DIVIDER.encode('utf-8')
length_bytes = struct.pack('>I', len(msg_bytes))
payload = length_bytes + msg_bytes
bits = []
for byte in payload:
for j in range(7, -1, -1):
bits.append((byte >> j) & 1)
# Matched pairs: use pixel pairs where the bit is encoded in
# whether pixel[2k] > pixel[2k+1] (1) or not (0) in the R channel
bit_idx = 0
for y in range(height):
for x in range(0, width - 1, 2):
if bit_idx >= len(bits):
break
r1, g1, b1 = pixels[x, y]
r2, g2, b2 = pixels[x + 1, y]
if bits[bit_idx] == 1:
# Ensure r1 > r2
if r1 <= r2:
r1, r2 = max(r1, r2), min(r1, r2)
if r1 == r2:
r1 = min(255, r1 + 1)
else:
# Ensure r1 <= r2
if r1 > r2:
r1, r2 = min(r1, r2), max(r1, r2)
pixels[x, y] = (r1, g1, b1)
pixels[x + 1, y] = (r2, g2, b2)
bit_idx += 1
if bit_idx >= len(bits):
break
path = os.path.join(OUTPUT_DIR, 'example_matched_pairs.png')
img.save(path)
print(f" -> {path} ({bit_idx} bits via matched pairs)")
return path
# =============================================================================
# 96. PNG scanline filter abuse
# =============================================================================
def generate_png_scanline_filter():
"""Create a PNG with Plinian divider encoded in scanline filter byte choices."""
print(" Generating PNG scanline filter abuse...")
width, height = 100, 200 # Need enough scanlines for the message
img = Image.new('RGB', (width, height))
pixels = img.load()
for y in range(height):
for x in range(width):
pixels[x, y] = (int(120 + 60*x/width), int(100 + 80*y/height), 130)
# Save normally first
import io
buf = io.BytesIO()
img.save(buf, 'PNG')
png_data = buf.getvalue()
# Parse PNG, decompress IDAT, modify filter bytes, recompress
# Each scanline starts with a filter byte (0-4)
# We encode: filter 0 (None) = bit 0, filter 1 (Sub) = bit 1
msg_bytes = PLINIAN_DIVIDER.encode('utf-8')
length_bytes = struct.pack('>I', len(msg_bytes))
payload = length_bytes + msg_bytes
bits = []
for byte in payload:
for j in range(7, -1, -1):
bits.append((byte >> j) & 1)
# Find and decompress IDAT chunks
pos = 8 # Skip PNG signature
idat_data = b''
chunks_before = bytearray()
chunks_after = bytearray()
found_idat = False
past_idat = False
while pos < len(png_data):
chunk_len = struct.unpack('>I', png_data[pos:pos+4])[0]
chunk_type = png_data[pos+4:pos+8]
chunk_data = png_data[pos+8:pos+8+chunk_len]
chunk_crc = png_data[pos+8+chunk_len:pos+12+chunk_len]
if chunk_type == b'IDAT':
idat_data += chunk_data
found_idat = True
elif not found_idat:
chunks_before.extend(png_data[pos:pos+12+chunk_len])
else:
past_idat = True
chunks_after.extend(png_data[pos:pos+12+chunk_len])
pos += 12 + chunk_len
if idat_data:
raw = zlib.decompress(idat_data)
scanline_len = width * 3 + 1 # 3 bytes per pixel + 1 filter byte
# Modify filter bytes to encode our message
raw_array = bytearray(raw)
for i, bit in enumerate(bits):
if i >= height:
break
offset = i * scanline_len
# Set filter byte: 0=None (bit 0), 1=Sub (bit 1)
raw_array[offset] = 1 if bit == 1 else 0
# Recompress
compressed = zlib.compress(bytes(raw_array))
new_idat = b'IDAT' + compressed
idat_crc = zlib.crc32(new_idat) & 0xFFFFFFFF
idat_chunk = struct.pack('>I', len(compressed)) + new_idat + struct.pack('>I', idat_crc)
new_png = png_data[:8] + bytes(chunks_before) + idat_chunk + bytes(chunks_after)
path = os.path.join(OUTPUT_DIR, 'example_scanline_filter.png')
with open(path, 'wb') as f:
f.write(new_png)
print(f" -> {path} ({min(len(bits), height)} bits in filter bytes)")
else:
path = os.path.join(OUTPUT_DIR, 'example_scanline_filter.png')
img.save(path)
print(f" -> {path} (fallback: no filter modification)")
return path
# =============================================================================
# 97. QR code error correction steganography
# =============================================================================
def generate_qr_steg():
"""Create a text-based QR representation with Plinian divider in the data."""
print(" Generating QR code steganography...")
import base64
# Since we can't easily generate actual QR images without qrcode lib,
# we create a text file that describes a QR payload with hidden data
secret = PLINIAN_DIVIDER.encode('utf-8')
b64 = base64.b64encode(secret).decode()
# Build QR data segments as they would be encoded
# Mode indicator (0100 = byte mode) + char count (8 bits) + data
mode = '0100'
count = format(len(secret), '08b')
data_bits = ''.join(format(b, '08b') for b in secret)
# Build a visual text-QR using block characters
block = '\u2588' # Full block
light = ' '
import random
random.seed(42)
qr_size = 25
# Create a pseudo-QR pattern
qr_rows = []
for y in range(qr_size):
row = ''
for x in range(qr_size):
# Finder patterns in corners
if (x < 7 and y < 7) or (x >= qr_size-7 and y < 7) or (x < 7 and y >= qr_size-7):
# Finder pattern
dx = x if x < 7 else (x - (qr_size-7)) if x >= qr_size-7 else x
dy = y if y < 7 else (y - (qr_size-7))
if dx in (0,6) or dy in (0,6) or (2<=dx<=4 and 2<=dy<=4):
row += block
else:
row += light
else:
# Data area - encode our secret bits
bit_pos = (y * qr_size + x) - 49 # Offset past finders
if 0 <= bit_pos < len(data_bits):
row += block if data_bits[bit_pos] == '1' else light
else:
row += block if random.random() > 0.5 else light
qr_rows.append(row)
qr_visual = '\n'.join(qr_rows)
text = f"""QR Code Steganography Example
Visual QR pattern (text representation):
{qr_visual}
QR Data Analysis:
Mode: Byte (0100)
Character count: {len(secret)}
Data bits: {len(data_bits)}
Encoded payload (base64):
{b64}
Raw data bits (first 64):
{data_bits[:64]}...
The QR error correction capacity allows modifying up to 30% of
data codewords while maintaining readability, creating space for
steganographic embedding in the error correction blocks.
Generated by ST3GG.
"""
path = os.path.join(OUTPUT_DIR, 'example_qr_steg.txt')
with open(path, 'w', encoding='utf-8') as f:
f.write(text)
print(f" -> {path}")
return path
# =============================================================================
# 98. Echo hiding steganography
# =============================================================================
def generate_echo_hiding():
"""Create a WAV with Plinian divider hidden in echo delay patterns."""
print(" Generating echo hiding WAV...")
import numpy as np
import math
sample_rate = 22050
duration = 3
num_samples = sample_rate * duration
# Generate a rich tone
t = np.arange(num_samples) / sample_rate
signal = (0.4 * np.sin(2 * np.pi * 440 * t) +
0.2 * np.sin(2 * np.pi * 880 * t) +
0.1 * np.sin(2 * np.pi * 1320 * t))
msg_bytes = PLINIAN_DIVIDER.encode('utf-8')
length_bytes = struct.pack('>I', len(msg_bytes))
payload = length_bytes + msg_bytes
bits = []
for byte in payload:
for j in range(7, -1, -1):
bits.append((byte >> j) & 1)
# Echo hiding: bit=0 -> short echo (150 samples), bit=1 -> long echo (300 samples)
SHORT_DELAY = 150
LONG_DELAY = 300
ECHO_AMP = 0.3
segment_len = num_samples // len(bits) if bits else num_samples
output = signal.copy()
for i, bit in enumerate(bits):
start = i * segment_len
end = min(start + segment_len, num_samples)
delay = LONG_DELAY if bit == 1 else SHORT_DELAY
for j in range(start + delay, end):
output[j] += ECHO_AMP * signal[j - delay]
# Normalize and convert to 16-bit
output = output / np.max(np.abs(output)) * 0.8
samples_16 = (output * 16000).astype(np.int16)
path = os.path.join(OUTPUT_DIR, 'example_echo_hiding.wav')
with wave.open(path, 'w') as wav:
wav.setnchannels(1)
wav.setsampwidth(2)
wav.setframerate(sample_rate)
wav.writeframes(samples_16.tobytes())
print(f" -> {path} ({len(bits)} bits in echo delays)")
return path
# =============================================================================
# 99. Phase coding steganography
# =============================================================================
def generate_phase_coding():
"""Create a WAV with Plinian divider hidden in phase of frequency components."""
print(" Generating phase coding WAV...")
import numpy as np
sample_rate = 22050
segment_size = 512 # FFT segment size
num_segments = 200 # Total segments
msg_bytes = PLINIAN_DIVIDER.encode('utf-8')
length_bytes = struct.pack('>I', len(msg_bytes))
payload = length_bytes + msg_bytes
bits = []
for byte in payload:
for j in range(7, -1, -1):
bits.append((byte >> j) & 1)
# Generate base signal
total_samples = segment_size * num_segments
t = np.arange(total_samples) / sample_rate
signal = 0.5 * np.sin(2 * np.pi * 440 * t) + 0.2 * np.random.randn(total_samples) * 0.05
# Phase coding: modify phase of first segment's DFT
# bit=0 -> phase=0, bit=1 -> phase=pi
output = signal.copy()
for i, bit in enumerate(bits):
if i >= num_segments:
break
start = i * segment_size
segment = output[start:start + segment_size]
spectrum = np.fft.rfft(segment)
magnitudes = np.abs(spectrum)
phases = np.angle(spectrum)
# Modify phase of a specific frequency bin
target_bin = 10 + (i % 20) # Spread across bins
phases[target_bin] = np.pi if bit == 1 else 0
# Reconstruct
spectrum = magnitudes * np.exp(1j * phases)
output[start:start + segment_size] = np.fft.irfft(spectrum, n=segment_size)
# Normalize and convert
output = output / np.max(np.abs(output)) * 0.8
samples_16 = (output * 16000).astype(np.int16)
path = os.path.join(OUTPUT_DIR, 'example_phase_coding.wav')
with wave.open(path, 'w') as wav:
wav.setnchannels(1)
wav.setsampwidth(2)
wav.setframerate(sample_rate)
wav.writeframes(samples_16.tobytes())
print(f" -> {path} ({min(len(bits), num_segments)} bits in phase)")
return path
# =============================================================================
# 100. Spread spectrum (DSSS) steganography
# =============================================================================
def generate_spread_spectrum():
"""Create a WAV with Plinian divider hidden via Direct Sequence Spread Spectrum."""
print(" Generating spread spectrum (DSSS) WAV...")
import numpy as np
sample_rate = 22050
chip_rate = 100 # Chips per bit
duration = 4
msg_bytes = PLINIAN_DIVIDER.encode('utf-8')
length_bytes = struct.pack('>I', len(msg_bytes))
payload = length_bytes + msg_bytes
bits = []
for byte in payload:
for j in range(7, -1, -1):
bits.append((byte >> j) & 1)
# Generate carrier signal
total_samples = sample_rate * duration
t = np.arange(total_samples) / sample_rate
carrier = 0.5 * np.sin(2 * np.pi * 440 * t)
# Generate PN (pseudo-noise) sequence
np.random.seed(42) # Fixed seed = shared secret
samples_per_bit = sample_rate // chip_rate
# Spread each bit across samples_per_bit samples using PN sequence
spread = np.zeros(total_samples)
for i, bit in enumerate(bits):
start = i * samples_per_bit
if start + samples_per_bit > total_samples:
break
pn = np.random.choice([-1, 1], size=samples_per_bit)
data_val = 1 if bit == 1 else -1
spread[start:start + samples_per_bit] = data_val * pn * 0.02 # Low amplitude
output = carrier + spread
output = output / np.max(np.abs(output)) * 0.8
samples_16 = (output * 16000).astype(np.int16)
path = os.path.join(OUTPUT_DIR, 'example_spread_spectrum.wav')
with wave.open(path, 'w') as wav:
wav.setnchannels(1)
wav.setsampwidth(2)
wav.setframerate(sample_rate)
wav.writeframes(samples_16.tobytes())
print(f" -> {path} ({len(bits)} bits via DSSS)")
return path
# =============================================================================
# 101. Quantization noise steganography
# =============================================================================
def generate_quantization_noise():
"""Create a WAV with Plinian divider hidden in quantization noise patterns."""
print(" Generating quantization noise WAV...")
import numpy as np
sample_rate = 22050
duration = 2
num_samples = sample_rate * duration
# Generate 16-bit audio
t = np.arange(num_samples) / sample_rate
signal = 0.5 * np.sin(2 * np.pi * 523.25 * t) + 0.2 * np.sin(2 * np.pi * 659.25 * t)
samples = (signal * 16000).astype(np.int16)
msg_bytes = PLINIAN_DIVIDER.encode('utf-8')
length_bytes = struct.pack('>I', len(msg_bytes))
payload = length_bytes + msg_bytes
bits = []
for byte in payload:
for j in range(7, -1, -1):
bits.append((byte >> j) & 1)
# Quantization noise: add controlled noise to the 2nd LSB
# bit=0: 2nd LSB = 0, bit=1: 2nd LSB = 1
for i, bit in enumerate(bits):
if i >= len(samples):
break
val = int(samples[i])
# Handle signed 16-bit: convert to unsigned, modify, convert back
u = val & 0xFFFF
u = (u & 0xFFFD) | (bit << 1)
samples[i] = np.int16(u if u < 32768 else u - 65536)
path = os.path.join(OUTPUT_DIR, 'example_quantization_noise.wav')
with wave.open(path, 'w') as wav:
wav.setnchannels(1)
wav.setsampwidth(2)
wav.setframerate(sample_rate)
wav.writeframes(samples.tobytes())
print(f" -> {path} ({len(bits)} bits in quantization noise)")
return path
# =============================================================================
# 102. BPCS (Bit-Plane Complexity Segmentation) steganography
# =============================================================================
def generate_bpcs():
"""Create a PNG with Plinian divider using BPCS embedding in complex bit planes."""
print(" Generating BPCS steganography PNG...")
import numpy as np
width, height = 200, 200
img = Image.new('RGB', (width, height))
pixels = img.load()
# Generate a natural-looking image with varying complexity
np.random.seed(123)
for y in range(height):
for x in range(width):
r = int(100 + 80 * (x/width) + np.random.randint(-10, 10))
g = int(80 + 100 * (y/height) + np.random.randint(-10, 10))
b = int(60 + 80 * ((x+y)/(width+height)) + np.random.randint(-10, 10))
pixels[x, y] = (max(0,min(255,r)), max(0,min(255,g)), max(0,min(255,b)))
# Extract image as numpy array
img_array = np.array(img, dtype=np.uint8)
msg_bytes = PLINIAN_DIVIDER.encode('utf-8')
length_bytes = struct.pack('>I', len(msg_bytes))
payload = length_bytes + msg_bytes
# BPCS: replace "complex" 8x8 blocks in bit plane 0 with message data
# Complexity threshold: blocks with >40% transitions are "complex enough"
BLOCK_SIZE = 8
THRESHOLD = 0.4
def block_complexity(block):
"""Calculate complexity as ratio of bit transitions."""
transitions = 0
total = 0
for r in range(block.shape[0]):
for c in range(block.shape[1] - 1):
if block[r, c] != block[r, c + 1]:
transitions += 1
total += 1
for r in range(block.shape[0] - 1):
for c in range(block.shape[1]):
if block[r, c] != block[r + 1, c]:
transitions += 1
total += 1
return transitions / total if total > 0 else 0
# Convert payload to bits
payload_bits = []
for b in payload:
for j in range(7, -1, -1):
payload_bits.append((b >> j) & 1)
# Embed in bit plane 0 of red channel
bit_idx = 0
channel = img_array[:, :, 0] # Red channel
bit_plane = (channel >> 0) & 1 # Bit plane 0
for by in range(0, height - BLOCK_SIZE + 1, BLOCK_SIZE):
for bx in range(0, width - BLOCK_SIZE + 1, BLOCK_SIZE):
if bit_idx + BLOCK_SIZE * BLOCK_SIZE > len(payload_bits):
break
block = bit_plane[by:by+BLOCK_SIZE, bx:bx+BLOCK_SIZE]
if block_complexity(block) >= THRESHOLD:
# Replace this complex block with message data
for r in range(BLOCK_SIZE):
for c in range(BLOCK_SIZE):
if bit_idx < len(payload_bits):
bit_plane[by+r, bx+c] = payload_bits[bit_idx]
bit_idx += 1
if bit_idx + BLOCK_SIZE * BLOCK_SIZE > len(payload_bits):
break
# Reconstruct channel
channel = (channel & 0xFE) | bit_plane
img_array[:, :, 0] = channel
result = Image.fromarray(img_array)
path = os.path.join(OUTPUT_DIR, 'example_bpcs.png')
result.save(path)
print(f" -> {path} ({bit_idx} bits via BPCS)")
return path
# =============================================================================
# 103. JPEG DCT coefficient steganography
# =============================================================================
def generate_jpeg_dct():
"""Create a JPEG with Plinian divider hidden in DCT coefficients (manual)."""
print(" Generating JPEG DCT coefficient steganography...")
import numpy as np
width, height = 128, 128 # Multiple of 8 for DCT blocks
img = Image.new('RGB', (width, height))
pixels = img.load()
for y in range(height):
for x in range(width):
r = int(140 + 60 * np.sin(x * 0.1) + 30 * np.cos(y * 0.08))
g = int(120 + 50 * np.cos(x * 0.08 + y * 0.05))
b = int(100 + 40 * np.sin((x + y) * 0.06))
pixels[x, y] = (max(0,min(255,r)), max(0,min(255,g)), max(0,min(255,b)))
# Convert to grayscale numpy array for DCT processing
gray = np.array(img.convert('L'), dtype=np.float64)
msg_bytes = PLINIAN_DIVIDER.encode('utf-8')
length_bytes = struct.pack('>I', len(msg_bytes))
payload = length_bytes + msg_bytes
bits = []
for b in payload:
for j in range(7, -1, -1):
bits.append((b >> j) & 1)
# Manual 2D DCT using numpy (type-II DCT via FFT)
def dct2(block):
return np.real(np.fft.fft2(block))
def idct2(block):
return np.real(np.fft.ifft2(block))
# Embed bits in mid-frequency DCT coefficients of 8x8 blocks
bit_idx = 0
BLOCK = 8
for by in range(0, height, BLOCK):
for bx in range(0, width, BLOCK):
if bit_idx >= len(bits):
break
block = gray[by:by+BLOCK, bx:bx+BLOCK].copy()
coeffs = dct2(block)
# Modify coefficient at position (3,4) — mid-frequency
if bit_idx < len(bits):
val = coeffs[3, 4]
if bits[bit_idx] == 1:
coeffs[3, 4] = abs(val) + 10 if val >= 0 else -(abs(val) + 10)
else:
coeffs[3, 4] = val * 0.5 # Reduce magnitude
bit_idx += 1
gray[by:by+BLOCK, bx:bx+BLOCK] = np.clip(idct2(coeffs), 0, 255)
if bit_idx >= len(bits):
break
# Save as grayscale image (the DCT modification is in the pixel data)
result = Image.fromarray(gray.astype(np.uint8), 'L')
path = os.path.join(OUTPUT_DIR, 'example_dct_manual.png')
result.save(path)
print(f" -> {path} ({bit_idx} bits in DCT coefficients)")
return path
# =============================================================================
# 104. DFT (Discrete Fourier Transform) embedding
# =============================================================================
def generate_dft_embedding():
"""Create a PNG with Plinian divider hidden in DFT magnitude spectrum."""
print(" Generating DFT embedding PNG...")
import numpy as np
width, height = 128, 128
img = Image.new('L', (width, height))
pixels = img.load()
for y in range(height):
for x in range(width):
pixels[x, y] = int(128 + 60 * np.sin(x * 0.1) + 40 * np.cos(y * 0.12))
gray = np.array(img, dtype=np.float64)
msg_bytes = PLINIAN_DIVIDER.encode('utf-8')
length_bytes = struct.pack('>I', len(msg_bytes))
payload = length_bytes + msg_bytes
bits = []
for b in payload:
for j in range(7, -1, -1):
bits.append((b >> j) & 1)
# 2D DFT
spectrum = np.fft.fft2(gray)
magnitude = np.abs(spectrum)
phase = np.angle(spectrum)
# Embed bits in magnitude of mid-frequency components
bit_idx = 0
for freq in range(10, 60):
if bit_idx >= len(bits):
break
r, c = freq, freq
if bits[bit_idx] == 1:
magnitude[r, c] *= 1.5
magnitude[height - r, width - c] *= 1.5 # Conjugate symmetry
else:
magnitude[r, c] *= 0.7
magnitude[height - r, width - c] *= 0.7
bit_idx += 1
# Reconstruct
spectrum = magnitude * np.exp(1j * phase)
result = np.real(np.fft.ifft2(spectrum))
result = np.clip(result, 0, 255).astype(np.uint8)
path = os.path.join(OUTPUT_DIR, 'example_dft.png')
Image.fromarray(result, 'L').save(path)
print(f" -> {path} ({bit_idx} bits in DFT magnitude)")
return path
# =============================================================================
# 105. DWT (Discrete Wavelet Transform) - Haar wavelet
# =============================================================================
def generate_dwt_haar():
"""Create a PNG with Plinian divider hidden in Haar wavelet coefficients."""
print(" Generating DWT (Haar wavelet) PNG...")
import numpy as np
width, height = 128, 128
img = Image.new('L', (width, height))
pixels = img.load()
np.random.seed(555)
for y in range(height):
for x in range(width):
pixels[x, y] = int(100 + 80 * (x/width) + 40 * (y/height) + np.random.randint(-5, 5))
gray = np.array(img, dtype=np.float64)
msg_bytes = PLINIAN_DIVIDER.encode('utf-8')
length_bytes = struct.pack('>I', len(msg_bytes))
payload = length_bytes + msg_bytes
bits = []
for b in payload:
for j in range(7, -1, -1):
bits.append((b >> j) & 1)
# Simple Haar wavelet transform (1 level)
h = height // 2
w = width // 2
LL = np.zeros((h, w))
LH = np.zeros((h, w))
HL = np.zeros((h, w))
HH = np.zeros((h, w))
for y in range(h):
for x in range(w):
a = gray[2*y, 2*x]
b_val = gray[2*y, 2*x+1]
c = gray[2*y+1, 2*x]
d = gray[2*y+1, 2*x+1]
LL[y, x] = (a + b_val + c + d) / 4
LH[y, x] = (a + b_val - c - d) / 4
HL[y, x] = (a - b_val + c - d) / 4
HH[y, x] = (a - b_val - c + d) / 4
# Embed bits in HH (high-frequency detail) coefficients
bit_idx = 0
for y in range(h):
for x in range(w):
if bit_idx >= len(bits):
break
if bits[bit_idx] == 1:
HH[y, x] = abs(HH[y, x]) + 5
else:
HH[y, x] = abs(HH[y, x]) * 0.3
bit_idx += 1
if bit_idx >= len(bits):
break
# Inverse Haar
result = np.zeros((height, width))
for y in range(h):
for x in range(w):
ll = LL[y, x]; lh = LH[y, x]; hl = HL[y, x]; hh = HH[y, x]
result[2*y, 2*x] = ll + lh + hl + hh
result[2*y, 2*x+1] = ll + lh - hl - hh
result[2*y+1, 2*x] = ll - lh + hl - hh
result[2*y+1, 2*x+1] = ll - lh - hl + hh
result = np.clip(result, 0, 255).astype(np.uint8)
path = os.path.join(OUTPUT_DIR, 'example_dwt_haar.png')
Image.fromarray(result, 'L').save(path)
print(f" -> {path} ({bit_idx} bits in HH wavelet band)")
return path
# =============================================================================
# 106. Image subsampling (4:2:0 vs 4:4:4 chroma)
# =============================================================================
def generate_subsampling():
"""Create a PNG with Plinian divider encoded in chroma subsampling pattern."""
print(" Generating chroma subsampling steganography...")
import numpy as np
width, height = 200, 200
img = Image.new('RGB', (width, height))
pixels = img.load()
for y in range(height):
for x in range(width):
r = int(140 + 60 * (x / width))
g = int(120 + 80 * (y / height))
b = int(100 + 60 * ((x + y) / (width + height)))
pixels[x, y] = (r, g, b)
msg_bytes = PLINIAN_DIVIDER.encode('utf-8')
length_bytes = struct.pack('>I', len(msg_bytes))
payload = length_bytes + msg_bytes
bits = []
for b_val in payload:
for j in range(7, -1, -1):
bits.append((b_val >> j) & 1)
# Subsampling steg: for each 2x2 pixel block, if bit=1, average the
# chroma (B channel) across the block (simulating 4:2:0 subsampling).
# If bit=0, leave chroma at full resolution (4:4:4).
bit_idx = 0
for by in range(0, height - 1, 2):
for bx in range(0, width - 1, 2):
if bit_idx >= len(bits):
break
if bits[bit_idx] == 1:
# Average B channel across 2x2 block (4:2:0 simulation)
b_avg = 0
for dy in range(2):
for dx in range(2):
r, g, b = pixels[bx + dx, by + dy]
b_avg += b
b_avg //= 4
for dy in range(2):
for dx in range(2):
r, g, _ = pixels[bx + dx, by + dy]
pixels[bx + dx, by + dy] = (r, g, b_avg)
bit_idx += 1
if bit_idx >= len(bits):
break
path = os.path.join(OUTPUT_DIR, 'example_subsampling.png')
img.save(path)
print(f" -> {path} ({bit_idx} bits in chroma subsampling)")
return path
# =============================================================================
# 107. Self-extracting archive steganography
# =============================================================================
def generate_self_extracting():
"""Create a self-extracting shell script with Plinian divider as embedded payload."""
print(" Generating self-extracting archive...")
import base64, tarfile, io
secret = PLINIAN_DIVIDER.encode('utf-8')
b64_secret = base64.b64encode(secret).decode()
# Create a tar.gz payload with the secret
tar_buf = io.BytesIO()
with tarfile.open(fileobj=tar_buf, mode='w:gz') as tf:
info = tarfile.TarInfo(name='secret.txt')
info.size = len(secret)
tf.addfile(info, io.BytesIO(secret))
tar_b64 = base64.b64encode(tar_buf.getvalue()).decode()
script = f'''#!/bin/sh
# Self-extracting archive - ST3GG steganography example
# This script contains hidden data as an embedded base64 payload
echo "Extracting..."
PAYLOAD="{tar_b64}"
echo "$PAYLOAD" | base64 -d | tar xzf - 2>/dev/null
if [ -f secret.txt ]; then
echo "Secret extracted to secret.txt"
cat secret.txt
else
echo "Extraction failed"
fi
# Hidden direct payload (not used by extraction):
# {b64_secret}
# End of self-extracting archive
'''
path = os.path.join(OUTPUT_DIR, 'example_self_extracting.sh')
with open(path, 'w') as f:
f.write(script)
os.chmod(path, 0o755)
print(f" -> {path}")
return path
# =============================================================================
# 108. Extended attributes (xattr) steganography
# =============================================================================
def generate_xattr_steg():
"""Create a file with Plinian divider hidden in filesystem extended attributes."""
print(" Generating xattr steganography...")
import base64
secret = PLINIAN_DIVIDER.encode('utf-8')
# Create the carrier file
path = os.path.join(OUTPUT_DIR, 'example_xattr.txt')
with open(path, 'w') as f:
f.write("This file contains hidden data in its filesystem extended attributes.\n")
f.write("Use 'getfattr -d' or 'xattr -l' to view them.\n")
f.write("The actual file content is innocuous.\n")
# Set extended attributes with the secret
try:
os.setxattr(path, b'user.st3gg.payload', secret)
os.setxattr(path, b'user.st3gg.b64', base64.b64encode(secret))
os.setxattr(path, b'user.st3gg.hex', secret.hex().encode())
os.setxattr(path, b'user.st3gg.flag', b'ST3GG{x4ttr_m4st3r}')
print(f" -> {path} (4 xattr attributes set)")
except OSError as e:
# xattr may not be supported on all filesystems
print(f" -> {path} (xattr not supported: {e})")
return path
# =============================================================================
# 109. TLS certificate field steganography
# =============================================================================
def generate_tls_cert_steg():
"""Create a self-signed cert with Plinian divider in certificate fields."""
print(" Generating TLS certificate steganography...")
import base64
secret = PLINIAN_DIVIDER.encode('utf-8')
b64_secret = base64.b64encode(secret).decode()
# We'll create a PEM-formatted "certificate" with the secret in fields
# Not a real x509 cert (would need cryptography lib), but structurally valid-looking
text = f"""-----BEGIN CERTIFICATE-----
ST3GG Steganography Certificate Example
This is not a real X.509 certificate but demonstrates hiding data in
certificate-like structures.
Subject: CN={b64_secret}
Issuer: CN=ST3GG CA, O=STEGOSAURUS WRECKS, L={secret.hex()}
Serial: {int.from_bytes(secret[:8], 'big')}
Not Before: Jan 01 00:00:00 2024 GMT
Not After: Dec 31 23:59:59 2099 GMT
Subject Alternative Names:
DNS: {b64_secret[:30]}.example.com
DNS: {secret.hex()[:30]}.st3gg.local
Extensions:
X509v3 Subject Key Identifier: {secret.hex()[:40]}
X509v3 Authority Key Identifier: {secret.hex()[40:]}
1.2.3.4.5.6.7.8.9: {PLINIAN_DIVIDER}
Payload (base64): {b64_secret}
-----END CERTIFICATE-----
"""
path = os.path.join(OUTPUT_DIR, 'example_tls_cert.pem')
with open(path, 'w', encoding='utf-8') as f:
f.write(text)
print(f" -> {path}")
return path
# =============================================================================
# Main
# =============================================================================
def main():
print("=" * 60)
print("ST3GG Example File Generator")
print("=" * 60)
print(f"Output directory: {OUTPUT_DIR}")
print(f"Hidden message: {SECRET_MSG}")
print()
files = []
# Original examples
files.append(generate_lsb_png())
files.append(generate_text_chunk_png())
files.append(generate_trailing_data_png())
files.append(generate_zero_width_text())
files.append(generate_whitespace_text())
files.append(generate_invisible_ink_text())
files.append(generate_audio_lsb_wav())
files.append(generate_exif_png())
# Chunk 1: Image formats
files.append(generate_lsb_bmp())
files.append(generate_gif_comment())
files.append(generate_gif_lsb())
files.append(generate_tiff_metadata())
files.append(generate_tiff_lsb())
files.append(generate_ppm_lsb())
files.append(generate_pgm_lsb())
files.append(generate_svg_hidden())
files.append(generate_ico_lsb())
files.append(generate_webp_metadata())
files.append(generate_webp_lsb())
# Chunk 2: Document & structured data formats
files.append(generate_html_hidden())
files.append(generate_xml_hidden())
files.append(generate_json_hidden())
files.append(generate_csv_hidden())
files.append(generate_yaml_hidden())
files.append(generate_pdf_hidden())
files.append(generate_rtf_hidden())
files.append(generate_markdown_hidden())
# Chunk 3: Audio, binary & archive formats
files.append(generate_aiff_lsb())
files.append(generate_au_lsb())
files.append(generate_zip_hidden())
files.append(generate_tar_hidden())
files.append(generate_gzip_hidden())
files.append(generate_sqlite_hidden())
files.append(generate_hexdump_hidden())
files.append(generate_midi_hidden())
files.append(generate_pcap_hidden())
# Chunk 4: Code & config formats
files.append(generate_python_hidden())
files.append(generate_js_hidden())
files.append(generate_c_hidden())
files.append(generate_css_hidden())
files.append(generate_ini_hidden())
files.append(generate_shell_hidden())
files.append(generate_sql_hidden())
files.append(generate_latex_hidden())
files.append(generate_toml_hidden())
# Chunk 5: Unicode & text tricks
files.append(generate_homoglyph())
files.append(generate_variation_selector())
files.append(generate_combining_diacritics())
files.append(generate_confusable_whitespace())
files.append(generate_emoji_substitution())
# Chunk 6: Network protocol steganography
files.append(generate_dns_tunnel_pcap())
files.append(generate_icmp_steg_pcap())
files.append(generate_tcp_covert_pcap())
files.append(generate_http_header_pcap())
# Chunk 7: Image format tricks
files.append(generate_png_zip_polyglot())
files.append(generate_png_filter_encoding())
files.append(generate_alpha_lsb())
# Chunk 8: Misc techniques
files.append(generate_json_key_ordering())
files.append(generate_capitalization_encoding())
files.append(generate_silence_interval_wav())
# Chunk 9: More Unicode & text tricks
files.append(generate_directional_override())
files.append(generate_hangul_filler())
files.append(generate_braille_pattern())
files.append(generate_math_alphanumeric())
files.append(generate_unicode_normalization())
files.append(generate_sentence_length())
files.append(generate_word_choice())
files.append(generate_misspelling())
# Chunk 10: Network & encoding tricks
files.append(generate_ip_ttl_covert())
files.append(generate_ip_id_covert())
files.append(generate_tcp_window_covert())
files.append(generate_tcp_urgent_covert())
files.append(generate_dns_txt_record())
files.append(generate_covert_timing())
files.append(generate_base32_file())
files.append(generate_morse_code())
# Chunk 11: Image techniques
files.append(generate_pvd())
files.append(generate_histogram_shifting())
files.append(generate_lsb_multibit())
files.append(generate_lsb_msb_first())
files.append(generate_bmp_dib_header())
files.append(generate_gif_disposal())
files.append(generate_jpeg_app_segment())
files.append(generate_color_space())
files.append(generate_png_gama())
# Chunk 12: Document, archive & misc
files.append(generate_pdf_javascript())
files.append(generate_pdf_incremental())
files.append(generate_pdf_form_fields())
files.append(generate_html_events())
files.append(generate_xml_entities())
files.append(generate_nested_zip())
files.append(generate_emoji_skin_tone())
files.append(generate_punycode())
# Chunk 13: Final techniques
files.append(generate_jpeg_restart_markers())
files.append(generate_matched_pairs_lsb())
files.append(generate_png_scanline_filter())
files.append(generate_qr_steg())
# Chunk 14: Audio DSP techniques
files.append(generate_echo_hiding())
files.append(generate_phase_coding())
files.append(generate_spread_spectrum())
files.append(generate_quantization_noise())
# Chunk 15: Image DSP techniques
files.append(generate_bpcs())
files.append(generate_jpeg_dct())
files.append(generate_dft_embedding())
files.append(generate_dwt_haar())
files.append(generate_subsampling())
# Chunk 16: Misc final techniques
files.append(generate_self_extracting())
files.append(generate_xattr_steg())
files.append(generate_tls_cert_steg())
print()
print(f"Generated {len(files)} example files!")
print()
for f in files:
size = os.path.getsize(f)
print(f" {os.path.basename(f):40s} {size:>8,} bytes")
if __name__ == '__main__':
main()
Reference in New Issue View Git Blame Copy Permalink