Steganography

English | 中文 | 繁體中文 | 한국어 | 日本語 | Deutsch | Español | Français | Italiano | Dansk | Norsk | Polski | Русский | Bosanski | Українська | Português (BR) | العربية | ไทย | Türkçe | বাংলা | हिन्दी | Ελληνικά | Tiếng Việt

The most comprehensive steganography analysis toolkit for AI agents.

LSB detection, chi-square steganalysis, RS analysis, DCT forensics, F5/JSteg/OutGuess detection, BPCS analysis, video & GIF steganography, network covert channels, MP3 stego, spread spectrum watermarks, archive stego, QR code analysis, audio steganography, zero-width text encoding, file forensics, polyglot detection, encoding identification — unified into a single MCP server.
128 tools. 17 categories. 4 dependencies. 100% offline. Zero API keys required. Every tool runs locally.

The Problem • How It's Different • Quick Start • What The AI Can Do • Tools (128) • CLI Usage • Architecture • Contributing

The Problem

Steganography is the art of hiding data in plain sight — inside images, audio files, documents, and even Unicode text. It is used in CTF competitions, digital forensics investigations, covert communication channels, and malware payloads. Detecting it requires a combination of statistical analysis, format-specific parsing, entropy measurement, and domain expertise.

Traditional steganography analysis workflow:
  detect image stego          ->  zsteg + stegsolve (2 tools, Ruby + Java)
  chi-square analysis         ->  custom Python script
  RS analysis                 ->  custom MATLAB/Python code
  JPEG DCT forensics          ->  stegdetect (abandoned C tool from 2004)
  extract LSB data            ->  zsteg + steghide + openstego (3 tools)
  audio steganography         ->  Audacity manual + custom scripts
  zero-width text detection   ->  web-based tools + manual inspection
  file forensics / binwalk    ->  binwalk + foremost + xxd (3 tools)
  EXIF metadata               ->  exiftool (Perl dependency)
  encoding detection          ->  CyberChef web UI + manual guessing
  ─────────────────────────────────
  Total: 10+ tools, 5+ languages, hours of manual correlation

steganography-mcp gives your AI agent 128 tools across 17 categories via the Model Context Protocol. The agent performs image steganalysis, advanced JPEG forensics (F5/JSteg/OutGuess/PVD detection), BPCS analysis, video & GIF steganography, network covert channel detection, MP3 stego, spread spectrum watermark detection, archive stego, QR code analysis, audio analysis, text steganography detection, file forensics, document analysis, and encoding identification — all in a single conversation, all running 100% locally with zero dependencies on external services.

With steganography-mcp:
  You: "Analyze this CTF challenge image for hidden data"

  Agent: -> img_detect: Chi-square p=0.0001 (LSB embedding detected),
            RS analysis estimates 42% embedding rate, entropy anomaly
            in lower-right quadrant
         -> img_lsb_extract: Extracted 847 bytes from RGB LSBs
         -> crypto_detect: Extracted data is Base64-encoded
         -> crypto_decode: Decoded to "FLAG{hidden_in_plain_sight_2024}"
         -> img_known_tools: Signature match for OpenStego

         "The image contains LSB steganography embedded with OpenStego.
          Chi-square test confirms LSB replacement in all three RGB
          channels with 42% embedding rate. The hidden payload is
          Base64-encoded and decodes to the flag:
          FLAG{hidden_in_plain_sight_2024}"

How It's Different

Most steganography tools are single-purpose utilities. steganography-mcp gives your AI agent the ability to reason across all steganography techniques simultaneously.

Quick Start

Option 1: npx (no install)

npx -y steganography-mcp

All 128 tools work immediately. No API keys. No configuration. 100% offline.

Option 2: bunx (faster)

bunx steganography-mcp

Option 3: Clone

git clone https://github.com/badchars/steganography-mcp.git
cd steganography-mcp
bun install

Connect to your AI agent

# With npx
claude mcp add steganography -- npx -y steganography-mcp

# With local clone
claude mcp add steganography -- bun run /path/to/steganography-mcp/src/index.ts

{
  "mcpServers": {
    "steganography": {
      "command": "npx",
      "args": ["-y", "steganography-mcp"]
    }
  }
}

Start analyzing

You: "Check this image for hidden data"

That's it. The agent runs chi-square analysis, RS analysis, entropy mapping, metadata extraction, appended data detection, and tool signature scanning — automatically.

What The AI Can Do

CTF Challenge Solver

You: "Solve this CTF steganography challenge — the image is at challenge.png"

Agent: -> img_detect: Chi-square steganalysis detects LSB embedding
          (p=0.00012), RS analysis estimates 38% embedding rate,
          entropy anomaly at blocks (12,4)-(15,8)
       -> img_lsb_extract: Extracted 1,247 bytes from RGB channel LSBs
       -> crypto_detect: Data matches Base64 pattern (confidence: 0.95)
       -> crypto_decode: "Q1RGe3N0M2cwX21hc3Rlcn0=" -> "CTF{st3g0_master}"
       -> img_known_tools: OpenStego signature detected in PNG chunks

       "Found the flag: CTF{st3g0_master}
        The image uses LSB steganography embedded by OpenStego.
        The payload was Base64-encoded in the RGB least significant
        bits with a 38% embedding rate."

Digital Forensics Investigation

You: "Analyze suspect.png and suspect.wav for covert communication"

Agent: -> img_detect: No LSB stego detected, but appended data found
          (12,847 bytes after PNG IEND marker)
       -> file_identify: Appended data starts with ZIP signature (PK)
       -> img_metadata: PNG tEXt chunk contains unusual key "comm"
          with Base64 value
       -> audio_detect: WAV file has LSB chi-square anomaly (p=0.003)
       -> audio_silence: 3 silent sections with active LSBs detected
       -> audio_lsb_extract: Extracted 2,048 bytes of hidden data

       "Both files contain hidden data:
        1. suspect.png has a ZIP archive appended after the PNG EOF
           marker, plus a Base64-encoded message in metadata
        2. suspect.wav contains LSB steganography, specifically in
           silent sections — a strong indicator of intentional hiding.
        Recommend extracting the ZIP and analyzing WAV payload."

Zero-Width Text Detection

You: "This email looks normal but might have hidden text"

Agent: -> text_detect: 847 zero-width characters detected between
          visible characters
       -> text_zwc_detect: ZWSP (342), ZWNJ (505) found at 127
          positions throughout the text
       -> text_zwc_extract: Binary decoding yields "EXFIL-ROUTE-7"
       -> text_invisible_scan: 3 additional invisible Unicode chars
          (U+2060, U+FEFF) found in header section

       "The email contains a hidden message encoded with zero-width
        characters: 'EXFIL-ROUTE-7'. 847 invisible characters are
        dispersed throughout the visible text using ZWSP/ZWNJ binary
        encoding. Additionally, 3 Word Joiner and BOM characters
        were found in the header — likely metadata artifacts."

JPEG Forensic Analysis

You: "Is this JPEG image authentic or has it been tampered with?"

Agent: -> jpeg_structure: 14 markers parsed, normal JFIF structure
       -> jpeg_double_compression: Double compression DETECTED —
          blocking artifact score 0.73, quantization anomaly ratio 0.81
       -> jpeg_quantization: Quality ~75 (luminance), but residual
          patterns suggest original was quality ~92
       -> jpeg_exif_deep: EXIF says "iPhone 14 Pro" but Software
          field says "Adobe Photoshop 25.0"
       -> jpeg_thumbnail_compare: Thumbnail dimensions do NOT match
          main image (thumbnail: 4032x3024, main: 2048x1536)

       "This JPEG has been tampered with. Evidence:
        1. Double compression detected — the image was decoded and
           re-encoded at lower quality (original ~92, current ~75)
        2. EXIF claims iPhone 14 Pro but software field reveals
           Photoshop editing
        3. Thumbnail is from the original 4032x3024 capture but
           the main image was resized to 2048x1536
        All three findings independently confirm post-capture
        modification."

Tools Reference (128 tools)

Category Overview

CLI Usage

# Show help
npx -y steganography-mcp --help

# List all 128 tools with descriptions
npx -y steganography-mcp --list

# Detect steganography in an image
npx -y steganography-mcp --tool img_detect '{"file_path":"challenge.png"}'

# Extract hidden message from LSBs
npx -y steganography-mcp --tool img_lsb_extract '{"file_path":"stego.png"}'

# Chi-square steganalysis
npx -y steganography-mcp --tool img_chi_square '{"file_path":"suspect.png"}'

# RS analysis (Fridrich-Goljan-Du method)
npx -y steganography-mcp --tool img_rs_analysis '{"file_path":"suspect.png"}'

# JPEG double compression detection
npx -y steganography-mcp --tool jpeg_double_compression '{"file_path":"photo.jpg"}'

# Deep EXIF analysis
npx -y steganography-mcp --tool jpeg_exif_deep '{"file_path":"photo.jpg"}'

# Audio steganography detection
npx -y steganography-mcp --tool audio_detect '{"file_path":"message.wav"}'

# Detect zero-width character encoding
npx -y steganography-mcp --tool text_zwc_detect '{"text":"suspicious text here"}'

# Embed a hidden message with zero-width characters
npx -y steganography-mcp --tool text_zwc_embed '{"text":"cover text","message":"secret"}'

# Identify file type and detect polyglots
npx -y steganography-mcp --tool file_polyglot '{"file_path":"suspicious.pdf"}'

# Scan for embedded files (binwalk-style)
npx -y steganography-mcp --tool file_embedded '{"file_path":"mystery.bin"}'

# Entropy visualization
npx -y steganography-mcp --tool file_entropy_visual '{"file_path":"data.bin"}'

# Auto-detect encoding
npx -y steganography-mcp --tool crypto_detect '{"input":"aGVsbG8gd29ybGQ="}'

# XOR brute-force
npx -y steganography-mcp --tool crypto_xor '{"input":"4f5243484e"}'

# Detect cipher patterns
npx -y steganography-mcp --tool crypto_patterns '{"input":"Gur dhvpx oebja sbk"}'

# Video steganography detection
npx -y steganography-mcp --tool video_detect '{"file_path":"movie.avi"}'

# GIF palette LSB analysis
npx -y steganography-mcp --tool gif_palette_lsb '{"file_path":"animation.gif"}'

# Network covert channel detection
npx -y steganography-mcp --tool net_dns_tunnel '{"file_path":"capture.pcap"}'

# MP3 hidden data detection
npx -y steganography-mcp --tool mp3_detect '{"file_path":"song.mp3"}'

# F5 JPEG stego detection
npx -y steganography-mcp --tool jpegadv_f5_detect '{"file_path":"suspect.jpg"}'

# BPCS embedding detection
npx -y steganography-mcp --tool bpcs_detect '{"file_path":"image.png"}'

# Archive slack space analysis
npx -y steganography-mcp --tool archive_slack '{"file_path":"archive.zip"}'

# QR code stego detection
npx -y steganography-mcp --tool qr_detect '{"file_path":"qrcode.bmp"}'

# Spread spectrum watermark detection
npx -y steganography-mcp --tool spread_patchwork '{"file_path":"image.png"}'

# Create a polyglot file
npx -y steganography-mcp --tool create_polyglot '{"file1_path":"image.png","file2_path":"secret.zip","output_path":"polyglot.png"}'

# Using Bun (faster startup)
bunx steganography-mcp --tool img_detect '{"file_path":"image.png"}'

Use Cases

CTF Challenges

Solve steganography challenges in capture-the-flag competitions. The AI agent can systematically apply all detection techniques — LSB analysis, metadata inspection, appended data, encoding detection, and cipher identification — to find hidden flags in images, audio files, documents, and text.

Digital Forensics

Detect covert communication channels in forensic investigations. Analyze suspect files for hidden data using statistical steganalysis (chi-square, RS analysis), check for data appended after EOF markers, scan for embedded files, and identify steganography tool signatures.

Security Research

Analyze steganography tools and techniques. Compare original and stego images pixel-by-pixel, study DCT coefficient distributions in JPEG stego, measure entropy changes from embedding, and reverse-engineer encoding schemes.

Education

Learn how steganography techniques work. Embed and extract LSB messages, encode text with zero-width characters, visualize bit planes and entropy maps, analyze file structures with hex dumps, and study cipher patterns with frequency analysis.

Incident Response

During incident response, check documents and images for hidden exfiltration channels. Scan PDFs for hidden JavaScript and embedded files, detect zero-width character encoding in emails, identify polyglot files, and analyze suspicious encodings.

Architecture

src/
  index.ts                    # CLI entrypoint (--help, --list, --tool, stdio server)
  protocol/
    mcp-server.ts             # MCP server setup (stdio transport)
    tools.ts                  # Tool registry — all 128 tools assembled here
  types/
    index.ts                  # Shared types (ToolDef, ToolContext, ToolResult)
  utils/
    binary.ts                 # Binary file reading, hex dump, format detection
    stats.ts                  # Shannon entropy, chi-square, DFT, autocorrelation, BPCS complexity, patchwork test
    cache.ts                  # TTL cache
    png-parser.ts             # Pure TS PNG parser (IHDR, chunks, pixel data)
    jpeg-parser.ts            # Pure TS JPEG parser (markers, EXIF, quantization, DCT coefficients)
    wav-parser.ts             # Pure TS WAV parser (RIFF chunks, PCM samples)
    bmp-parser.ts             # Pure TS BMP parser (header, pixel data)
    avi-parser.ts             # Pure TS AVI/RIFF parser (chunks, streams, idx1, frames)
    gif-parser.ts             # Pure TS GIF89a parser (color tables, extensions, LZW blocks)
    pcap-parser.ts            # Pure TS PCAP parser (IP/TCP/UDP/ICMP/DNS/HTTP)
    mp3-parser.ts             # Pure TS MP3 parser (ID3v1/v2, frame headers)
    zip-parser.ts             # Pure TS ZIP parser (local headers, central directory, extra fields)
  image/                      # Image Steganalysis tools (14)
  jpeg/                       # JPEG Analysis tools (7)
  jpegadv/                    # Advanced JPEG tools (7) — F5, JSteg, OutGuess, PVD
  audio/                      # Audio Steganalysis tools (7)
  text/                       # Text & Unicode tools (10)
  file/                       # File Forensics tools (10)
  document/                   # Document Analysis tools (5)
  crypto/                     # Encoding & Crypto tools (7)
  video/                      # Video Steganography tools (8) — AVI frame analysis
  gif/                        # GIF Steganography tools (8) — palette, LZW, animation
  network/                    # Network Steganography tools (8) — PCAP covert channels
  mp3/                        # MP3 Steganography tools (7) — ID3, padding, frames
  spread/                     # Spread Spectrum tools (5) — DFT, watermark, patchwork
  bpcs/                       # BPCS Analysis tools (5) — bit-plane complexity
  archive/                    # Archive Steganography tools (7) — ZIP slack, extra fields
  create/                     # Create & Embed tools (7) — EOF inject, polyglot, palette
  qrcode/                     # QR Code Steganography tools (6) — ECC, modules, compare
  data/
    encoding-patterns.ts      # Encoding regex patterns + decoders
    magic-bytes.ts            # File signature database (100+ formats)
    stego-signatures.ts       # Known steganography tool signatures
    unicode-invisible.ts      # Invisible Unicode character database

Design decisions:

• 4 dependencies, nothing else — @modelcontextprotocol/sdk for the MCP protocol, zod for input validation, pngjs for PNG pixel access, jpeg-js for JPEG decoding. No bloated dependency tree. No native modules. No C bindings. No Python. No Java.
• 100% offline — Every tool runs entirely locally. No HTTP requests. No API calls. No telemetry. No cloud dependencies. Your files never leave your machine.
• Pure TypeScript statistical analysis — Chi-square test, RS analysis (Fridrich-Goljan-Du), Sample Pair Analysis, Shannon entropy, DFT, autocorrelation, BPCS border complexity, patchwork test, Index of Coincidence, and frequency analysis are all implemented in pure TypeScript. No external math libraries.
• 11 custom format parsers — PNG, JPEG, WAV, BMP, AVI/RIFF, GIF89a, PCAP, MP3/ID3, and ZIP are parsed with zero external dependencies using the utils/ parsers. This allows deep format-specific analysis that general-purpose libraries cannot provide.
• 17 providers, 1 server — Each analysis category is an independent module. The AI agent picks which tools to use based on the investigation context.
• Clean ToolDef pattern — Every tool follows the same { name, description, schema, execute } pattern. Adding a new tool is a single object in the appropriate module.
• Zod validation on every field — Every schema field has .describe() for AI agent context. Invalid inputs are caught before execution with clear error messages.

Part of the MCP Security Suite

Contributing

Contributions are welcome. See CONTRIBUTING.md for guidelines.

For authorized security research and educational purposes only.
Always ensure you have proper authorization before performing steganography analysis on files you do not own.

MIT License • Built by Orhan Yildirim • [email protected]