Add minimum participant constraints (#453)

* Add validation for missing identifier in signing package (#442)

* Add error handling for identifier having an invalid commitment (#442)

* Fixed comment (#442)

* Add validation for participant numbers (#443)

Add to split() and generate_secret_polynomial()

* Add participant validation for dkg and repairable (#443)

frost-core/src/frost/keys.rs

@@ -466,6 +466,8 @@ pub fn split<C: Ciphersuite, R: RngCore + CryptoRng>(
     identifiers: IdentifierList<C>,
     rng: &mut R,
 ) -> Result<(HashMap<Identifier<C>, SecretShare<C>>, PublicKeyPackage<C>), Error<C>> {
+    validate_num_of_signers(min_signers, max_signers)?;
+
     let group_public = VerifyingKey::from(key);
 
     let coefficients = generate_coefficients::<C, R>(min_signers as usize - 1, rng);
@@ -665,6 +667,25 @@ where
     }
 }
 
+fn validate_num_of_signers<C: Ciphersuite>(
+    min_signers: u16,
+    max_signers: u16,
+) -> Result<(), Error<C>> {
+    if min_signers < 2 {
+        return Err(Error::InvalidMinSigners);
+    }
+
+    if max_signers < 2 {
+        return Err(Error::InvalidMaxSigners);
+    }
+
+    if min_signers > max_signers {
+        return Err(Error::InvalidMinSigners);
+    }
+
+    Ok(())
+}
+
 /// Generate a secret polynomial to use in secret sharing, for the given
 /// secret value. Also validates the given parameters.
 ///
@@ -679,17 +700,7 @@ pub(crate) fn generate_secret_polynomial<C: Ciphersuite>(
     min_signers: u16,
     mut coefficients: Vec<Scalar<C>>,
 ) -> Result<(Vec<Scalar<C>>, VerifiableSecretSharingCommitment<C>), Error<C>> {
-    if min_signers < 2 {
-        return Err(Error::InvalidMinSigners);
-    }
-
-    if max_signers < 2 {
-        return Err(Error::InvalidMaxSigners);
-    }
-
-    if min_signers > max_signers {
-        return Err(Error::InvalidMinSigners);
-    }
+    validate_num_of_signers(min_signers, max_signers)?;
 
     if coefficients.len() != min_signers as usize - 1 {
         return Err(Error::InvalidCoefficients);

frost-core/src/frost/keys/dkg.rs

@@ -41,8 +41,8 @@ use crate::{
 
 use super::{
     evaluate_polynomial, evaluate_vss, generate_coefficients, generate_secret_polynomial,
-    KeyPackage, PublicKeyPackage, SecretShare, SigningShare, VerifiableSecretSharingCommitment,
-    VerifyingShare,
+    validate_num_of_signers, KeyPackage, PublicKeyPackage, SecretShare, SigningShare,
+    VerifiableSecretSharingCommitment, VerifyingShare,
 };
 
 /// DKG Round 1 structures.
@@ -237,6 +237,8 @@ pub fn part1<C: Ciphersuite, R: RngCore + CryptoRng>(
     min_signers: u16,
     mut rng: R,
 ) -> Result<(round1::SecretPackage<C>, round1::Package<C>), Error<C>> {
+    validate_num_of_signers::<C>(min_signers, max_signers)?;
+
     let secret: SigningKey<C> = SigningKey::new(&mut rng);
 
     // Round 1, Step 1

frost-core/src/frost/keys/repairable.rs

@@ -26,6 +26,10 @@ pub fn repair_share_step_1<C: Ciphersuite, R: RngCore + CryptoRng>(
     rng: &mut R,
     participant: Identifier<C>,
 ) -> Result<HashMap<Identifier<C>, Scalar<C>>, Error<C>> {
+    if helpers.len() < 2 {
+        return Err(Error::InvalidMinSigners);
+    }
+
     if helpers.is_empty() {
         return Err(Error::IncorrectNumberOfIdentifiers);
     }

frost-core/src/tests/ciphersuite_generic.rs

@@ -59,6 +59,30 @@ pub fn check_share_generation<C: Ciphersuite, R: RngCore + CryptoRng>(mut rng: R
     );
 }
 
+/// Test share generation with a Ciphersuite
+pub fn check_share_generation_fails_with_invalid_signers<C: Ciphersuite, R: RngCore + CryptoRng>(
+    min_signers: u16,
+    max_signers: u16,
+    error: Error<C>,
+    mut rng: R,
+) {
+    let secret = crate::SigningKey::<C>::new(&mut rng);
+
+    // Use arbitrary number of coefficients so tests don't fail for overflow reasons
+    let coefficients = frost::keys::generate_coefficients::<C, _>(3, &mut rng);
+
+    let secret_shares = frost::keys::generate_secret_shares(
+        &secret,
+        max_signers,
+        min_signers,
+        coefficients,
+        &frost::keys::default_identifiers(max_signers),
+    );
+
+    assert!(secret_shares.is_err());
+    assert!(secret_shares == Err(error))
+}
+
 /// Test FROST signing with trusted dealer with a Ciphersuite.
 pub fn check_sign_with_dealer<C: Ciphersuite, R: RngCore + CryptoRng>(
     mut rng: R,
@@ -89,6 +113,42 @@ pub fn check_sign_with_dealer<C: Ciphersuite, R: RngCore + CryptoRng>(
     check_sign(min_signers, key_packages, rng, pubkeys)
 }
 
+/// Test FROST signing with trusted dealer fails with invalid numbers of signers.
+pub fn check_sign_with_dealer_fails_with_invalid_signers<C: Ciphersuite, R: RngCore + CryptoRng>(
+    min_signers: u16,
+    max_signers: u16,
+    error: Error<C>,
+    mut rng: R,
+) {
+    let out = frost::keys::generate_with_dealer(
+        max_signers,
+        min_signers,
+        frost::keys::IdentifierList::Default::<C>,
+        &mut rng,
+    );
+
+    assert!(out.is_err());
+    assert!(out == Err(error))
+}
+
+/// Test DKG part1 fails with invalid numbers of signers.
+pub fn check_dkg_part1_fails_with_invalid_signers<C: Ciphersuite, R: RngCore + CryptoRng>(
+    min_signers: u16,
+    max_signers: u16,
+    error: Error<C>,
+    mut rng: R,
+) {
+    let out = frost::keys::dkg::part1(
+        Identifier::try_from(1).unwrap(),
+        max_signers,
+        min_signers,
+        &mut rng,
+    );
+
+    assert!(out.is_err());
+    assert!(out == Err(error))
+}
+
 /// Test FROST signing with the given shares.
 pub fn check_sign<C: Ciphersuite + PartialEq, R: RngCore + CryptoRng>(
     min_signers: u16,

frost-core/src/tests/repairable.rs

@@ -15,7 +15,7 @@ use crate::{
         },
         Identifier,
     },
-    Ciphersuite, Field, Group, Scalar,
+    Ciphersuite, Error, Field, Group, Scalar,
 };
 
 /// We want to test that recover share matches the original share
@@ -210,3 +210,35 @@ pub fn check_repair_share_step_3<C: Ciphersuite, R: RngCore + CryptoRng>(
 
     assert!(actual.value == expected.value);
 }
+
+/// Test repair share step 1 fails with invalid numbers of signers.
+pub fn check_repair_share_step_1_fails_with_invalid_min_signers<
+    C: Ciphersuite,
+    R: RngCore + CryptoRng,
+>(
+    mut rng: R,
+) {
+    // Generate shares
+    let max_signers = 3;
+    let min_signers = 2; // This is to make sure this test fails at the right point
+    let (shares, _pubkeys): (HashMap<Identifier<C>, SecretShare<C>>, PublicKeyPackage<C>) =
+        frost::keys::generate_with_dealer(
+            max_signers,
+            min_signers,
+            frost::keys::IdentifierList::Default,
+            &mut rng,
+        )
+        .unwrap();
+
+    let helper = Identifier::try_from(3).unwrap();
+
+    let out = repair_share_step_1(
+        &[helper],
+        &shares[&helper],
+        &mut rng,
+        Identifier::try_from(2).unwrap(),
+    );
+
+    assert!(out.is_err());
+    assert!(out == Err(Error::InvalidMinSigners))
+}

frost-ed25519/src/keys/repairable.rs

@@ -89,4 +89,13 @@ mod tests {
             &REPAIR_SHARE,
         );
     }
+
+    #[test]
+    fn check_repair_share_step_1_fails_with_invalid_min_signers() {
+        let rng = thread_rng();
+        frost_core::tests::repairable::check_repair_share_step_1_fails_with_invalid_min_signers::<
+            Ed25519Sha512,
+            _,
+        >(rng);
+    }
 }

frost-ed25519/tests/integration_tests.rs

@@ -10,6 +10,48 @@ fn check_sign_with_dkg() {
     frost_core::tests::ciphersuite_generic::check_sign_with_dkg::<Ed25519Sha512, _>(rng);
 }
 
+#[test]
+fn check_dkg_part1_fails_with_invalid_signers_min_signers() {
+    let rng = thread_rng();
+
+    let min_signers = 1;
+    let max_signers = 3;
+    let error = Error::InvalidMinSigners;
+
+    frost_core::tests::ciphersuite_generic::check_sign_with_dealer_fails_with_invalid_signers::<
+        Ed25519Sha512,
+        _,
+    >(min_signers, max_signers, error, rng);
+}
+
+#[test]
+fn check_dkg_part1_fails_with_min_signers_greater_than_max() {
+    let rng = thread_rng();
+
+    let min_signers = 3;
+    let max_signers = 2;
+    let error: frost_core::Error<Ed25519Sha512> = Error::InvalidMinSigners;
+
+    frost_core::tests::ciphersuite_generic::check_sign_with_dealer_fails_with_invalid_signers::<
+        Ed25519Sha512,
+        _,
+    >(min_signers, max_signers, error, rng);
+}
+
+#[test]
+fn check_dkg_part1_fails_with_invalid_signers_max_signers() {
+    let rng = thread_rng();
+
+    let min_signers = 3;
+    let max_signers = 1;
+    let error = Error::InvalidMaxSigners;
+
+    frost_core::tests::ciphersuite_generic::check_sign_with_dealer_fails_with_invalid_signers::<
+        Ed25519Sha512,
+        _,
+    >(min_signers, max_signers, error, rng);
+}
+
 #[test]
 fn check_rts() {
     let rng = thread_rng();
@@ -24,6 +66,48 @@ fn check_sign_with_dealer() {
     frost_core::tests::ciphersuite_generic::check_sign_with_dealer::<Ed25519Sha512, _>(rng);
 }
 
+#[test]
+fn check_sign_with_dealer_fails_with_invalid_min_signers() {
+    let rng = thread_rng();
+
+    let min_signers = 1;
+    let max_signers = 3;
+    let error = Error::InvalidMinSigners;
+
+    frost_core::tests::ciphersuite_generic::check_sign_with_dealer_fails_with_invalid_signers::<
+        Ed25519Sha512,
+        _,
+    >(min_signers, max_signers, error, rng);
+}
+
+#[test]
+fn check_sign_with_dealer_fails_with_min_signers_greater_than_max() {
+    let rng = thread_rng();
+
+    let min_signers = 3;
+    let max_signers = 2;
+    let error: frost_core::Error<Ed25519Sha512> = Error::InvalidMinSigners;
+
+    frost_core::tests::ciphersuite_generic::check_sign_with_dealer_fails_with_invalid_signers::<
+        Ed25519Sha512,
+        _,
+    >(min_signers, max_signers, error, rng);
+}
+
+#[test]
+fn check_sign_with_dealer_fails_with_invalid_max_signers() {
+    let rng = thread_rng();
+
+    let min_signers = 3;
+    let max_signers = 1;
+    let error = Error::InvalidMaxSigners;
+
+    frost_core::tests::ciphersuite_generic::check_sign_with_dealer_fails_with_invalid_signers::<
+        Ed25519Sha512,
+        _,
+    >(min_signers, max_signers, error, rng);
+}
+
 /// This is testing that Shamir's secret sharing to compute and arbitrary
 /// value is working.
 #[test]
@@ -32,6 +116,48 @@ fn check_share_generation_ed25519_sha512() {
     frost_core::tests::ciphersuite_generic::check_share_generation::<Ed25519Sha512, _>(rng);
 }
 
+#[test]
+fn check_share_generation_fails_with_invalid_min_signers() {
+    let rng = thread_rng();
+
+    let min_signers = 0;
+    let max_signers = 3;
+    let error = Error::InvalidMinSigners;
+
+    frost_core::tests::ciphersuite_generic::check_share_generation_fails_with_invalid_signers::<
+        Ed25519Sha512,
+        _,
+    >(min_signers, max_signers, error, rng);
+}
+
+#[test]
+fn check_share_generation_fails_with_min_signers_greater_than_max() {
+    let rng = thread_rng();
+
+    let min_signers = 3;
+    let max_signers = 2;
+    let error: frost_core::Error<Ed25519Sha512> = Error::InvalidMinSigners;
+
+    frost_core::tests::ciphersuite_generic::check_share_generation_fails_with_invalid_signers::<
+        Ed25519Sha512,
+        _,
+    >(min_signers, max_signers, error, rng);
+}
+
+#[test]
+fn check_share_generation_fails_with_invalid_max_signers() {
+    let rng = thread_rng();
+
+    let min_signers = 3;
+    let max_signers = 0;
+    let error = Error::InvalidMaxSigners;
+
+    frost_core::tests::ciphersuite_generic::check_share_generation_fails_with_invalid_signers::<
+        Ed25519Sha512,
+        _,
+    >(min_signers, max_signers, error, rng);
+}
+
 lazy_static! {
     pub static ref VECTORS: Value =
         serde_json::from_str(include_str!("../tests/helpers/vectors.json").trim())

frost-ed448/src/keys/repairable.rs

@@ -89,4 +89,13 @@ mod tests {
             &REPAIR_SHARE,
         );
     }
+
+    #[test]
+    fn check_repair_share_step_1_fails_with_invalid_min_signers() {
+        let rng = thread_rng();
+        frost_core::tests::repairable::check_repair_share_step_1_fails_with_invalid_min_signers::<
+            Ed448Shake256,
+            _,
+        >(rng);
+    }
 }

frost-ed448/tests/integration_tests.rs

@@ -10,6 +10,48 @@ fn check_sign_with_dkg() {
     frost_core::tests::ciphersuite_generic::check_sign_with_dkg::<Ed448Shake256, _>(rng);
 }
 
+#[test]
+fn check_dkg_part1_fails_with_invalid_signers_min_signers() {
+    let rng = thread_rng();
+
+    let min_signers = 1;
+    let max_signers = 3;
+    let error = Error::InvalidMinSigners;
+
+    frost_core::tests::ciphersuite_generic::check_sign_with_dealer_fails_with_invalid_signers::<
+        Ed448Shake256,
+        _,
+    >(min_signers, max_signers, error, rng);
+}
+
+#[test]
+fn check_dkg_part1_fails_with_min_signers_greater_than_max() {
+    let rng = thread_rng();
+
+    let min_signers = 3;
+    let max_signers = 2;
+    let error: frost_core::Error<Ed448Shake256> = Error::InvalidMinSigners;
+
+    frost_core::tests::ciphersuite_generic::check_sign_with_dealer_fails_with_invalid_signers::<
+        Ed448Shake256,
+        _,
+    >(min_signers, max_signers, error, rng);
+}
+
+#[test]
+fn check_dkg_part1_fails_with_invalid_signers_max_signers() {
+    let rng = thread_rng();
+
+    let min_signers = 3;
+    let max_signers = 1;
+    let error = Error::InvalidMaxSigners;
+
+    frost_core::tests::ciphersuite_generic::check_sign_with_dealer_fails_with_invalid_signers::<
+        Ed448Shake256,
+        _,
+    >(min_signers, max_signers, error, rng);
+}
+
 #[test]
 fn check_rts() {
     let rng = thread_rng();
@@ -24,6 +66,48 @@ fn check_sign_with_dealer() {
     frost_core::tests::ciphersuite_generic::check_sign_with_dealer::<Ed448Shake256, _>(rng);
 }
 
+#[test]
+fn check_sign_with_dealer_fails_with_invalid_min_signers() {
+    let rng = thread_rng();
+
+    let min_signers = 1;
+    let max_signers = 3;
+    let error = Error::InvalidMinSigners;
+
+    frost_core::tests::ciphersuite_generic::check_sign_with_dealer_fails_with_invalid_signers::<
+        Ed448Shake256,
+        _,
+    >(min_signers, max_signers, error, rng);
+}
+
+#[test]
+fn check_sign_with_dealer_fails_with_min_signers_greater_than_max() {
+    let rng = thread_rng();
+
+    let min_signers = 3;
+    let max_signers = 2;
+    let error: frost_core::Error<Ed448Shake256> = Error::InvalidMinSigners;
+
+    frost_core::tests::ciphersuite_generic::check_sign_with_dealer_fails_with_invalid_signers::<
+        Ed448Shake256,
+        _,
+    >(min_signers, max_signers, error, rng);
+}
+
+#[test]
+fn check_sign_with_dealer_fails_with_invalid_max_signers() {
+    let rng = thread_rng();
+
+    let min_signers = 3;
+    let max_signers = 1;
+    let error = Error::InvalidMaxSigners;
+
+    frost_core::tests::ciphersuite_generic::check_sign_with_dealer_fails_with_invalid_signers::<
+        Ed448Shake256,
+        _,
+    >(min_signers, max_signers, error, rng);
+}
+
 /// This is testing that Shamir's secret sharing to compute and arbitrary
 /// value is working.
 #[test]
@@ -32,6 +116,48 @@ fn check_share_generation_ed448_shake256() {
     frost_core::tests::ciphersuite_generic::check_share_generation::<Ed448Shake256, _>(rng);
 }
 
+#[test]
+fn check_share_generation_fails_with_invalid_min_signers() {
+    let rng = thread_rng();
+
+    let min_signers = 0;
+    let max_signers = 3;
+    let error = Error::InvalidMinSigners;
+
+    frost_core::tests::ciphersuite_generic::check_share_generation_fails_with_invalid_signers::<
+        Ed448Shake256,
+        _,
+    >(min_signers, max_signers, error, rng);
+}
+
+#[test]
+fn check_share_generation_fails_with_min_signers_greater_than_max() {
+    let rng = thread_rng();
+
+    let min_signers = 3;
+    let max_signers = 2;
+    let error: frost_core::Error<Ed448Shake256> = Error::InvalidMinSigners;
+
+    frost_core::tests::ciphersuite_generic::check_share_generation_fails_with_invalid_signers::<
+        Ed448Shake256,
+        _,
+    >(min_signers, max_signers, error, rng);
+}
+
+#[test]
+fn check_share_generation_fails_with_invalid_max_signers() {
+    let rng = thread_rng();
+
+    let min_signers = 3;
+    let max_signers = 0;
+    let error = Error::InvalidMaxSigners;
+
+    frost_core::tests::ciphersuite_generic::check_share_generation_fails_with_invalid_signers::<
+        Ed448Shake256,
+        _,
+    >(min_signers, max_signers, error, rng);
+}
+
 lazy_static! {
     pub static ref VECTORS: Value =
         serde_json::from_str(include_str!("../tests/helpers/vectors.json").trim())

frost-p256/src/keys/repairable.rs

@@ -89,4 +89,13 @@ mod tests {
             &REPAIR_SHARE,
         );
     }
+
+    #[test]
+    fn check_repair_share_step_1_fails_with_invalid_min_signers() {
+        let rng = thread_rng();
+        frost_core::tests::repairable::check_repair_share_step_1_fails_with_invalid_min_signers::<
+            P256Sha256,
+            _,
+        >(rng);
+    }
 }

frost-p256/tests/integration_tests.rs

@@ -10,6 +10,48 @@ fn check_sign_with_dkg() {
     frost_core::tests::ciphersuite_generic::check_sign_with_dkg::<P256Sha256, _>(rng);
 }
 
+#[test]
+fn check_dkg_part1_fails_with_invalid_signers_min_signers() {
+    let rng = thread_rng();
+
+    let min_signers = 1;
+    let max_signers = 3;
+    let error = Error::InvalidMinSigners;
+
+    frost_core::tests::ciphersuite_generic::check_sign_with_dealer_fails_with_invalid_signers::<
+        P256Sha256,
+        _,
+    >(min_signers, max_signers, error, rng);
+}
+
+#[test]
+fn check_dkg_part1_fails_with_min_signers_greater_than_max() {
+    let rng = thread_rng();
+
+    let min_signers = 3;
+    let max_signers = 2;
+    let error: frost_core::Error<P256Sha256> = Error::InvalidMinSigners;
+
+    frost_core::tests::ciphersuite_generic::check_sign_with_dealer_fails_with_invalid_signers::<
+        P256Sha256,
+        _,
+    >(min_signers, max_signers, error, rng);
+}
+
+#[test]
+fn check_dkg_part1_fails_with_invalid_signers_max_signers() {
+    let rng = thread_rng();
+
+    let min_signers = 3;
+    let max_signers = 1;
+    let error = Error::InvalidMaxSigners;
+
+    frost_core::tests::ciphersuite_generic::check_sign_with_dealer_fails_with_invalid_signers::<
+        P256Sha256,
+        _,
+    >(min_signers, max_signers, error, rng);
+}
+
 #[test]
 fn check_rts() {
     let rng = thread_rng();
@@ -24,6 +66,48 @@ fn check_sign_with_dealer() {
     frost_core::tests::ciphersuite_generic::check_sign_with_dealer::<P256Sha256, _>(rng);
 }
 
+#[test]
+fn check_sign_with_dealer_fails_with_invalid_min_signers() {
+    let rng = thread_rng();
+
+    let min_signers = 1;
+    let max_signers = 3;
+    let error = Error::InvalidMinSigners;
+
+    frost_core::tests::ciphersuite_generic::check_sign_with_dealer_fails_with_invalid_signers::<
+        P256Sha256,
+        _,
+    >(min_signers, max_signers, error, rng);
+}
+
+#[test]
+fn check_sign_with_dealer_fails_with_min_signers_greater_than_max() {
+    let rng = thread_rng();
+
+    let min_signers = 3;
+    let max_signers = 2;
+    let error: frost_core::Error<P256Sha256> = Error::InvalidMinSigners;
+
+    frost_core::tests::ciphersuite_generic::check_sign_with_dealer_fails_with_invalid_signers::<
+        P256Sha256,
+        _,
+    >(min_signers, max_signers, error, rng);
+}
+
+#[test]
+fn check_sign_with_dealer_fails_with_invalid_max_signers() {
+    let rng = thread_rng();
+
+    let min_signers = 3;
+    let max_signers = 1;
+    let error = Error::InvalidMaxSigners;
+
+    frost_core::tests::ciphersuite_generic::check_sign_with_dealer_fails_with_invalid_signers::<
+        P256Sha256,
+        _,
+    >(min_signers, max_signers, error, rng);
+}
+
 /// This is testing that Shamir's secret sharing to compute and arbitrary
 /// value is working.
 #[test]
@@ -32,6 +116,48 @@ fn check_share_generation_p256_sha256() {
     frost_core::tests::ciphersuite_generic::check_share_generation::<P256Sha256, _>(rng);
 }
 
+#[test]
+fn check_share_generation_fails_with_invalid_min_signers() {
+    let rng = thread_rng();
+
+    let min_signers = 0;
+    let max_signers = 3;
+    let error = Error::InvalidMinSigners;
+
+    frost_core::tests::ciphersuite_generic::check_share_generation_fails_with_invalid_signers::<
+        P256Sha256,
+        _,
+    >(min_signers, max_signers, error, rng);
+}
+
+#[test]
+fn check_share_generation_fails_with_min_signers_greater_than_max() {
+    let rng = thread_rng();
+
+    let min_signers = 3;
+    let max_signers = 2;
+    let error: frost_core::Error<P256Sha256> = Error::InvalidMinSigners;
+
+    frost_core::tests::ciphersuite_generic::check_share_generation_fails_with_invalid_signers::<
+        P256Sha256,
+        _,
+    >(min_signers, max_signers, error, rng);
+}
+
+#[test]
+fn check_share_generation_fails_with_invalid_max_signers() {
+    let rng = thread_rng();
+
+    let min_signers = 3;
+    let max_signers = 0;
+    let error = Error::InvalidMaxSigners;
+
+    frost_core::tests::ciphersuite_generic::check_share_generation_fails_with_invalid_signers::<
+        P256Sha256,
+        _,
+    >(min_signers, max_signers, error, rng);
+}
+
 lazy_static! {
     pub static ref VECTORS: Value =
         serde_json::from_str(include_str!("../tests/helpers/vectors.json").trim())

frost-ristretto255/src/keys/repairable.rs

@@ -91,4 +91,13 @@ mod tests {
             &REPAIR_SHARE,
         );
     }
+
+    #[test]
+    fn check_repair_share_step_1_fails_with_invalid_min_signers() {
+        let rng = thread_rng();
+        frost_core::tests::repairable::check_repair_share_step_1_fails_with_invalid_min_signers::<
+            Ristretto255Sha512,
+            _,
+        >(rng);
+    }
 }

frost-ristretto255/tests/integration_tests.rs

@@ -10,6 +10,48 @@ fn check_sign_with_dkg() {
     frost_core::tests::ciphersuite_generic::check_sign_with_dkg::<Ristretto255Sha512, _>(rng);
 }
 
+#[test]
+fn check_dkg_part1_fails_with_invalid_signers_min_signers() {
+    let rng = thread_rng();
+
+    let min_signers = 1;
+    let max_signers = 3;
+    let error = Error::InvalidMinSigners;
+
+    frost_core::tests::ciphersuite_generic::check_sign_with_dealer_fails_with_invalid_signers::<
+        Ristretto255Sha512,
+        _,
+    >(min_signers, max_signers, error, rng);
+}
+
+#[test]
+fn check_dkg_part1_fails_with_min_signers_greater_than_max() {
+    let rng = thread_rng();
+
+    let min_signers = 3;
+    let max_signers = 2;
+    let error: frost_core::Error<Ristretto255Sha512> = Error::InvalidMinSigners;
+
+    frost_core::tests::ciphersuite_generic::check_sign_with_dealer_fails_with_invalid_signers::<
+        Ristretto255Sha512,
+        _,
+    >(min_signers, max_signers, error, rng);
+}
+
+#[test]
+fn check_dkg_part1_fails_with_invalid_signers_max_signers() {
+    let rng = thread_rng();
+
+    let min_signers = 3;
+    let max_signers = 1;
+    let error = Error::InvalidMaxSigners;
+
+    frost_core::tests::ciphersuite_generic::check_sign_with_dealer_fails_with_invalid_signers::<
+        Ristretto255Sha512,
+        _,
+    >(min_signers, max_signers, error, rng);
+}
+
 #[test]
 fn check_rts() {
     let rng = thread_rng();
@@ -24,6 +66,48 @@ fn check_sign_with_dealer() {
     frost_core::tests::ciphersuite_generic::check_sign_with_dealer::<Ristretto255Sha512, _>(rng);
 }
 
+#[test]
+fn check_sign_with_dealer_fails_with_invalid_min_signers() {
+    let rng = thread_rng();
+
+    let min_signers = 1;
+    let max_signers = 3;
+    let error = Error::InvalidMinSigners;
+
+    frost_core::tests::ciphersuite_generic::check_sign_with_dealer_fails_with_invalid_signers::<
+        Ristretto255Sha512,
+        _,
+    >(min_signers, max_signers, error, rng);
+}
+
+#[test]
+fn check_sign_with_dealer_fails_with_min_signers_greater_than_max() {
+    let rng = thread_rng();
+
+    let min_signers = 3;
+    let max_signers = 2;
+    let error: frost_core::Error<Ristretto255Sha512> = Error::InvalidMinSigners;
+
+    frost_core::tests::ciphersuite_generic::check_sign_with_dealer_fails_with_invalid_signers::<
+        Ristretto255Sha512,
+        _,
+    >(min_signers, max_signers, error, rng);
+}
+
+#[test]
+fn check_sign_with_dealer_fails_with_invalid_max_signers() {
+    let rng = thread_rng();
+
+    let min_signers = 3;
+    let max_signers = 1;
+    let error = Error::InvalidMaxSigners;
+
+    frost_core::tests::ciphersuite_generic::check_sign_with_dealer_fails_with_invalid_signers::<
+        Ristretto255Sha512,
+        _,
+    >(min_signers, max_signers, error, rng);
+}
+
 /// This is testing that Shamir's secret sharing to compute and arbitrary
 /// value is working.
 #[test]
@@ -32,6 +116,48 @@ fn check_share_generation_ristretto255_sha512() {
     frost_core::tests::ciphersuite_generic::check_share_generation::<Ristretto255Sha512, _>(rng);
 }
 
+#[test]
+fn check_share_generation_fails_with_invalid_min_signers() {
+    let rng = thread_rng();
+
+    let min_signers = 0;
+    let max_signers = 3;
+    let error = Error::InvalidMinSigners;
+
+    frost_core::tests::ciphersuite_generic::check_share_generation_fails_with_invalid_signers::<
+        Ristretto255Sha512,
+        _,
+    >(min_signers, max_signers, error, rng);
+}
+
+#[test]
+fn check_share_generation_fails_with_min_signers_greater_than_max() {
+    let rng = thread_rng();
+
+    let min_signers = 3;
+    let max_signers = 2;
+    let error: frost_core::Error<Ristretto255Sha512> = Error::InvalidMinSigners;
+
+    frost_core::tests::ciphersuite_generic::check_share_generation_fails_with_invalid_signers::<
+        Ristretto255Sha512,
+        _,
+    >(min_signers, max_signers, error, rng);
+}
+
+#[test]
+fn check_share_generation_fails_with_invalid_max_signers() {
+    let rng = thread_rng();
+
+    let min_signers = 3;
+    let max_signers = 0;
+    let error = Error::InvalidMaxSigners;
+
+    frost_core::tests::ciphersuite_generic::check_share_generation_fails_with_invalid_signers::<
+        Ristretto255Sha512,
+        _,
+    >(min_signers, max_signers, error, rng);
+}
+
 lazy_static! {
     pub static ref VECTORS: Value =
         serde_json::from_str(include_str!("../tests/helpers/vectors.json").trim())

frost-secp256k1/src/keys/repairable.rs

@@ -89,4 +89,13 @@ mod tests {
             &REPAIR_SHARE,
         );
     }
+
+    #[test]
+    fn check_repair_share_step_1_fails_with_invalid_min_signers() {
+        let rng = thread_rng();
+        frost_core::tests::repairable::check_repair_share_step_1_fails_with_invalid_min_signers::<
+            Secp256K1Sha256,
+            _,
+        >(rng);
+    }
 }

frost-secp256k1/tests/integration_tests.rs

@@ -10,6 +10,48 @@ fn check_sign_with_dkg() {
     frost_core::tests::ciphersuite_generic::check_sign_with_dkg::<Secp256K1Sha256, _>(rng);
 }
 
+#[test]
+fn check_dkg_part1_fails_with_invalid_signers_min_signers() {
+    let rng = thread_rng();
+
+    let min_signers = 1;
+    let max_signers = 3;
+    let error = Error::InvalidMinSigners;
+
+    frost_core::tests::ciphersuite_generic::check_sign_with_dealer_fails_with_invalid_signers::<
+        Secp256K1Sha256,
+        _,
+    >(min_signers, max_signers, error, rng);
+}
+
+#[test]
+fn check_dkg_part1_fails_with_min_signers_greater_than_max() {
+    let rng = thread_rng();
+
+    let min_signers = 3;
+    let max_signers = 2;
+    let error: frost_core::Error<Secp256K1Sha256> = Error::InvalidMinSigners;
+
+    frost_core::tests::ciphersuite_generic::check_sign_with_dealer_fails_with_invalid_signers::<
+        Secp256K1Sha256,
+        _,
+    >(min_signers, max_signers, error, rng);
+}
+
+#[test]
+fn check_dkg_part1_fails_with_invalid_signers_max_signers() {
+    let rng = thread_rng();
+
+    let min_signers = 3;
+    let max_signers = 1;
+    let error = Error::InvalidMaxSigners;
+
+    frost_core::tests::ciphersuite_generic::check_sign_with_dealer_fails_with_invalid_signers::<
+        Secp256K1Sha256,
+        _,
+    >(min_signers, max_signers, error, rng);
+}
+
 #[test]
 fn check_rts() {
     let rng = thread_rng();
@@ -24,6 +66,48 @@ fn check_sign_with_dealer() {
     frost_core::tests::ciphersuite_generic::check_sign_with_dealer::<Secp256K1Sha256, _>(rng);
 }
 
+#[test]
+fn check_sign_with_dealer_fails_with_invalid_min_signers() {
+    let rng = thread_rng();
+
+    let min_signers = 1;
+    let max_signers = 3;
+    let error = Error::InvalidMinSigners;
+
+    frost_core::tests::ciphersuite_generic::check_sign_with_dealer_fails_with_invalid_signers::<
+        Secp256K1Sha256,
+        _,
+    >(min_signers, max_signers, error, rng);
+}
+
+#[test]
+fn check_sign_with_dealer_fails_with_min_signers_greater_than_max() {
+    let rng = thread_rng();
+
+    let min_signers = 3;
+    let max_signers = 2;
+    let error: frost_core::Error<Secp256K1Sha256> = Error::InvalidMinSigners;
+
+    frost_core::tests::ciphersuite_generic::check_sign_with_dealer_fails_with_invalid_signers::<
+        Secp256K1Sha256,
+        _,
+    >(min_signers, max_signers, error, rng);
+}
+
+#[test]
+fn check_sign_with_dealer_fails_with_invalid_max_signers() {
+    let rng = thread_rng();
+
+    let min_signers = 3;
+    let max_signers = 1;
+    let error = Error::InvalidMaxSigners;
+
+    frost_core::tests::ciphersuite_generic::check_sign_with_dealer_fails_with_invalid_signers::<
+        Secp256K1Sha256,
+        _,
+    >(min_signers, max_signers, error, rng);
+}
+
 /// This is testing that Shamir's secret sharing to compute and arbitrary
 /// value is working.
 #[test]
@@ -32,6 +116,48 @@ fn check_share_generation_secp256k1_sha256() {
     frost_core::tests::ciphersuite_generic::check_share_generation::<Secp256K1Sha256, _>(rng);
 }
 
+#[test]
+fn check_share_generation_fails_with_invalid_min_signers() {
+    let rng = thread_rng();
+
+    let min_signers = 0;
+    let max_signers = 3;
+    let error = Error::InvalidMinSigners;
+
+    frost_core::tests::ciphersuite_generic::check_share_generation_fails_with_invalid_signers::<
+        Secp256K1Sha256,
+        _,
+    >(min_signers, max_signers, error, rng);
+}
+
+#[test]
+fn check_share_generation_fails_with_min_signers_greater_than_max() {
+    let rng = thread_rng();
+
+    let min_signers = 3;
+    let max_signers = 2;
+    let error: frost_core::Error<Secp256K1Sha256> = Error::InvalidMinSigners;
+
+    frost_core::tests::ciphersuite_generic::check_share_generation_fails_with_invalid_signers::<
+        Secp256K1Sha256,
+        _,
+    >(min_signers, max_signers, error, rng);
+}
+
+#[test]
+fn check_share_generation_fails_with_invalid_max_signers() {
+    let rng = thread_rng();
+
+    let min_signers = 3;
+    let max_signers = 0;
+    let error = Error::InvalidMaxSigners;
+
+    frost_core::tests::ciphersuite_generic::check_share_generation_fails_with_invalid_signers::<
+        Secp256K1Sha256,
+        _,
+    >(min_signers, max_signers, error, rng);
+}
+
 lazy_static! {
     pub static ref VECTORS: Value =
         serde_json::from_str(include_str!("../tests/helpers/vectors.json").trim())