Replace AsynStreamCipher impl with inherent methods in CFB crates (#99)

It's a quick-and-dirty solution for the removal of the trait from
`cipher`. I plan to do a more involved rework later.

Author: newpavlov

cfb-mode/src/decrypt.rs

@@ -1,9 +1,9 @@
 use cipher::{
-    AlgorithmName, Array, AsyncStreamCipher, Block, BlockCipherDecrypt, BlockCipherEncBackend,
-    BlockCipherEncClosure, BlockCipherEncrypt, BlockModeDecBackend, BlockModeDecClosure,
-    BlockModeDecrypt, BlockSizeUser, InOut, InnerIvInit, Iv, IvSizeUser, IvState, ParBlocks,
-    ParBlocksSizeUser,
+    AlgorithmName, Array, Block, BlockCipherDecrypt, BlockCipherEncBackend, BlockCipherEncClosure,
+    BlockCipherEncrypt, BlockModeDecBackend, BlockModeDecClosure, BlockModeDecrypt, BlockSizeUser,
+    InnerIvInit, Iv, IvSizeUser, IvState, ParBlocks, ParBlocksSizeUser,
     common::{BlockSizes, InnerUser},
+    inout::{InOut, InOutBuf, NotEqualError},
     typenum::Unsigned,
 };
 use core::fmt;
@@ -186,7 +186,36 @@ where
     }
 }
 
-impl<C> AsyncStreamCipher for Decryptor<C> where C: BlockCipherEncrypt {}
+impl<C> Decryptor<C>
+where
+    C: BlockCipherEncrypt,
+{
+    /// Decrypt data using `InOutBuf`.
+    pub fn decrypt_inout(mut self, data: InOutBuf<'_, '_, u8>) {
+        let (blocks, mut tail) = data.into_chunks();
+        self.decrypt_blocks_inout(blocks);
+        let n = tail.len();
+        if n != 0 {
+            let mut block = Block::<Self>::default();
+            block[..n].copy_from_slice(tail.get_in());
+            self.decrypt_block(&mut block);
+            tail.get_out().copy_from_slice(&block[..n]);
+        }
+    }
+
+    /// Decrypt data in place.
+    pub fn decrypt(self, buf: &mut [u8]) {
+        self.decrypt_inout(buf.into());
+    }
+
+    /// Decrypt data from buffer to buffer.
+    ///
+    /// # Errors
+    /// If `in_buf` and `out_buf` have different lengths.
+    pub fn decrypt_b2b(self, in_buf: &[u8], out_buf: &mut [u8]) -> Result<(), NotEqualError> {
+        InOutBuf::new(in_buf, out_buf).map(|b| self.decrypt_inout(b))
+    }
+}
 
 impl<C> InnerUser for Decryptor<C>
 where

cfb-mode/src/encrypt.rs

@@ -1,11 +1,11 @@
 use cipher::{
-    AlgorithmName, AsyncStreamCipher, Block, BlockCipherDecrypt, BlockCipherEncBackend,
-    BlockCipherEncClosure, BlockCipherEncrypt, BlockModeEncBackend, BlockModeEncClosure,
-    BlockModeEncrypt, BlockSizeUser, InOut, InnerIvInit, Iv, IvSizeUser, IvState,
-    ParBlocksSizeUser,
+    AlgorithmName, Block, BlockCipherDecrypt, BlockCipherEncBackend, BlockCipherEncClosure,
+    BlockCipherEncrypt, BlockModeEncBackend, BlockModeEncClosure, BlockModeEncrypt, BlockSizeUser,
+    InnerIvInit, Iv, IvSizeUser, IvState, ParBlocksSizeUser,
     array::Array,
     common::{BlockSizes, InnerUser},
     consts::U1,
+    inout::{InOut, InOutBuf, NotEqualError},
 };
 use core::fmt;
 
@@ -75,7 +75,36 @@ where
     }
 }
 
-impl<C> AsyncStreamCipher for Encryptor<C> where C: BlockCipherEncrypt {}
+impl<C> Encryptor<C>
+where
+    C: BlockCipherEncrypt,
+{
+    /// Encrypt data using `InOutBuf`.
+    pub fn encrypt_inout(mut self, data: InOutBuf<'_, '_, u8>) {
+        let (blocks, mut tail) = data.into_chunks();
+        self.encrypt_blocks_inout(blocks);
+        let n = tail.len();
+        if n != 0 {
+            let mut block = Block::<Self>::default();
+            block[..n].copy_from_slice(tail.get_in());
+            self.encrypt_block(&mut block);
+            tail.get_out().copy_from_slice(&block[..n]);
+        }
+    }
+
+    /// Encrypt data in place.
+    pub fn encrypt(self, buf: &mut [u8]) {
+        self.encrypt_inout(buf.into());
+    }
+
+    /// Encrypt data from buffer to buffer.
+    ///
+    /// # Errors
+    /// If `in_buf` and `out_buf` have different lengths.
+    pub fn encrypt_b2b(self, in_buf: &[u8], out_buf: &mut [u8]) -> Result<(), NotEqualError> {
+        InOutBuf::new(in_buf, out_buf).map(|b| self.encrypt_inout(b))
+    }
+}
 
 impl<C> InnerUser for Encryptor<C>
 where

cfb-mode/src/lib.rs

@@ -14,7 +14,7 @@
 //!
 //! # Example
 //! ```
-//! use aes::cipher::{AsyncStreamCipher, KeyIvInit};
+//! use aes::cipher::KeyIvInit;
 //! use hex_literal::hex;
 //!
 //! type Aes128CfbEnc = cfb_mode::Encryptor<aes::Aes128>;

cfb-mode/tests/async_stream.rs

@@ -1,12 +1,10 @@
-//! Tests for the `AsyncStreamCipher` trait methods
+//! Tests for inherent methods
 use aes::*;
 use cfb_mode::{BufDecryptor, BufEncryptor, Decryptor, Encryptor};
-use cipher::KeyInit;
+use cipher::{KeyInit, KeyIvInit};
 
 #[test]
 fn aes128_cfb_async_test() {
-    use cipher::{AsyncStreamCipher, KeyIvInit};
-
     type Enc = Encryptor<Aes128>;
     type Dec = Decryptor<Aes128>;
 
@@ -34,8 +32,6 @@ fn aes128_cfb_async_test() {
 
 #[test]
 fn aes128_cfb_buffered_test() {
-    use cipher::{AsyncStreamCipher, KeyIvInit};
-
     type Enc = Encryptor<Aes128>;
 
     type BufEnc = BufEncryptor<Aes128>;

cfb8/src/decrypt.rs

@@ -1,11 +1,11 @@
 use cipher::{
-    AlgorithmName, AsyncStreamCipher, Block, BlockCipherEncBackend, BlockCipherEncClosure,
-    BlockCipherEncrypt, BlockModeDecBackend, BlockModeDecClosure, BlockModeDecrypt, BlockSizeUser,
-    InnerIvInit, Iv, IvState, ParBlocksSizeUser,
+    AlgorithmName, Block, BlockCipherEncBackend, BlockCipherEncClosure, BlockCipherEncrypt,
+    BlockModeDecBackend, BlockModeDecClosure, BlockModeDecrypt, BlockSizeUser, InnerIvInit, Iv,
+    IvState, ParBlocksSizeUser,
     array::Array,
     common::{BlockSizes, InnerUser, IvSizeUser},
     consts::U1,
-    inout::InOut,
+    inout::{InOut, InOutBuf, NotEqualError},
 };
 use core::fmt;
 
@@ -67,7 +67,36 @@ where
     }
 }
 
-impl<C: BlockCipherEncrypt> AsyncStreamCipher for Decryptor<C> {}
+impl<C> Decryptor<C>
+where
+    C: BlockCipherEncrypt,
+{
+    /// Decrypt data using `InOutBuf`.
+    pub fn decrypt_inout(&mut self, data: InOutBuf<'_, '_, u8>) {
+        let (blocks, mut tail) = data.into_chunks();
+        self.decrypt_blocks_inout(blocks);
+        let n = tail.len();
+        if n != 0 {
+            let mut block = Block::<Self>::default();
+            block[..n].copy_from_slice(tail.get_in());
+            self.decrypt_block(&mut block);
+            tail.get_out().copy_from_slice(&block[..n]);
+        }
+    }
+
+    /// Decrypt data in place.
+    pub fn decrypt(&mut self, buf: &mut [u8]) {
+        self.decrypt_inout(buf.into());
+    }
+
+    /// Decrypt data from buffer to buffer.
+    ///
+    /// # Errors
+    /// If `in_buf` and `out_buf` have different lengths.
+    pub fn decrypt_b2b(&mut self, in_buf: &[u8], out_buf: &mut [u8]) -> Result<(), NotEqualError> {
+        InOutBuf::new(in_buf, out_buf).map(|b| self.decrypt_inout(b))
+    }
+}
 
 impl<C> InnerUser for Decryptor<C>
 where

cfb8/src/encrypt.rs

@@ -1,11 +1,11 @@
 use cipher::{
-    AlgorithmName, AsyncStreamCipher, Block, BlockCipherEncBackend, BlockCipherEncClosure,
-    BlockCipherEncrypt, BlockModeEncBackend, BlockModeEncClosure, BlockModeEncrypt, BlockSizeUser,
-    InnerIvInit, Iv, IvState, ParBlocksSizeUser,
+    AlgorithmName, Block, BlockCipherEncBackend, BlockCipherEncClosure, BlockCipherEncrypt,
+    BlockModeEncBackend, BlockModeEncClosure, BlockModeEncrypt, BlockSizeUser, InnerIvInit, Iv,
+    IvState, ParBlocksSizeUser,
     array::Array,
     common::{BlockSizes, InnerUser, IvSizeUser},
     consts::U1,
-    inout::InOut,
+    inout::{InOut, InOutBuf, NotEqualError},
 };
 use core::fmt;
 
@@ -67,7 +67,36 @@ where
     }
 }
 
-impl<C: BlockCipherEncrypt> AsyncStreamCipher for Encryptor<C> {}
+impl<C> Encryptor<C>
+where
+    C: BlockCipherEncrypt,
+{
+    /// Encrypt data using `InOutBuf`.
+    pub fn encrypt_inout(&mut self, data: InOutBuf<'_, '_, u8>) {
+        let (blocks, mut tail) = data.into_chunks();
+        self.encrypt_blocks_inout(blocks);
+        let n = tail.len();
+        if n != 0 {
+            let mut block = Block::<Self>::default();
+            block[..n].copy_from_slice(tail.get_in());
+            self.encrypt_block(&mut block);
+            tail.get_out().copy_from_slice(&block[..n]);
+        }
+    }
+
+    /// Encrypt data in place.
+    pub fn encrypt(&mut self, buf: &mut [u8]) {
+        self.encrypt_inout(buf.into());
+    }
+
+    /// Encrypt data from buffer to buffer.
+    ///
+    /// # Errors
+    /// If `in_buf` and `out_buf` have different lengths.
+    pub fn encrypt_b2b(&mut self, in_buf: &[u8], out_buf: &mut [u8]) -> Result<(), NotEqualError> {
+        InOutBuf::new(in_buf, out_buf).map(|b| self.encrypt_inout(b))
+    }
+}
 
 impl<C> InnerUser for Encryptor<C>
 where

cfb8/src/lib.rs

@@ -14,7 +14,7 @@
 //!
 //! # Example
 //! ```
-//! use aes::cipher::{AsyncStreamCipher, KeyIvInit};
+//! use aes::cipher::KeyIvInit;
 //! use hex_literal::hex;
 //!
 //! type Aes128Cfb8Enc = cfb8::Encryptor<aes::Aes128>;

cfb8/tests/async_stream.rs

@@ -1,7 +1,7 @@
-//! Tests for the [`AsyncStreamCipher`] methods.
+//! Tests for inherent methods.
 use aes::*;
 use cfb8::{Decryptor, Encryptor};
-use cipher::{AsyncStreamCipher, KeyIvInit};
+use cipher::KeyIvInit;
 
 #[test]
 fn aes128_cfb8_async_test() {
@@ -14,17 +14,17 @@ fn aes128_cfb8_async_test() {
     for (i, b) in pt.iter_mut().enumerate() {
         *b = (i % 11) as u8;
     }
-    let enc = Enc::new_from_slices(&key, &iv).unwrap();
+    let mut enc = Enc::new_from_slices(&key, &iv).unwrap();
     let mut ct = pt;
     enc.encrypt(&mut ct);
     for i in 1..100 {
-        let enc = Enc::new_from_slices(&key, &iv).unwrap();
+        let mut enc = Enc::new_from_slices(&key, &iv).unwrap();
         let mut t = pt;
         let t = &mut t[..i];
         enc.encrypt(t);
         assert_eq!(t, &ct[..i]);
 
-        let dec = Dec::new_from_slices(&key, &iv).unwrap();
+        let mut dec = Dec::new_from_slices(&key, &iv).unwrap();
         dec.decrypt(t);
         assert_eq!(t, &pt[..i]);
     }