Simon/test utils folder

benches/naive_ot_based_ecdsa.rs

@@ -1,10 +1,7 @@
-mod utils;
-
 use criterion::{criterion_group, Criterion};
 use frost_secp256k1::{Secp256K1Sha256, VerifyingKey};
 use rand::Rng;
 use rand_core::OsRng;
-use utils::ecdsa_generate_rerandpresig_args;
 
 use threshold_signatures::{
     ecdsa::{
@@ -18,10 +15,21 @@ use threshold_signatures::{
     },
     participants::Participant,
     protocol::Protocol,
-    test_utils::{generate_participants_with_random_ids, run_keygen, run_protocol},
+    test_utils::{
+        ecdsa_generate_rerandpresig_args, generate_participants_with_random_ids, run_keygen,
+        run_protocol,
+    },
 };
 
-use utils::MAX_MALICIOUS;
+use std::{env, sync::LazyLock};
+
+// fix malicious number of participants
+pub static MAX_MALICIOUS: LazyLock<usize> = std::sync::LazyLock::new(|| {
+    env::var("MAX_MALICIOUS")
+        .ok()
+        .and_then(|v| v.parse().ok())
+        .unwrap_or(6)
+});
 
 fn threshold() -> usize {
     *crate::MAX_MALICIOUS + 1

benches/naive_robust_ecdsa.rs

@@ -1,9 +1,7 @@
-mod utils;
 use criterion::{criterion_group, Criterion};
 use frost_secp256k1::{Secp256K1Sha256, VerifyingKey};
 use rand::Rng;
 use rand_core::OsRng;
-use utils::ecdsa_generate_rerandpresig_args;
 
 use threshold_signatures::{
     ecdsa::{
@@ -15,10 +13,21 @@ use threshold_signatures::{
     },
     participants::Participant,
     protocol::Protocol,
-    test_utils::{generate_participants_with_random_ids, run_keygen, run_protocol},
+    test_utils::{
+        ecdsa_generate_rerandpresig_args, generate_participants_with_random_ids, run_keygen,
+        run_protocol,
+    },
 };
 
-use utils::MAX_MALICIOUS;
+use std::{env, sync::LazyLock};
+
+// fix malicious number of participants
+pub static MAX_MALICIOUS: LazyLock<usize> = std::sync::LazyLock::new(|| {
+    env::var("MAX_MALICIOUS")
+        .ok()
+        .and_then(|v| v.parse().ok())
+        .unwrap_or(6)
+});
 
 fn participants_num() -> usize {
     2 * *crate::MAX_MALICIOUS + 1

src/confidential_key_derivation/ciphersuite.rs

@@ -299,20 +299,14 @@ impl FromOkm for ScalarWrapper {
 mod tests {
     use blstrs::Scalar;
     use digest::generic_array::GenericArray;
-    use elliptic_curve::hash2curve::FromOkm;
-    use elliptic_curve::Field;
-    use elliptic_curve::Group;
-    use rand::Rng;
-    use rand::RngCore;
+    use elliptic_curve::{hash2curve::FromOkm, Field, Group};
+    use rand::{Rng, RngCore};
     use rand_core::OsRng;
 
-    use crate::confidential_key_derivation::ciphersuite::verify_signature;
-    use crate::confidential_key_derivation::ciphersuite::ScalarWrapper;
-    use crate::confidential_key_derivation::VerifyingKey;
     use crate::{
         confidential_key_derivation::{
-            ciphersuite::{hash_to_curve, BLS12381SHA256},
-            ElementG2,
+            ciphersuite::{hash_to_curve, verify_signature, ScalarWrapper, BLS12381SHA256},
+            ElementG2, VerifyingKey,
         },
         test_utils::check_common_traits_for_type,
     };

src/confidential_key_derivation/protocol.rs

@@ -181,7 +181,7 @@ fn compute_signature_share(
 mod test {
     use super::*;
     use crate::confidential_key_derivation::ciphersuite::hash_to_curve;
-    use crate::test_utils::{one_coordinator_output, run_protocol, GenProtocol};
+    use crate::test_utils::{check_one_coordinator_output, run_protocol, GenProtocol};
     use rand::Rng;
 
     #[test]
@@ -240,7 +240,7 @@ mod test {
         let result = run_protocol(protocols).unwrap();
 
         // test one single some for the coordinator
-        let ckd = one_coordinator_output(result, coordinator).unwrap();
+        let ckd = check_one_coordinator_output(result, coordinator).unwrap();
 
         // compute msk . H(app_id)
         let confidential_key = ckd.unmask(app_sk);

src/dkg.rs

@@ -659,8 +659,9 @@ pub mod test {
     use super::domain_separate_hash;
     use crate::crypto::ciphersuite::Ciphersuite;
     use crate::participants::{Participant, ParticipantList};
-    use crate::test_utils::generate_participants;
-    use crate::test_utils::{assert_public_key_invariant, run_keygen, run_refresh, run_reshare};
+    use crate::test_utils::{
+        assert_public_key_invariant, generate_participants, run_keygen, run_refresh, run_reshare,
+    };
     use frost_core::{Field, Group};
 
     #[test]

src/ecdsa/mod.rs

@@ -190,20 +190,17 @@ mod test {
         },
         participants::ParticipantList,
         test_utils::{
-            generate_participants, generate_participants_with_random_ids, random_32_bytes,
-            MockCryptoRng,
+            ecdsa_generate_rerandpresig_args, generate_participants,
+            generate_participants_with_random_ids, MockCryptoRng,
         },
     };
 
     use elliptic_curve::ops::{Invert, LinearCombination, Reduce};
 
-    use frost_core::{
-        keys::SigningShare, Ciphersuite, SigningKey as FrostSigningKey,
-        VerifyingKey as FrostVerifyingKey,
-    };
+    use frost_core::{keys::SigningShare, Ciphersuite, SigningKey as FrostSigningKey};
 
     use k256::{
-        ecdsa::{signature::Verifier, SigningKey, VerifyingKey},
+        ecdsa::{signature::Verifier, SigningKey},
         ProjectivePoint, Secp256k1,
     };
     use rand_core::{CryptoRngCore, OsRng, RngCore};
@@ -217,7 +214,7 @@ mod test {
         hasher.update(msg);
 
         let sk = SigningKey::random(&mut OsRng);
-        let pk = VerifyingKey::from(&sk);
+        let pk = ecdsa::VerifyingKey::from(&sk);
         let (sig, _) = sk.sign_digest_recoverable(hasher.clone()).unwrap();
         assert!(pk.verify(msg, &sig).is_ok());
 
@@ -250,7 +247,7 @@ mod test {
 
         let keygen_output = KeygenOutput {
             private_share: SigningShare::<C>::new(Scalar::ONE),
-            public_key: FrostVerifyingKey::<C>::from(signing_key),
+            public_key: frost_core::VerifyingKey::<C>::from(signing_key),
         };
 
         // When
@@ -269,19 +266,16 @@ mod test {
         rng: &mut impl CryptoRngCore,
         num_participants: usize,
     ) -> (RerandomizationArguments, Scalar) {
-        let sk = SigningKey::random(&mut OsRng);
-        let pk = *VerifyingKey::from(sk).as_affine();
-        let tweak = Tweak::new(frost_core::random_nonzero::<Secp256K1Sha256, _>(&mut OsRng));
         let (_, big_r) = <C>::generate_nonce(&mut OsRng);
+        let (_, pk) = <C>::generate_nonce(&mut OsRng);
+        let pk = frost_core::VerifyingKey::new(pk);
         let big_r = big_r.to_affine();
 
-        let msg_hash = random_32_bytes(rng);
-        let entropy = random_32_bytes(rng);
         // Generate unique ten ParticipantId values
         let participants = generate_participants_with_random_ids(num_participants, rng);
-        let participants = ParticipantList::new(&participants).unwrap();
+        // Generate Rerandomization arguments
+        let (args, _) = ecdsa_generate_rerandpresig_args(rng, &participants, pk, big_r);
 
-        let args = RerandomizationArguments::new(pk, tweak, msg_hash, big_r, participants, entropy);
         let delta = args.derive_randomness().unwrap();
         (args, delta)
     }
@@ -315,7 +309,7 @@ mod test {
         let mut rng = OsRng;
         let (mut args, delta) = compute_random_outputs(&mut rng, num_participants);
         // different msg_hash
-        args.msg_hash = random_32_bytes(&mut rng);
+        args.msg_hash = [0; 32];
         let delta_prime = args.derive_randomness().unwrap();
         assert_ne!(delta, delta_prime);
     }

src/ecdsa/ot_based_ecdsa/presign.rs

@@ -188,9 +188,10 @@ async fn do_presign(
 #[cfg(test)]
 mod test {
     use super::*;
+    use crate::test_utils::{run_protocol, GenProtocol};
     use crate::{
         ecdsa::{ot_based_ecdsa::triples::test::deal, KeygenOutput, Polynomial, ProjectivePoint},
-        test_utils::{generate_participants, run_protocol, GenProtocol},
+        test_utils::generate_participants,
     };
     use frost_secp256k1::{
         keys::{PublicKeyPackage, SigningShare},

src/ecdsa/ot_based_ecdsa/test.rs

@@ -2,27 +2,23 @@ use super::{
     presign::presign,
     sign::sign,
     triples::{generate_triple_many, test::deal, TriplePub, TripleShare},
-    PresignArguments, PresignOutput,
+    PresignArguments, PresignOutput, RerandomizedPresignOutput,
 };
 use crate::participants::Participant;
 use crate::protocol::Protocol;
 use crate::test_utils::{
-    assert_public_key_invariant, generate_participants, generate_participants_with_random_ids,
-    one_coordinator_output, run_keygen, run_protocol, run_refresh, run_reshare, run_sign,
+    assert_public_key_invariant, check_one_coordinator_output, generate_participants,
+    generate_participants_with_random_ids, run_keygen, run_protocol, run_refresh, run_reshare,
+    run_sign, GenOutput, GenProtocol,
 };
-use crate::{
-    crypto::hash::test::scalar_hash_secp256k1, ecdsa::ot_based_ecdsa::RerandomizedPresignOutput,
-};
-use crate::{
-    ecdsa::{
-        Element, ParticipantList, RerandomizationArguments, Secp256K1Sha256, Signature,
-        SignatureOption, Tweak,
-    },
-    test_utils::{GenOutput, GenProtocol},
+
+use crate::crypto::hash::test::scalar_hash_secp256k1;
+use crate::ecdsa::{
+    Element, ParticipantList, RerandomizationArguments, Secp256K1Sha256, Signature,
+    SignatureOption, Tweak,
 };
 
-use rand::rngs::OsRng;
-use rand::Rng;
+use rand::{rngs::OsRng, Rng};
 use rand_core::RngCore;
 use std::error::Error;
 
@@ -62,7 +58,7 @@ pub fn run_sign_without_rerandomization(
     )
     .unwrap();
     // test one single some for the coordinator
-    let signature = one_coordinator_output(result, coordinator).unwrap();
+    let signature = check_one_coordinator_output(result, coordinator).unwrap();
     (coordinator, signature)
 }
 
@@ -111,7 +107,7 @@ pub fn run_sign_with_rerandomization(
     let coordinator = participants_presign[index].0;
 
     // run sign instanciation with the necessary arguments
-    let result = crate::test_utils::run_sign::<Secp256K1Sha256, _, _, _>(
+    let result = run_sign::<Secp256K1Sha256, _, _, _>(
         rerand_participants_presign,
         coordinator,
         derived_pk,
@@ -124,7 +120,7 @@ pub fn run_sign_with_rerandomization(
     )?;
 
     // test one single some for the coordinator
-    let signature = one_coordinator_output(result, coordinator)?;
+    let signature = check_one_coordinator_output(result, coordinator)?;
     Ok((tweak, coordinator, signature))
 }
 

src/ecdsa/ot_based_ecdsa/triples/generation.rs

@@ -1136,8 +1136,7 @@ mod test {
 
     use crate::{
         ecdsa::{ot_based_ecdsa::triples::generate_triple, ProjectivePoint},
-        participants::Participant,
-        participants::ParticipantList,
+        participants::{Participant, ParticipantList},
         protocol::Protocol,
         test_utils::{generate_participants, run_protocol},
     };

src/ecdsa/robust_ecdsa/presign.rs

@@ -355,15 +355,11 @@ impl Shares {
 #[cfg(test)]
 mod test {
     use super::*;
-    use rand_core::OsRng;
-
     use crate::ecdsa::KeygenOutput;
     use crate::test_utils::{generate_participants, run_protocol, GenProtocol};
-    use frost_secp256k1::keys::PublicKeyPackage;
     use frost_secp256k1::VerifyingKey;
-
     use k256::ProjectivePoint;
-    use std::collections::BTreeMap;
+    use rand_core::OsRng;
 
     #[test]
     fn test_presign() {
@@ -380,10 +376,9 @@ mod test {
             // simulating the key packages for each participant
             let private_share = f.eval_at_participant(*p).unwrap();
             let verifying_key = VerifyingKey::new(big_x);
-            let public_key_package = PublicKeyPackage::new(BTreeMap::new(), verifying_key);
             let keygen_out = KeygenOutput {
                 private_share: SigningShare::new(private_share.0),
-                public_key: *public_key_package.verifying_key(),
+                public_key: verifying_key,
             };
 
             let protocol = presign(
@@ -403,9 +398,6 @@ mod test {
 
         assert!(result.len() == 5);
         // testing that big_r is the same accross participants
-        assert_eq!(result[0].1.big_r, result[1].1.big_r);
-        assert_eq!(result[1].1.big_r, result[2].1.big_r);
-        assert_eq!(result[2].1.big_r, result[3].1.big_r);
-        assert_eq!(result[3].1.big_r, result[4].1.big_r);
+        assert!(result.windows(2).all(|w| w[0].1.big_r == w[1].1.big_r));
     }
 }

src/ecdsa/robust_ecdsa/sign.rs

@@ -300,9 +300,6 @@ mod test {
 
     #[test]
     fn test_sign_fails_if_s_is_zero() {
-        use crate::ecdsa::{ProjectivePoint, Secp256K1ScalarField};
-        use crate::test_utils::generate_participants;
-
         let participants = generate_participants(2);
 
         // presignatures with s_me = 0 for each participant