fips205 0.4.1

FIPS 205: Stateless Hash-Based Digital Signature Standard
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
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

use criterion::{criterion_group, criterion_main, Criterion};
use fips205::traits::{KeyGen, Signer, Verifier};
use fips205::{
    slh_dsa_sha2_128f, slh_dsa_sha2_128s, slh_dsa_sha2_192f, slh_dsa_sha2_192s, slh_dsa_sha2_256f,
    slh_dsa_sha2_256s, slh_dsa_shake_128f, slh_dsa_shake_128s, slh_dsa_shake_192f,
    slh_dsa_shake_192s, slh_dsa_shake_256f, slh_dsa_shake_256s,
};


#[allow(clippy::redundant_closure)]
pub fn criterion_benchmark(c: &mut Criterion) {
    let message = [0u8, 1, 2, 3, 4, 5, 6, 7];
    let hedged = false;

    let (pk_sha2_128s, sk_sha2_128s) = slh_dsa_sha2_128s::KG::try_keygen().unwrap();
    let (pk_sha2_128f, sk_sha2_128f) = slh_dsa_sha2_128f::KG::try_keygen().unwrap();
    let (pk_sha2_192s, sk_sha2_192s) = slh_dsa_sha2_192s::KG::try_keygen().unwrap();
    let (pk_sha2_192f, sk_sha2_192f) = slh_dsa_sha2_192f::KG::try_keygen().unwrap();
    let (pk_sha2_256s, sk_sha2_256s) = slh_dsa_sha2_256s::KG::try_keygen().unwrap();
    let (pk_sha2_256f, sk_sha2_256f) = slh_dsa_sha2_256f::KG::try_keygen().unwrap();
    let (pk_shake_128s, sk_shake_128s) = slh_dsa_shake_128s::KG::try_keygen().unwrap();
    let (pk_shake_128f, sk_shake_128f) = slh_dsa_shake_128f::KG::try_keygen().unwrap();
    let (pk_shake_192s, sk_shake_192s) = slh_dsa_shake_192s::KG::try_keygen().unwrap();
    let (pk_shake_192f, sk_shake_192f) = slh_dsa_shake_192f::KG::try_keygen().unwrap();
    let (pk_shake_256s, sk_shake_256s) = slh_dsa_shake_256s::KG::try_keygen().unwrap();
    let (pk_shake_256f, sk_shake_256f) = slh_dsa_shake_256f::KG::try_keygen().unwrap();

    let sig_sha2_128s = sk_sha2_128s.try_sign(&message, b"context", hedged).unwrap();
    let sig_sha2_128f = sk_sha2_128f.try_sign(&message, b"context", hedged).unwrap();
    let sig_sha2_192s = sk_sha2_192s.try_sign(&message, b"context", hedged).unwrap();
    let sig_sha2_192f = sk_sha2_192f.try_sign(&message, b"context", hedged).unwrap();
    let sig_sha2_256s = sk_sha2_256s.try_sign(&message, b"context", hedged).unwrap();
    let sig_sha2_256f = sk_sha2_256f.try_sign(&message, b"context", hedged).unwrap();
    let sig_shake_128s = sk_shake_128s.try_sign(&message, b"context", hedged).unwrap();
    let sig_shake_128f = sk_shake_128f.try_sign(&message, b"context", hedged).unwrap();
    let sig_shake_192s = sk_shake_192s.try_sign(&message, b"context", hedged).unwrap();
    let sig_shake_192f = sk_shake_192f.try_sign(&message, b"context", hedged).unwrap();
    let sig_shake_256s = sk_shake_256s.try_sign(&message, b"context", hedged).unwrap();
    let sig_shake_256f = sk_shake_256f.try_sign(&message, b"context", hedged).unwrap();

    c.bench_function("sha2_128f  keygen", |b| b.iter(|| slh_dsa_sha2_128f::KG::try_keygen()));
    c.bench_function("sha2_192f  keygen", |b| b.iter(|| slh_dsa_sha2_192f::KG::try_keygen()));
    c.bench_function("sha2_256f  keygen", |b| b.iter(|| slh_dsa_sha2_256f::KG::try_keygen()));
    c.bench_function("shake_128f keygen", |b| b.iter(|| slh_dsa_shake_128f::KG::try_keygen()));
    c.bench_function("shake_192f keygen", |b| b.iter(|| slh_dsa_shake_192f::KG::try_keygen()));
    c.bench_function("shake_256f keygen", |b| b.iter(|| slh_dsa_shake_256f::KG::try_keygen()));
    c.bench_function("sha2_128s  keygen", |b| b.iter(|| slh_dsa_sha2_128s::KG::try_keygen()));
    c.bench_function("sha2_192s  keygen", |b| b.iter(|| slh_dsa_sha2_192s::KG::try_keygen()));
    c.bench_function("sha2_256s  keygen", |b| b.iter(|| slh_dsa_sha2_256s::KG::try_keygen()));
    c.bench_function("shake_128s keygen", |b| b.iter(|| slh_dsa_shake_128s::KG::try_keygen()));
    c.bench_function("shake_192s keygen", |b| b.iter(|| slh_dsa_shake_192s::KG::try_keygen()));
    c.bench_function("shake_256s keygen", |b| b.iter(|| slh_dsa_shake_256s::KG::try_keygen()));
    //
    c.bench_function("sha2_128f  sign  ", |b| {
        b.iter(|| sk_sha2_128f.try_sign(&message, b"context", hedged))
    });
    c.bench_function("sha2_192f  sign  ", |b| {
        b.iter(|| sk_sha2_192f.try_sign(&message, b"context", hedged))
    });
    c.bench_function("sha2_256f  sign  ", |b| {
        b.iter(|| sk_sha2_256f.try_sign(&message, b"context", hedged))
    });
    c.bench_function("shake_128f sign  ", |b| {
        b.iter(|| sk_shake_128f.try_sign(&message, b"context", hedged))
    });
    c.bench_function("shake_192f sign  ", |b| {
        b.iter(|| sk_shake_192f.try_sign(&message, b"context", hedged))
    });
    c.bench_function("shake_256f sign  ", |b| {
        b.iter(|| sk_shake_256f.try_sign(&message, b"context", hedged))
    });
    c.bench_function("sha2_128s  sign  ", |b| {
        b.iter(|| sk_sha2_128s.try_sign(&message, b"context", hedged))
    });
    c.bench_function("sha2_192s  sign  ", |b| {
        b.iter(|| sk_sha2_192s.try_sign(&message, b"context", hedged))
    });
    c.bench_function("sha2_256s  sign  ", |b| {
        b.iter(|| sk_sha2_256s.try_sign(&message, b"context", hedged))
    });
    c.bench_function("shake_128s sign  ", |b| {
        b.iter(|| sk_shake_128s.try_sign(&message, b"context", hedged))
    });
    c.bench_function("shake_192s sign  ", |b| {
        b.iter(|| sk_shake_192s.try_sign(&message, b"context", hedged))
    });
    c.bench_function("shake_256s sign  ", |b| {
        b.iter(|| sk_shake_256s.try_sign(&message, b"context", hedged))
    });
    //
    c.bench_function("sha2_128f  verify", |b| {
        b.iter(|| pk_sha2_128f.verify(&message, &sig_sha2_128f, b"context"))
    });
    c.bench_function("sha2_192f  verify", |b| {
        b.iter(|| pk_sha2_192f.verify(&message, &sig_sha2_192f, b"context"))
    });
    c.bench_function("sha2_256f  verify", |b| {
        b.iter(|| pk_sha2_256f.verify(&message, &sig_sha2_256f, b"context"))
    });
    c.bench_function("shake_128f verify", |b| {
        b.iter(|| pk_shake_128f.verify(&message, &sig_shake_128f, b"context"))
    });
    c.bench_function("shake_192f verify", |b| {
        b.iter(|| pk_shake_192f.verify(&message, &sig_shake_192f, b"context"))
    });
    c.bench_function("shake_256f verify", |b| {
        b.iter(|| pk_shake_256f.verify(&message, &sig_shake_256f, b"context"))
    });
    c.bench_function("sha2_128s  verify", |b| {
        b.iter(|| pk_sha2_128s.verify(&message, &sig_sha2_128s, b"context"))
    });
    c.bench_function("sha2_192s  verify", |b| {
        b.iter(|| pk_sha2_192s.verify(&message, &sig_sha2_192s, b"context"))
    });
    c.bench_function("sha2_256s  verify", |b| {
        b.iter(|| pk_sha2_256s.verify(&message, &sig_sha2_256s, b"context"))
    });
    c.bench_function("shake_128s verify", |b| {
        b.iter(|| pk_shake_128s.verify(&message, &sig_shake_128s, b"context"))
    });
    c.bench_function("shake_192s verify", |b| {
        b.iter(|| pk_shake_192s.verify(&message, &sig_shake_192s, b"context"))
    });
    c.bench_function("shake_256s verify", |b| {
        b.iter(|| pk_shake_256s.verify(&message, &sig_shake_256s, b"context"))
    });
}

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