From f5668d725e2bb39d7ce26a61d46dc8a85263c07e Mon Sep 17 00:00:00 2001 From: Nirvan Tyagi Date: Mon, 12 Aug 2024 16:09:38 -0700 Subject: [PATCH 1/6] Benchmarks for VOPRF and V-POPRF --- Cargo.toml | 9 +++++++ benches/poprf.rs | 68 ++++++++++++++++++++++++++++++++++++++++++++++++ benches/voprf.rs | 61 +++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 138 insertions(+) create mode 100644 benches/poprf.rs create mode 100644 benches/voprf.rs diff --git a/Cargo.toml b/Cargo.toml index c96c30e..506eefd 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -43,6 +43,7 @@ subtle = { version = "2.3", default-features = false } zeroize = { version = "1.5", default-features = false } [dev-dependencies] +criterion = "0.3" generic-array = { version = "0.14", features = ["more_lengths"] } hex = "0.4" p256 = { version = "0.13", default-features = false, features = [ @@ -63,6 +64,14 @@ regex = "1" serde_json = "1" sha2 = "0.10" +[[bench]] +name = "voprf" +harness = false + +[[bench]] +name = "poprf" +harness = false + [package.metadata.docs.rs] all-features = true rustdoc-args = ["--cfg", "docsrs"] diff --git a/benches/poprf.rs b/benches/poprf.rs new file mode 100644 index 0000000..0d800ec --- /dev/null +++ b/benches/poprf.rs @@ -0,0 +1,68 @@ +use criterion::{criterion_group, criterion_main, BatchSize, Criterion}; + +use rand::{rngs::StdRng, SeedableRng}; +use voprf::{PoprfClient, PoprfServer, Ristretto255}; + +fn bench_client_blind(c: &mut Criterion) { + let rng = StdRng::seed_from_u64(0_u64); + c.bench_function("client_blind", move |b| { + b.iter_batched_ref( + || rng.clone(), + |mut rng| { + PoprfClient::::blind(b"input", &mut rng) + .expect("Unable to construct client") + }, + BatchSize::SmallInput, + ) + }); +} + +fn bench_server_evaluate(c: &mut Criterion) { + let mut rng = StdRng::seed_from_u64(0_u64); + let server = PoprfServer::::new(&mut rng).unwrap(); + let client_blind_result = + PoprfClient::::blind(b"input", &mut rng).expect("Unable to construct client"); + c.bench_function("server_eval", move |b| { + b.iter_batched_ref( + || rng.clone(), + |mut rng| { + server + .blind_evaluate(&mut rng, &client_blind_result.message, Some(b"tag")) + .expect("Unable to perform server evaluation") + }, + BatchSize::SmallInput, + ) + }); +} + +fn bench_client_finalize(c: &mut Criterion) { + let mut rng = StdRng::seed_from_u64(0_u64); + let server = PoprfServer::::new(&mut rng).unwrap(); + let client_blind_result = + PoprfClient::::blind(b"input", &mut rng).expect("Unable to construct client"); + let server_evaluate_result = server + .blind_evaluate(&mut rng, &client_blind_result.message, Some(b"tag")) + .expect("Unable to perform server evaluation"); + c.bench_function("client_final", move |b| { + b.iter(|| { + client_blind_result + .state + .finalize( + b"input", + &server_evaluate_result.message, + &server_evaluate_result.proof, + server.get_public_key(), + Some(b"tag"), + ) + .expect("Unable to perform client finalization") + }) + }); +} + +criterion_group!( + poprf, + bench_client_blind, + bench_server_evaluate, + bench_client_finalize +); +criterion_main!(poprf); diff --git a/benches/voprf.rs b/benches/voprf.rs new file mode 100644 index 0000000..bba66e1 --- /dev/null +++ b/benches/voprf.rs @@ -0,0 +1,61 @@ +use criterion::{criterion_group, criterion_main, BatchSize, Criterion}; + +use rand::{rngs::StdRng, SeedableRng}; +use voprf::{Ristretto255, VoprfClient, VoprfServer}; + +fn bench_client_blind(c: &mut Criterion) { + let rng = StdRng::seed_from_u64(0_u64); + c.bench_function("client_blind", move |b| { + b.iter_batched_ref( + || rng.clone(), + |mut rng| { + VoprfClient::::blind(b"input", &mut rng) + .expect("Unable to construct client") + }, + BatchSize::SmallInput, + ) + }); +} + +fn bench_server_evaluate(c: &mut Criterion) { + let mut rng = StdRng::seed_from_u64(0_u64); + let server = VoprfServer::::new(&mut rng).unwrap(); + let client_blind_result = + VoprfClient::::blind(b"input", &mut rng).expect("Unable to construct client"); + c.bench_function("server_eval", move |b| { + b.iter_batched_ref( + || rng.clone(), + |mut rng| server.blind_evaluate(&mut rng, &client_blind_result.message), + BatchSize::SmallInput, + ) + }); +} + +fn bench_client_finalize(c: &mut Criterion) { + let mut rng = StdRng::seed_from_u64(0_u64); + let server = VoprfServer::::new(&mut rng).unwrap(); + let client_blind_result = + VoprfClient::::blind(b"input", &mut rng).expect("Unable to construct client"); + let server_evaluate_result = server.blind_evaluate(&mut rng, &client_blind_result.message); + c.bench_function("client_final", move |b| { + b.iter(|| { + client_blind_result + .state + .finalize( + b"input", + &server_evaluate_result.message, + &server_evaluate_result.proof, + server.get_public_key(), + ) + .expect("Unable to perform client finalization") + }) + }); +} + +criterion_group!( + voprf, + bench_client_blind, + bench_server_evaluate, + bench_client_finalize +); +criterion_main!(voprf); From f927179cfd10bdaefd4f6c4a59712cdbbcefad23 Mon Sep 17 00:00:00 2001 From: Nirvan Tyagi Date: Wed, 14 Aug 2024 12:44:17 -0700 Subject: [PATCH 2/6] Support other cipher suites in microbenchmarks --- Cargo.toml | 5 ++ benches/poprf.rs | 139 +++++++++++++++++++++++++++++------------------ benches/voprf.rs | 130 ++++++++++++++++++++++++++++---------------- 3 files changed, 172 insertions(+), 102 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 506eefd..11eec3a 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -44,6 +44,7 @@ zeroize = { version = "1.5", default-features = false } [dev-dependencies] criterion = "0.3" +paste = "1.0" generic-array = { version = "0.14", features = ["more_lengths"] } hex = "0.4" p256 = { version = "0.13", default-features = false, features = [ @@ -64,6 +65,10 @@ regex = "1" serde_json = "1" sha2 = "0.10" +[[bench]] +name = "oprf" +harness = false + [[bench]] name = "voprf" harness = false diff --git a/benches/poprf.rs b/benches/poprf.rs index 0d800ec..cbf4e5f 100644 --- a/benches/poprf.rs +++ b/benches/poprf.rs @@ -1,68 +1,99 @@ use criterion::{criterion_group, criterion_main, BatchSize, Criterion}; +use paste::paste; use rand::{rngs::StdRng, SeedableRng}; use voprf::{PoprfClient, PoprfServer, Ristretto255}; +use p256::NistP256 as P256; +use p384::NistP384 as P384; +use p521::NistP521 as P521; -fn bench_client_blind(c: &mut Criterion) { - let rng = StdRng::seed_from_u64(0_u64); - c.bench_function("client_blind", move |b| { - b.iter_batched_ref( - || rng.clone(), - |mut rng| { - PoprfClient::::blind(b"input", &mut rng) - .expect("Unable to construct client") - }, - BatchSize::SmallInput, - ) - }); -} +macro_rules! make_poprf_benches { + ($cipher_suite:ident) => { + + paste! { + fn [](c: &mut Criterion) { + let rng = StdRng::seed_from_u64(0_u64); + c.bench_function(&format!("{}_{}", "poprf_client_blind", stringify!($cipher_suite).to_lowercase()), move |b| { + b.iter_batched_ref( + || rng.clone(), + |mut rng| { + PoprfClient::<$cipher_suite>::blind(b"input", &mut rng) + .expect("Unable to construct client") + }, + BatchSize::SmallInput, + ) + }); + } + } + + paste! { + fn [](c: &mut Criterion) { + let mut rng = StdRng::seed_from_u64(0_u64); + let server = PoprfServer::<$cipher_suite>::new(&mut rng).unwrap(); + let client_blind_result = + PoprfClient::<$cipher_suite>::blind(b"input", &mut rng).expect("Unable to construct client"); + c.bench_function(&format!("{}_{}", "poprf_server_eval", stringify!($cipher_suite).to_lowercase()), move |b| { + b.iter_batched_ref( + || rng.clone(), + |mut rng| { + server + .blind_evaluate(&mut rng, &client_blind_result.message, Some(b"tag")) + .expect("Unable to perform server evaluation") + }, + BatchSize::SmallInput, + ) + }); + } + } -fn bench_server_evaluate(c: &mut Criterion) { - let mut rng = StdRng::seed_from_u64(0_u64); - let server = PoprfServer::::new(&mut rng).unwrap(); - let client_blind_result = - PoprfClient::::blind(b"input", &mut rng).expect("Unable to construct client"); - c.bench_function("server_eval", move |b| { - b.iter_batched_ref( - || rng.clone(), - |mut rng| { - server + paste! { + fn [](c: &mut Criterion) { + let mut rng = StdRng::seed_from_u64(0_u64); + let server = PoprfServer::<$cipher_suite>::new(&mut rng).unwrap(); + let client_blind_result = + PoprfClient::<$cipher_suite>::blind(b"input", &mut rng).expect("Unable to construct client"); + let server_evaluate_result = server .blind_evaluate(&mut rng, &client_blind_result.message, Some(b"tag")) - .expect("Unable to perform server evaluation") - }, - BatchSize::SmallInput, - ) - }); -} + .expect("Unable to perform server evaluation"); + c.bench_function(&format!("{}_{}", "poprf_client_final", stringify!($cipher_suite).to_lowercase()), move |b| { + b.iter(|| { + client_blind_result + .state + .finalize( + b"input", + &server_evaluate_result.message, + &server_evaluate_result.proof, + server.get_public_key(), + Some(b"tag"), + ) + .expect("Unable to perform client finalization") + }) + }); + } + } -fn bench_client_finalize(c: &mut Criterion) { - let mut rng = StdRng::seed_from_u64(0_u64); - let server = PoprfServer::::new(&mut rng).unwrap(); - let client_blind_result = - PoprfClient::::blind(b"input", &mut rng).expect("Unable to construct client"); - let server_evaluate_result = server - .blind_evaluate(&mut rng, &client_blind_result.message, Some(b"tag")) - .expect("Unable to perform server evaluation"); - c.bench_function("client_final", move |b| { - b.iter(|| { - client_blind_result - .state - .finalize( - b"input", - &server_evaluate_result.message, - &server_evaluate_result.proof, - server.get_public_key(), - Some(b"tag"), - ) - .expect("Unable to perform client finalization") - }) - }); + }; } +make_poprf_benches!(Ristretto255); +make_poprf_benches!(P256); +make_poprf_benches!(P384); +make_poprf_benches!(P521); + + criterion_group!( poprf, - bench_client_blind, - bench_server_evaluate, - bench_client_finalize + bench_poprf_client_blind_ristretto255, + bench_poprf_server_evaluate_ristretto255, + bench_poprf_client_finalize_ristretto255, + bench_poprf_client_blind_p256, + bench_poprf_server_evaluate_p256, + bench_poprf_client_finalize_p256, + bench_poprf_client_blind_p384, + bench_poprf_server_evaluate_p384, + bench_poprf_client_finalize_p384, + bench_poprf_client_blind_p521, + bench_poprf_server_evaluate_p521, + bench_poprf_client_finalize_p521 ); criterion_main!(poprf); diff --git a/benches/voprf.rs b/benches/voprf.rs index bba66e1..460dbb8 100644 --- a/benches/voprf.rs +++ b/benches/voprf.rs @@ -1,61 +1,95 @@ use criterion::{criterion_group, criterion_main, BatchSize, Criterion}; +use paste::paste; use rand::{rngs::StdRng, SeedableRng}; use voprf::{Ristretto255, VoprfClient, VoprfServer}; +use p256::NistP256 as P256; +use p384::NistP384 as P384; +use p521::NistP521 as P521; -fn bench_client_blind(c: &mut Criterion) { - let rng = StdRng::seed_from_u64(0_u64); - c.bench_function("client_blind", move |b| { - b.iter_batched_ref( - || rng.clone(), - |mut rng| { - VoprfClient::::blind(b"input", &mut rng) - .expect("Unable to construct client") - }, - BatchSize::SmallInput, - ) - }); -} +macro_rules! make_voprf_benches { + ($cipher_suite:ident) => { -fn bench_server_evaluate(c: &mut Criterion) { - let mut rng = StdRng::seed_from_u64(0_u64); - let server = VoprfServer::::new(&mut rng).unwrap(); - let client_blind_result = - VoprfClient::::blind(b"input", &mut rng).expect("Unable to construct client"); - c.bench_function("server_eval", move |b| { - b.iter_batched_ref( - || rng.clone(), - |mut rng| server.blind_evaluate(&mut rng, &client_blind_result.message), - BatchSize::SmallInput, - ) - }); -} + paste! { + fn [](c: &mut Criterion) { + let rng = StdRng::seed_from_u64(0_u64); + c.bench_function(&format!("{}_{}", "voprf_client_blind", stringify!($cipher_suite).to_lowercase()), move |b| { + b.iter_batched_ref( + || rng.clone(), + |mut rng| { + VoprfClient::<$cipher_suite>::blind(b"input", &mut rng) + .expect("Unable to construct client") + }, + BatchSize::SmallInput, + ) + }); + } + } + + paste! { + fn [](c: &mut Criterion) { + let mut rng = StdRng::seed_from_u64(0_u64); + let server = VoprfServer::<$cipher_suite>::new(&mut rng).unwrap(); + let client_blind_result = + VoprfClient::<$cipher_suite>::blind(b"input", &mut rng).expect("Unable to construct client"); + c.bench_function(&format!("{}_{}", "voprf_server_eval", stringify!($cipher_suite).to_lowercase()), move |b| { + b.iter_batched_ref( + || rng.clone(), + |mut rng| { + server + .blind_evaluate(&mut rng, &client_blind_result.message); + }, + BatchSize::SmallInput, + ) + }); + } + } -fn bench_client_finalize(c: &mut Criterion) { - let mut rng = StdRng::seed_from_u64(0_u64); - let server = VoprfServer::::new(&mut rng).unwrap(); - let client_blind_result = - VoprfClient::::blind(b"input", &mut rng).expect("Unable to construct client"); - let server_evaluate_result = server.blind_evaluate(&mut rng, &client_blind_result.message); - c.bench_function("client_final", move |b| { - b.iter(|| { - client_blind_result - .state - .finalize( - b"input", - &server_evaluate_result.message, - &server_evaluate_result.proof, - server.get_public_key(), - ) - .expect("Unable to perform client finalization") - }) - }); + paste! { + fn [](c: &mut Criterion) { + let mut rng = StdRng::seed_from_u64(0_u64); + let server = VoprfServer::<$cipher_suite>::new(&mut rng).unwrap(); + let client_blind_result = + VoprfClient::<$cipher_suite>::blind(b"input", &mut rng).expect("Unable to construct client"); + let server_evaluate_result = server + .blind_evaluate(&mut rng, &client_blind_result.message); + c.bench_function(&format!("{}_{}", "voprf_client_final", stringify!($cipher_suite).to_lowercase()), move |b| { + b.iter(|| { + client_blind_result + .state + .finalize( + b"input", + &server_evaluate_result.message, + &server_evaluate_result.proof, + server.get_public_key(), + ) + .expect("Unable to perform client finalization") + }) + }); + } + } + + }; } +make_voprf_benches!(Ristretto255); +make_voprf_benches!(P256); +make_voprf_benches!(P384); +make_voprf_benches!(P521); + criterion_group!( voprf, - bench_client_blind, - bench_server_evaluate, - bench_client_finalize + bench_voprf_client_blind_ristretto255, + bench_voprf_server_evaluate_ristretto255, + bench_voprf_client_finalize_ristretto255, + bench_voprf_client_blind_p256, + bench_voprf_server_evaluate_p256, + bench_voprf_client_finalize_p256, + bench_voprf_client_blind_p384, + bench_voprf_server_evaluate_p384, + bench_voprf_client_finalize_p384, + bench_voprf_client_blind_p521, + bench_voprf_server_evaluate_p521, + bench_voprf_client_finalize_p521 ); criterion_main!(voprf); From 43634f7e6e1af0eb3517f4e027c6e871909b83f3 Mon Sep 17 00:00:00 2001 From: Nirvan Tyagi Date: Wed, 14 Aug 2024 12:44:34 -0700 Subject: [PATCH 3/6] Add OPRF microbenchmarks --- benches/oprf.rs | 91 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 91 insertions(+) create mode 100644 benches/oprf.rs diff --git a/benches/oprf.rs b/benches/oprf.rs new file mode 100644 index 0000000..905fbb9 --- /dev/null +++ b/benches/oprf.rs @@ -0,0 +1,91 @@ +use criterion::{criterion_group, criterion_main, BatchSize, Criterion}; +use paste::paste; + +use rand::{rngs::StdRng, SeedableRng}; +use voprf::{Ristretto255, OprfClient, OprfServer}; +use p256::NistP256 as P256; +use p384::NistP384 as P384; +use p521::NistP521 as P521; + +macro_rules! make_oprf_benches { + ($cipher_suite:ident) => { + + paste! { + fn [](c: &mut Criterion) { + let rng = StdRng::seed_from_u64(0_u64); + c.bench_function(&format!("{}_{}", "oprf_client_blind", stringify!($cipher_suite).to_lowercase()), move |b| { + b.iter_batched_ref( + || rng.clone(), + |mut rng| { + OprfClient::<$cipher_suite>::blind(b"input", &mut rng) + .expect("Unable to construct client") + }, + BatchSize::SmallInput, + ) + }); + } + } + + paste! { + fn [](c: &mut Criterion) { + let mut rng = StdRng::seed_from_u64(0_u64); + let server = OprfServer::<$cipher_suite>::new(&mut rng).unwrap(); + let client_blind_result = + OprfClient::<$cipher_suite>::blind(b"input", &mut rng).expect("Unable to construct client"); + c.bench_function(&format!("{}_{}", "oprf_server_eval", stringify!($cipher_suite).to_lowercase()), move |b| { + b.iter( + || { + server + .blind_evaluate(&client_blind_result.message); + } + ) + }); + } + } + + paste! { + fn [](c: &mut Criterion) { + let mut rng = StdRng::seed_from_u64(0_u64); + let server = OprfServer::<$cipher_suite>::new(&mut rng).unwrap(); + let client_blind_result = + OprfClient::<$cipher_suite>::blind(b"input", &mut rng).expect("Unable to construct client"); + let server_evaluate_result = server + .blind_evaluate(&client_blind_result.message); + c.bench_function(&format!("{}_{}", "oprf_client_final", stringify!($cipher_suite).to_lowercase()), move |b| { + b.iter(|| { + client_blind_result + .state + .finalize( + b"input", + &server_evaluate_result, + ) + .expect("Unable to perform client finalization") + }) + }); + } + } + + }; +} + +make_oprf_benches!(Ristretto255); +make_oprf_benches!(P256); +make_oprf_benches!(P384); +make_oprf_benches!(P521); + +criterion_group!( + oprf, + bench_oprf_client_blind_ristretto255, + bench_oprf_server_evaluate_ristretto255, + bench_oprf_client_finalize_ristretto255, + bench_oprf_client_blind_p256, + bench_oprf_server_evaluate_p256, + bench_oprf_client_finalize_p256, + bench_oprf_client_blind_p384, + bench_oprf_server_evaluate_p384, + bench_oprf_client_finalize_p384, + bench_oprf_client_blind_p521, + bench_oprf_server_evaluate_p521, + bench_oprf_client_finalize_p521 +); +criterion_main!(oprf); From a8a7f91deb18a5b60aebcc6974bd6513bd38558b Mon Sep 17 00:00:00 2001 From: Nirvan Tyagi Date: Wed, 14 Aug 2024 12:44:51 -0700 Subject: [PATCH 4/6] Update README with microbenchmarks instructions --- README.md | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/README.md b/README.md index a001518..580940d 100644 --- a/README.md +++ b/README.md @@ -23,6 +23,15 @@ voprf = "0.5" Rust **1.65** or higher. +Microbenchmarks +--------------- + +The library also comes with a suite of microbenchmarks for each mode `oprf`, `voprf`, `poprf` that can be run via: +``` +cargo bench --bench +``` + + Contributors ------------ From 7c05c316a8c8645584f36145c7a457bcbe711d91 Mon Sep 17 00:00:00 2001 From: Nirvan Tyagi Date: Wed, 14 Aug 2024 12:56:03 -0700 Subject: [PATCH 5/6] Add benchmarks CI rule --- .github/workflows/main.yml | 32 ++++++++++++++++++++++++++++++++ 1 file changed, 32 insertions(+) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index f2fb11a..254c171 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -103,7 +103,39 @@ jobs: - uses: hecrj/setup-rust-action@v2 - run: rustup target add ${{ matrix.target }} - run: cargo build --verbose --target=${{ matrix.target }} --no-default-features ${{ matrix.frontend_feature }} ${{ matrix.backend_feature }} + + benches: + name: cargo bench compilation + runs-on: ubuntu-latest + strategy: + fail-fast: false + matrix: + backend_feature: + - --features ristretto255-ciphersuite + - + frontend_feature: + - + - --features danger + - --features serde + toolchain: + - stable + - 1.65.0 + steps: + - name: Checkout sources + uses: actions/checkout@v4 + - name: Install ${{ matrix.toolchain }} toolchain + uses: actions-rs/toolchain@v1 + with: + profile: minimal + toolchain: ${{ matrix.toolchain }} + override: true + + - name: Run cargo bench --no-run + uses: actions-rs/cargo@v1 + with: + command: bench + args: --no-default-features ${{ matrix.backend_feature }} --no-run clippy: name: cargo clippy From 5077b0ca131646ffe1c3e35ccfc21b2b6b800239 Mon Sep 17 00:00:00 2001 From: Nirvan Tyagi Date: Wed, 14 Aug 2024 14:12:07 -0700 Subject: [PATCH 6/6] Cargo fmt --- benches/oprf.rs | 4 ++-- benches/poprf.rs | 5 ++--- benches/voprf.rs | 4 ++-- 3 files changed, 6 insertions(+), 7 deletions(-) diff --git a/benches/oprf.rs b/benches/oprf.rs index 905fbb9..149f199 100644 --- a/benches/oprf.rs +++ b/benches/oprf.rs @@ -1,11 +1,11 @@ use criterion::{criterion_group, criterion_main, BatchSize, Criterion}; use paste::paste; -use rand::{rngs::StdRng, SeedableRng}; -use voprf::{Ristretto255, OprfClient, OprfServer}; use p256::NistP256 as P256; use p384::NistP384 as P384; use p521::NistP521 as P521; +use rand::{rngs::StdRng, SeedableRng}; +use voprf::{OprfClient, OprfServer, Ristretto255}; macro_rules! make_oprf_benches { ($cipher_suite:ident) => { diff --git a/benches/poprf.rs b/benches/poprf.rs index cbf4e5f..7abb188 100644 --- a/benches/poprf.rs +++ b/benches/poprf.rs @@ -1,11 +1,11 @@ use criterion::{criterion_group, criterion_main, BatchSize, Criterion}; use paste::paste; -use rand::{rngs::StdRng, SeedableRng}; -use voprf::{PoprfClient, PoprfServer, Ristretto255}; use p256::NistP256 as P256; use p384::NistP384 as P384; use p521::NistP521 as P521; +use rand::{rngs::StdRng, SeedableRng}; +use voprf::{PoprfClient, PoprfServer, Ristretto255}; macro_rules! make_poprf_benches { ($cipher_suite:ident) => { @@ -80,7 +80,6 @@ make_poprf_benches!(P256); make_poprf_benches!(P384); make_poprf_benches!(P521); - criterion_group!( poprf, bench_poprf_client_blind_ristretto255, diff --git a/benches/voprf.rs b/benches/voprf.rs index 460dbb8..f89bec7 100644 --- a/benches/voprf.rs +++ b/benches/voprf.rs @@ -1,11 +1,11 @@ use criterion::{criterion_group, criterion_main, BatchSize, Criterion}; use paste::paste; -use rand::{rngs::StdRng, SeedableRng}; -use voprf::{Ristretto255, VoprfClient, VoprfServer}; use p256::NistP256 as P256; use p384::NistP384 as P384; use p521::NistP521 as P521; +use rand::{rngs::StdRng, SeedableRng}; +use voprf::{Ristretto255, VoprfClient, VoprfServer}; macro_rules! make_voprf_benches { ($cipher_suite:ident) => {