chore(deps): bump block-padding from 0.4.0-rc.4 to 0.4.1

Author: baloo

Cargo.lock

@@ -17,7 +17,7 @@ use inout::{InOut, InOutBuf, NotEqualError};
 #[cfg(feature = "block-padding")]
 use inout::{
     InOutBufReserved, PadError,
-    block_padding::{Padding, UnpadError},
+    block_padding::{self, Padding},
 };
 
 mod backends;
@@ -87,7 +87,7 @@ pub trait BlockCipherEncrypt: BlockSizeUser + Sized {
     /// Returns [`PadError`] if length of output buffer is not sufficient.
     #[cfg(feature = "block-padding")]
     #[inline]
-    fn encrypt_padded_inout<'out, P: Padding<Self::BlockSize>>(
+    fn encrypt_padded_inout<'out, P: Padding>(
         &self,
         data: InOutBufReserved<'_, 'out, u8>,
     ) -> Result<&'out [u8], PadError> {
@@ -104,7 +104,7 @@ pub trait BlockCipherEncrypt: BlockSizeUser + Sized {
     /// Returns [`PadError`] if length of output buffer is not sufficient.
     #[cfg(feature = "block-padding")]
     #[inline]
-    fn encrypt_padded<'a, P: Padding<Self::BlockSize>>(
+    fn encrypt_padded<'a, P: Padding>(
         &self,
         buf: &'a mut [u8],
         msg_len: usize,
@@ -118,7 +118,7 @@ pub trait BlockCipherEncrypt: BlockSizeUser + Sized {
     /// Returns [`PadError`] if length of output buffer is not sufficient.
     #[cfg(feature = "block-padding")]
     #[inline]
-    fn encrypt_padded_b2b<'a, P: Padding<Self::BlockSize>>(
+    fn encrypt_padded_b2b<'a, P: Padding>(
         &self,
         msg: &[u8],
         out_buf: &'a mut [u8],
@@ -130,7 +130,7 @@ pub trait BlockCipherEncrypt: BlockSizeUser + Sized {
     /// Pad input and encrypt into a newly allocated Vec. Returns resulting ciphertext Vec.
     #[cfg(all(feature = "block-padding", feature = "alloc"))]
     #[inline]
-    fn encrypt_padded_vec<P: Padding<Self::BlockSize>>(&self, msg: &[u8]) -> Vec<u8> {
+    fn encrypt_padded_vec<P: Padding>(&self, msg: &[u8]) -> Vec<u8> {
         use crypto_common::typenum::Unsigned;
         let bs = Self::BlockSize::USIZE;
         let mut out = vec![0; bs * (msg.len() / bs + 1)];
@@ -197,67 +197,64 @@ pub trait BlockCipherDecrypt: BlockSizeUser {
 
     /// Decrypt input and unpad it. Returns resulting plaintext slice.
     ///
-    /// Returns [`UnpadError`] if padding is malformed or if input length is
+    /// Returns [`block_padding::Error`] if padding is malformed or if input length is
     /// not multiple of `Self::BlockSize`.
     #[cfg(feature = "block-padding")]
     #[inline]
-    fn decrypt_padded_inout<'out, P: Padding<Self::BlockSize>>(
+    fn decrypt_padded_inout<'out, P: Padding>(
         &self,
         data: InOutBuf<'_, 'out, u8>,
-    ) -> Result<&'out [u8], UnpadError> {
+    ) -> Result<&'out [u8], block_padding::Error> {
         let (mut blocks, tail) = data.into_chunks();
         if !tail.is_empty() {
-            return Err(UnpadError);
+            return Err(block_padding::Error);
         }
         self.decrypt_blocks_inout(blocks.reborrow());
-        P::unpad_blocks(blocks.into_out())
+        P::unpad_blocks::<Self::BlockSize>(blocks.into_out())
     }
 
     /// Decrypt input and unpad it in-place. Returns resulting plaintext slice.
     ///
-    /// Returns [`UnpadError`] if padding is malformed or if input length is
+    /// Returns [`block_padding::Error`] if padding is malformed or if input length is
     /// not multiple of `Self::BlockSize`.
     #[cfg(feature = "block-padding")]
     #[inline]
-    fn decrypt_padded<'a, P: Padding<Self::BlockSize>>(
+    fn decrypt_padded<'a, P: Padding>(
         &self,
         buf: &'a mut [u8],
-    ) -> Result<&'a [u8], UnpadError> {
+    ) -> Result<&'a [u8], block_padding::Error> {
         self.decrypt_padded_inout::<P>(buf.into())
     }
 
     /// Decrypt input and unpad it buffer-to-buffer. Returns resulting
     /// plaintext slice.
     ///
-    /// Returns [`UnpadError`] if padding is malformed or if input length is
+    /// Returns [`block_padding::Error`] if padding is malformed or if input length is
     /// not multiple of `Self::BlockSize`.
     #[cfg(feature = "block-padding")]
     #[inline]
-    fn decrypt_padded_b2b<'a, P: Padding<Self::BlockSize>>(
+    fn decrypt_padded_b2b<'a, P: Padding>(
         &self,
         in_buf: &[u8],
         out_buf: &'a mut [u8],
-    ) -> Result<&'a [u8], UnpadError> {
+    ) -> Result<&'a [u8], block_padding::Error> {
         if out_buf.len() < in_buf.len() {
-            return Err(UnpadError);
+            return Err(block_padding::Error);
         }
         let n = in_buf.len();
         // note: `new` always returns `Ok` here
-        let buf = InOutBuf::new(in_buf, &mut out_buf[..n]).map_err(|_| UnpadError)?;
+        let buf = InOutBuf::new(in_buf, &mut out_buf[..n]).map_err(|_| block_padding::Error)?;
         self.decrypt_padded_inout::<P>(buf)
     }
 
     /// Decrypt input and unpad it in a newly allocated Vec. Returns resulting
     /// plaintext `Vec`.
     ///
-    /// Returns [`UnpadError`] if padding is malformed or if input length is
+    /// Returns [`block_padding::Error`] if padding is malformed or if input length is
     /// not multiple of `Self::BlockSize`.
     #[cfg(all(feature = "block-padding", feature = "alloc"))]
     #[inline]
-    fn decrypt_padded_vec<P: Padding<Self::BlockSize>>(
-        &self,
-        buf: &[u8],
-    ) -> Result<Vec<u8>, UnpadError> {
+    fn decrypt_padded_vec<P: Padding>(&self, buf: &[u8]) -> Result<Vec<u8>, block_padding::Error> {
         let mut out = vec![0; buf.len()];
         let len = self.decrypt_padded_b2b::<P>(buf, &mut out)?.len();
         out.truncate(len);
@@ -338,7 +335,7 @@ pub trait BlockModeEncrypt: BlockSizeUser + Sized {
     /// Returns [`PadError`] if length of output buffer is not sufficient.
     #[cfg(feature = "block-padding")]
     #[inline]
-    fn encrypt_padded_inout<'out, P: Padding<Self::BlockSize>>(
+    fn encrypt_padded_inout<'out, P: Padding>(
         mut self,
         data: InOutBufReserved<'_, 'out, u8>,
     ) -> Result<&'out [u8], PadError> {
@@ -355,11 +352,7 @@ pub trait BlockModeEncrypt: BlockSizeUser + Sized {
     /// Returns [`PadError`] if length of output buffer is not sufficient.
     #[cfg(feature = "block-padding")]
     #[inline]
-    fn encrypt_padded<P: Padding<Self::BlockSize>>(
-        self,
-        buf: &mut [u8],
-        msg_len: usize,
-    ) -> Result<&[u8], PadError> {
+    fn encrypt_padded<P: Padding>(self, buf: &mut [u8], msg_len: usize) -> Result<&[u8], PadError> {
         let buf = InOutBufReserved::from_mut_slice(buf, msg_len).map_err(|_| PadError)?;
         self.encrypt_padded_inout::<P>(buf)
     }
@@ -369,7 +362,7 @@ pub trait BlockModeEncrypt: BlockSizeUser + Sized {
     /// Returns [`PadError`] if length of output buffer is not sufficient.
     #[cfg(feature = "block-padding")]
     #[inline]
-    fn encrypt_padded_b2b<'a, P: Padding<Self::BlockSize>>(
+    fn encrypt_padded_b2b<'a, P: Padding>(
         self,
         msg: &[u8],
         out_buf: &'a mut [u8],
@@ -381,7 +374,7 @@ pub trait BlockModeEncrypt: BlockSizeUser + Sized {
     /// Pad input and encrypt into a newly allocated Vec. Returns resulting ciphertext Vec.
     #[cfg(all(feature = "block-padding", feature = "alloc"))]
     #[inline]
-    fn encrypt_padded_vec<P: Padding<Self::BlockSize>>(self, msg: &[u8]) -> Vec<u8> {
+    fn encrypt_padded_vec<P: Padding>(self, msg: &[u8]) -> Vec<u8> {
         use crypto_common::typenum::Unsigned;
         let bs = Self::BlockSize::USIZE;
         let mut out = vec![0; bs * (msg.len() / bs + 1)];
@@ -452,67 +445,61 @@ pub trait BlockModeDecrypt: BlockSizeUser + Sized {
 
     /// Decrypt input and unpad it. Returns resulting plaintext slice.
     ///
-    /// Returns [`UnpadError`] if padding is malformed or if input length is
+    /// Returns [`block_padding::Error`] if padding is malformed or if input length is
     /// not multiple of `Self::BlockSize`.
     #[cfg(feature = "block-padding")]
     #[inline]
-    fn decrypt_padded_inout<'out, P: Padding<Self::BlockSize>>(
+    fn decrypt_padded_inout<'out, P: Padding>(
         mut self,
         data: InOutBuf<'_, 'out, u8>,
-    ) -> Result<&'out [u8], UnpadError> {
+    ) -> Result<&'out [u8], block_padding::Error> {
         let (mut blocks, tail) = data.into_chunks();
         if !tail.is_empty() {
-            return Err(UnpadError);
+            return Err(block_padding::Error);
         }
         self.decrypt_blocks_inout(blocks.reborrow());
-        P::unpad_blocks(blocks.into_out())
+        P::unpad_blocks::<Self::BlockSize>(blocks.into_out())
     }
 
     /// Decrypt input and unpad it in-place. Returns resulting plaintext slice.
     ///
-    /// Returns [`UnpadError`] if padding is malformed or if input length is
+    /// Returns [`block_padding::Error`] if padding is malformed or if input length is
     /// not multiple of `Self::BlockSize`.
     #[cfg(feature = "block-padding")]
     #[inline]
-    fn decrypt_padded<P: Padding<Self::BlockSize>>(
-        self,
-        buf: &mut [u8],
-    ) -> Result<&[u8], UnpadError> {
+    fn decrypt_padded<P: Padding>(self, buf: &mut [u8]) -> Result<&[u8], block_padding::Error> {
         self.decrypt_padded_inout::<P>(buf.into())
     }
 
     /// Decrypt input and unpad it buffer-to-buffer. Returns resulting
     /// plaintext slice.
     ///
-    /// Returns [`UnpadError`] if padding is malformed or if input length is
+    /// Returns [`block_padding::Error`] if padding is malformed or if input length is
     /// not multiple of `Self::BlockSize`.
     #[cfg(feature = "block-padding")]
     #[inline]
-    fn decrypt_padded_b2b<'a, P: Padding<Self::BlockSize>>(
+    fn decrypt_padded_b2b<'a, P: Padding>(
         self,
         in_buf: &[u8],
         out_buf: &'a mut [u8],
-    ) -> Result<&'a [u8], UnpadError> {
+    ) -> Result<&'a [u8], block_padding::Error> {
         if out_buf.len() < in_buf.len() {
-            return Err(UnpadError);
+            return Err(block_padding::Error);
         }
         let n = in_buf.len();
         // note: `new` always returns `Ok` here
-        let buf = InOutBuf::new(in_buf, &mut out_buf[..n]).map_err(|_| UnpadError)?;
+        let buf = InOutBuf::new(in_buf, &mut out_buf[..n]).map_err(|_| block_padding::Error)?;
         self.decrypt_padded_inout::<P>(buf)
     }
 
     /// Decrypt input and unpad it in a newly allocated Vec. Returns resulting
     /// plaintext `Vec`.
     ///
-    /// Returns [`UnpadError`] if padding is malformed or if input length is
+    /// Returns [`block_padding::Error`] if padding is malformed or if input length is
     /// not multiple of `Self::BlockSize`.
     #[cfg(all(feature = "block-padding", feature = "alloc"))]
     #[inline]
-    fn decrypt_padded_vec<P: Padding<Self::BlockSize>>(
-        self,
-        buf: &[u8],
-    ) -> Result<Vec<u8>, UnpadError> {
+    fn decrypt_padded_vec<P: Padding>(self, buf: &[u8]) -> Result<Vec<u8>, block_padding::Error> {
         let mut out = vec![0; buf.len()];
         let len = self.decrypt_padded_b2b::<P>(buf, &mut out)?.len();
         out.truncate(len);