sm4: upgrade cipher to 0.5.0

Author: zonyitoo

sm4/src/armv8/autodetect/linux.rs

@@ -1,8 +1,9 @@
 #![allow(unsafe_code)]
 
 use cipher::{
-    consts::U16, AlgorithmName, BlockCipher, BlockClosure, BlockDecrypt, BlockEncrypt,
-    BlockSizeUser, Key, KeyInit, KeySizeUser,
+    AlgorithmName, Block, BlockCipherDecBackend, BlockCipherDecClosure, BlockCipherDecrypt,
+    BlockCipherEncBackend, BlockCipherEncClosure, BlockCipherEncrypt, BlockSizeUser, InOut, Key,
+    KeyInit, KeySizeUser, ParBlocks, ParBlocksSizeUser, consts::U16,
 };
 use core::{fmt, mem::ManuallyDrop};
 
@@ -67,10 +68,8 @@ impl BlockSizeUser for Sm4 {
     type BlockSize = U16;
 }
 
-impl BlockCipher for Sm4 {}
-
-impl BlockEncrypt for Sm4 {
-    fn encrypt_with_backend(&self, f: impl BlockClosure<BlockSize = U16>) {
+impl BlockCipherEncrypt for Sm4 {
+    fn encrypt_with_backend(&self, f: impl BlockCipherEncClosure<BlockSize = U16>) {
         unsafe {
             if self.token.get() {
                 self.cipher.sm4.encrypt_with_backend(f);
@@ -81,8 +80,8 @@ impl BlockEncrypt for Sm4 {
     }
 }
 
-impl BlockDecrypt for Sm4 {
-    fn decrypt_with_backend(&self, f: impl BlockClosure<BlockSize = U16>) {
+impl BlockCipherDecrypt for Sm4 {
+    fn decrypt_with_backend(&self, f: impl BlockCipherDecClosure<BlockSize = U16>) {
         unsafe {
             if self.token.get() {
                 self.cipher.sm4.decrypt_with_backend(f);

sm4/src/armv8/neon.rs

@@ -7,19 +7,16 @@
 #[cfg(feature = "zeroize")]
 use cipher::zeroize::{Zeroize, ZeroizeOnDrop};
 use cipher::{
-    consts::{U16, U4},
-    generic_array::GenericArray,
-    inout::InOut,
-    AlgorithmName, Block, BlockCipher, BlockDecrypt, BlockSizeUser, Key, KeyInit, KeySizeUser,
-    ParBlocks, ParBlocksSizeUser,
+    AlgorithmName, Block, BlockCipherDecBackend, BlockCipherDecClosure, BlockCipherDecrypt,
+    BlockCipherEncBackend, BlockCipherEncClosure, BlockCipherEncrypt, BlockSizeUser, InOut, Key,
+    KeyInit, KeySizeUser, ParBlocks, ParBlocksSizeUser,
+    consts::{U4, U16},
 };
 use cipher::{BlockBackend, BlockEncrypt};
 use core::{arch::aarch64::*, fmt};
 
 use crate::consts::SBOX;
 
-type ParBlocks4<T> = GenericArray<Block<T>, U4>;
-
 #[inline]
 #[target_feature(enable = "neon")]
 unsafe fn sbox_table_lookup(
@@ -45,8 +42,8 @@ unsafe fn sbox_table_lookup(
 
 #[inline]
 #[target_feature(enable = "neon")]
-pub(super) unsafe fn sm4_process4<T: BlockSizeUser>(
-    blocks: InOut<'_, '_, ParBlocks4<T>>,
+pub(super) unsafe fn sm4_process4<T: ParBlocksSizeUser>(
+    blocks: InOut<'_, '_, ParBlocks<T>>,
     rk: &[u32; 32],
     encrypt: bool,
 ) {
@@ -161,8 +158,6 @@ pub struct Sm4 {
     rk: [u32; 32],
 }
 
-impl BlockCipher for Sm4 {}
-
 impl KeySizeUser for Sm4 {
     type KeySize = U16;
 }
@@ -203,8 +198,9 @@ impl BlockSizeUser for Sm4 {
     type BlockSize = U16;
 }
 
-impl BlockEncrypt for Sm4 {
-    fn encrypt_with_backend(&self, f: impl cipher::BlockClosure<BlockSize = Self::BlockSize>) {
+impl BlockCipherEncrypt for Sm4 {
+    #[inline]
+    fn encrypt_with_backend(&self, f: impl BlockCipherEncClosure<BlockSize = Self::BlockSize>) {
         f.call(&mut Sm4Enc(self))
     }
 }
@@ -219,20 +215,20 @@ impl<'a> ParBlocksSizeUser for Sm4Enc<'a> {
     type ParBlocksSize = U4;
 }
 
-impl<'a> BlockBackend for Sm4Enc<'a> {
+impl<'a> BlockCipherEncBackend for Sm4Enc<'a> {
     #[inline(always)]
-    fn proc_block(&mut self, block: InOut<'_, '_, Block<Self>>) {
+    fn encrypt_block(&self, block: InOut<'_, '_, Block<Self>>) {
         crate::soft::sm4_encrypt::<Self>(block, &self.0.rk);
     }
 
     #[inline(always)]
-    fn proc_par_blocks(&mut self, blocks: InOut<'_, '_, ParBlocks<Self>>) {
+    fn encrypt_par_blocks(&self, blocks: InOut<'_, '_, ParBlocks<Self>>) {
         unsafe { sm4_process4::<Self>(blocks, &self.0.rk, true) }
     }
 }
 
-impl BlockDecrypt for Sm4 {
-    fn decrypt_with_backend(&self, f: impl cipher::BlockClosure<BlockSize = Self::BlockSize>) {
+impl BlockCipherDecrypt for Sm4 {
+    fn decrypt_with_backend(&self, f: impl BlockCipherDecClosure<BlockSize = Self::BlockSize>) {
         f.call(&mut Sm4Dec(self))
     }
 }
@@ -247,14 +243,14 @@ impl<'a> ParBlocksSizeUser for Sm4Dec<'a> {
     type ParBlocksSize = U4;
 }
 
-impl<'a> BlockBackend for Sm4Dec<'a> {
+impl<'a> BlockCipherDecBackend for Sm4Dec<'a> {
     #[inline(always)]
-    fn proc_block(&mut self, block: InOut<'_, '_, Block<Self>>) {
+    fn decrypt_block(&mut self, block: InOut<'_, '_, Block<Self>>) {
         crate::soft::sm4_decrypt::<Self>(block, &self.0.rk);
     }
 
     #[inline(always)]
-    fn proc_par_blocks(&mut self, blocks: InOut<'_, '_, ParBlocks<Self>>) {
+    fn decrypt_par_blocks(&mut self, blocks: InOut<'_, '_, ParBlocks<Self>>) {
         unsafe { sm4_process4::<Self>(blocks, &self.0.rk, false) }
     }
 }

sm4/src/armv8/sm4e.rs

@@ -7,11 +7,10 @@
 #[cfg(feature = "zeroize")]
 use cipher::zeroize::ZeroizeOnDrop;
 use cipher::{
-    consts::{U16, U4, U8},
-    generic_array::GenericArray,
-    inout::{InOut, InOutBuf},
-    AlgorithmName, Block, BlockCipher, BlockDecrypt, BlockSizeUser, Key, KeyInit, KeySizeUser,
-    ParBlocks, ParBlocksSizeUser, Unsigned,
+    AlgorithmName, Block, BlockCipherDecBackend, BlockCipherDecClosure, BlockCipherDecrypt,
+    BlockCipherEncBackend, BlockCipherEncClosure, BlockCipherEncrypt, BlockSizeUser, InOut, Key,
+    KeyInit, KeySizeUser, ParBlocks, ParBlocksSizeUser,
+    consts::{U4, U8, U16},
 };
 use cipher::{BlockBackend, BlockEncrypt};
 use core::{arch::aarch64::*, fmt};
@@ -92,13 +91,10 @@ macro_rules! sm4_e {
     }
 }
 
-type ParBlocks4<T> = GenericArray<Block<T>, U4>;
-type ParBlocks8<T> = GenericArray<Block<T>, U8>;
-
 #[inline]
 #[target_feature(enable = "sm4")]
-pub(super) unsafe fn sm4_encrypt4<T: BlockSizeUser>(
-    blocks: InOut<'_, '_, ParBlocks4<T>>,
+pub(super) unsafe fn sm4_encrypt4<T: ParBlocksSizeUser>(
+    blocks: InOut<'_, '_, ParBlocks<T>>,
     rk: &[uint32x4_t; 8],
 ) {
     let (in_ptr, out_ptr) = blocks.into_raw();
@@ -127,8 +123,8 @@ pub(super) unsafe fn sm4_encrypt4<T: BlockSizeUser>(
 
 #[inline]
 #[target_feature(enable = "sm4")]
-pub(super) unsafe fn sm4_encrypt8<T: BlockSizeUser>(
-    blocks: InOut<'_, '_, ParBlocks8<T>>,
+pub(super) unsafe fn sm4_encrypt8<T: ParBlocksSizeUser>(
+    blocks: InOut<'_, '_, ParBlocks<T>>,
     rk: &[uint32x4_t; 8],
 ) {
     let (in_ptr, out_ptr) = blocks.into_raw();
@@ -165,7 +161,7 @@ pub(super) unsafe fn sm4_encrypt8<T: BlockSizeUser>(
 
 #[inline]
 #[target_feature(enable = "sm4")]
-pub(super) unsafe fn sm4_encrypt1<T: BlockSizeUser>(
+pub(super) unsafe fn sm4_encrypt1<T: BlocksSizeUser>(
     block: InOut<'_, '_, Block<T>>,
     rk: &[uint32x4_t; 8],
 ) {
@@ -189,8 +185,8 @@ pub(super) unsafe fn sm4_encrypt1<T: BlockSizeUser>(
 
 #[inline]
 #[target_feature(enable = "sm4")]
-pub(super) unsafe fn sm4_decrypt4<T: BlockSizeUser>(
-    blocks: InOut<'_, '_, ParBlocks4<T>>,
+pub(super) unsafe fn sm4_decrypt4<T: ParBlocksSizeUser>(
+    blocks: InOut<'_, '_, ParBlocks<T>>,
     rk: &[uint32x4_t; 8],
 ) {
     let (in_ptr, out_ptr) = blocks.into_raw();
@@ -220,7 +216,7 @@ pub(super) unsafe fn sm4_decrypt4<T: BlockSizeUser>(
 #[inline]
 #[target_feature(enable = "sm4")]
 pub(super) unsafe fn sm4_decrypt8<T: BlockSizeUser>(
-    blocks: InOut<'_, '_, ParBlocks8<T>>,
+    blocks: InOut<'_, '_, ParBlocks<T>>,
     rk: &[uint32x4_t; 8],
 ) {
     let (in_ptr, out_ptr) = blocks.into_raw();
@@ -286,8 +282,6 @@ pub struct Sm4 {
     drk: [uint32x4_t; 8],
 }
 
-impl BlockCipher for Sm4 {}
-
 impl KeySizeUser for Sm4 {
     type KeySize = U16;
 }
@@ -359,8 +353,9 @@ impl BlockSizeUser for Sm4 {
     type BlockSize = U16;
 }
 
-impl BlockEncrypt for Sm4 {
-    fn encrypt_with_backend(&self, f: impl cipher::BlockClosure<BlockSize = Self::BlockSize>) {
+impl BlockCipherEncrypt for Sm4 {
+    #[inline]
+    fn encrypt_with_backend(&self, f: impl BlockCipherEncClosure<BlockSize = Self::BlockSize>) {
         f.call(&mut Sm4Enc(self))
     }
 }
@@ -375,14 +370,14 @@ impl<'a> ParBlocksSizeUser for Sm4Enc<'a> {
     type ParBlocksSize = U8;
 }
 
-impl<'a> BlockBackend for Sm4Enc<'a> {
+impl<'a> BlockCipherEncBackend for Sm4Enc<'a> {
     #[inline(always)]
-    fn proc_block(&mut self, block: InOut<'_, '_, Block<Self>>) {
+    fn encrypt_block(&self, block: InOut<'_, '_, Block<Self>>) {
         unsafe { sm4_encrypt1::<Self>(block, &self.0.erk) }
     }
 
     #[inline(always)]
-    fn proc_tail_blocks(&mut self, blocks: InOutBuf<'_, '_, Block<Self>>) {
+    fn encrypt_tail_blocks(&self, blocks: InOutBuf<'_, '_, Block<Self>>) {
         assert!(blocks.len() < Self::ParBlocksSize::USIZE);
 
         let (chunks, tail) = blocks.into_chunks::<U4>();
@@ -396,13 +391,13 @@ impl<'a> BlockBackend for Sm4Enc<'a> {
     }
 
     #[inline(always)]
-    fn proc_par_blocks(&mut self, blocks: InOut<'_, '_, ParBlocks<Self>>) {
+    fn encrypt_par_blocks(&mut self, blocks: InOut<'_, '_, ParBlocks<Self>>) {
         unsafe { sm4_encrypt8::<Self>(blocks, &self.0.erk) }
     }
 }
 
-impl BlockDecrypt for Sm4 {
-    fn decrypt_with_backend(&self, f: impl cipher::BlockClosure<BlockSize = Self::BlockSize>) {
+impl BlockCipherDecrypt for Sm4 {
+    fn decrypt_with_backend(&self, f: impl BlockCipherDecClosure<BlockSize = Self::BlockSize>) {
         f.call(&mut Sm4Dec(self))
     }
 }
@@ -417,14 +412,14 @@ impl<'a> ParBlocksSizeUser for Sm4Dec<'a> {
     type ParBlocksSize = U8;
 }
 
-impl<'a> BlockBackend for Sm4Dec<'a> {
+impl<'a> BlockCipherDecBackend for Sm4Dec<'a> {
     #[inline(always)]
-    fn proc_block(&mut self, block: InOut<'_, '_, Block<Self>>) {
+    fn decrypt_block(&self, block: InOut<'_, '_, Block<Self>>) {
         unsafe { sm4_decrypt1::<Self>(block, &self.0.drk) }
     }
 
     #[inline(always)]
-    fn proc_tail_blocks(&mut self, blocks: InOutBuf<'_, '_, Block<Self>>) {
+    fn decrypt_tail_blocks(&self, blocks: InOutBuf<'_, '_, Block<Self>>) {
         assert!(blocks.len() < Self::ParBlocksSize::USIZE);
 
         let (chunks, tail) = blocks.into_chunks::<U4>();
@@ -438,7 +433,7 @@ impl<'a> BlockBackend for Sm4Dec<'a> {
     }
 
     #[inline(always)]
-    fn proc_par_blocks(&mut self, blocks: InOut<'_, '_, ParBlocks<Self>>) {
+    fn decrypt_par_blocks(&mut self, blocks: InOut<'_, '_, ParBlocks<Self>>) {
         unsafe { sm4_decrypt8::<Self>(blocks, &self.0.drk) }
     }
 }