Merge pull request #84 from iron-fish/mat/more-errors

replace some panics with result returning

Author: mat-if

src/dkg/round1.rs

@@ -146,16 +146,16 @@ pub fn export_secret_package<R: RngCore + CryptoRng>(
     pkg: &SecretPackage,
     identity: &Identity,
     csrng: R,
-) -> io::Result<Vec<u8>> {
+) -> Result<Vec<u8>, IronfishFrostError> {
     let serializable = <&SerializableSecretPackage>::from(pkg);
     if serializable.identifier != identity.to_frost_identifier() {
-        return Err(io::Error::other("identity mismatch"));
+        return Err(IronfishFrostError::InvalidInput(
+            "identity mismatch".to_string(),
+        ));
     }
 
     let mut serialized = Vec::new();
-    serializable
-        .serialize_into(&mut serialized)
-        .expect("serialization failed");
+    serializable.serialize_into(&mut serialized)?;
     Ok(multienc::encrypt(&serialized, [identity], csrng))
 }
 
@@ -267,7 +267,7 @@ impl PublicPackage {
     }
 
     pub fn deserialize_from<R: io::Read>(mut reader: R) -> Result<Self, IronfishFrostError> {
-        let identity = Identity::deserialize_from(&mut reader).expect("reading identity failed");
+        let identity = Identity::deserialize_from(&mut reader)?;
 
         let frost_package = read_variable_length_bytes(&mut reader)?;
         let frost_package = Package::deserialize(&frost_package)?;
@@ -320,8 +320,7 @@ where
     )?;
 
     let encrypted_secret_package =
-        export_secret_package(&secret_package, self_identity, &mut csrng)
-            .map_err(IronfishFrostError::EncryptionError)?;
+        export_secret_package(&secret_package, self_identity, &mut csrng)?;
 
     let group_secret_key_shard = GroupSecretKeyShard::random(&mut csrng);
 

src/dkg/round2.rs

@@ -147,16 +147,16 @@ pub fn export_secret_package<R: RngCore + CryptoRng>(
     pkg: &SecretPackage,
     identity: &Identity,
     csrng: R,
-) -> io::Result<Vec<u8>> {
+) -> Result<Vec<u8>, IronfishFrostError> {
     let serializable = SerializableSecretPackage::from(pkg.clone());
     if serializable.identifier != identity.to_frost_identifier() {
-        return Err(io::Error::other("identity mismatch"));
+        return Err(IronfishFrostError::InvalidInput(
+            "identity mismatch".to_string(),
+        ));
     }
 
     let mut serialized = Vec::new();
-    serializable
-        .serialize_into(&mut serialized)
-        .expect("serialization failed");
+    serializable.serialize_into(&mut serialized)?;
     Ok(multienc::encrypt(&serialized, [identity], csrng))
 }
 
@@ -441,30 +441,38 @@ where
     }
 
     // Sanity check
-    assert_eq!(round1_public_packages.len(), identities.len());
-    assert_eq!(round1_public_packages.len(), round1_frost_packages.len());
+    if round1_public_packages.len() != identities.len()
+        || round1_public_packages.len() != round1_frost_packages.len()
+    {
+        return Err(IronfishFrostError::InvalidInput(
+            "incorrect number of packages or identities provided".to_string(),
+        ));
+    }
 
     // The public package for `self_identity` must be excluded from `frost::keys::dkg::part2`
     // inputs
     round1_frost_packages
         .remove(&self_identity.to_frost_identifier())
-        .expect("missing public package for self_identity");
+        .ok_or(IronfishFrostError::InvalidInput(
+            "missing public package for self_identity".to_string(),
+        ))?;
 
     // Run the FROST DKG round 2
     let (round2_secret_package, round2_packages) =
         frost::keys::dkg::part2(round1_secret_package.clone(), &round1_frost_packages)?;
 
     // Encrypt the secret package
     let encrypted_secret_package =
-        export_secret_package(&round2_secret_package, &self_identity, &mut csrng)
-            .map_err(IronfishFrostError::EncryptionError)?;
+        export_secret_package(&round2_secret_package, &self_identity, &mut csrng)?;
 
     // Convert the Identifier->Package map to an Identity->PublicPackage map
     let mut round2_public_packages = Vec::new();
     for (identifier, package) in round2_packages {
         let identity = *identities
             .get(&identifier)
-            .expect("round2 generated package for unknown identifier");
+            .ok_or(IronfishFrostError::InvalidInput(
+                "round2 generated package for unknown identifier".to_string(),
+            ))?;
 
         let public_package = PublicPackage::new(
             self_identity.clone(),
@@ -520,7 +528,9 @@ where
         let identity = Identity::deserialize_from(participant)?;
         let round2_public_package = round2_packages
             .remove(&identity.to_frost_identifier())
-            .expect("missing round 2 public package for participant");
+            .ok_or(IronfishFrostError::InvalidInput(
+                "missing round 2 public package for particiant".to_string(),
+            ))?;
         round2_public_packages.push(round2_public_package);
     }
 

src/dkg/round3.rs

@@ -210,7 +210,11 @@ where
     }
 
     // Sanity check
-    assert_eq!(round1_public_packages.len(), round1_frost_packages.len());
+    if round1_public_packages.len() != round1_frost_packages.len() {
+        return Err(IronfishFrostError::InvalidInput(
+            "incorrect number of round 1 packages provided".to_string(),
+        ));
+    }
 
     // The public package for `identity` must be excluded from `frost::keys::dkg::part3`
     // inputs
@@ -264,7 +268,11 @@ where
         }
     }
 
-    assert_eq!(round2_public_packages.len(), round2_frost_packages.len());
+    if round2_public_packages.len() != round2_frost_packages.len() {
+        return Err(IronfishFrostError::InvalidInput(
+            "incorrect number of round 2 packages provided".to_string(),
+        ));
+    }
 
     let (key_package, public_key_package) = part3(
         &round2_secret_package,