openpgp: Use dynamically dispatched buffered reader in Decryptor.

1 files changed, 45 insertions, 25 deletions

diff --git a/openpgp/src/crypto/symmetric.rs b/openpgp/src/crypto/symmetric.rs
index 9d165814..6245d08a 100644
--- a/openpgp/src/crypto/symmetric.rs
+++ b/openpgp/src/crypto/symmetric.rs
@@ -7,6 +7,9 @@ use std::fmt;
 use crate::Result;
 use crate::SymmetricAlgorithm;
 use crate::{vec_resize, vec_truncate};
+use crate::{
+    parse::Cookie,
+};
 
 use buffered_reader::BufferedReader;
 
@@ -37,9 +40,9 @@ pub(crate) trait Mode: Send + Sync {
 }
 
 /// A `Read`er for decrypting symmetrically encrypted data.
-pub struct Decryptor<R: io::Read> {
+pub struct Decryptor<'a> {
     // The encrypted data.
-    source: R,
+    source: Box<dyn BufferedReader<Cookie> + 'a>,
 
     dec: Box<dyn Mode>,
     block_size: usize,
@@ -48,12 +51,28 @@ pub struct Decryptor<R: io::Read> {
     // Ciphertext buffer.
     ciphertext: Vec<u8>,
 }
-assert_send_and_sync!(Decryptor<R> where R: io::Read);
+assert_send_and_sync!(Decryptor<'_>);
+
+impl<'a> Decryptor<'a> {
+    /// Instantiate a new symmetric decryptor.
+    ///
+    /// `reader` is the source to wrap.
+    pub fn new<R>(algo: SymmetricAlgorithm, key: &[u8], source: R)
+                  -> Result<Self>
+    where
+        R: io::Read + Send + Sync + 'a,
+    {
+        Self::from_buffered_reader(
+            algo, key,
+            Box::new(buffered_reader::Generic::with_cookie(
+                source, None, Default::default())))
+    }
 
-impl<R: io::Read> Decryptor<R> {
-    /// Instantiate a new symmetric decryptor.  `reader` is the source
-    /// to wrap.
-    pub fn new(algo: SymmetricAlgorithm, key: &[u8], source: R) -> Result<Self> {
+    /// Instantiate a new symmetric decryptor.
+    fn from_buffered_reader(algo: SymmetricAlgorithm, key: &[u8],
+                            source: Box<dyn BufferedReader<Cookie> + 'a>)
+                            -> Result<Self>
+    {
         let block_size = algo.block_size()?;
         let iv = vec![0; block_size];
         let dec = algo.make_decrypt_cfb(key, iv)?;
@@ -105,7 +124,7 @@ fn read_exact<R: io::Read>(reader: &mut R, mut buffer: &mut [u8])
 // gratuitiously do a short read.  Specifically, if the return value
 // is less than `plaintext.len()`, then it is either because we
 // reached the end of the input or an error occurred.
-impl<R: io::Read> io::Read for Decryptor<R> {
+impl<'a> io::Read for Decryptor<'a> {
     fn read(&mut self, plaintext: &mut [u8]) -> io::Result<usize> {
         let mut pos = 0;
 
@@ -188,38 +207,40 @@ impl<R: io::Read> io::Read for Decryptor<R> {
 
 /// A `BufferedReader` that decrypts symmetrically-encrypted data as
 /// it is read.
-pub(crate) struct BufferedReaderDecryptor<R: BufferedReader<C>, C: fmt::Debug + Send + Sync> {
-    reader: buffered_reader::Generic<Decryptor<R>, C>,
+pub(crate) struct BufferedReaderDecryptor<'a> {
+    reader: buffered_reader::Generic<Decryptor<'a>, Cookie>,
 }
 
-impl <R: BufferedReader<C>, C: fmt::Debug + Send + Sync> BufferedReaderDecryptor<R, C> {
+impl<'a> BufferedReaderDecryptor<'a> {
     /// Like `new()`, but sets a cookie, which can be retrieved using
     /// the `cookie_ref` and `cookie_mut` methods, and set using
     /// the `cookie_set` method.
-    pub fn with_cookie(algo: SymmetricAlgorithm, key: &[u8], reader: R,
-                       cookie: C)
+    pub fn with_cookie(algo: SymmetricAlgorithm, key: &[u8],
+                       reader: Box<dyn BufferedReader<Cookie> + 'a>,
+                       cookie: Cookie)
         -> Result<Self>
     {
         Ok(BufferedReaderDecryptor {
             reader: buffered_reader::Generic::with_cookie(
-                Decryptor::new(algo, key, reader)?, None, cookie),
+                Decryptor::from_buffered_reader(algo, key, reader)?,
+                None, cookie),
         })
     }
 }
 
-impl<R: BufferedReader<C>, C: fmt::Debug + Send + Sync> io::Read for BufferedReaderDecryptor<R, C> {
+impl<'a> io::Read for BufferedReaderDecryptor<'a> {
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
         self.reader.read(buf)
     }
 }
 
-impl<R: BufferedReader<C>, C: fmt::Debug + Send + Sync> fmt::Display for BufferedReaderDecryptor<R, C> {
+impl<'a> fmt::Display for BufferedReaderDecryptor<'a> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "BufferedReaderDecryptor")
     }
 }
 
-impl<R: BufferedReader<C>, C: fmt::Debug + Send + Sync> fmt::Debug for BufferedReaderDecryptor<R, C> {
+impl<'a> fmt::Debug for BufferedReaderDecryptor<'a> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.debug_struct("BufferedReaderDecryptor")
             .field("reader", &self.get_ref().unwrap())
@@ -227,8 +248,7 @@ impl<R: BufferedReader<C>, C: fmt::Debug + Send + Sync> fmt::Debug for BufferedR
     }
 }
 
-impl<R: BufferedReader<C>, C: fmt::Debug + Send + Sync> BufferedReader<C>
-        for BufferedReaderDecryptor<R, C> {
+impl<'a> BufferedReader<Cookie> for BufferedReaderDecryptor<'a> {
     fn buffer(&self) -> &[u8] {
         self.reader.buffer()
     }
@@ -274,28 +294,28 @@ impl<R: BufferedReader<C>, C: fmt::Debug + Send + Sync> BufferedReader<C>
         self.reader.steal_eof()
     }
 
-    fn get_mut(&mut self) -> Option<&mut dyn BufferedReader<C>> {
+    fn get_mut(&mut self) -> Option<&mut dyn BufferedReader<Cookie>> {
         Some(&mut self.reader.reader_mut().source)
     }
 
-    fn get_ref(&self) -> Option<&dyn BufferedReader<C>> {
+    fn get_ref(&self) -> Option<&dyn BufferedReader<Cookie>> {
         Some(&self.reader.reader_ref().source)
     }
 
     fn into_inner<'b>(self: Box<Self>)
-            -> Option<Box<dyn BufferedReader<C> + 'b>> where Self: 'b {
+            -> Option<Box<dyn BufferedReader<Cookie> + 'b>> where Self: 'b {
         Some(self.reader.into_reader().source.as_boxed())
     }
 
-    fn cookie_set(&mut self, cookie: C) -> C {
+    fn cookie_set(&mut self, cookie: Cookie) -> Cookie {
         self.reader.cookie_set(cookie)
     }
 
-    fn cookie_ref(&self) -> &C {
+    fn cookie_ref(&self) -> &Cookie {
         self.reader.cookie_ref()
     }
 
-    fn cookie_mut(&mut self) -> &mut C {
+    fn cookie_mut(&mut self) -> &mut Cookie {
         self.reader.cookie_mut()
     }
 }