Interface Padding

block-padding/src/lib.rs:15–81

Trait for message padding algorithms.

/// Trait for message padding algorithms.
pub trait Padding: 'static {
    /// Pads `block` filled with data up to `pos` (i.e the message length
    /// stored in `block` is equal to `pos`).
    ///
    /// # Panics
    /// If `pos` is bigger than `block.len()`. Most padding algorithms also
    /// panic if they are equal.
    fn raw_pad(block: &mut [u8], pos: usize);

    /// Unpad data in `block`.
    ///
    /// # Errors
    /// If the block contains malformed padding.
    fn raw_unpad(block: &[u8]) -> Result<&[u8], Error>;

    /// Pads `block` filled with data up to `pos` (i.e the message length
    /// stored in `block` is equal to `pos`).
    ///
    /// # Panics
    /// If `pos` is bigger than `BlockSize`. Most padding algorithms also
    /// panic if they are equal.
    #[inline]
    fn pad<BlockSize: ArraySize>(block: &mut Array<u8, BlockSize>, pos: usize) {
        Self::raw_pad(block.as_mut_slice(), pos);
    }

    /// Unpad data in `block`.
    ///
    /// # Errors
    /// If the block contains malformed padding.
    #[inline]
    fn unpad<BlockSize: ArraySize>(block: &Array<u8, BlockSize>) -> Result<&[u8], Error> {
        Self::raw_unpad(block.as_slice())
    }

    /// Pad message and return padded tail block.
    ///
    /// [`PaddedData::Error`] is returned only by [`NoPadding`] if `data` length is not multiple
    /// of the block size. [`NoPadding`] and [`ZeroPadding`] return [`PaddedData::NoPad`]
    /// if `data` length is multiple of block size. All other padding implementations
    /// should always return [`PaddedData::Pad`].
    #[inline]
    #[must_use]
    fn pad_detached<BlockSize: ArraySize>(data: &[u8]) -> PaddedData<'_, BlockSize> {
        let (blocks, tail) = Array::slice_as_chunks(data);
        let mut tail_block = Array::default();
        let pos = tail.len();
        tail_block[..pos].copy_from_slice(tail);
        Self::pad(&mut tail_block, pos);
        PaddedData::Pad { blocks, tail_block }
    }

    /// Unpad data in `blocks` and return unpadded byte slice.
    ///
    /// # Errors
    /// If `blocks` contain malformed padding.
    #[inline]
    fn unpad_blocks<BlockSize: ArraySize>(blocks: &[Array<u8, BlockSize>]) -> Result<&[u8], Error> {