Migrate to AeadInOut

Replaces the previous `AeadInPlaceDetached` impls with `AeadInOut`,
which was introduced in RustCrypto/traits#1793

Author: tarcieri

Cargo.lock

@@ -4,12 +4,12 @@ members = [
     "aes-gcm",
     "aes-gcm-siv",
     "aes-siv",
-    "ascon-aead",
-    "ccm",
-    "chacha20poly1305",
-    "deoxys",
-    "eax",
-    "ocb3",
+    #"ascon-aead",
+    #"ccm",
+    #"chacha20poly1305",
+    #"deoxys",
+    #"eax",
+    #"ocb3",
     "xaes-256-gcm",
 ]
 resolver = "2"
@@ -18,8 +18,8 @@ resolver = "2"
 aead-stream = { path = "./aead-stream" }
 aes-gcm     = { path = "./aes-gcm" }
 
-aead          = { git = "https://github.com/RustCrypto/traits.git" }
-crypto-common = { git = "https://github.com/RustCrypto/traits.git" }
+aead          = { git = "https://github.com/baloo/traits.git", branch = "baloo/aead/bicephalbuffer" }
+crypto-common = { git = "https://github.com/baloo/traits.git", branch = "baloo/aead/bicephalbuffer" }
 
 chacha20 = { git = "https://github.com/RustCrypto/stream-ciphers.git" }
 

Cargo.toml

@@ -17,7 +17,7 @@ categories = ["cryptography", "no-std"]
 rust-version = "1.85"
 
 [dependencies]
-aead = { version = "0.6.0-rc.0", default-features = false }
+aead = { version = "0.6.0-rc.0", default-features = false, features = ["inout"] }
 aes = { version = "=0.9.0-pre.3", optional = true }
 cipher = "=0.5.0-pre.8"
 ctr = "0.10.0-pre.2"

aes-gcm-siv/Cargo.toml

@@ -78,12 +78,12 @@
 //! provide an impl of [`aead::Buffer`] for `bytes::BytesMut` (re-exported from the
 //! [`aead`] crate as [`aead::bytes::BytesMut`]).
 
-pub use aead::{self, AeadCore, AeadInPlaceDetached, Error, Key, KeyInit, KeySizeUser};
+pub use aead::{self, AeadCore, AeadInOut, Error, Key, KeyInit, KeySizeUser};
 
 #[cfg(feature = "aes")]
 pub use aes;
 
-use aead::PostfixTagged;
+use aead::{PostfixTagged, inout::InOutBuf};
 use cipher::{
     BlockCipherEncrypt, BlockSizeUser, InnerIvInit, StreamCipherCore,
     array::Array,
@@ -165,28 +165,28 @@ where
 
 impl<Aes> PostfixTagged for AesGcmSiv<Aes> {}
 
-impl<Aes> AeadInPlaceDetached for AesGcmSiv<Aes>
+impl<Aes> AeadInOut for AesGcmSiv<Aes>
 where
     Aes: BlockSizeUser<BlockSize = U16> + BlockCipherEncrypt + KeyInit,
 {
-    fn encrypt_in_place_detached(
+    fn encrypt_inout_detached(
         &self,
         nonce: &Nonce,
         associated_data: &[u8],
-        buffer: &mut [u8],
+        buffer: InOutBuf<'_, '_, u8>,
     ) -> Result<Tag, Error> {
         Cipher::<Aes>::new(&self.key_generating_key, nonce)
-            .encrypt_in_place_detached(associated_data, buffer)
+            .encrypt_inout_detached(associated_data, buffer)
     }
 
-    fn decrypt_in_place_detached(
+    fn decrypt_inout_detached(
         &self,
         nonce: &Nonce,
         associated_data: &[u8],
-        buffer: &mut [u8],
+        buffer: InOutBuf<'_, '_, u8>,
         tag: &Tag,
     ) -> Result<(), Error> {
-        Cipher::<Aes>::new(&self.key_generating_key, nonce).decrypt_in_place_detached(
+        Cipher::<Aes>::new(&self.key_generating_key, nonce).decrypt_inout_detached(
             associated_data,
             buffer,
             tag,
@@ -268,30 +268,30 @@ where
     }
 
     /// Encrypt the given message in-place, returning the authentication tag.
-    pub(crate) fn encrypt_in_place_detached(
+    pub(crate) fn encrypt_inout_detached(
         mut self,
         associated_data: &[u8],
-        buffer: &mut [u8],
+        buffer: InOutBuf<'_, '_, u8>,
     ) -> Result<Tag, Error> {
         if buffer.len() as u64 > P_MAX || associated_data.len() as u64 > A_MAX {
             return Err(Error);
         }
 
         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)
     }
 
     /// Decrypt the given message, first authenticating ciphertext integrity
     /// and returning an error if it's been tampered with.
-    pub(crate) fn decrypt_in_place_detached(
+    pub(crate) fn decrypt_inout_detached(
         mut self,
         associated_data: &[u8],
-        buffer: &mut [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_out());
 
         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)
         }
     }