From 98fc10359fc71eb4caf83230107778624393828e Mon Sep 17 00:00:00 2001 From: eschorn1 Date: Sun, 10 Mar 2024 18:07:57 -0500 Subject: [PATCH] benchmarks --- CHANGELOG.md | 6 ++++ Cargo.toml | 18 +++++----- benches/README.md | 48 ++++++++++++++++++++++++++ benches/benchmark.rs | 80 ++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 142 insertions(+), 10 deletions(-) create mode 100644 benches/README.md create mode 100644 benches/benchmark.rs diff --git a/CHANGELOG.md b/CHANGELOG.md index dd48b90..e1379cb 100644 --- a/CHANGELOG.md +++ b/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 diff --git a/Cargo.toml b/Cargo.toml index 45890ac..b54cb30 100644 --- a/Cargo.toml +++ b/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] -opt-level = 3 - - -#[[bench]] -#name = "benchmark" -#harness = false +[[bench]] +name = "benchmark" +harness = false [profile.bench] @@ -58,4 +55,5 @@ debug-assertions = false incremental = false lto = true opt-level = 3 -overflow-checks = false \ No newline at end of file +overflow-checks = false +codegen-units = 1 diff --git a/benches/README.md b/benches/README.md new file mode 100644 index 0000000..547f772 --- /dev/null +++ b/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] +~~~ \ No newline at end of file diff --git a/benches/benchmark.rs b/benches/benchmark.rs new file mode 100644 index 0000000..35e909f --- /dev/null +++ b/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);