[cryptography/secp256r1] Add batch verification

cryptography/src/secp256r1/benches/batch_verify_multiple_messages.rs

@@ -0,0 +1,40 @@
+use commonware_cryptography::{secp256r1, BatchVerifier, Signer as _};
+use commonware_math::algebra::Random;
+use criterion::{criterion_group, BatchSize, Criterion};
+use rand::{thread_rng, Rng};
+use std::hint::black_box;
+
+fn benchmark_batch_verify_multiple_messages(c: &mut Criterion) {
+    let namespace = b"namespace";
+    for n_messages in [1, 10, 100, 1000].into_iter() {
+        let mut msgs = Vec::with_capacity(n_messages);
+        for _ in 0..n_messages {
+            let mut msg = [0u8; 32];
+            thread_rng().fill(&mut msg);
+            msgs.push(msg);
+        }
+        c.bench_function(&format!("{}/msgs={}", module_path!(), n_messages), |b| {
+            b.iter_batched(
+                || {
+                    let mut batch = secp256r1::recoverable::Batch::new();
+                    let signer = secp256r1::recoverable::PrivateKey::random(&mut thread_rng());
+                    for msg in msgs.iter() {
+                        let sig = signer.sign(namespace, msg);
+                        assert!(batch.add(namespace, msg, &signer.public_key(), &sig));
+                    }
+                    batch
+                },
+                |batch| {
+                    black_box(batch.verify(&mut thread_rng()));
+                },
+                BatchSize::SmallInput,
+            );
+        });
+    }
+}
+
+criterion_group! {
+    name = benches;
+    config = Criterion::default().sample_size(10);
+    targets = benchmark_batch_verify_multiple_messages
+}

cryptography/src/secp256r1/benches/batch_verify_multiple_public_keys.rs

@@ -0,0 +1,36 @@
+use commonware_cryptography::{secp256r1, BatchVerifier, Signer as _};
+use commonware_math::algebra::Random;
+use criterion::{criterion_group, BatchSize, Criterion};
+use rand::{thread_rng, Rng};
+use std::hint::black_box;
+
+fn benchmark_batch_verify_multiple_public_keys(c: &mut Criterion) {
+    let namespace = b"namespace";
+    let mut msg = [0u8; 32];
+    thread_rng().fill(&mut msg);
+    for n_signers in [1, 10, 100, 1000].into_iter() {
+        c.bench_function(&format!("{}/pks={}", module_path!(), n_signers), |b| {
+            b.iter_batched(
+                || {
+                    let mut batch = secp256r1::recoverable::Batch::new();
+                    for _ in 0..n_signers {
+                        let signer = secp256r1::recoverable::PrivateKey::random(&mut thread_rng());
+                        let sig = signer.sign(namespace, &msg);
+                        assert!(batch.add(namespace, &msg, &signer.public_key(), &sig));
+                    }
+                    batch
+                },
+                |batch| {
+                    black_box(batch.verify(&mut thread_rng()));
+                },
+                BatchSize::SmallInput,
+            );
+        });
+    }
+}
+
+criterion_group! {
+    name = benches;
+    config = Criterion::default().sample_size(10);
+    targets = benchmark_batch_verify_multiple_public_keys
+}

cryptography/src/secp256r1/benches/bench.rs

@@ -1,9 +1,13 @@
 use criterion::criterion_main;
 
+mod batch_verify_multiple_messages;
+mod batch_verify_multiple_public_keys;
 mod signature_generation;
 mod signature_verification;
 
 criterion_main!(
     signature_generation::benches,
-    signature_verification::benches
+    signature_verification::benches,
+    batch_verify_multiple_public_keys::benches,
+    batch_verify_multiple_messages::benches,
 );