A high-performance benchmarking tool for comparing classical and post-quantum cryptographic algorithms. Features optimized implementations with statistical analysis and accurate performance measurements.

Digital Signatures:

• Classical: Ed25519, RSA-PSS (2048-bit), ECDSA (P-256)
• Post-Quantum: ML-DSA-44 (Dilithium), Falcon-512

Key Exchange Mechanisms:

• Classical: X25519 (Curve25519 DH), ECDH (P-256), RSA-KEM
• Post-Quantum: ML-KEM-512 (Kyber)

• Pre-generated Keys: Keys generated once and reused (70-80% speedup)
• Statistical Analysis: 50-100 iterations per operation
• Accurate Timing: High-resolution measurements with standard deviation
• Dual Benchmark Modes:
  • Interactive mode with real-time output
  • Criterion benchmarks with HTML reports

System Info: Ubuntu Linux, Rust 1.70+
Total Time: 0.49s (0.28s key generation + 0.21s benchmarking)

More detailed statistical analysis with warmup, outlier detection, and HTML reports.

# Rust 1.70 or later
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

git clone <repository-url>
cd enc_test
cargo build --release

Run the optimized benchmark with real-time output:

cargo run --release

Command Line Options:

# Show help
cargo run --release -- --help

# Show version
cargo run --release -- --version

# Run comparison mode (shows performance improvement)
cargo run --release -- comparison

Expected Output:

╔═══════════════════════════════════════════════════════════════╗
║         Cryptographic Benchmarking Tool v0.2.0               ║
║    Classical & Post-Quantum Cryptography Performance         ║
╚═══════════════════════════════════════════════════════════════╝

⏳ Generating benchmark keys...
✓ All keys generated successfully (0.28s)

═══════════════════════════════════════════════════════════════
                   SIGNATURE ALGORITHMS
═══════════════════════════════════════════════════════════════

--- Ed25519 ---
Sign:   16.000 μs (min: 16 μs, max: 29 μs, σ: 1.23 μs)
Verify: 35.000 μs (min: 32 μs, max: 64 μs, σ: 3.45 μs)
...

╔════════════════════════════════════════════════════════╗
║                 BENCHMARK SUMMARY                      ║
╚════════════════════════════════════════════════════════╝
  📊 Statistics:      100 iterations per operation
  ⚡ Key Generation:  0.28s (one-time cost)
  🔬 Benchmark Time:  0.21s (all operations)
  ⏱️  Total Time:      0.49s

✅ All benchmarks completed successfully!

cargo bench

Results will be saved to target/criterion/ with detailed HTML reports.

View Reports:

# Open in browser
firefox target/criterion/report/index.html
# Or
xdg-open target/criterion/report/index.html

Signatures:

1. ML-KEM-512 Decapsulate: 8 μs (Post-Quantum winner!)
2. Ed25519 Sign: 16 μs (Classical winner)
3. ML-DSA-44 Verify: 26 μs

Key Exchange:

1. ML-KEM-512: 8-18 μs (Revolutionary speed!)
2. X25519 DH: 45-65 μs (Battle-tested)
3. ECDH P-256: 136-290 μs

Signatures:

1. Falcon-512 Sign: 7.09 ms (Criterion) / 366 μs (Interactive)*
2. Falcon-512 Verify: 7.23 ms (Criterion) / 37 μs (Interactive)*
3. RSA-2048 Sign: 163.7 ms (Needs key generation!)
4. RSA-2048 Verify: 157.5 ms

Key Exchange:

1. RSA-KEM: 166-177 ms (Very slow!)

*Note: Large discrepancy between Criterion and interactive benchmarks for Falcon suggests key generation overhead in Criterion helper functions.

Surprising Result: Post-quantum ML-KEM-512 is 3x faster than classical X25519! 🎉

enc_test/
├── src/
│   ├── main.rs              # Interactive benchmark CLI
│   ├── lib.rs               # Library exports
│   ├── signatures.rs        # Signature algorithms + helpers
│   ├── kem.rs               # KEM algorithms + helpers
│   ├── keys.rs              # Pre-generated key management
│   ├── measurement.rs       # Statistical benchmarking
│   ├── error.rs             # Error handling
│   └── constants.rs         # Configuration constants
├── benches/
│   └── crypto_bench.rs      # Criterion benchmarks
├── Cargo.toml               # Dependencies
└── README.md                # This file

pub struct BenchmarkKeys {
    pub ed25519_signing: Ed25519SigningKey,
    pub rsa_private: RsaPrivateKey,
    pub dilithium_public: mldsa44::PublicKey,
    // ... all algorithm keys
}

Benefits:

• RSA key generation (~200ms) done once
• Post-quantum key generation amortized
• 70-80% performance improvement

pub struct BenchmarkResult {
    pub mean_duration: Duration,
    pub std_deviation: f64,
    pub min_duration: Duration,
    pub max_duration: Duration,
}

Features:

• Warmup cycles (10 iterations)
• Multiple measurements (50-100 iterations)
• Outlier detection
• Standard deviation calculation

Edit src/constants.rs:

pub const DEFAULT_MEASUREMENT_ITERATIONS: usize = 100;
pub const DEFAULT_WARMUP_ITERATIONS: usize = 10;

pub const DEFAULT_MESSAGE: &[u8] = b"Your custom test message";

Edit benches/crypto_bench.rs:

criterion_group!(
    name = benches;
    config = Criterion::default()
        .sample_size(100)      // Number of samples
        .warm_up_time(Duration::from_secs(3));
    targets = benchmark_signatures, benchmark_kem
);

cargo doc --open

use crypto_benchmark::{BenchmarkKeys, signatures, kem};

fn main() {
    // Generate keys once
    let keys = BenchmarkKeys::generate().unwrap();
    
    // Run benchmarks
    signatures::benchmark_signatures_optimized(&keys);
    kem::benchmark_kem_optimized(&keys);
}

# Run tests
cargo test

# Run tests with output
cargo test -- --nocapture

# Check code
cargo check --all-targets

# Lint
cargo clippy --all-targets

Mean Time: Average execution time (most important) Min/Max: Best and worst case performance StdDev: Consistency (lower = more consistent) Outliers: Anomalous measurements (higher % = less reliable)

1. Use Ed25519 for speed: Fastest classical signature
2. Use ML-KEM-512 for quantum resistance: Faster than classical!
3. Avoid RSA: Too slow for modern applications
4. Pre-generate keys: Never generate keys in hot path

1. Run multiple times: Results vary by ~5-10%
2. Use release mode: Debug is 10x slower
3. Close other apps: Reduces CPU noise
4. Check outliers: High outliers = unreliable results

# Best accuracy
cargo run --release

# Most detailed
cargo bench

# Both
cargo run --release && cargo bench

NIST Standards:

• ML-DSA (FIPS 204 - Digital Signatures)
• ML-KEM (FIPS 203 - Key Encapsulation)

Classical Standards:

• Ed25519 (RFC 8032)
• RSA-PSS (RFC 8017)
• ECDSA (FIPS 186-4)

ed25519-dalek = "2.0"      # Ed25519 signatures
rsa = "0.9"                # RSA cryptography
p256 = "0.13"              # ECDSA & ECDH
pqcrypto-mldsa = "0.1.2"   # ML-DSA (Dilithium)
pqcrypto-mlkem = "0.1.1"   # ML-KEM (Kyber)
pqcrypto-falcon = "0.4.1"  # Falcon signatures
criterion = "0.7"          # Benchmarking framework

Discrepancy Alert: Falcon shows significant performance differences between benchmark modes:

Explanation: The Criterion helper functions (falcon_sign, falcon_verify) generate new keys on each iteration, while the interactive benchmark uses pre-generated keys from BenchmarkKeys. This demonstrates the importance of key reuse in production systems.

Recommendation: For production performance estimates, use the interactive benchmark results which reflect real-world usage with key caching.

• Compare classical vs post-quantum performance
• Study cryptographic algorithm characteristics
• Generate performance data for papers

• Assess algorithm performance impact
• Plan migration to post-quantum crypto
• Evaluate resource requirements

• Choose appropriate algorithms
• Performance budgeting
• Capacity planning

We welcome contributions! Whether you're fixing bugs, adding new algorithms, improving documentation, or optimizing performance, your help is appreciated.

1. Read CONTRIBUTING.md for detailed guidelines
2. Fork the repository
3. Create a feature branch (git checkout -b feature/amazing-feature)
4. Make your changes with tests
5. Test thoroughly (cargo test && cargo clippy && cargo fmt)
6. Commit with conventional commits (git commit -m 'feat: add amazing feature')
7. Push to your fork (git push origin feature/amazing-feature)
8. Open a Pull Request

• 🐛 Bug Fixes: Fix issues or improve error handling
• ✨ New Algorithms: Add SPHINCS+, BIKE, or other cryptographic algorithms
• ⚡ Performance: Optimize existing implementations
• 📚 Documentation: Improve README, add examples, fix typos
• 🧪 Tests: Increase test coverage or add integration tests
• 🔧 CI/CD: Improve build process or add automation

See CONTRIBUTING.md for complete guidelines including:

• Coding standards and style guide
• Testing requirements
• Commit message format
• Pull request process
• How to add new algorithms

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

✅ You can:

• Use this software for commercial purposes
• Modify and distribute the code
• Use it privately
• Sublicense the code

⚠️ You must:

• Include the original copyright notice
• Include a copy of the license

❌ Limitation:

• The software is provided "as is" without warranty

For the full license text, see LICENSE.

This project exists thanks to all the people who contribute!

Want to contribute? See CONTRIBUTING.md to get started!

We're always looking for help with:

• Adding new cryptographic algorithms
• Performance optimizations
• Documentation improvements
• Bug fixes and testing
• Code reviews

• NIST PQC Project: Post-quantum algorithm standardization
• Rust Crypto: Excellent cryptographic libraries
• Criterion.rs: Professional benchmarking framework
• All Contributors: Thank you for making this project better!

• Issues: GitHub Issues
• Documentation: cargo doc --open
• Discussions: GitHub Discussions

• Add more post-quantum algorithms (SPHINCS+, BIKE)
• GPU acceleration support
• WebAssembly benchmarks
• CI/CD integration
• Performance regression testing
• JSON/CSV export
• Comparison charts

⚡ Fast. Secure. Future-proof.

Last updated: October 1, 2025
Version: 0.2.0