fix: make hashers panicing less

Author: vmx

storage-proofs/benches/encode.rs

@@ -54,7 +54,7 @@ fn encode_single_node<H: Hasher>(
 
     let node_data = H::Domain::try_from_bytes(&data[start..end]).unwrap();
     let key_data = H::Domain::try_from_bytes(&key).unwrap();
-    let encoded = H::sloth_encode(&key_data, &node_data);
+    let encoded = H::sloth_encode(&key_data, &node_data).unwrap();
     encoded.write_bytes(&mut data[start..end]).unwrap();
 }
 

storage-proofs/src/drgporep.rs

@@ -459,7 +459,7 @@ where
             let end = start + NODE_SIZE;
 
             let node_data = H::Domain::try_from_bytes(&data[start..end])?;
-            let encoded = H::sloth_encode(key.as_ref(), &node_data);
+            let encoded = H::sloth_encode(key.as_ref(), &node_data)?;
 
             encoded.write_bytes(&mut data[start..end])?;
         }

storage-proofs/src/hasher/blake2s.rs

@@ -38,17 +38,17 @@ impl Hasher for Blake2sHasher {
         Ok(<Self::Function as HashFunction<Self::Domain>>::hash(data))
     }
 
-    fn sloth_encode(key: &Self::Domain, ciphertext: &Self::Domain) -> Self::Domain {
+    fn sloth_encode(key: &Self::Domain, ciphertext: &Self::Domain) -> Result<Self::Domain> {
         // TODO: validate this is how sloth should work in this case
         let k = (*key).into();
         let c = (*ciphertext).into();
 
-        sloth::encode::<Bls12>(&k, &c).into()
+        Ok(sloth::encode::<Bls12>(&k, &c).into())
     }
 
-    fn sloth_decode(key: &Self::Domain, ciphertext: &Self::Domain) -> Self::Domain {
+    fn sloth_decode(key: &Self::Domain, ciphertext: &Self::Domain) -> Result<Self::Domain> {
         // TODO: validate this is how sloth should work in this case
-        sloth::decode::<Bls12>(&(*key).into(), &(*ciphertext).into()).into()
+        Ok(sloth::decode::<Bls12>(&(*key).into(), &(*ciphertext).into()).into())
     }
 }
 
@@ -247,8 +247,8 @@ impl HashFunction<Blake2sDomain> for Blake2sFunction {
             Some(_) => {
                 let bits = alloc_bits
                     .iter()
-                    .map(|v| v.get_value().unwrap())
-                    .collect::<Vec<bool>>();
+                    .map(|v| v.get_value().ok_or(SynthesisError::AssignmentMissing))
+                    .collect::<std::result::Result<Vec<bool>, SynthesisError>>()?;
                 // TODO: figure out if we can avoid this
                 let frs = multipack::compute_multipacking::<E>(&bits);
                 Ok(frs[0])

storage-proofs/src/hasher/pedersen.rs

@@ -32,20 +32,20 @@ impl Hasher for PedersenHasher {
     }
 
     #[inline]
-    fn sloth_encode(key: &Self::Domain, ciphertext: &Self::Domain) -> Self::Domain {
+    fn sloth_encode(key: &Self::Domain, ciphertext: &Self::Domain) -> Result<Self::Domain> {
         // Unrapping here is safe; `Fr` elements and hash domain elements are the same byte length.
-        let key = Fr::from_repr(key.0).unwrap();
-        let ciphertext = Fr::from_repr(ciphertext.0).unwrap();
-        sloth::encode::<Bls12>(&key, &ciphertext).into()
+        let key = Fr::from_repr(key.0)?;
+        let ciphertext = Fr::from_repr(ciphertext.0)?;
+        Ok(sloth::encode::<Bls12>(&key, &ciphertext).into())
     }
 
     #[inline]
-    fn sloth_decode(key: &Self::Domain, ciphertext: &Self::Domain) -> Self::Domain {
+    fn sloth_decode(key: &Self::Domain, ciphertext: &Self::Domain) -> Result<Self::Domain> {
         // Unrapping here is safe; `Fr` elements and hash domain elements are the same byte length.
-        let key = Fr::from_repr(key.0).unwrap();
-        let ciphertext = Fr::from_repr(ciphertext.0).unwrap();
+        let key = Fr::from_repr(key.0)?;
+        let ciphertext = Fr::from_repr(ciphertext.0)?;
 
-        sloth::decode::<Bls12>(&key, &ciphertext).into()
+        Ok(sloth::decode::<Bls12>(&key, &ciphertext).into())
     }
 }
 

storage-proofs/src/hasher/sha256.rs

@@ -30,17 +30,17 @@ impl Hasher for Sha256Hasher {
         Ok(<Self::Function as HashFunction<Self::Domain>>::hash(data))
     }
 
-    fn sloth_encode(key: &Self::Domain, ciphertext: &Self::Domain) -> Self::Domain {
+    fn sloth_encode(key: &Self::Domain, ciphertext: &Self::Domain) -> Result<Self::Domain> {
         // TODO: validate this is how sloth should work in this case
         let k = (*key).into();
         let c = (*ciphertext).into();
 
-        sloth::encode::<Bls12>(&k, &c).into()
+        Ok(sloth::encode::<Bls12>(&k, &c).into())
     }
 
-    fn sloth_decode(key: &Self::Domain, ciphertext: &Self::Domain) -> Self::Domain {
+    fn sloth_decode(key: &Self::Domain, ciphertext: &Self::Domain) -> Result<Self::Domain> {
         // TODO: validate this is how sloth should work in this case
-        sloth::decode::<Bls12>(&(*key).into(), &(*ciphertext).into()).into()
+        Ok(sloth::decode::<Bls12>(&(*key).into(), &(*ciphertext).into()).into())
     }
 }
 
@@ -223,8 +223,8 @@ impl HashFunction<Sha256Domain> for Sha256Function {
         let fr = if alloc_bits[0].get_value().is_some() {
             let be_bits = alloc_bits
                 .iter()
-                .map(|v| v.get_value().unwrap())
-                .collect::<Vec<bool>>();
+                .map(|v| v.get_value().ok_or(SynthesisError::AssignmentMissing))
+                .collect::<std::result::Result<Vec<bool>, SynthesisError>>()?;
 
             let le_bits = be_bits
                 .chunks(8)

storage-proofs/src/hasher/types.rs

@@ -74,8 +74,8 @@ pub trait Hasher: Clone + ::std::fmt::Debug + Eq + Default + Send + Sync {
     type Function: HashFunction<Self::Domain>;
 
     fn create_label(data: &[u8], m: usize) -> Result<Self::Domain>;
-    fn sloth_encode(key: &Self::Domain, ciphertext: &Self::Domain) -> Self::Domain;
-    fn sloth_decode(key: &Self::Domain, ciphertext: &Self::Domain) -> Self::Domain;
+    fn sloth_encode(key: &Self::Domain, ciphertext: &Self::Domain) -> Result<Self::Domain>;
+    fn sloth_decode(key: &Self::Domain, ciphertext: &Self::Domain) -> Result<Self::Domain>;
 
     fn name() -> String;
 }