openpgp: Don't unwrap.

2 files changed, 26 insertions, 10 deletions

diff --git a/openpgp/src/parse.rs b/openpgp/src/parse.rs
index 0b6975de..e011576d 100644
--- a/openpgp/src/parse.rs
+++ b/openpgp/src/parse.rs
@@ -2043,7 +2043,7 @@ impl OnePassSig3 {
         assert!(! fake_eof);
 
         let mut reader = HashedReader::new(
-            reader, want_hashes_for, algos);
+            reader, want_hashes_for, algos)?;
         reader.cookie_mut().level = Some(recursion_depth - 1);
         // Account for this OPS packet.
         reader.cookie_mut().sig_group_mut().ops_count += 1;
@@ -5390,7 +5390,7 @@ impl<'a> PacketParser<'a> {
                 // And the hasher.
                 let mut reader = HashedReader::new(
                     reader, HashesFor::MDC,
-                    vec![HashingMode::Binary(HashAlgorithm::SHA1)]);
+                    vec![HashingMode::Binary(HashAlgorithm::SHA1)])?;
                 reader.cookie_mut().level = Some(self.recursion_depth());
 
                 t!("Pushing HashedReader, level {:?}.",
diff --git a/openpgp/src/parse/hashed_reader.rs b/openpgp/src/parse/hashed_reader.rs
index e122a1db..1ec70d62 100644
--- a/openpgp/src/parse/hashed_reader.rs
+++ b/openpgp/src/parse/hashed_reader.rs
@@ -72,6 +72,16 @@ impl<T> HashingMode<T> {
         }
     }
 
+    pub(crate) fn mapf<U, F: Fn(T) -> Result<U>>(self, f: F)
+                                                 -> Result<HashingMode<U>> {
+        use self::HashingMode::*;
+        match self {
+            Binary(t) => Ok(Binary(f(t)?)),
+            Text(t) => Ok(Text(f(t)?)),
+            TextLastWasCr(t) => Ok(TextLastWasCr(f(t)?)),
+        }
+    }
+
     pub(crate) fn as_ref(&self) -> &T {
         use self::HashingMode::*;
         match self {
@@ -208,18 +218,24 @@ impl<R: BufferedReader<Cookie>> HashedReader<R> {
     /// compute the hash.
     pub fn new(reader: R, hashes_for: HashesFor,
                algos: Vec<HashingMode<HashAlgorithm>>)
-            -> Self {
+            -> Result<Self> {
         let mut cookie = Cookie::default();
-        for mode in &algos {
-            cookie.sig_group_mut().hashes
-                .push(mode.map(|algo| algo.context().unwrap())); // XXX: Don't unwrap.
+
+        for mode in algos {
+            let mode = mode.mapf(|algo| {
+                let ctx = algo.context()?;
+                Ok(ctx)
+            })?;
+
+            cookie.sig_group_mut().hashes.push(mode);
         }
+
         cookie.hashes_for = hashes_for;
 
-        HashedReader {
+        Ok(HashedReader {
             reader,
             cookie,
-        }
+        })
     }
 }
 
@@ -489,7 +505,7 @@ pub(crate) fn hash_buffered_reader<R>(reader: R,
     where R: BufferedReader<crate::parse::Cookie>,
 {
     let mut reader
-        = HashedReader::new(reader, HashesFor::Signature, algos.to_vec());
+        = HashedReader::new(reader, HashesFor::Signature, algos.to_vec())?;
 
     // Hash all of the data.
     reader.drop_eof()?;
@@ -546,7 +562,7 @@ mod test {
                 = HashedReader::new(reader, HashesFor::MDC,
                                     test.expected.keys().cloned()
                                     .map(HashingMode::Binary)
-                                    .collect());
+                                    .collect()).unwrap();
 
             assert_eq!(reader.steal_eof().unwrap(), test.data);