Use BlockCipherEncrypt/BlockCipherDecrypt trait names

tarcieri · tarcieri · commit bdeaf6dcfc96 · 2024-01-21T17:07:03.000-07:00
Updates the previous `BlockEncrypt`/`BlockEncrypt` trait names to use the new ones introduced in RustCrypto/traits#1482
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -23,3 +23,6 @@ members = [
 
 [profile.dev]
 opt-level = 2
+
+[patch.crates-io.cipher]
+git = "https://github.com/RustCrypto/traits.git"
diff --git a/aes/src/armv8.rs b/aes/src/armv8.rs
@@ -25,7 +25,7 @@ use crate::{Block, Block8};
 use cipher::{
     consts::{U16, U24, U32, U8},
     inout::InOut,
-    AlgorithmName, BlockBackend, BlockCipher, BlockClosure, BlockDecrypt, BlockEncrypt,
+    AlgorithmName, BlockBackend, BlockCipher, BlockClosure, BlockCipherDecrypt, BlockCipherEncrypt,
     BlockSizeUser, Key, KeyInit, KeySizeUser, ParBlocksSizeUser,
 };
 use core::arch::aarch64::*;
@@ -98,13 +98,13 @@ macro_rules! define_aes_impl {
             type BlockSize = U16;
         }
 
-        impl BlockEncrypt for $name {
+        impl BlockCipherEncrypt for $name {
             fn encrypt_with_backend(&self, f: impl BlockClosure<BlockSize = U16>) {
                 self.encrypt.encrypt_with_backend(f)
             }
         }
 
-        impl BlockDecrypt for $name {
+        impl BlockCipherDecrypt for $name {
             fn decrypt_with_backend(&self, f: impl BlockClosure<BlockSize = U16>) {
                 self.decrypt.decrypt_with_backend(f)
             }
@@ -158,7 +158,7 @@ macro_rules! define_aes_impl {
             type BlockSize = U16;
         }
 
-        impl BlockEncrypt for $name_enc {
+        impl BlockCipherEncrypt for $name_enc {
             fn encrypt_with_backend(&self, f: impl BlockClosure<BlockSize = U16>) {
                 f.call(&mut self.get_enc_backend())
             }
@@ -233,7 +233,7 @@ macro_rules! define_aes_impl {
             type BlockSize = U16;
         }
 
-        impl BlockDecrypt for $name_dec {
+        impl BlockCipherDecrypt for $name_dec {
             fn decrypt_with_backend(&self, f: impl BlockClosure<BlockSize = U16>) {
                 f.call(&mut self.get_dec_backend());
             }
diff --git a/aes/src/autodetect.rs b/aes/src/autodetect.rs
@@ -4,7 +4,7 @@
 use crate::soft;
 use cipher::{
     consts::{U16, U24, U32},
-    AlgorithmName, BlockCipher, BlockClosure, BlockDecrypt, BlockEncrypt, BlockSizeUser, Key,
+    AlgorithmName, BlockCipher, BlockClosure, BlockCipherDecrypt, BlockCipherEncrypt, BlockSizeUser, Key,
     KeyInit, KeySizeUser,
 };
 use core::fmt;
@@ -130,7 +130,7 @@ macro_rules! define_aes_impl {
 
         impl BlockCipher for $name {}
 
-        impl BlockEncrypt for $name {
+        impl BlockCipherEncrypt for $name {
             fn encrypt_with_backend(&self, f: impl BlockClosure<BlockSize = U16>) {
                 unsafe {
                     if self.token.get() {
@@ -149,7 +149,7 @@ macro_rules! define_aes_impl {
             }
         }
 
-        impl BlockDecrypt for $name {
+        impl BlockCipherDecrypt for $name {
             fn decrypt_with_backend(&self, f: impl BlockClosure<BlockSize = U16>) {
                 unsafe {
                     if self.token.get() {
@@ -249,7 +249,7 @@ macro_rules! define_aes_impl {
 
         impl BlockCipher for $name_enc {}
 
-        impl BlockEncrypt for $name_enc {
+        impl BlockCipherEncrypt for $name_enc {
             fn encrypt_with_backend(&self, f: impl BlockClosure<BlockSize = U16>) {
                 unsafe {
                     if self.token.get() {
@@ -378,7 +378,7 @@ macro_rules! define_aes_impl {
 
         impl BlockCipher for $name_dec {}
 
-        impl BlockDecrypt for $name_dec {
+        impl BlockCipherDecrypt for $name_dec {
             fn decrypt_with_backend(&self, f: impl BlockClosure<BlockSize = U16>) {
                 unsafe {
                     if self.token.get() {
diff --git a/aes/src/lib.rs b/aes/src/lib.rs
@@ -52,7 +52,7 @@
 //! ```
 //! use aes::Aes128;
 //! use aes::cipher::{
-//!     BlockCipher, BlockEncrypt, BlockDecrypt, KeyInit,
+//!     BlockCipher, BlockCipherEncrypt, BlockCipherDecrypt, KeyInit,
 //!     array::Array,
 //! };
 //!
diff --git a/aes/src/ni.rs b/aes/src/ni.rs
@@ -37,7 +37,7 @@ use crate::{Block, Block8};
 use cipher::{
     consts::{U16, U24, U32, U8},
     inout::InOut,
-    AlgorithmName, BlockBackend, BlockCipher, BlockClosure, BlockDecrypt, BlockEncrypt,
+    AlgorithmName, BlockBackend, BlockCipher, BlockClosure, BlockCipherDecrypt, BlockCipherEncrypt,
     BlockSizeUser, Key, KeyInit, KeySizeUser, ParBlocksSizeUser,
 };
 use core::fmt;
@@ -109,13 +109,13 @@ macro_rules! define_aes_impl {
             type BlockSize = U16;
         }
 
-        impl BlockEncrypt for $name {
+        impl BlockCipherEncrypt for $name {
             fn encrypt_with_backend(&self, f: impl BlockClosure<BlockSize = U16>) {
                 self.encrypt.encrypt_with_backend(f)
             }
         }
 
-        impl BlockDecrypt for $name {
+        impl BlockCipherDecrypt for $name {
             fn decrypt_with_backend(&self, f: impl BlockClosure<BlockSize = U16>) {
                 self.decrypt.decrypt_with_backend(f)
             }
@@ -171,7 +171,7 @@ macro_rules! define_aes_impl {
             type BlockSize = U16;
         }
 
-        impl BlockEncrypt for $name_enc {
+        impl BlockCipherEncrypt for $name_enc {
             fn encrypt_with_backend(&self, f: impl BlockClosure<BlockSize = U16>) {
                 f.call(&mut self.get_enc_backend())
             }
@@ -246,7 +246,7 @@ macro_rules! define_aes_impl {
             type BlockSize = U16;
         }
 
-        impl BlockDecrypt for $name_dec {
+        impl BlockCipherDecrypt for $name_dec {
             fn decrypt_with_backend(&self, f: impl BlockClosure<BlockSize = U16>) {
                 f.call(&mut self.get_dec_backend());
             }
diff --git a/aes/src/soft.rs b/aes/src/soft.rs
@@ -16,7 +16,7 @@ use crate::Block;
 use cipher::{
     consts::{U16, U24, U32},
     inout::InOut,
-    AlgorithmName, BlockBackend, BlockCipher, BlockClosure, BlockDecrypt, BlockEncrypt,
+    AlgorithmName, BlockBackend, BlockCipher, BlockClosure, BlockCipherDecrypt, BlockCipherEncrypt,
     BlockSizeUser, Key, KeyInit, KeySizeUser, ParBlocksSizeUser,
 };
 use core::fmt;
@@ -74,13 +74,13 @@ macro_rules! define_aes_impl {
 
         impl BlockCipher for $name {}
 
-        impl BlockEncrypt for $name {
+        impl BlockCipherEncrypt for $name {
             fn encrypt_with_backend(&self, f: impl BlockClosure<BlockSize = U16>) {
                 f.call(&mut self.get_enc_backend())
             }
         }
 
-        impl BlockDecrypt for $name {
+        impl BlockCipherDecrypt for $name {
             fn decrypt_with_backend(&self, f: impl BlockClosure<BlockSize = U16>) {
                 f.call(&mut self.get_dec_backend())
             }
@@ -155,7 +155,7 @@ macro_rules! define_aes_impl {
             type BlockSize = U16;
         }
 
-        impl BlockEncrypt for $name_enc {
+        impl BlockCipherEncrypt for $name_enc {
             fn encrypt_with_backend(&self, f: impl BlockClosure<BlockSize = U16>) {
                 f.call(&mut self.get_enc_backend())
             }
@@ -224,7 +224,7 @@ macro_rules! define_aes_impl {
             type BlockSize = U16;
         }
 
-        impl BlockDecrypt for $name_dec {
+        impl BlockCipherDecrypt for $name_dec {
             fn decrypt_with_backend(&self, f: impl BlockClosure<BlockSize = U16>) {
                 f.call(&mut self.get_dec_backend());
             }
diff --git a/aria/src/lib.rs b/aria/src/lib.rs
@@ -11,7 +11,7 @@
 //! # Examples
 //! ```
 //! use aria::cipher::array::Array;
-//! use aria::cipher::{Key, Block, BlockEncrypt, BlockDecrypt, KeyInit};
+//! use aria::cipher::{Key, Block, BlockCipherEncrypt, BlockCipherDecrypt, KeyInit};
 //! use aria::Aria128;
 //!
 //! let key = Array::from([0u8; 16]);
diff --git a/aria/tests/mod.rs b/aria/tests/mod.rs
@@ -1,5 +1,5 @@
 use aria::{Aria128, Aria192, Aria256};
-use cipher::{array::Array, BlockDecrypt, BlockEncrypt, KeyInit};
+use cipher::{array::Array, BlockCipherDecrypt, BlockCipherEncrypt, KeyInit};
 use hex_literal::hex;
 
 /// Test vector from RFC 5794, Appendix A.1
diff --git a/belt-block/tests/mod.rs b/belt-block/tests/mod.rs
@@ -3,7 +3,7 @@
 use belt_block::{belt_block_raw, belt_wblock_dec, belt_wblock_enc, to_u32};
 #[cfg(feature = "cipher")]
 use belt_block::{
-    cipher::{BlockDecrypt, BlockEncrypt, KeyInit},
+    cipher::{BlockCipherDecrypt, BlockCipherEncrypt, KeyInit},
     BeltBlock,
 };
 use hex_literal::hex;
diff --git a/camellia/src/lib.rs b/camellia/src/lib.rs
@@ -11,7 +11,7 @@
 //! # Examples
 //! ```
 //! use camellia::cipher::array::Array;
-//! use camellia::cipher::{BlockDecrypt, BlockEncrypt, KeyInit};
+//! use camellia::cipher::{BlockCipherDecrypt, BlockCipherEncrypt, KeyInit};
 //! use camellia::Camellia128;
 //!
 //! let key = Array::from([0_u8; 16]);
diff --git a/cast5/src/lib.rs b/cast5/src/lib.rs
@@ -11,7 +11,7 @@
 //! # Examples
 //! ```
 //! use cast5::cipher::array::Array;
-//! use cast5::cipher::{Key, Block, BlockEncrypt, BlockDecrypt, KeyInit};
+//! use cast5::cipher::{Key, Block, BlockCipherEncrypt, BlockCipherDecrypt, KeyInit};
 //! use cast5::Cast5;
 //!
 //! let key = Array::from([0u8; 16]);
diff --git a/cast5/tests/mod.rs b/cast5/tests/mod.rs
@@ -1,5 +1,5 @@
 use cast5::Cast5;
-use cipher::{array::Array, BlockDecrypt, BlockEncrypt, KeyInit};
+use cipher::{array::Array, BlockCipherDecrypt, BlockCipherEncrypt, KeyInit};
 use hex_literal::hex;
 
 /// Test vectors from RFC 2144 Appendix B.1
diff --git a/cast6/src/lib.rs b/cast6/src/lib.rs
@@ -11,7 +11,7 @@
 //! # Examples
 //! ```
 //! use cast6::cipher::array::Array;
-//! use cast6::cipher::{Key, Block, BlockEncrypt, BlockDecrypt, KeyInit};
+//! use cast6::cipher::{Key, Block, BlockCipherEncrypt, BlockCipherDecrypt, KeyInit};
 //! use cast6::Cast6;
 //!
 //! let key = Array::from([0u8; 32]);
diff --git a/cast6/tests/mod.rs b/cast6/tests/mod.rs
@@ -1,5 +1,5 @@
 use cast6::Cast6;
-use cipher::{Block, BlockDecrypt, BlockEncrypt, KeyInit};
+use cipher::{Block, BlockCipherDecrypt, BlockCipherEncrypt, KeyInit};
 use hex_literal::hex;
 
 /// Test vectors from RFC 2612 Appendix A
diff --git a/kuznyechik/src/soft/mod.rs b/kuznyechik/src/soft/mod.rs
@@ -1,6 +1,6 @@
 use crate::{BlockSize, Key, KeySize};
 use cipher::{
-    AlgorithmName, BlockCipher, BlockClosure, BlockDecrypt, BlockEncrypt, BlockSizeUser, KeyInit,
+    AlgorithmName, BlockCipher, BlockClosure, BlockCipherDecrypt, BlockCipherEncrypt, BlockSizeUser, KeyInit,
     KeySizeUser,
 };
 use core::fmt;
@@ -51,13 +51,13 @@ impl From<&KuznyechikEnc> for Kuznyechik {
     }
 }
 
-impl BlockEncrypt for Kuznyechik {
+impl BlockCipherEncrypt for Kuznyechik {
     fn encrypt_with_backend(&self, f: impl BlockClosure<BlockSize = BlockSize>) {
         f.call(&mut EncBackend(&self.keys));
     }
 }
 
-impl BlockDecrypt for Kuznyechik {
+impl BlockCipherDecrypt for Kuznyechik {
     fn decrypt_with_backend(&self, f: impl BlockClosure<BlockSize = BlockSize>) {
         f.call(&mut DecBackend(&self.keys));
     }
@@ -111,7 +111,7 @@ impl KeyInit for KuznyechikEnc {
     }
 }
 
-impl BlockEncrypt for KuznyechikEnc {
+impl BlockCipherEncrypt for KuznyechikEnc {
     fn encrypt_with_backend(&self, f: impl BlockClosure<BlockSize = BlockSize>) {
         f.call(&mut EncBackend(&self.keys));
     }
@@ -179,7 +179,7 @@ impl From<&KuznyechikEnc> for KuznyechikDec {
     }
 }
 
-impl BlockDecrypt for KuznyechikDec {
+impl BlockCipherDecrypt for KuznyechikDec {
     fn decrypt_with_backend(&self, f: impl BlockClosure<BlockSize = BlockSize>) {
         f.call(&mut DecBackend(&self.keys));
     }
diff --git a/kuznyechik/src/sse2/mod.rs b/kuznyechik/src/sse2/mod.rs
@@ -2,7 +2,7 @@
 
 use crate::{BlockSize, Key, KeySize};
 use cipher::{
-    AlgorithmName, BlockCipher, BlockClosure, BlockDecrypt, BlockEncrypt, BlockSizeUser, KeyInit,
+    AlgorithmName, BlockCipher, BlockClosure, BlockCipherDecrypt, BlockCipherEncrypt, BlockSizeUser, KeyInit,
     KeySizeUser,
 };
 use core::fmt;
@@ -60,13 +60,13 @@ impl From<&KuznyechikEnc> for Kuznyechik {
     }
 }
 
-impl BlockEncrypt for Kuznyechik {
+impl BlockCipherEncrypt for Kuznyechik {
     fn encrypt_with_backend(&self, f: impl BlockClosure<BlockSize = BlockSize>) {
         f.call(&mut EncBackend(&self.enc_keys));
     }
 }
 
-impl BlockDecrypt for Kuznyechik {
+impl BlockCipherDecrypt for Kuznyechik {
     fn decrypt_with_backend(&self, f: impl BlockClosure<BlockSize = BlockSize>) {
         f.call(&mut DecBackend(&self.dec_keys));
     }
@@ -121,7 +121,7 @@ impl KeyInit for KuznyechikEnc {
     }
 }
 
-impl BlockEncrypt for KuznyechikEnc {
+impl BlockCipherEncrypt for KuznyechikEnc {
     fn encrypt_with_backend(&self, f: impl BlockClosure<BlockSize = BlockSize>) {
         f.call(&mut EncBackend(&self.keys));
     }
@@ -194,7 +194,7 @@ impl From<&KuznyechikEnc> for KuznyechikDec {
     }
 }
 
-impl BlockDecrypt for KuznyechikDec {
+impl BlockCipherDecrypt for KuznyechikDec {
     fn decrypt_with_backend(&self, f: impl BlockClosure<BlockSize = BlockSize>) {
         f.call(&mut DecBackend(&self.keys));
     }
diff --git a/kuznyechik/tests/mod.rs b/kuznyechik/tests/mod.rs
@@ -1,4 +1,4 @@
-use cipher::{Block, BlockDecrypt, BlockEncrypt, KeyInit};
+use cipher::{Block, BlockCipherDecrypt, BlockCipherEncrypt, KeyInit};
 use hex_literal::hex;
 use kuznyechik::{Kuznyechik, KuznyechikDec, KuznyechikEnc};
 
diff --git a/magma/src/lib.rs b/magma/src/lib.rs
@@ -14,7 +14,7 @@
 //! use magma::Magma;
 //! use magma::cipher::{
 //!     array::Array,
-//!     BlockEncrypt, BlockDecrypt, KeyInit,
+//!     BlockCipherEncrypt, BlockCipherDecrypt, KeyInit,
 //! };
 //! use hex_literal::hex;
 //!
diff --git a/rc2/tests/mod.rs b/rc2/tests/mod.rs
@@ -1,5 +1,5 @@
 use cipher::array::Array;
-use cipher::{BlockDecrypt, BlockEncrypt, KeyInit};
+use cipher::{BlockCipherDecrypt, BlockCipherEncrypt, KeyInit};
 
 struct Test {
     key: &'static [u8],
diff --git a/rc5/src/block_cipher.rs b/rc5/src/block_cipher.rs
@@ -6,7 +6,7 @@ use cipher::{
     crypto_common::BlockSizes,
     inout::InOut,
     typenum::{Diff, IsLess, Le, NonZero, Sum, Unsigned, U1, U2, U256},
-    AlgorithmName, Block, BlockBackend, BlockCipher, BlockDecrypt, BlockEncrypt, BlockSizeUser,
+    AlgorithmName, Block, BlockBackend, BlockCipher, BlockCipherDecrypt, BlockCipherEncrypt, BlockSizeUser,
     KeyInit, KeySizeUser, ParBlocksSizeUser,
 };
 
@@ -95,7 +95,7 @@ where
     type BlockSize = BlockSize<W>;
 }
 
-impl<W, R, B> BlockEncrypt for RC5<W, R, B>
+impl<W, R, B> BlockCipherEncrypt for RC5<W, R, B>
 where
     W: Word,
     // Block size
@@ -208,7 +208,7 @@ where
     }
 }
 
-impl<W, R, B> BlockDecrypt for RC5<W, R, B>
+impl<W, R, B> BlockCipherDecrypt for RC5<W, R, B>
 where
     W: Word,
     // Block size
diff --git a/rc5/tests/mod.rs b/rc5/tests/mod.rs
diff --git a/sm4/tests/mod.rs b/sm4/tests/mod.rs
diff --git a/speck/tests/mod.rs b/speck/tests/mod.rs
diff --git a/threefish/tests/mod.rs b/threefish/tests/mod.rs
diff --git a/twofish/tests/mod.rs b/twofish/tests/mod.rs

Original file line number	Diff line number	Diff line change
`@@ -25,7 +25,7 @@ use crate::{Block, Block8};`
`25`	`25`	`use cipher::{`
`26`	`26`	`consts::{U16, U24, U32, U8},`
`27`	`27`	`inout::InOut,`
`28`		`- AlgorithmName, BlockBackend, BlockCipher, BlockClosure, BlockDecrypt, BlockEncrypt,`
	`28`	`+ AlgorithmName, BlockBackend, BlockCipher, BlockClosure, BlockCipherDecrypt, BlockCipherEncrypt,`
`29`	`29`	`BlockSizeUser, Key, KeyInit, KeySizeUser, ParBlocksSizeUser,`
`30`	`30`	`};`
`31`	`31`	`use core::arch::aarch64::*;`
`@@ -98,13 +98,13 @@ macro_rules! define_aes_impl {`
`98`	`98`	`type BlockSize = U16;`
`99`	`99`	`}`
`100`	`100`
`101`		`- impl BlockEncrypt for $name {`
	`101`	`+ impl BlockCipherEncrypt for $name {`
`102`	`102`	`fn encrypt_with_backend(&self, f: impl BlockClosure<BlockSize = U16>) {`
`103`	`103`	`self.encrypt.encrypt_with_backend(f)`
`104`	`104`	`}`
`105`	`105`	`}`
`106`	`106`
`107`		`- impl BlockDecrypt for $name {`
	`107`	`+ impl BlockCipherDecrypt for $name {`
`108`	`108`	`fn decrypt_with_backend(&self, f: impl BlockClosure<BlockSize = U16>) {`
`109`	`109`	`self.decrypt.decrypt_with_backend(f)`
`110`	`110`	`}`
`@@ -158,7 +158,7 @@ macro_rules! define_aes_impl {`
`158`	`158`	`type BlockSize = U16;`
`159`	`159`	`}`
`160`	`160`
`161`		`- impl BlockEncrypt for $name_enc {`
	`161`	`+ impl BlockCipherEncrypt for $name_enc {`
`162`	`162`	`fn encrypt_with_backend(&self, f: impl BlockClosure<BlockSize = U16>) {`
`163`	`163`	`f.call(&mut self.get_enc_backend())`
`164`	`164`	`}`
`@@ -233,7 +233,7 @@ macro_rules! define_aes_impl {`
`233`	`233`	`type BlockSize = U16;`
`234`	`234`	`}`
`235`	`235`
`236`		`- impl BlockDecrypt for $name_dec {`
	`236`	`+ impl BlockCipherDecrypt for $name_dec {`
`237`	`237`	`fn decrypt_with_backend(&self, f: impl BlockClosure<BlockSize = U16>) {`
`238`	`238`	`f.call(&mut self.get_dec_backend());`
`239`	`239`	`}`
Original file line number	Diff line number	Diff line change
`@@ -37,7 +37,7 @@ use crate::{Block, Block8};`
`37`	`37`	`use cipher::{`
`38`	`38`	`consts::{U16, U24, U32, U8},`
`39`	`39`	`inout::InOut,`
`40`		`- AlgorithmName, BlockBackend, BlockCipher, BlockClosure, BlockDecrypt, BlockEncrypt,`
	`40`	`+ AlgorithmName, BlockBackend, BlockCipher, BlockClosure, BlockCipherDecrypt, BlockCipherEncrypt,`
`41`	`41`	`BlockSizeUser, Key, KeyInit, KeySizeUser, ParBlocksSizeUser,`
`42`	`42`	`};`
`43`	`43`	`use core::fmt;`
`@@ -109,13 +109,13 @@ macro_rules! define_aes_impl {`
`109`	`109`	`type BlockSize = U16;`
`110`	`110`	`}`
`111`	`111`
`112`		`- impl BlockEncrypt for $name {`
	`112`	`+ impl BlockCipherEncrypt for $name {`
`113`	`113`	`fn encrypt_with_backend(&self, f: impl BlockClosure<BlockSize = U16>) {`
`114`	`114`	`self.encrypt.encrypt_with_backend(f)`
`115`	`115`	`}`
`116`	`116`	`}`
`117`	`117`
`118`		`- impl BlockDecrypt for $name {`
	`118`	`+ impl BlockCipherDecrypt for $name {`
`119`	`119`	`fn decrypt_with_backend(&self, f: impl BlockClosure<BlockSize = U16>) {`
`120`	`120`	`self.decrypt.decrypt_with_backend(f)`
`121`	`121`	`}`
`@@ -171,7 +171,7 @@ macro_rules! define_aes_impl {`
`171`	`171`	`type BlockSize = U16;`
`172`	`172`	`}`
`173`	`173`
`174`		`- impl BlockEncrypt for $name_enc {`
	`174`	`+ impl BlockCipherEncrypt for $name_enc {`
`175`	`175`	`fn encrypt_with_backend(&self, f: impl BlockClosure<BlockSize = U16>) {`
`176`	`176`	`f.call(&mut self.get_enc_backend())`
`177`	`177`	`}`
`@@ -246,7 +246,7 @@ macro_rules! define_aes_impl {`
`246`	`246`	`type BlockSize = U16;`
`247`	`247`	`}`
`248`	`248`
`249`		`- impl BlockDecrypt for $name_dec {`
	`249`	`+ impl BlockCipherDecrypt for $name_dec {`
`250`	`250`	`fn decrypt_with_backend(&self, f: impl BlockClosure<BlockSize = U16>) {`
`251`	`251`	`f.call(&mut self.get_dec_backend());`
`252`	`252`	`}`
Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@ use crate::Block;`
`16`	`16`	`use cipher::{`
`17`	`17`	`consts::{U16, U24, U32},`
`18`	`18`	`inout::InOut,`
`19`		`- AlgorithmName, BlockBackend, BlockCipher, BlockClosure, BlockDecrypt, BlockEncrypt,`
	`19`	`+ AlgorithmName, BlockBackend, BlockCipher, BlockClosure, BlockCipherDecrypt, BlockCipherEncrypt,`
`20`	`20`	`BlockSizeUser, Key, KeyInit, KeySizeUser, ParBlocksSizeUser,`
`21`	`21`	`};`
`22`	`22`	`use core::fmt;`
`@@ -74,13 +74,13 @@ macro_rules! define_aes_impl {`
`74`	`74`
`75`	`75`	`impl BlockCipher for $name {}`
`76`	`76`
`77`		`- impl BlockEncrypt for $name {`
	`77`	`+ impl BlockCipherEncrypt for $name {`
`78`	`78`	`fn encrypt_with_backend(&self, f: impl BlockClosure<BlockSize = U16>) {`
`79`	`79`	`f.call(&mut self.get_enc_backend())`
`80`	`80`	`}`
`81`	`81`	`}`
`82`	`82`
`83`		`- impl BlockDecrypt for $name {`
	`83`	`+ impl BlockCipherDecrypt for $name {`
`84`	`84`	`fn decrypt_with_backend(&self, f: impl BlockClosure<BlockSize = U16>) {`
`85`	`85`	`f.call(&mut self.get_dec_backend())`
`86`	`86`	`}`
`@@ -155,7 +155,7 @@ macro_rules! define_aes_impl {`
`155`	`155`	`type BlockSize = U16;`
`156`	`156`	`}`
`157`	`157`
`158`		`- impl BlockEncrypt for $name_enc {`
	`158`	`+ impl BlockCipherEncrypt for $name_enc {`
`159`	`159`	`fn encrypt_with_backend(&self, f: impl BlockClosure<BlockSize = U16>) {`
`160`	`160`	`f.call(&mut self.get_enc_backend())`
`161`	`161`	`}`
`@@ -224,7 +224,7 @@ macro_rules! define_aes_impl {`
`224`	`224`	`type BlockSize = U16;`
`225`	`225`	`}`
`226`	`226`
`227`		`- impl BlockDecrypt for $name_dec {`
	`227`	`+ impl BlockCipherDecrypt for $name_dec {`
`228`	`228`	`fn decrypt_with_backend(&self, f: impl BlockClosure<BlockSize = U16>) {`
`229`	`229`	`f.call(&mut self.get_dec_backend());`
`230`	`230`	`}`