commonware-cryptography 2026.4.0

Generate keys, sign arbitrary messages, and deterministically verify 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
39
40
41
42
43
44
45
46
47
48

use commonware_cryptography::{
    ed25519::PrivateKey,
    handshake::{
        dial_end, dial_start, listen_end, listen_start, Context, Error, RecvCipher, SendCipher,
    },
    transcript::Transcript,
    Signer,
};
use commonware_math::algebra::Random;
use criterion::criterion_main;
use rand::SeedableRng as _;
use rand_chacha::ChaCha8Rng;

mod handshake;
mod transport;

fn connect() -> Result<(SendCipher, RecvCipher), Error> {
    let mut rng = ChaCha8Rng::seed_from_u64(0);
    let dialer_crypto = PrivateKey::random(&mut rng);
    let listener_crypto = PrivateKey::random(&mut rng);

    let (d_state, msg1) = dial_start(
        &mut rng,
        Context::new(
            &Transcript::new(b"bench_namespace"),
            0,
            0..1,
            dialer_crypto.clone(),
            listener_crypto.public_key(),
        ),
    );
    let (l_state, msg2) = listen_start(
        &mut rng,
        Context::new(
            &Transcript::new(b"bench_namespace"),
            0,
            0..1,
            listener_crypto,
            dialer_crypto.public_key(),
        ),
        msg1,
    )?;
    let (msg3, d_send, _) = dial_end(d_state, msg2)?;
    let (_, l_recv) = listen_end(l_state, msg3)?;
    Ok((d_send, l_recv))
}

criterion_main!(handshake::benches, transport::benches);