make decrypt_in_place inout aware

Author: baloo

deoxys/src/modes.rs

@@ -203,6 +203,8 @@ where
         let mut computed_tag = Tag::default();
         let mut checksum = Checksum::default();
         let mut tweak = Tweak::default();
+        let buffer: InOutBuf<'_, '_, u8> = buffer.into();
+        let buffer_len = buffer.len();
 
         // Associated Data
         <Self as DeoxysModeInternal<B>>::compute_ad_tag(
@@ -224,61 +226,68 @@ where
         if !buffer.is_empty() {
             tweak[0] = (tweak[0] & 0xf) | TWEAK_M;
 
-            for (index, data) in buffer.chunks_mut(16).enumerate() {
+            let (data_blocks, tail) = buffer.into_chunks();
+            let data_blocks_len = data_blocks.len();
+
+            for (index, mut data) in data_blocks.into_iter().enumerate() {
                 // Copy block number
                 let tmp = tweak[8] & 0xf0;
                 tweak[8..].copy_from_slice(&(index as u64).to_be_bytes());
                 tweak[8] = (tweak[8] & 0xf) | tmp;
 
-                if data.len() == 16 {
-                    let data: &mut Block = data.try_into().unwrap();
-                    B::decrypt_in_place(data.into(), tweak.as_ref(), subkeys);
+                B::decrypt_in_place(data.reborrow(), tweak.as_ref(), subkeys);
 
-                    for (c, d) in checksum.iter_mut().zip(data.iter()) {
-                        *c ^= d;
-                    }
-                } else {
-                    // Last block checksum
-                    tweak[0] = (tweak[0] & 0xf) | TWEAK_M_LAST;
+                for (c, d) in checksum.iter_mut().zip(data.get_out().iter()) {
+                    *c ^= d;
+                }
+            }
 
-                    let mut block = Block::default();
-                    B::encrypt_in_place((&mut block).into(), tweak.as_ref(), subkeys);
+            let mut data = tail;
+            let index = data_blocks_len;
+            if !data.is_empty() {
+                // Copy block number
+                let tmp = tweak[8] & 0xf0;
+                tweak[8..].copy_from_slice(&(index as u64).to_be_bytes());
+                tweak[8] = (tweak[8] & 0xf) | tmp;
 
-                    for (d, b) in data.iter_mut().zip(block.iter()) {
-                        *d ^= b;
-                    }
+                // Last block checksum
+                tweak[0] = (tweak[0] & 0xf) | TWEAK_M_LAST;
+
+                let mut block = Block::default();
+                B::encrypt_in_place((&mut block).into(), tweak.as_ref(), subkeys);
 
-                    block.fill(0);
+                data.xor_in2out((block[..data.len()]).into());
 
-                    block[0..data.len()].copy_from_slice(data);
-                    block[data.len()] = 0x80;
+                block.fill(0);
 
-                    for (c, d) in checksum.iter_mut().zip(block.iter()) {
-                        *c ^= d;
-                    }
+                block[0..data.len()].copy_from_slice(data.get_in());
+                block[data.len()] = 0x80;
 
-                    // Tag computing.
-                    tweak[0] = (tweak[0] & 0xf) | TWEAK_CHKSUM;
+                for (c, d) in checksum.iter_mut().zip(block.iter()) {
+                    *c ^= d;
+                }
 
-                    let tmp = tweak[8] & 0xf0;
-                    tweak[8..].copy_from_slice(&((index + 1) as u64).to_be_bytes());
-                    tweak[8] = (tweak[8] & 0xf) | tmp;
+                // Tag computing.
+                tweak[0] = (tweak[0] & 0xf) | TWEAK_CHKSUM;
 
-                    B::encrypt_in_place((&mut checksum).into(), tweak.as_ref(), subkeys);
+                let tmp = tweak[8] & 0xf0;
+                tweak[8..].copy_from_slice(&((index + 1) as u64).to_be_bytes());
+                tweak[8] = (tweak[8] & 0xf) | tmp;
 
-                    for (t, c) in computed_tag.iter_mut().zip(checksum.iter()) {
-                        *t ^= c;
-                    }
+                B::encrypt_in_place((&mut checksum).into(), tweak.as_ref(), subkeys);
+
+                for (t, c) in computed_tag.iter_mut().zip(checksum.iter()) {
+                    *t ^= c;
                 }
             }
         }
 
-        if buffer.len() % 16 == 0 {
+        if buffer_len % 16 == 0 {
             // Tag computing without last block
             tweak[0] = (tweak[0] & 0xf) | TWEAK_TAG;
 
             let tmp = tweak[8] & 0xf0;
-            tweak[8..].copy_from_slice(&((buffer.len() / 16) as u64).to_be_bytes());
+            tweak[8..].copy_from_slice(&((buffer_len / 16) as u64).to_be_bytes());
             tweak[8] = (tweak[8] & 0xf) | tmp;
 
             B::encrypt_in_place((&mut checksum).into(), tweak.as_ref(), subkeys);