Anyhide - Hide Anything in Anything
Hide anything inside anything. Anyhide is an advanced steganography and encryption tool that conceals any data (text, files, binaries) within any carrier file (images, videos, documents, executables) using hybrid encryption with forward secrecy and plausible deniability.
Why Anyhide?
Traditional steganography modifies the carrier file and transmits it. Anyhide is different:
| Traditional Steganography | Anyhide |
|---|---|
| Modifies the carrier file | Never touches the carrier |
| Transmits the modified file | Transmits only a short code |
| Carrier can be analyzed | Carrier stays untouched |
| Hide text in images | Hide anything in anything |
Use cases:
- Hide encrypted files inside a shared video
- Conceal sensitive documents using a public PDF as carrier
- Store secrets referenced by any file both parties have
- Covert communication with plausible deniability
How It Works
Anyhide uses a pre-shared carrier model:
- Both parties have the same file (ANY file: image, video, PDF, text, etc.)
- Sender hides data by finding byte patterns in the carrier
- Only an encrypted code is transmitted - the carrier is never sent
- Receiver uses the same carrier + code to extract the hidden data
┌─────────────────────────────────────────────────────────────┐
│ SENDER RECEIVER │
│ │
│ carrier.mp4 ──┐ ┌── carrier.mp4 │
│ │ │ (same file) │
│ secret.zip ───┼──► ANYHIDE CODE ─────┼──► secret.zip │
│ │ (only this │ │
│ passphrase ───┘ is sent) └── passphrase │
│ │
│ The carrier is NEVER transmitted │
└─────────────────────────────────────────────────────────────┘
Key Features
- Any carrier: text, images, audio, video, PDFs, executables, archives
- Any payload: text messages, binary files, documents, archives
- Dual-layer encryption: Symmetric (ChaCha20) + Asymmetric (X25519)
- Forward secrecy ratchet: Key rotation per message - past messages stay secure even if keys leak
- Ephemeral keys: Generate rotating keys for perfect forward secrecy
- Message signing: Ed25519 signatures for sender authentication
- Message expiration: Auto-expiring messages
- Code splitting: Split codes for multi-channel delivery
- QR code support: Share codes via QR
- Plausible deniability: Wrong passphrase returns garbage, not an error
- Never fails: Decoder always returns something - prevents brute-force detection
- Library support: Use Anyhide in your own Rust projects
Installation
From crates.io
Download Pre-built Binary
Download from GitHub Releases:
- Linux:
anyhide-linux-x86_64oranyhide-linux-aarch64 - macOS:
anyhide-macos-x86_64(Intel) oranyhide-macos-aarch64(Apple Silicon) - Windows:
anyhide-windows-x86_64.exe
Build from Source
Quick Start
1. Generate Keys
# Creates: mykeys.pub, mykeys.key, mykeys.sign.pub, mykeys.sign.key
2. Encode a Message
# Using any text file as carrier
# Output: AwNhYmNkZWZn... (send this code)
3. Decode a Message
# Output: ama park
Command Reference
Generate Keys
)
)
)
)
)
# Long-term keys (default)
# Creates: mykeys.pub, mykeys.key, mykeys.sign.pub, mykeys.sign.key
# Ephemeral keys (individual files)
# Creates: alice.pub, alice.key (with EPHEMERAL PEM headers)
# Ephemeral keys (consolidated separate files)
# Adds/updates contact "bob" in both JSON files
# Ephemeral keys (unified file)
# Adds/updates contact "bob" with my_private and placeholder their_public
Encode
)
)
)
Decode
)
)
)
)
)
)
)
)
)
)
Other Commands
Examples
Binary Files as Carrier
Use any file (video, PDF, image, executable) as carrier:
# Hide text in a shared video
# Hide a ZIP file inside a PDF
# Extract hidden file
Message Signing
# Sign message
# Verify signature
# Output: From Alice
# Signature: VALID
Message Expiration
# Message expires in 24 hours
# After expiration: returns garbage (not an error)
Code Splitting
# Split into 3 parts
# Output: part-1: xxx, part-2: yyy, part-3: zzz
# Decode with all parts in order
# Wrong order = garbage (plausible deniability)
QR Codes
# Generate code + QR in one step
# Read QR and decode
# Split QR codes
# Creates: code-1.png, code-2.png, code-3.png
Forward Secrecy Ratchet
Enable key rotation per message for perfect forward secrecy.
Ephemeral Key Storage Formats
Anyhide supports 3 storage formats for ephemeral keys:
Option 1: Individual PEM files (simple, single contact)
# Creates: alice.pub, alice.key (with EPHEMERAL headers)
Option 2: Separate consolidated JSON files (multiple contacts)
# mykeys.eph.key: JSON with your private keys for each contact
# contacts.eph.pub: JSON with each contact's public key
Option 3: Unified JSON file (recommended for chat apps)
# contacts.eph: JSON with both my_private and their_public per contact
Automatic Ratchet with Individual Files
# Step 1: Both parties generate ephemeral keys and exchange public keys
# Step 2: Alice sends message (keys rotate automatically)
# Output: Just the code (alice.key updated with next keypair)
# Step 3: Bob decodes (their public key updated automatically)
# Output: Hello Bob (alice.pub updated with her next public key)
# Step 4: Bob replies (keys rotate again)
# Output: Just the code (bob.key updated)
Automatic Ratchet with Separated Stores
For environments where you want private keys and public keys in separate files:
# Step 1: Setup - create separated key stores
# Exchange initial public keys
# Step 2: Alice sends message
# Output: Just the code (alice.eph.key[bob] updated with next keypair)
# Step 3: Bob decodes
# Output: Hello Bob (bob.eph.pub[alice] updated with Alice's next public key)
Automatic Ratchet with Unified Store (Recommended)
# Step 1: Setup - create unified key stores for each party
# Exchange public keys initially
# Step 2: Alice sends message
# Output: Just the code (alice.eph[bob].my_private updated)
# Step 3: Bob decodes
# Output: Hello Bob (bob.eph[alice].their_public updated)
# Step 4: Bob replies
# Output: Just the code (bob.eph[alice].my_private updated)
Key points:
- Messages are always clean - no key information displayed
- Keys rotate automatically after each encode/decode
- Use
-vfor verbose output if you need to see key details - The
--keyflag is deprecated - use--my-keyand--their-keyinstead
Library Usage for Chat Applications
use ;
use ;
// Initial setup: generate keys for Bob
let my_keypair = generate_ephemeral;
save_unified_keys_for_contact?;
// Encode with ratchet enabled
let config = EncoderConfig ;
let result = encode_with_config?;
// result.next_keypair contains your NEXT key pair
// Save it for the next message you send
// result.code contains the encrypted message
// On receiving a reply, decode and get their next key
let decoded = decode_with_config;
if let Some = decoded.next_public_key
How the ratchet works:
- Each message includes sender's NEXT public key
- Recipient uses that key for the reply
- Keys rotate with every message exchange
- Compromised keys cannot decrypt past messages
Security Properties
- Four-Factor Security: Carrier + Passphrase + Private Key + Correct Version
- Never-Fail Decoder: Always produces output - no error signals for attackers
- Plausible Deniability: Wrong inputs return garbage, not errors
- Forward Secrecy: Ephemeral keys protect past messages
- Code Splitting: Wrong order = garbage (no error)
Disclaimer
Anyhide is provided for educational and legitimate privacy purposes only.
This software is a tool, and like any tool, it can be used for good or bad purposes. The authors:
- DO NOT endorse or encourage any illegal activities
- ARE NOT responsible for how this software is used
- PROVIDE this software "as is" without warranty
You are solely responsible for ensuring your use complies with all applicable laws.
Documentation
- User Manual: This README
- Architecture & Development: ARCHITECTURE.md
- Version History: CHANGELOG.md
License
MIT License - see LICENSE for details.
Version
Current version: 0.8.1 (see CHANGELOG.md)