diff options
author | Justus Winter <justus@sequoia-pgp.org> | 2021-11-03 12:04:19 +0100 |
---|---|---|
committer | Justus Winter <justus@sequoia-pgp.org> | 2021-11-03 12:18:59 +0100 |
commit | 028ca6e0aeb3120cfdfdbf0cc6bf546cd6465171 (patch) | |
tree | b97f26bcb01706186526b5cb93fd9861f72fd485 /openpgp/src/crypto | |
parent | b78690261254350fc1a4e3475a913c5c998a3248 (diff) |
openpgp: Use dynamically dispatched buffered reader in Decryptor.
Diffstat (limited to 'openpgp/src/crypto')
-rw-r--r-- | openpgp/src/crypto/symmetric.rs | 70 |
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() } } |