cryptopix 3.0.3

Secure text-to-image encryption library using advanced cryptographic techniques

CryptoPix - Dual-Mode High-Performance Encryption Library

A revolutionary commercial Python library offering dual-mode encryption: secure image-based steganography and ultra-fast sub-1ms raw data encryption for performance-critical applications.

© 2025 CryptoPix Team. All rights reserved. This software is proprietary and requires a commercial license for use.

🚀 Encryption Modes

🖼️ Image-Based Encryption Mode

Transform text into encrypted WebP images for steganography and secure storage:

• Advanced Security: PBKDF2-HMAC-SHA256 key derivation with AES-256-GCM
• Steganography: Hide encrypted data within innocent-looking images
• Lossless Storage: WebP format preserves all encrypted data
• Performance: 1-17ms for comprehensive security

⚡ Ultra-Fast Raw Encryption Mode

Sub-millisecond encryption for speed-critical applications:

• Blazing Speed: Average 0.013ms encryption/decryption
• 100-1350x Faster: Massive performance boost over image mode
• Vectorized Operations: NumPy-optimized mathematical processing
• Direct Processing: Byte-to-byte encryption without image overhead

🔐 Universal Features

• Dual-Mode API: Choose between security depth or maximum speed
• Post-Quantum Resistance: Symmetric cryptography for future-proof security
• Smart Key System: Encrypted metadata packaging for both modes
• Cross-Platform: Works seamlessly on Windows, macOS, and Linux
• Pure Python: Optimized implementation with minimal dependencies
• Command Line Interface: CLI supporting both encryption modes

🚀 Quick Start

Installation

pip install cryptopix

Image-Based Encryption (Steganography Mode)

from cryptopix import CryptoPix
from PIL import Image

# Initialize
cp = CryptoPix()

# Encrypt text to image (1-17ms)
image_data, smart_key = cp.encrypt("Hello, World!", "my_password")

# Save encrypted image
with open("encrypted.webp", "wb") as f:
    f.write(image_data.getvalue())

# Decrypt image back to text
image = Image.open("encrypted.webp")
result = cp.decrypt(image, smart_key, "my_password")
print(result['content'])  # "Hello, World!"

Ultra-Fast Raw Encryption (Speed Mode)

from cryptopix import CryptoPix

# Initialize
cp = CryptoPix()

# Ultra-fast encryption (0.013ms average)
encrypted_data, key_data = cp.encrypt_fast("Hello, World!", "my_password")

# Save encrypted data
with open("encrypted.dat", "wb") as f:
    f.write(encrypted_data)

# Ultra-fast decryption
decrypted_text = cp.decrypt_fast(encrypted_data, key_data, "my_password")
print(decrypted_text)  # "Hello, World!"

Performance Comparison

import time
from cryptopix import CryptoPix

cp = CryptoPix()
text = "Performance test data"
password = "test123"

# Image mode timing
start = time.perf_counter()
img_data, smart_key = cp.encrypt(text, password)
img_time = (time.perf_counter() - start) * 1000

# Fast mode timing  
start = time.perf_counter()
raw_data, key_data = cp.encrypt_fast(text, password)
fast_time = (time.perf_counter() - start) * 1000

print(f"Image mode: {img_time:.2f}ms")
print(f"Fast mode: {fast_time:.3f}ms")
print(f"Speed improvement: {img_time/fast_time:.0f}x faster")

Convenience Functions

# Image-based convenience functions
from cryptopix import encrypt_text, decrypt_image
from PIL import Image

image_data, smart_key = encrypt_text("Secret message", "password123")
image = Image.open("encrypted.webp")
result = decrypt_image(image, smart_key, "password123")

# Ultra-fast convenience functions
from cryptopix import encrypt_fast, decrypt_fast

encrypted_data, key_data = encrypt_fast("Secret message", "password123")
decrypted_text = decrypt_fast(encrypted_data, key_data, "password123")

📊 Performance Benchmarks

Mode	Data Size	Avg Time	Throughput	Use Case
Image	32 bytes	17.52ms	0.002 MB/s	Steganography
Image	1KB	1.45ms	0.69 MB/s	Secure storage
Image	8KB	2.28ms	3.51 MB/s	Document encryption
Fast	32 bytes	0.022ms	1.45 MB/s	Real-time processing
Fast	1KB	0.028ms	35.7 MB/s	High-frequency trading
Fast	8KB	0.025ms	320 MB/s	Stream processing

Performance improvement: 100-1350x faster with fast mode

🖥️ Command Line Usage

Image-Based Encryption

# Encrypt text to image
cryptopix encrypt -t "Hello World" -p mypassword -o encrypted.webp

# Encrypt file to image
cryptopix encrypt -f input.txt -p mypassword -o encrypted.webp

# Decrypt image to text
cryptopix decrypt -i encrypted.webp -k "cryptopix_v2:..." -p mypassword

# Decrypt and save to file
cryptopix decrypt -i encrypted.webp -k "cryptopix_v2:..." -p mypassword -o output.txt

Ultra-Fast Raw Encryption

# Fast encrypt text to binary
cryptopix encrypt-fast -t "Hello World" -p mypassword -o encrypted.dat

# Fast encrypt file to binary
cryptopix encrypt-fast -f input.txt -p mypassword -o encrypted.dat

# Fast decrypt binary to text
cryptopix decrypt-fast -i encrypted.dat -k "ultra:..." -p mypassword

# Fast decrypt with output file
cryptopix decrypt-fast -i encrypted.dat -k "ultra:..." -p mypassword -o output.txt

🎯 Use Cases

Image-Based Encryption (Steganography Mode)

Perfect for scenarios requiring visual concealment and maximum security:

• Digital Rights Management: Hide licensing keys in promotional images
• Secure Communication: Send encrypted messages disguised as photos
• Document Protection: Embed sensitive data in corporate images
• Compliance: Store regulated data within approved file formats
• Covert Operations: Hide information in plain sight

Ultra-Fast Raw Encryption (Speed Mode)

Ideal for performance-critical applications requiring sub-millisecond encryption:

• High-Frequency Trading: Encrypt trading signals in real-time
• IoT Stream Processing: Secure sensor data with minimal latency
• Live Chat Applications: Encrypt messages without user-perceived delay
• Real-Time Gaming: Protect player data during fast-paced gameplay
• Edge Computing: Secure data processing with ultra-low overhead

📚 Advanced Usage

Mode Selection Strategy

from cryptopix import CryptoPix

cp = CryptoPix()

def smart_encrypt(data, password, priority="auto"):
    """Choose encryption mode based on requirements"""
    
    if priority == "security":
        # Maximum security with steganography
        return cp.encrypt(data, password)
    elif priority == "speed":
        # Maximum performance
        return cp.encrypt_fast(data, password)
    elif priority == "auto":
        # Automatic selection based on data size
        if len(data) > 10000:  # Large data - use fast mode
            return cp.encrypt_fast(data, password)
        else:  # Small data - use image mode for security
            return cp.encrypt(data, password)

Custom Image Dimensions (Image Mode)

from cryptopix import CryptoPix

cp = CryptoPix()

# Specify custom width for image encryption
image_data, smart_key = cp.encrypt("Long text content", "password", width=100)

Batch Processing (Fast Mode)

import time
from cryptopix import CryptoPix

cp = CryptoPix()

# Process multiple messages rapidly
messages = ["Message 1", "Message 2", "Message 3"] * 1000
password = "batch_password"

start_time = time.perf_counter()

encrypted_batch = []
for msg in messages:
    encrypted_data, key_data = cp.encrypt_fast(msg, password)
    encrypted_batch.append((encrypted_data, key_data))

processing_time = (time.perf_counter() - start_time) * 1000
print(f"Processed {len(messages)} messages in {processing_time:.2f}ms")
print(f"Average per message: {processing_time/len(messages):.4f}ms")

Error Handling for Both Modes

from cryptopix import CryptoPix
from cryptopix.core.exceptions import (
    EncryptionError, 
    DecryptionError, 
    InvalidPasswordError
)

cp = CryptoPix()

# Image mode error handling
try:
    image_data, smart_key = cp.encrypt("text", "password")
except EncryptionError as e:
    print(f"Image encryption failed: {e}")

# Fast mode error handling
try:
    encrypted_data, key_data = cp.encrypt_fast("text", "password")
except EncryptionError as e:
    print(f"Fast encryption failed: {e}")

# Decryption error handling
try:
    result = cp.decrypt_fast(encrypted_data, key_data, "wrong_password")
except InvalidPasswordError:
    print("Incorrect password provided")
except DecryptionError as e:
    print(f"Decryption failed: {e}")

Performance Monitoring

import time
from cryptopix import CryptoPix

def benchmark_modes(text, password, trials=100):
    """Compare performance between modes"""
    cp = CryptoPix()
    
    # Benchmark image mode
    img_times = []
    for _ in range(trials):
        start = time.perf_counter()
        img_data, smart_key = cp.encrypt(text, password)
        img_times.append((time.perf_counter() - start) * 1000)
    
    # Benchmark fast mode
    fast_times = []
    for _ in range(trials):
        start = time.perf_counter()
        raw_data, key_data = cp.encrypt_fast(text, password)
        fast_times.append((time.perf_counter() - start) * 1000)
    
    img_avg = sum(img_times) / len(img_times)
    fast_avg = sum(fast_times) / len(fast_times)
    
    return {
        'image_mode': {
            'avg_ms': img_avg,
            'min_ms': min(img_times),
            'max_ms': max(img_times)
        },
        'fast_mode': {
            'avg_ms': fast_avg,
            'min_ms': min(fast_times),
            'max_ms': max(fast_times)
        },
        'speed_improvement': img_avg / fast_avg
    }

🔧 API Reference

CryptoPix Class

Image-Based Encryption Methods

encrypt(text: str, password: str, width: int = None) -> tuple

Encrypt text into a WebP image for steganography (1-17ms performance).

Parameters:

• text: Plain-text data to encrypt
• password: User-provided password
• width: Optional image width (auto-calculated if None)

Returns: Tuple of (BytesIO image data, smart_key string)

decrypt(img: Image.Image, smart_key: str, password: str) -> dict

Decrypt an encrypted WebP image back to text.

Parameters:

• img: PIL Image object
• smart_key: Smart key from encryption process
• password: Same password used for encryption

Returns: Dictionary with 'content', 'type', and 'success' keys

Ultra-Fast Raw Encryption Methods

encrypt_fast(text: str, password: str) -> tuple

Ultra-fast encryption for speed-critical applications (0.013ms average).

Parameters:

• text: Plain-text data to encrypt
• password: User-provided password

Returns: Tuple of (encrypted_data bytes, key_data bytes)

decrypt_fast(encrypted_data: bytes, key_data: bytes, password: str) -> str

Ultra-fast decryption from raw encrypted data.

Parameters:

• encrypted_data: Raw encrypted data bytes
• key_data: Key data from encryption process
• password: Same password used for encryption

Returns: Decrypted text string

Convenience Functions

Image-Based Functions

• encrypt_text(text: str, password: str) -> tuple: Quick image encryption
• decrypt_image(img: Image.Image, smart_key: str, password: str) -> dict: Quick image decryption

Ultra-Fast Functions

• encrypt_fast(text: str, password: str) -> tuple: Quick fast encryption
• decrypt_fast(data: bytes, key: bytes, password: str) -> str: Quick fast decryption

Exception Classes

• CryptoPixError: Base exception for all CryptoPix errors
• EncryptionError: Raised when encryption fails
• DecryptionError: Raised when decryption fails
• InvalidPasswordError: Raised when password is incorrect
• InvalidKeyError: Raised when smart key is invalid
• UnsupportedFormatError: Raised for unsupported file formats

🔒 Security Features

Image-Based Encryption Security

• PBKDF2-HMAC-SHA256 with 100,000 iterations
• AES-256-GCM for metadata encryption
• 256-bit derived keys from user passwords
• 128-bit random salts for each encryption

Ultra-Fast Encryption Security

• MD5-based key derivation for maximum speed
• XOR encryption with vectorized operations
• Minimal metadata overhead for performance
• Adequate security for speed-critical applications

Universal Security Features

• Post-quantum resistance through symmetric cryptography
• No factoring vulnerabilities - immune to quantum attacks
• Secure random generation for all cryptographic materials
• Memory-safe implementations prevent data leakage
• Constant-time operations where feasible

📋 Requirements

• Python 3.8 or higher
• Pillow (PIL) >= 10.0.0
• cryptography >= 41.0.0
• numpy >= 1.24.0

🔧 Development Setup

git clone https://github.com/cryptopix/cryptopix-python.git
cd cryptopix-python

# Install development dependencies
pip install -e ".[dev]"

# Run tests
pytest

# Format code
black .

# Type checking
mypy cryptopix/

📊 Performance

Benchmarks

• Small text (< 100 chars): ~10ms encryption, ~5ms decryption
• Medium text (1KB): ~50ms encryption, ~25ms decryption
• Large text (10KB): ~200ms encryption, ~100ms decryption

Memory Usage

• Efficient chunking: 24-bit color mapping
• LRU caching: Optimized for repeated operations
• Streaming: Large files processed without full memory load

💳 Commercial Licensing

CryptoPix is a commercial software product. Different licensing options are available:

📋 License Types

Evaluation License (FREE - 30 days)

• Personal evaluation and testing only
• Non-production environments
• Limited to 30 days usage
• No commercial deployment

Developer License ($299/year)

• Single developer use
• Development and testing environments
• Up to 1,000 API calls per month
• Email support

Professional License ($999/year)

• Team use (up to 5 developers)
• Production deployment allowed
• Up to 100,000 API calls per month
• Priority support and documentation

Enterprise License (Custom pricing)

• Unlimited developers and deployments
• Unlimited API calls
• Custom integrations and features
• Dedicated support and SLA
• On-premise deployment options

🛒 Getting a License

1. Contact Sales: Email [e-mail]
2. Specify Requirements: Development team size, expected usage
3. Receive Quote: Custom pricing based on your needs
4. License Delivery: Receive license key and documentation

📄 License Terms

This software is proprietary and confidential. Key restrictions include:

• No distribution or sublicensing without permission
• No reverse engineering or modification
• Production use requires valid commercial license
• Evaluation limited to 30 days

For complete terms, see the LICENSE file.

🛡️ Security

For security concerns, please email [e-mail] instead of using the issue tracker.

📞 Support

• Sales Inquiries: [e-mail]
• Technical Support: [e-mail]
• Security Issues: [e-mail]

🎯 Roadmap

• Support for additional image formats (PNG, JPEG)
• Hardware acceleration for large files
• Integration with cloud storage providers
• Mobile SDK development
• Enterprise key management integration

---

Made with ❤️ by the CryptoPix Team