-
-
avalanche_comparison
-
latency_comparison
-
hamming_distribution
-
paradox_scaling_dimensions
Inspiration
Paradox was born from a simple question:
Can visual information itself become a source of cryptographic entropy?
Traditional cryptographic systems derive keys from passwords, random number generators, or hardware entropy sources. We wanted to explore a completely different approach — using images as the foundation for deterministic key generation.
The project was inspired by:
- Cryptographic key derivation functions (KDFs)
- Entropy extraction techniques
- Recursive algorithms
- Image processing and pixel analysis
- Hash-chain based state evolution
- The idea of exploring unconventional entropy domains
Instead of asking "How can we generate random keys?", we asked:
"Can we transform the visual complexity of an image into reproducible cryptographic material?"
This question eventually evolved into Paradox (Recursive Visual Entropy Key Derivation Engine - RVE-KDE).
What it does
Paradox is an experimental image-driven cryptographic key derivation framework.
It converts visual information contained inside an image into deterministic cryptographic keys that can be used with standard encryption algorithms.
Core Workflow
Image
↓
Visual Entropy Extraction
↓
Recursive Traversal
↓
Hash Chain Evolution
↓
Entropy Pool Generation
↓
Key Derivation
↓
AES / ChaCha Encryption
Features
- Deterministic image-based key generation
- Recursive image traversal engine
- Multi-layer entropy extraction
- Hash-chain driven coordinate evolution
- Nonce-based reproducibility
- Multiple security levels
- AES-256-GCM support
- ChaCha20-Poly1305 support
- Public Python package distribution
Supported Operations
- Generate cryptographic keys from images
- Encrypt text data
- Encrypt files
- Decrypt encrypted content
- Reproduce identical keys from identical inputs
How we built it
Paradox was designed as a modular Python framework where each component has a dedicated responsibility.
Image Processing Layer
Responsible for:
- Loading images
- Reading pixel values
- Extracting color information
- Generating visual entropy candidates
Recursive Walk Engine
The heart of Paradox.
Instead of processing images sequentially, the system:
- Selects an initial coordinate
- Traverses image regions recursively
- Evolves traversal paths dynamically
- Extracts entropy from visited locations
Hash Chain Engine
Used to continuously evolve traversal states.
Functions:
- Prevent predictable coordinate selection
- Generate new traversal states
- Influence recursion paths
Entropy Collection Layer
Responsible for collecting:
- Pixel values
- RGB color channels
- Coordinate information
- Traversal states
and converting them into entropy pools.
Key Derivation Layer
Collected entropy is processed using:
- HKDF
- BLAKE3
to generate:
- 128-bit keys
- 256-bit keys
- 512-bit keys
Encryption Layer
Generated keys are used with:
- AES-256-GCM
- ChaCha20-Poly1305
for authenticated encryption.
Development Stack
- Python
- NumPy
- Pillow
- Cryptography
- BLAKE3
- PyTest
- GitHub Actions
- PyPI
- Zenodo
Challenges we ran into
Building a cryptography-inspired research project introduced several challenges.
Deterministic Reproducibility
One of the hardest problems was ensuring:
Same Image
+ Same Nonce
+ Same Parameters
= Same Key
every single time.
Recursive Traversal Design
Challenges included:
- Designing traversal logic
- Preventing recursion loops
- Maintaining reproducibility
- Balancing randomness and determinism
Entropy Validation
Generating entropy is easy.
Proving that it behaves well is difficult.
We needed to build benchmark suites for:
- Entropy analysis
- Avalanche effect testing
- Collision testing
- Bit distribution analysis
Performance Tradeoffs
Recursive image processing is computationally expensive.
We had to balance:
- Security complexity
- Traversal depth
- Execution time
Packaging & Distribution
Turning a prototype into a public package required:
- Documentation
- Testing
- CI/CD setup
- Release engineering
- Package publishing
Accomplishments that we're proud of
Successfully Built the Core Framework
We transformed a theoretical idea into a fully functional implementation.
Published on PyPI
Paradox is publicly available as:
pip install paradox-rvekde
Open-Sourced the Project
The entire framework is publicly available through GitHub.
Obtained a DOI
The project has been archived on Zenodo and assigned a permanent DOI:
DOI: https://doi.org/10.5281/zenodo.20811708
Comprehensive Testing
Built and validated:
- 46 automated unit tests
- Encryption/decryption tests
- Key derivation tests
- Entropy validation tests
Benchmarking Against Existing KDFs
Compared Paradox against:
- PBKDF2
- HKDF
- Argon2id
- BLAKE3-KDF
Research Contribution
Created a novel framework that explores visual information as an entropy domain for cryptographic key generation.
What we learned
This project taught us lessons that extend beyond software development.
Entropy Is Not Randomness
We learned that:
- Random-looking outputs are not enough
- Entropy must be measurable
- Cryptographic properties must be validated
Benchmarking Is Essential
Every claim requires evidence.
This led us to build:
- Avalanche effect tests
- Entropy analysis tools
- Collision detection suites
Determinism Is Hard
Making a system reproducible while maintaining complexity is significantly more challenging than it initially appears.
Security Requires Responsibility
We learned the importance of:
- Avoiding exaggerated claims
- Clearly stating limitations
- Positioning experimental work appropriately
Open Source Development
Publishing a project taught us:
- Package management
- Release workflows
- Documentation standards
- Software distribution practices
What's next for Paradox
Paradox is currently a research-oriented framework, and we see multiple directions for future development.
Advanced Cryptanalysis
- Adversarial testing
- Security evaluation
- Statistical robustness analysis
Larger Benchmark Datasets
- Millions of generated keys
- Diverse image collections
- Cross-platform validation
Performance Optimization
Potential future implementations:
- Rust backend
- C++ acceleration
- GPU-assisted processing
Multi-Modal Entropy Sources
Expand beyond images:
- Audio
- Video
- Sensor streams
- Hybrid entropy systems
Academic Publication
Planned outputs:
- Research whitepaper
- IEEE conference submission
- Peer-reviewed publication
Community Contributions
Future goals include:
- Open-source contributions
- External validation
- Research collaborations
- Security reviews
Long-Term Vision
Our goal is not to replace established cryptographic standards, but to explore whether visual information can serve as a meaningful and reproducible entropy source for future cryptographic research.
Log in or sign up for Devpost to join the conversation.