benchmarks

CHANGELOG.md

@@ -5,6 +5,12 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## 0.1.2 (2024-03-TK)
+
+- Internal improvements, removed dependency on generic-array
+- Supporting examples for benchmarking, CT measurements, WASM development
+- Additional testcases
+
 ## 0.1.1 (2024-02-14)
 
 - Initial release

Cargo.toml

@@ -13,15 +13,16 @@ rust-version = "1.70"
 
 
 [dependencies]
-zeroize = { version = "1.6.0", default-features = false, features = ["zeroize_derive"] }  # For MSRV 1.70
+zeroize = { version = "1.6.0", default-features = false, features = ["zeroize_derive"] }  # For MSRV 1.70 (dated)
 rand_core = { version = "0.6.4", default-features = false }
-sha3 = { version = "0.10.2", default-features = false }  # For MSRV 1.70
+sha3 = { version = "0.10.2", default-features = false }  # For MSRV 1.70 (dated)
 sha2 = { version = "0.10.8", default-features = false }
 
 
 [dev-dependencies]
 rand_chacha = "0.3.1"
 hex = "0.4.3"
+criterion = "0.4.0"  # For MSRV 1.70 (dated)
 
 
 [features]
@@ -43,13 +44,9 @@ slh_dsa_sha2_256f = []
 slh_dsa_shake_256f = []
 
 
-[profile.dev]
+[[bench]]
-opt-level = 3
+name = "benchmark"
-
+harness = false
-
-#[[bench]]
-#name = "benchmark"
-#harness = false
 
 
 [profile.bench]
@@ -59,3 +56,4 @@ incremental = false
 lto = true
 opt-level = 3
 overflow-checks = false
+codegen-units = 1

benches/README.md

@@ -0,0 +1,48 @@
+
+Figure-of-merit ... no particular care taken to disable turbo boost etc
+
+~~~
+// $ RUSTFLAGS="-C target-cpu=native" cargo bench
+// Intel® Core™ i7-7700K CPU @ 4.20GHz × 8
+
+// Mar 10 2024
+
+sha2_128f  keygen       time:   [1.8046 ms 1.8049 ms 1.8053 ms]
+sha2_192f  keygen       time:   [2.6420 ms 2.6425 ms 2.6432 ms]
+sha2_256f  keygen       time:   [6.9202 ms 6.9300 ms 6.9481 ms]
+shake_128f keygen       time:   [2.9981 ms 3.0007 ms 3.0050 ms]
+shake_192f keygen       time:   [4.2558 ms 4.2562 ms 4.2568 ms]
+shake_256f keygen       time:   [11.221 ms 11.236 ms 11.266 ms]
+sha2_128s  keygen       time:   [115.98 ms 116.09 ms 116.20 ms]
+sha2_192s  keygen       time:   [169.23 ms 169.36 ms 169.49 ms]
+sha2_256s  keygen       time:   [110.80 ms 110.83 ms 110.86 ms]
+shake_128s keygen       time:   [186.05 ms 186.39 ms 186.98 ms]
+shake_192s keygen       time:   [272.52 ms 272.68 ms 272.86 ms]
+shake_256s keygen       time:   [178.79 ms 178.95 ms 179.17 ms]
+
+sha2_128f  sign         time:   [42.183 ms 42.204 ms 42.239 ms]
+sha2_192f  sign         time:   [69.770 ms 69.801 ms 69.859 ms]
+sha2_256f  sign         time:   [142.39 ms 142.45 ms 142.54 ms]
+shake_128f sign         time:   [67.953 ms 67.966 ms 67.986 ms]
+shake_192f sign         time:   [109.94 ms 109.95 ms 109.96 ms]
+shake_256f sign         time:   [224.70 ms 224.71 ms 224.73 ms]
+sha2_128s  sign         time:   [878.51 ms 878.70 ms 878.91 ms]
+sha2_192s  sign         time:   [1.5740 s 1.5750 s 1.5761 s]
+sha2_256s  sign         time:   [1.3848 s 1.3855 s 1.3865 s]
+shake_128s sign         time:   [1.4197 s 1.4206 s 1.4216 s]
+shake_192s sign         time:   [2.4545 s 2.4554 s 2.4565 s]
+shake_256s sign         time:   [2.1544 s 2.1550 s 2.1557 s]
+
+sha2_128f  verify       time:   [2.5928 ms 2.5939 ms 2.5958 ms]
+sha2_192f  verify       time:   [3.7586 ms 3.7621 ms 3.7659 ms]
+sha2_256f  verify       time:   [3.8196 ms 3.8216 ms 3.8242 ms]
+shake_128f verify       time:   [4.0462 ms 4.0494 ms 4.0542 ms]
+shake_192f verify       time:   [5.9527 ms 5.9531 ms 5.9536 ms]
+shake_256f verify       time:   [5.9491 ms 5.9501 ms 5.9513 ms]
+sha2_128s  verify       time:   [871.01 µs 871.07 µs 871.15 µs]
+sha2_192s  verify       time:   [1.2818 ms 1.2832 ms 1.2846 ms]
+sha2_256s  verify       time:   [1.8911 ms 1.8925 ms 1.8942 ms]
+shake_128s verify       time:   [1.4506 ms 1.4513 ms 1.4522 ms]
+shake_192s verify       time:   [2.1333 ms 2.1342 ms 2.1355 ms]
+shake_256s verify       time:   [2.8122 ms 2.8139 ms 2.8161 ms]
+~~~

benches/benchmark.rs

@@ -0,0 +1,80 @@
+use criterion::{criterion_group, criterion_main, Criterion};
+use fips205::traits::{KeyGen, Signer, Verifier};
+use fips205::{slh_dsa_sha2_128s, slh_dsa_shake_128s, slh_dsa_sha2_128f, slh_dsa_shake_128f,
+              slh_dsa_sha2_192s, slh_dsa_shake_192s, slh_dsa_sha2_192f, slh_dsa_shake_192f,
+              slh_dsa_sha2_256s, slh_dsa_shake_256s, slh_dsa_sha2_256f, slh_dsa_shake_256f};
+
+
+#[allow(clippy::redundant_closure)]
+pub fn criterion_benchmark(c: &mut Criterion) {
+    let message = [0u8, 1, 2, 3, 4, 5, 6, 7];
+    let randomize = false;
+
+    let (pk_sha2_128s, sk_sha2_128s) = slh_dsa_sha2_128s::KG::try_keygen_vt().unwrap();
+    let (pk_sha2_128f, sk_sha2_128f) = slh_dsa_sha2_128f::KG::try_keygen_vt().unwrap();
+    let (pk_sha2_192s, sk_sha2_192s) = slh_dsa_sha2_192s::KG::try_keygen_vt().unwrap();
+    let (pk_sha2_192f, sk_sha2_192f) = slh_dsa_sha2_192f::KG::try_keygen_vt().unwrap();
+    let (pk_sha2_256s, sk_sha2_256s) = slh_dsa_sha2_256s::KG::try_keygen_vt().unwrap();
+    let (pk_sha2_256f, sk_sha2_256f) = slh_dsa_sha2_256f::KG::try_keygen_vt().unwrap();
+    let (pk_shake_128s, sk_shake_128s) = slh_dsa_shake_128s::KG::try_keygen_vt().unwrap();
+    let (pk_shake_128f, sk_shake_128f) = slh_dsa_shake_128f::KG::try_keygen_vt().unwrap();
+    let (pk_shake_192s, sk_shake_192s) = slh_dsa_shake_192s::KG::try_keygen_vt().unwrap();
+    let (pk_shake_192f, sk_shake_192f) = slh_dsa_shake_192f::KG::try_keygen_vt().unwrap();
+    let (pk_shake_256s, sk_shake_256s) = slh_dsa_shake_256s::KG::try_keygen_vt().unwrap();
+    let (pk_shake_256f, sk_shake_256f) = slh_dsa_shake_256f::KG::try_keygen_vt().unwrap();
+
+    let sig_sha2_128s = sk_sha2_128s.try_sign_ct(&message, randomize).unwrap();
+    let sig_sha2_128f = sk_sha2_128f.try_sign_ct(&message, randomize).unwrap();
+    let sig_sha2_192s = sk_sha2_192s.try_sign_ct(&message, randomize).unwrap();
+    let sig_sha2_192f = sk_sha2_192f.try_sign_ct(&message, randomize).unwrap();
+    let sig_sha2_256s = sk_sha2_256s.try_sign_ct(&message, randomize).unwrap();
+    let sig_sha2_256f = sk_sha2_256f.try_sign_ct(&message, randomize).unwrap();
+    let sig_shake_128s = sk_shake_128s.try_sign_ct(&message, randomize).unwrap();
+    let sig_shake_128f = sk_shake_128f.try_sign_ct(&message, randomize).unwrap();
+    let sig_shake_192s = sk_shake_192s.try_sign_ct(&message, randomize).unwrap();
+    let sig_shake_192f = sk_shake_192f.try_sign_ct(&message, randomize).unwrap();
+    let sig_shake_256s = sk_shake_256s.try_sign_ct(&message, randomize).unwrap();
+    let sig_shake_256f = sk_shake_256f.try_sign_ct(&message, randomize).unwrap();
+
+    c.bench_function("sha2_128f  keygen", |b| b.iter(|| slh_dsa_sha2_128f::KG::try_keygen_vt()));
+    c.bench_function("sha2_192f  keygen", |b| b.iter(|| slh_dsa_sha2_192f::KG::try_keygen_vt()));
+    c.bench_function("sha2_256f  keygen", |b| b.iter(|| slh_dsa_sha2_256f::KG::try_keygen_vt()));
+    c.bench_function("shake_128f keygen", |b| b.iter(|| slh_dsa_shake_128f::KG::try_keygen_vt()));
+    c.bench_function("shake_192f keygen", |b| b.iter(|| slh_dsa_shake_192f::KG::try_keygen_vt()));
+    c.bench_function("shake_256f keygen", |b| b.iter(|| slh_dsa_shake_256f::KG::try_keygen_vt()));
+    c.bench_function("sha2_128s  keygen", |b| b.iter(|| slh_dsa_sha2_128s::KG::try_keygen_vt()));
+    c.bench_function("sha2_192s  keygen", |b| b.iter(|| slh_dsa_sha2_192s::KG::try_keygen_vt()));
+    c.bench_function("sha2_256s  keygen", |b| b.iter(|| slh_dsa_sha2_256s::KG::try_keygen_vt()));
+    c.bench_function("shake_128s keygen", |b| b.iter(|| slh_dsa_shake_128s::KG::try_keygen_vt()));
+    c.bench_function("shake_192s keygen", |b| b.iter(|| slh_dsa_shake_192s::KG::try_keygen_vt()));
+    c.bench_function("shake_256s keygen", |b| b.iter(|| slh_dsa_shake_256s::KG::try_keygen_vt()));
+    //
+    c.bench_function("sha2_128f  sign  ", |b| b.iter(|| sk_sha2_128f.try_sign_ct(&message, randomize)));
+    c.bench_function("sha2_192f  sign  ", |b| b.iter(|| sk_sha2_192f.try_sign_ct(&message, randomize)));
+    c.bench_function("sha2_256f  sign  ", |b| b.iter(|| sk_sha2_256f.try_sign_ct(&message, randomize)));
+    c.bench_function("shake_128f sign  ", |b| b.iter(|| sk_shake_128f.try_sign_ct(&message, randomize)));
+    c.bench_function("shake_192f sign  ", |b| b.iter(|| sk_shake_192f.try_sign_ct(&message, randomize)));
+    c.bench_function("shake_256f sign  ", |b| b.iter(|| sk_shake_256f.try_sign_ct(&message, randomize)));
+    c.bench_function("sha2_128s  sign  ", |b| b.iter(|| sk_sha2_128s.try_sign_ct(&message, randomize)));
+    c.bench_function("sha2_192s  sign  ", |b| b.iter(|| sk_sha2_192s.try_sign_ct(&message, randomize)));
+    c.bench_function("sha2_256s  sign  ", |b| b.iter(|| sk_sha2_256s.try_sign_ct(&message, randomize)));
+    c.bench_function("shake_128s sign  ", |b| b.iter(|| sk_shake_128s.try_sign_ct(&message, randomize)));
+    c.bench_function("shake_192s sign  ", |b| b.iter(|| sk_shake_192s.try_sign_ct(&message, randomize)));
+    c.bench_function("shake_256s sign  ", |b| b.iter(|| sk_shake_256s.try_sign_ct(&message, randomize)));
+    //
+    c.bench_function("sha2_128f  verify", |b| b.iter(|| pk_sha2_128f.try_verify_vt(&message, &sig_sha2_128f)));
+    c.bench_function("sha2_192f  verify", |b| b.iter(|| pk_sha2_192f.try_verify_vt(&message, &sig_sha2_192f)));
+    c.bench_function("sha2_256f  verify", |b| b.iter(|| pk_sha2_256f.try_verify_vt(&message, &sig_sha2_256f)));
+    c.bench_function("shake_128f verify", |b| b.iter(|| pk_shake_128f.try_verify_vt(&message, &sig_shake_128f)));
+    c.bench_function("shake_192f verify", |b| b.iter(|| pk_shake_192f.try_verify_vt(&message, &sig_shake_192f)));
+    c.bench_function("shake_256f verify", |b| b.iter(|| pk_shake_256f.try_verify_vt(&message, &sig_shake_256f)));
+    c.bench_function("sha2_128s  verify", |b| b.iter(|| pk_sha2_128s.try_verify_vt(&message, &sig_sha2_128s)));
+    c.bench_function("sha2_192s  verify", |b| b.iter(|| pk_sha2_192s.try_verify_vt(&message, &sig_sha2_192s)));
+    c.bench_function("sha2_256s  verify", |b| b.iter(|| pk_sha2_256s.try_verify_vt(&message, &sig_sha2_256s)));
+    c.bench_function("shake_128s verify", |b| b.iter(|| pk_shake_128s.try_verify_vt(&message, &sig_shake_128s)));
+    c.bench_function("shake_192s verify", |b| b.iter(|| pk_shake_192s.try_verify_vt(&message, &sig_shake_192s)));
+    c.bench_function("shake_256s verify", |b| b.iter(|| pk_shake_256s.try_verify_vt(&message, &sig_shake_256s)));
+}
+
+criterion_group!(benches, criterion_benchmark);
+criterion_main!(benches);