finish inout migration

Author: baloo

aes-gcm-siv/src/lib.rs

@@ -278,10 +278,10 @@ where
         }
 
         self.polyval.update_padded(associated_data);
-        self.polyval.update_padded(buffer);
+        self.polyval.update_padded(buffer.get_in());
 
         let tag = self.finish_tag(associated_data.len(), buffer.len());
-        init_ctr(&self.enc_cipher, &tag).apply_keystream_partial(buffer.into());
+        init_ctr(&self.enc_cipher, &tag).apply_keystream_partial(buffer);
 
         Ok(tag)
     }
@@ -291,7 +291,7 @@ where
     pub(crate) fn decrypt_inout_detached(
         mut self,
         associated_data: &[u8],
-        buffer: InOutBuf<'_, '_, u8>,
+        mut buffer: InOutBuf<'_, '_, u8>,
         tag: &Tag,
     ) -> Result<(), Error> {
         if buffer.len() as u64 > C_MAX || associated_data.len() as u64 > A_MAX {
@@ -301,8 +301,8 @@ where
         self.polyval.update_padded(associated_data);
 
         // TODO(tarcieri): interleave decryption and authentication
-        init_ctr(&self.enc_cipher, tag).apply_keystream_partial(buffer.into());
-        self.polyval.update_padded(buffer);
+        init_ctr(&self.enc_cipher, tag).apply_keystream_partial(buffer.reborrow());
+        self.polyval.update_padded(buffer.get_in());
 
         let expected_tag = self.finish_tag(associated_data.len(), buffer.len());
 
@@ -312,7 +312,7 @@ where
         } else {
             // On MAC verify failure, re-encrypt the plaintext buffer to
             // prevent accidental exposure.
-            init_ctr(&self.enc_cipher, tag).apply_keystream_partial(buffer.into());
+            init_ctr(&self.enc_cipher, tag).apply_keystream_partial(buffer);
             Err(Error)
         }
     }

aes-gcm/src/lib.rs

@@ -270,7 +270,7 @@ where
         &self,
         nonce: &Nonce<NonceSize>,
         associated_data: &[u8],
-        buffer: InOutBuf<'_, '_, u8>,
+        mut buffer: InOutBuf<'_, '_, u8>,
     ) -> Result<Tag<TagSize>, Error> {
         if buffer.len() as u64 > P_MAX || associated_data.len() as u64 > A_MAX {
             return Err(Error);
@@ -280,17 +280,17 @@ where
 
         // TODO(tarcieri): interleave encryption with GHASH
         // See: <https://github.com/RustCrypto/AEADs/issues/74>
-        ctr.apply_keystream_partial(buffer.into());
+        ctr.apply_keystream_partial(buffer.reborrow());
 
-        let full_tag = self.compute_tag(mask, associated_data, buffer);
+        let full_tag = self.compute_tag(mask, associated_data, buffer.get_in());
         Ok(Tag::try_from(&full_tag[..TagSize::to_usize()]).expect("tag size mismatch"))
     }
 
     fn decrypt_inout_detached(
         &self,
         nonce: &Nonce<NonceSize>,
         associated_data: &[u8],
-        buffer: InOutBuf<'_, '_, u8>,
+        mut buffer: InOutBuf<'_, '_, u8>,
         tag: &Tag<TagSize>,
     ) -> Result<(), Error> {
         if buffer.len() as u64 > C_MAX || associated_data.len() as u64 > A_MAX {
@@ -301,7 +301,7 @@ where
 
         // TODO(tarcieri): interleave encryption with GHASH
         // See: <https://github.com/RustCrypto/AEADs/issues/74>
-        let expected_tag = self.compute_tag(mask, associated_data, buffer);
+        let expected_tag = self.compute_tag(mask, associated_data, buffer.get_out());
 
         use subtle::ConstantTimeEq;
         if expected_tag[..TagSize::to_usize()].ct_eq(tag).into() {

aes-gcm/tests/common/mod.rs

@@ -90,11 +90,9 @@ macro_rules! tests {
             tag[0] ^= 0xaa;
 
             let cipher = <$aead>::new(&key);
-            assert!(
-                cipher
-                    .decrypt_inout_detached(&nonce, &[], &mut buffer, &tag)
-                    .is_err()
-            );
+            assert!(cipher
+                .decrypt_inout_detached(&nonce, &[], (buffer.as_mut_slice()).into(), &tag)
+                .is_err());
 
             assert_eq!(vector.ciphertext, buffer);
         }

aes-siv/src/siv.rs

@@ -70,9 +70,9 @@
 
 use crate::Tag;
 use aead::{
-    Buffer, Error,
-    array::{Array, ArraySize, typenum::U16},
+    array::{typenum::U16, Array, ArraySize},
     inout::InOutBuf,
+    Buffer, Error,
 };
 use aes::{Aes128, Aes256};
 use cipher::{
@@ -213,7 +213,7 @@ where
         // TODO(tarcieri): add offset param to `encrypt_inout_detached`
         buffer.as_mut().copy_within(..pt_len, IV_SIZE);
 
-        let tag = self.encrypt_inout_detached(headers, &mut buffer.as_mut()[IV_SIZE..])?;
+        let tag = self.encrypt_inout_detached(headers, (&mut buffer.as_mut()[IV_SIZE..]).into())?;
         buffer.as_mut()[..IV_SIZE].copy_from_slice(tag.as_slice());
         Ok(())
     }
@@ -227,15 +227,15 @@ where
     pub fn encrypt_inout_detached<I, T>(
         &mut self,
         headers: I,
-        plaintext: InOutBuf<'_, '_, u8>,
+        mut plaintext: InOutBuf<'_, '_, u8>,
     ) -> Result<Tag, Error>
     where
         I: IntoIterator<Item = T>,
         T: AsRef<[u8]>,
     {
         // Compute the synthetic IV for this plaintext
-        let siv_tag = s2v(&mut self.mac, headers, plaintext)?;
-        self.xor_with_keystream(siv_tag, plaintext);
+        let siv_tag = s2v(&mut self.mac, headers, plaintext.get_in())?;
+        self.xor_with_keystream(siv_tag, plaintext.get_out());
         Ok(siv_tag)
     }
 
@@ -271,7 +271,7 @@ where
         }
 
         let siv_tag = Tag::try_from(&buffer.as_ref()[..IV_SIZE]).expect("tag size mismatch");
-        self.decrypt_inout_detached(headers, &mut buffer.as_mut()[IV_SIZE..], &siv_tag)?;
+        self.decrypt_inout_detached(headers, (&mut buffer.as_mut()[IV_SIZE..]).into(), &siv_tag)?;
 
         let pt_len = buffer.len() - IV_SIZE;
 
@@ -290,22 +290,22 @@ where
     pub fn decrypt_inout_detached<I, T>(
         &mut self,
         headers: I,
-        ciphertext: InOutBuf<'_, '_, u8>,
+        mut ciphertext: InOutBuf<'_, '_, u8>,
         siv_tag: &Tag,
     ) -> Result<(), Error>
     where
         I: IntoIterator<Item = T>,
         T: AsRef<[u8]>,
     {
-        self.xor_with_keystream(*siv_tag, ciphertext);
-        let computed_siv_tag = s2v(&mut self.mac, headers, ciphertext)?;
+        self.xor_with_keystream(*siv_tag, ciphertext.get_out());
+        let computed_siv_tag = s2v(&mut self.mac, headers, ciphertext.get_in())?;
 
         // Note: `CtOutput` provides constant-time equality
         if CtOutput::<M>::new(computed_siv_tag) == CtOutput::new(*siv_tag) {
             Ok(())
         } else {
             // Re-encrypt the decrypted plaintext to avoid revealing it
-            self.xor_with_keystream(*siv_tag, ciphertext);
+            self.xor_with_keystream(*siv_tag, ciphertext.get_out());
             Err(Error)
         }
     }

aes-siv/tests/aead.rs

@@ -40,7 +40,7 @@ macro_rules! tests {
 
                 let cipher = <$aead>::new(&key);
                 let tag = cipher
-                    .encrypt_inout_detached(&nonce, vector.aad, &mut buffer)
+                    .encrypt_inout_detached(&nonce, vector.aad, buffer.as_mut_slice().into())
                     .unwrap();
                 let (expected_tag, expected_ciphertext) = vector.ciphertext.split_at(16);
                 assert_eq!(expected_tag, &tag[..]);
@@ -75,7 +75,7 @@ macro_rules! tests {
                 let mut buffer = vector.ciphertext[16..].to_vec();
 
                 <$aead>::new(&key)
-                    .decrypt_inout_detached(&nonce, vector.aad, &mut buffer, &tag)
+                    .decrypt_inout_detached(&nonce, vector.aad, buffer.as_mut_slice().into(), &tag)
                     .unwrap();
 
                 assert_eq!(vector.plaintext, buffer.as_slice());
@@ -107,8 +107,8 @@ macro_rules! tests {
 
 mod aes128cmacsivaead {
     use super::TestVector;
+    use aes_siv::aead::{array::Array, Aead, AeadInOut, KeyInit, Payload};
     use aes_siv::Aes128SivAead;
-    use aes_siv::aead::{Aead, AeadInOut, KeyInit, Payload, array::Array};
 
     /// AES-128-CMAC-SIV test vectors
     const TEST_VECTORS: &[TestVector<[u8; 32]>] = &[TestVector {
@@ -131,8 +131,8 @@ mod aes128cmacsivaead {
 #[cfg(feature = "pmac")]
 mod aes128pmacsivaead {
     use super::TestVector;
+    use aes_siv::aead::{array::Array, Aead, AeadInOut, KeyInit, Payload};
     use aes_siv::Aes128PmacSivAead;
-    use aes_siv::aead::{Aead, AeadInOut, KeyInit, Payload, array::Array};
 
     /// AES-128-PMAC-SIV test vectors
     const AES_128_PMAC_SIV_TEST_VECTORS: &[TestVector<[u8; 32]>] = &[TestVector {

ascon-aead/src/asconcore.rs

@@ -2,11 +2,12 @@
 // SPDX-License-Identifier: Apache-2.0 OR MIT
 
 use aead::{
-    Error,
-    array::{Array, ArraySize, typenum::Unsigned},
+    array::{typenum::Unsigned, Array, ArraySize},
     consts::{U16, U20},
+    inout::InOutBuf,
+    Error,
 };
-use ascon::{State, pad};
+use ascon::{pad, State};
 use subtle::ConstantTimeEq;
 
 /// Clear bytes from a 64 bit word.
@@ -339,28 +340,28 @@ impl<'a, P: Parameters> AsconCore<'a, P> {
 
     pub(crate) fn encrypt_inplace(
         &mut self,
-        message: &mut [u8],
+        mut message: InOutBuf<'_, '_, u8>,
         associated_data: &[u8],
     ) -> Array<u8, U16> {
         self.process_associated_data(associated_data);
-        self.process_encrypt_inplace(message);
+        self.process_encrypt_inplace(message.get_out());
         Array::from(self.process_final())
     }
 
     pub(crate) fn decrypt_inplace(
         &mut self,
-        ciphertext: &mut [u8],
+        mut ciphertext: InOutBuf<'_, '_, u8>,
         associated_data: &[u8],
         expected_tag: &Array<u8, U16>,
     ) -> Result<(), Error> {
         self.process_associated_data(associated_data);
-        self.process_decrypt_inplace(ciphertext);
+        self.process_decrypt_inplace(ciphertext.get_out());
 
         let tag = self.process_final();
         if bool::from(tag.ct_eq(expected_tag)) {
             Ok(())
         } else {
-            ciphertext.fill(0);
+            ciphertext.get_out().fill(0);
             Err(Error)
         }
     }

ccm/src/lib.rs

@@ -232,9 +232,9 @@ where
         &self,
         nonce: &Nonce<N>,
         adata: &[u8],
-        buffer: InOutBuf<'_, '_, u8>,
+        mut buffer: InOutBuf<'_, '_, u8>,
     ) -> Result<Tag<Self::TagSize>, Error> {
-        let mut full_tag = self.calc_mac(nonce, adata, buffer)?;
+        let mut full_tag = self.calc_mac(nonce, adata, buffer.get_in())?;
 
         let ext_nonce = Self::extend_nonce(nonce);
         // number of bytes left for counter (max 8)
@@ -243,11 +243,11 @@ where
         if cb > 4 {
             let mut ctr = Ctr64BE::from_core(CtrCore::inner_iv_init(&self.cipher, &ext_nonce));
             ctr.apply_keystream(&mut full_tag);
-            ctr.apply_keystream(buffer);
+            ctr.apply_keystream(buffer.get_out());
         } else {
             let mut ctr = Ctr32BE::from_core(CtrCore::inner_iv_init(&self.cipher, &ext_nonce));
             ctr.apply_keystream(&mut full_tag);
-            ctr.apply_keystream(buffer);
+            ctr.apply_keystream(buffer.get_out());
         }
 
         Ok(Tag::try_from(&full_tag[..M::to_usize()]).expect("tag size mismatch"))
@@ -257,7 +257,7 @@ where
         &self,
         nonce: &Nonce<N>,
         adata: &[u8],
-        buffer: InOutBuf<'_, '_, u8>,
+        mut buffer: InOutBuf<'_, '_, u8>,
         tag: &Tag<Self::TagSize>,
     ) -> Result<(), Error> {
         let ext_nonce = Self::extend_nonce(nonce);
@@ -267,14 +267,14 @@ where
         if cb > 4 {
             let mut ctr = Ctr64BE::from_core(CtrCore::inner_iv_init(&self.cipher, &ext_nonce));
             ctr.seek(C::BlockSize::USIZE);
-            ctr.apply_keystream(buffer);
+            ctr.apply_keystream(buffer.get_out());
         } else {
             let mut ctr = Ctr32BE::from_core(CtrCore::inner_iv_init(&self.cipher, &ext_nonce));
             ctr.seek(C::BlockSize::USIZE);
-            ctr.apply_keystream(buffer);
+            ctr.apply_keystream(buffer.get_out());
         }
 
-        let mut full_tag = self.calc_mac(nonce, adata, buffer)?;
+        let mut full_tag = self.calc_mac(nonce, adata, buffer.get_in())?;
 
         if cb > 4 {
             let mut ctr = Ctr64BE::from_core(CtrCore::inner_iv_init(&self.cipher, &ext_nonce));
@@ -287,7 +287,7 @@ where
         if full_tag[..tag.len()].ct_eq(tag).into() {
             Ok(())
         } else {
-            buffer.iter_mut().for_each(|v| *v = 0);
+            buffer.get_out().fill(0);
             Err(Error)
         }
     }

ccm/tests/mod.rs

@@ -1,10 +1,10 @@
 #![cfg(feature = "alloc")]
 
-use aead::{Aead, AeadInOut, KeyInit, Payload, array::Array};
+use aead::{array::Array, Aead, AeadInOut, KeyInit, Payload};
 use aes::{Aes128, Aes192, Aes256};
 use ccm::{
+    consts::{U10, U11, U12, U13, U14, U16, U4, U6, U7, U8, U9},
     Ccm,
-    consts::{U4, U6, U7, U8, U9, U10, U11, U12, U13, U14, U16},
 };
 use hex_literal::hex;
 
@@ -19,11 +19,11 @@ fn test_data_len_check() {
     let c = Cipher::new(&key);
 
     let mut buf1 = [1; u16::MAX as usize];
-    let res = c.encrypt_inout_detached(&nonce, &[], &mut buf1);
+    let res = c.encrypt_inout_detached(&nonce, &[], (&mut buf1[..]).into());
     assert!(res.is_ok());
 
     let mut buf2 = [1; u16::MAX as usize + 1];
-    let res = c.encrypt_inout_detached(&nonce, &[], &mut buf2);
+    let res = c.encrypt_inout_detached(&nonce, &[], (&mut buf2[..]).into());
     assert!(res.is_err());
 }