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
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

use commonware_cryptography::bls12381::primitives::group::{Scalar, G1, G2};
use commonware_math::algebra::{CryptoGroup, Random, Space};
use commonware_parallel::{Rayon, Sequential};
use criterion::{criterion_group, BatchSize, Criterion};
use rand::{rngs::StdRng, SeedableRng};
use std::{hint::black_box, num::NonZeroUsize};

fn bench_msm(c: &mut Criterion) {
    let par = Rayon::new(NonZeroUsize::new(8).unwrap()).unwrap();

    for n in [10, 50, 100, 200, 1000, 5000] {
        // G1 Sequential (conc=1)
        c.bench_function(
            &format!("{}/group=g1 n={} conc=1", module_path!(), n),
            |b| {
                b.iter_batched(
                    || {
                        let mut rng = StdRng::seed_from_u64(0);
                        let points: Vec<G1> = (0..n)
                            .map(|_| G1::generator() * &Scalar::random(&mut rng))
                            .collect();
                        let scalars: Vec<Scalar> =
                            (0..n).map(|_| Scalar::random(&mut rng)).collect();
                        (points, scalars)
                    },
                    |(points, scalars)| black_box(G1::msm(&points, &scalars, &Sequential)),
                    BatchSize::SmallInput,
                );
            },
        );

        // G1 Parallel (conc=8)
        c.bench_function(
            &format!("{}/group=g1 n={} conc=8", module_path!(), n),
            |b| {
                b.iter_batched(
                    || {
                        let mut rng = StdRng::seed_from_u64(0);
                        let points: Vec<G1> = (0..n)
                            .map(|_| G1::generator() * &Scalar::random(&mut rng))
                            .collect();
                        let scalars: Vec<Scalar> =
                            (0..n).map(|_| Scalar::random(&mut rng)).collect();
                        (points, scalars)
                    },
                    |(points, scalars)| black_box(G1::msm(&points, &scalars, &par)),
                    BatchSize::SmallInput,
                );
            },
        );

        // G2 Sequential (conc=1)
        c.bench_function(
            &format!("{}/group=g2 n={} conc=1", module_path!(), n),
            |b| {
                b.iter_batched(
                    || {
                        let mut rng = StdRng::seed_from_u64(0);
                        let points: Vec<G2> = (0..n)
                            .map(|_| G2::generator() * &Scalar::random(&mut rng))
                            .collect();
                        let scalars: Vec<Scalar> =
                            (0..n).map(|_| Scalar::random(&mut rng)).collect();
                        (points, scalars)
                    },
                    |(points, scalars)| black_box(G2::msm(&points, &scalars, &Sequential)),
                    BatchSize::SmallInput,
                );
            },
        );

        // G2 Parallel (conc=8)
        c.bench_function(
            &format!("{}/group=g2 n={} conc=8", module_path!(), n),
            |b| {
                b.iter_batched(
                    || {
                        let mut rng = StdRng::seed_from_u64(0);
                        let points: Vec<G2> = (0..n)
                            .map(|_| G2::generator() * &Scalar::random(&mut rng))
                            .collect();
                        let scalars: Vec<Scalar> =
                            (0..n).map(|_| Scalar::random(&mut rng)).collect();
                        (points, scalars)
                    },
                    |(points, scalars)| black_box(G2::msm(&points, &scalars, &par)),
                    BatchSize::SmallInput,
                );
            },
        );
    }
}

criterion_group! {
    name = benches;
    config = Criterion::default().sample_size(10);
    targets = bench_msm
}