Release v2.0.0 — Rust-Accelerated Core Rewrite 🦀⚡

This is a major architectural release that completely swaps the computationally intensive pipeline stages of Paradox
(coordinateevolution, walk loops, neighbor extraction, seed evolution, and entropy aggregation) with a native Rust
implementation exposed to Python via PyO3 and Maturin.
This update delivers massive performance improvements (up to a 31.2× latency speedup) while maintaining 100% bit-for-
bit key derivation parity and backward compatibility with the original v1 Python API.
──────

🚀 Key Highlights & Speedup Metrics

The transition of the coordinate mapping and recursive walk layer loops to Rust yields significant latency reductions:

Security Level	Steps × Layers	v1 Python (ms)	v2 Rust (ms)	Speedup Factor
LOW	1,000 × 2	91.0 ms	7.6 ms	11.9×
MEDIUM	10,000 × 4	2,140.0 ms	93.5 ms	22.9×
HIGH	100,000 × 8	58,300.0 ms	1,866.3 ms	31.2×

Note: Latency scales linearly in Rust, allowing the HIGH security configuration (800,000 recursive walk steps) to
execute in under 2 seconds (down from nearly a minute).
──────

🛠️ Codebase & Packaging Improvements

• PyO3 Bindings: Swapped the slow coordinate loop with _paradox_core , a native C extension.
• Maturin Build Integration: Added full configuration to pyproject.toml and Cargo.toml to support direct building
and publishing to PyPI.
• Ruff, Black, & MyPy Compliant: Standardized type-checking and code formatting to pass all static linting checks with
zero warnings.
• Critical Decryption Bugfix: Fixed a bug in encrypt.py where decrypted files were decoded to UTF-8 text strings
prior to output writing, which formerly corrupted non-text binary files (e.g. PDFs, ZIPs, images) during decryption.
• Circular Import Resolution: Refactored package level imports to prevent circular dependencies at startup.
──────

🧪 Cryptographic & Parity Validation

All 12 validation tests pass successfully:

• Bit-for-bit Parity: Verified key generation output against v1 baseline reference vectors.
• Avalanche Effect: Average bit difference of 50.1367% (ideal: 50.0%) within a strict ±5% cryptographic acceptance band.
• Shannon Entropy: Key entropy metrics consistently measure at 7.945204 bits/byte (ideal: 8.0) passing the Chi-Square
uniformity test (p = 0.75 > 0.01).
• Collisions: Zero collisions observed over 1,000 generated keys.
──────

📦 How to Install & Compile

# Clone the repository
git clone https://github.com/chiragferwani/paradox.git
cd paradox

# Activate virtual environment
python3 -m venv .venv
source .venv/bin/activate

# Install build tools and compile the extension
pip install maturin patchelf
export PYO3_USE_ABI3_FORWARD_COMPATIBILITY=1
maturin develop --release

Paradox RVE-KDE v1.0.2

Paradox RVE-KDE v1.0.2

Release Overview

Paradox (Recursive Visual Entropy Key Derivation Engine - RVE-KDE) is an experimental image-driven cryptographic key derivation framework that generates deterministic cryptographic keys through recursive visual entropy extraction and multi-layer image traversal.

Version 1.0.2 focuses on packaging improvements, documentation enhancements, release engineering refinements, and ecosystem readiness for public distribution through PyPI and GitHub.

---

Highlights

Published on PyPI

Paradox is now available as a public Python package:

pip install paradox-rvekde

Recursive Visual Entropy Engine

• Deterministic image-based entropy extraction
• Multi-layer recursive traversal
• Hash-chain driven coordinate evolution
• Configurable security levels
• Nonce-based reproducibility

Cryptographic Support

• AES-256-GCM
• ChaCha20-Poly1305
• HKDF-based key derivation
• BLAKE3 integration

Research Validation

Paradox has undergone extensive validation and benchmarking including:

• 46 automated unit tests

• Entropy analysis

• Avalanche effect testing

• Collision analysis

• Randomness evaluation

• Comparative benchmarking against:

  • PBKDF2
  • HKDF
  • Argon2id
  • BLAKE3-KDF

Benchmark Highlights

• Avalanche Effect: ~50.08%
• Shannon Entropy: ~7.999/8
• Collision Rate: 0% (observed during benchmark runs)
• Near-uniform bit distribution
• Deterministic key generation behavior

---

Documentation

This release includes:

• Professional README
• Security Policy
• Contribution Guidelines
• Research Documentation
• Benchmark Reports
• Citation Metadata
• Release Engineering Documentation

---

Known Limitations

Paradox is currently implemented in Python and prioritizes research experimentation over production performance.

The framework is significantly slower than traditional KDFs such as HKDF, PBKDF2, Argon2id, and BLAKE3 due to image processing and recursive traversal operations.

---

Research Disclaimer

Paradox is an experimental research-oriented key derivation framework and should not be considered a replacement for established cryptographic standards such as Argon2, PBKDF2, HKDF, or BLAKE3.

---

Future Roadmap

• Advanced adversarial image testing
• Expanded cryptanalysis suite
• Performance optimization
• Native Rust acceleration
• Additional entropy extraction strategies
• Academic publication and peer review

---

Links

PyPI:
https://pypi.org/project/paradox-rvekde/

Repository:
https://github.com/chiragferwani/paradox

Thank you for exploring Paradox and contributing to its development.

Paradox v1.0.0

• Recursive Visual Entropy Key Derivation Engine
• 46 unit tests passed
• Entropy benchmark results
• Avalanche benchmark results
• Research prototype release