quantum-shield 0.3.1

Hybrid post-quantum cryptography: X25519 + ML-KEM-1024 encryption and Ed25519 + ML-DSA-87 signatures
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

//! Wire-format serialization/parsing benchmarks.

use criterion::{criterion_group, criterion_main, Criterion};
use quantum_shield::{seal, Envelope, HybridCrypto, HybridSignature, PublicKeyBundle};

fn bench_codec(c: &mut Criterion) {
    let kp = HybridCrypto::generate().unwrap();

    let envelope = seal(b"codec benchmark payload", kp.public_keys()).unwrap();
    let env_bytes = envelope.to_bytes();
    c.bench_function("envelope_to_bytes", |b| b.iter(|| envelope.to_bytes()));
    c.bench_function("envelope_from_bytes", |b| {
        b.iter(|| Envelope::from_bytes(&env_bytes).unwrap());
    });

    let sig = kp.sign(b"msg", b"").unwrap();
    let sig_bytes = sig.to_bytes();
    c.bench_function("signature_to_bytes", |b| b.iter(|| sig.to_bytes()));
    c.bench_function("signature_from_bytes", |b| {
        b.iter(|| HybridSignature::from_bytes(&sig_bytes).unwrap());
    });

    let pub_bytes = kp.public_keys().to_bytes();
    c.bench_function("public_bundle_to_bytes", |b| {
        b.iter(|| kp.public_keys().to_bytes());
    });
    c.bench_function("public_bundle_from_bytes", |b| {
        b.iter(|| PublicKeyBundle::from_bytes(&pub_bytes).unwrap());
    });

    let secret = kp.to_secret_bytes();
    c.bench_function("secret_from_bytes", |b| {
        b.iter(|| HybridCrypto::from_secret_bytes(&secret).unwrap());
    });
}

criterion_group!(benches, bench_codec);
criterion_main!(benches);