Advanced Image Steganography

A modern, secure, and user-friendly application for hiding secret messages inside images using LSB (Least Significant Bit) steganography. Perfect for privacy-conscious users who want to communicate securely through seemingly innocent images.

Table of Contents

• Features
• Quick Start
• Detailed Usage
• Technical Details
• Installation
• Project Structure
• Security Features
• Use Cases
• Troubleshooting
• Contributing
• License

What the project includes

Security & Privacy

• SHA-256 Password Protection: Messages are secured with industry-standard hashing
• Visual Stealth: Images appear completely unchanged to the naked eye
• Format Validation: Comprehensive input validation prevents data corruption
• Error Handling: reliable error handling with user-friendly messages

Image Support

• Multiple Formats: PNG, BMP, and TIFF image support
• High Capacity: Automatic calculation of maximum message capacity
• Quality Preservation: Maintains original image quality
• Cross-Platform: Works on Windows, macOS, and Linux

User Experience

• Modern GUI: Clean, intuitive interface with tabbed navigation
• Real-time Processing: Fast encoding/decoding with progress indicators
• Visual Feedback: Progress bars and status messages
• Responsive Design: Adapts to different screen sizes

Performance

• Fast Processing: Optimized algorithms for quick encoding/decoding
• Memory Efficient: Handles large images without excessive memory usage
• Threaded Operations: Non-blocking UI during processing

Quick Start

Prerequisites

• Python 3.7 or higher
• 50MB free disk space
• Modern operating system (Windows 10+, macOS 10.14+, or Linux)

Installation

Method 1: Direct Installation

# Clone the repository
git clone https://github.com/Tuhin-SnapD/SteganoIt 
cd SteganoIt

# Install dependencies
pip install -r requirements.txt

# Run the application
python main.py

Method 2: Using Virtual Environment (Recommended)

# Create virtual environment
python -m venv steganography_env

# Activate virtual environment
# On Windows:
steganography_env\Scripts\activate
# On macOS/Linux:
source steganography_env/bin/activate

# Install dependencies
pip install -r requirements.txt

# Run the application
python main.py

Detailed Usage

Encoding a Message

1. Launch the Application

   python main.py
   

2. Select the " Encode Message" Tab

3. Choose Input Image

   • Click "Browse" to select a PNG, BMP, or TIFF image
   • The application will validate the image format and size

4. Enter Your Secret Message

   • Type or paste your message in the text area
   • The application shows real-time character count
   • Maximum capacity is automatically calculated

5. Set Password

   • Enter a strong password (minimum 8 characters recommended)
   • Password is hashed using SHA-256 for security

6. Choose Output Location

   • Specify where to save the encoded image
   • Default: [original_name]_encoded.png

7. Click " Encode Message"

   • Watch the progress indicator
   • Success message confirms completion

Decoding a Message

1. Switch to " Decode Message" Tab

2. Select Encoded Image

   • Browse for the image containing your hidden message

3. Enter Password

   • Use the same password used during encoding

4. Click " Decode Message"

   • The hidden message will appear in the text area
   • Success message confirms decoding

Best Practices

• Use Strong Passwords: Combine letters, numbers, and symbols
• Choose Appropriate Images: Larger images can hold more data
• Test Before Important Use: Always verify encoding/decoding works
• Keep Backups: Save original images before encoding
• Use PNG Format: Best compatibility and quality preservation

Technical Details

How LSB Steganography Works

LSB (Least Significant Bit) steganography works by modifying the least significant bits of image pixels to store hidden data. These changes are imperceptible to the human eye.

Encoding Process

# Simplified encoding algorithm
def encode_message(image, message, password):
    # 1. Hash password for security
    hashed_password = sha256(password.encode()).hexdigest()
    
    # 2. Combine password hash with message
    full_message = f"{hashed_password}:{message}"
    
    # 3. Convert to binary
    binary_message = text_to_binary(full_message)
    
    # 4. Add end marker
    binary_message += '1111111111111111'
    
    # 5. Embed in LSBs of pixels
    for i, bit in enumerate(binary_message):
        pixel_index = i // 3
        color_index = i % 3
        modify_lsb(pixels[pixel_index], color_index, bit)

Decoding Process

# Simplified decoding algorithm
def decode_message(image, password):
    # 1. Extract LSBs from all pixels
    binary_data = extract_lsbs(image)
    
    # 2. Find end marker
    end_index = binary_data.find('1111111111111111')
    
    # 3. Convert binary to text
    full_message = binary_to_text(binary_data[:end_index])
    
    # 4. Verify password hash
    stored_hash, message = full_message.split(':', 1)
    if stored_hash != sha256(password.encode()).hexdigest():
        raise AuthenticationError("Invalid password")
    
    return message

Capacity Calculation

The maximum message capacity depends on image dimensions:

Capacity = (width × height × 3) ÷ 8 characters

Examples:

• 1000×1000 image: ~375,000 characters
• 500×500 image: ~93,750 characters
• 200×200 image: ~15,000 characters

Supported Image Formats

Format	Extension	Advantages	Limitations
PNG	.png	Lossless, best quality	Larger file size
BMP	.bmp	Uncompressed, fast processing	Very large files
TIFF	.tiff, .tif	Professional format	Limited browser support

Installation

System Requirements

Minimum Requirements:

• Python 3.7+
• 50MB RAM
• 100MB disk space
• Any modern OS

Recommended Requirements:

• Python 3.9+
• 2GB RAM
• 500MB disk space
• SSD storage

Dependencies

The application requires only one external dependency:

Pillow>=9.0.0

What Pillow provides:

• Image loading and saving
• Format conversion
• Pixel manipulation
• Cross-platform compatibility

Installation Methods

1. Standard Installation

pip install -r requirements.txt

2. Development Installation

git clone https://github.com/Tuhin-SnapD/SteganoIt
cd SteganoIt
pip install -e .

3. Docker Installation (Optional)

FROM python:3.9-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
CMD ["python", "main.py"]

How files are organized

SteganoIt/
├── main.py                 # Main application file
├── requirements.txt        # Python dependencies
├── README.md              # This documentation
├── run.bat                # Windows batch file for easy execution
├── test.png               # Sample test image
├── .gitignore             # Git ignore file
└── docs/                  # Additional documentation (optional)
    ├── API.md             # API documentation
    ├── SECURITY.md        # Security considerations
    └── CONTRIBUTING.md    # Contribution guidelines

Code Architecture

main.py
├── SteganographyError     # Custom exception class
├── ImageSteganography     # Core steganography engine
│   ├── _validate_image()  # Image validation
│   ├── _hash_password()   # Password hashing
│   ├── _text_to_binary()  # Text conversion
│   ├── _binary_to_text()  # Binary conversion
│   ├── _calculate_capacity() # Capacity calculation
│   ├── encode()           # Message encoding
│   └── decode()           # Message decoding
└── SteganographyGUI       # User interface
    ├── __init__()         # GUI initialization
    ├── setup_ui()         # UI setup
    ├── setup_encode_tab() # Encode tab
    ├── setup_decode_tab() # Decode tab
    ├── setup_about_tab()  # About tab
    ├── browse_input_image() # File browser
    ├── browse_output_image() # Output browser
    ├── encode_message()   # Encoding handler
    └── decode_message()   # Decoding handler

Security Features

Password Protection

• SHA-256 Hashing: Passwords are never stored in plain text
• Salt-free: Simple implementation for educational purposes
• Verification: Password must match exactly for decoding

Data Integrity

• End Markers: Clear message boundaries prevent data corruption
• Format Validation: Only valid images are processed
• Error Handling: Graceful failure with informative messages

Privacy Considerations

• No Network Access: All processing happens locally
• No Data Collection: No telemetry or user tracking
• Temporary Files: No sensitive data left on disk

Security Best Practices

• Use strong, unique passwords
• Keep encoded images secure
• Don't share passwords through insecure channels
• Consider additional encryption for highly sensitive data

When to use it

Personal Privacy

• Secure Communication: Send hidden messages through social media
• Digital Watermarking: Embed ownership information in images
• Personal Notes: Hide sensitive information in family photos

Educational

• Learning Steganography: Understand how data hiding works
• Security Research: Study steganographic techniques
• Academic Projects: Demonstrate LSB steganography concepts

Professional

• Document Security: Hide metadata in business documents
• Asset Protection: Embed copyright information in images
• Covert Communication: Secure messaging in corporate environments

Creative

• Digital Art: Hide easter eggs in artwork
• Gaming: Create hidden clues in game assets
• Storytelling: Interactive narratives with hidden messages

Troubleshooting

Common Issues

Image file not found!"

• Cause: File path is incorrect or file doesn't exist
• Solution: Use the Browse button to select files
• Prevention: Always use the file browser

Message too long!"

• Cause: Message exceeds image capacity
• Solution: Use a larger image or shorter message
• Calculation: Capacity = (width × height × 3) ÷ 8

Incorrect password!"

• Cause: Wrong password or corrupted data
• Solution: Double-check password spelling and case
• Note: Passwords are case-sensitive

Invalid image format!"

• Cause: Unsupported file format
• Solution: Convert to PNG, BMP, or TIFF
• Supported: Only PNG, BMP, and TIFF formats

No valid message found!"

• Cause: Image doesn't contain encoded data
• Solution: Verify the image was encoded with this tool
• Check: Ensure image wasn't modified after encoding

Performance Issues

Slow Processing

• Large Images: Use smaller images for faster processing
• System Resources: Close other applications
• Format: PNG is generally fastest

Memory Errors

• Large Images: Process smaller images
• System RAM: Ensure sufficient available memory
• Format: BMP uses most memory, PNG uses least

Quality Issues

Image Quality Loss

• Cause: Multiple encoding/decoding cycles
• Solution: Always work with original images
• Prevention: Keep backups of original files

Corrupted Messages

• Cause: Image modification after encoding
• Solution: Don't edit encoded images
• Prevention: Use read-only files when possible

Getting Help

1. Check Error Messages: Read the full error message carefully
2. Verify Inputs: Ensure all fields are filled correctly
3. Test with Sample: Try with the included test image
4. Check Documentation: Review this README for solutions
5. Create Issue: Report bugs with detailed information

Contributing

We welcome contributions! Here's how you can help:

Ways to Contribute

• Bug Reports: Report issues with detailed descriptions
• Feature Requests: Suggest new functionality
• Code Contributions: Submit pull requests
• Documentation: Improve this README
• Testing: Test on different platforms

Development Setup

# Fork and clone the repository
git clone https://github.com/Tuhin-SnapD/SteganoIt
cd ImageSteganography

# Create development branch
git checkout -b feature/your-feature-name

# Make changes and test
python main.py

# Commit changes
git add .
git commit -m "Add your feature"

# Push and create pull request
git push origin feature/your-feature-name

Code Guidelines

• Follow PEP 8 style guidelines
• Add docstrings to new functions
• Include error handling
• Write clear commit messages
• Test on multiple platforms

Reporting Issues

When reporting issues, please include:

• Operating system and version
• Python version
• Error messages (full text)
• Steps to reproduce
• Sample images (if applicable)

License

This project is licensed under the MIT License - see the LICENSE file for details.

MIT License Summary

• Commercial use
• Modification
• Distribution
• Private use
• No warranty
• No liability

Third-Party Licenses

• Pillow: PIL License
• Python: PSF License

---

Support & Contact

• Issues: GitHub Issues
• Discussions: GitHub Discussions
• Email: your.email@example.com

Acknowledgments

• Pillow Team: For the excellent image processing library
• Python Community: For the amazing ecosystem
• Open Source Contributors: For inspiration and feedback

---

⭐ If you found this project helpful, please give it a star!

Last updated: December 2024