Struct block_buffer::BlockBuffer

impl<BS: BlockSizes, K: BufferKind> BlockBuffer<BS, K>

pub fn new(buf: &[u8]) -> Self

Create new buffer from slice.

Panics

If slice length is not valid for used buffer kind.

pub fn try_new(buf: &[u8]) -> Result<Self, Error>

Create new buffer from slice.

Returns an error if slice length is not valid for used buffer kind.

Examples found in repository ?

src/lib.rs (line 97)

96
97
98

    pub fn new(buf: &[u8]) -> Self {
        Self::try_new(buf).unwrap()
    }

pub fn digest_blocks(
 &mut self,
 input: &[u8],
 compress: impl FnMut(&[Block<Self>])
)

Digest data in input in blocks of size BlockSize using the compress function, which accepts slice of blocks.

pub fn reset(&mut self)

Reset buffer by setting cursor position to zero.

pub fn pad_with_zeros(&mut self) -> Block<Self>

Pad remaining data with zeros and return resulting block.

pub fn get_pos(&self) -> usize

Return current cursor position.

Examples found in repository ?

src/lib.rs (line 119)

    pub fn digest_blocks(&mut self, mut input: &[u8], mut compress: impl FnMut(&[Block<Self>])) {
        let pos = self.get_pos();
        // using `self.remaining()` for some reason
        // prevents panic elimination
        let rem = self.size() - pos;
        let n = input.len();
        // Note that checking condition `pos + n < BlockSize` is
        // equivalent to checking `n < rem`, where `rem` is equal
        // to `BlockSize - pos`. Using the latter allows us to work
        // around compiler accounting for possible overflow of
        // `pos + n` which results in it inserting unreachable
        // panic branches. Using `unreachable_unchecked` in `get_pos`
        // we convince compiler that `BlockSize - pos` never underflows.
        if K::invariant(n, rem) {
            // double slicing allows to remove panic branches
            self.buffer[pos..][..n].copy_from_slice(input);
            self.set_pos_unchecked(pos + n);
            return;
        }
        if pos != 0 {
            let (left, right) = input.split_at(rem);
            input = right;
            self.buffer[pos..].copy_from_slice(left);
            compress(slice::from_ref(&self.buffer));
        }

        let (blocks, leftover) = K::split_blocks(input);
        if !blocks.is_empty() {
            compress(blocks);
        }

        let n = leftover.len();
        self.buffer[..n].copy_from_slice(leftover);
        self.set_pos_unchecked(n);
    }

    /// Reset buffer by setting cursor position to zero.
    #[inline(always)]
    pub fn reset(&mut self) {
        self.set_pos_unchecked(0);
    }

    /// Pad remaining data with zeros and return resulting block.
    #[inline(always)]
    pub fn pad_with_zeros(&mut self) -> Block<Self> {
        let pos = self.get_pos();
        let mut res = self.buffer.clone();
        res[pos..].iter_mut().for_each(|b| *b = 0);
        self.set_pos_unchecked(0);
        res
    }

    /// Return current cursor position.
    #[inline(always)]
    pub fn get_pos(&self) -> usize {
        let pos = K::get_pos(&self.buffer, &self.pos);
        if !K::invariant(pos, BS::USIZE) {
            debug_assert!(false);
            // SAFETY: `pos` never breaks the invariant
            unsafe {
                core::hint::unreachable_unchecked();
            }
        }
        pos
    }

    /// Return slice of data stored inside the buffer.
    #[inline(always)]
    pub fn get_data(&self) -> &[u8] {
        &self.buffer[..self.get_pos()]
    }

    /// Set buffer content and cursor position.
    ///
    /// # Panics
    /// If `pos` is bigger or equal to block size.
    #[inline]
    pub fn set(&mut self, buf: Block<Self>, pos: usize) {
        assert!(K::invariant(pos, BS::USIZE));
        self.buffer = buf;
        self.set_pos_unchecked(pos);
    }

    /// Return size of the internal buffer in bytes.
    #[inline(always)]
    pub fn size(&self) -> usize {
        BS::USIZE
    }

    /// Return number of remaining bytes in the internal buffer.
    #[inline(always)]
    pub fn remaining(&self) -> usize {
        self.size() - self.get_pos()
    }

    #[inline(always)]
    fn set_pos_unchecked(&mut self, pos: usize) {
        debug_assert!(K::invariant(pos, BS::USIZE));
        K::set_pos(&mut self.buffer, &mut self.pos, pos)
    }
}

impl<BS: BlockSizes> BlockBuffer<BS, Eager> {
    /// Compress remaining data after padding it with `delim`, zeros and
    /// the `suffix` bytes. If there is not enough unused space, `compress`
    /// will be called twice.
    ///
    /// # Panics
    /// If suffix length is bigger than block size.
    #[inline(always)]
    pub fn digest_pad(&mut self, delim: u8, suffix: &[u8], mut compress: impl FnMut(&Block<Self>)) {
        if suffix.len() > BS::USIZE {
            panic!("suffix is too long");
        }
        let pos = self.get_pos();
        self.buffer[pos] = delim;
        for b in &mut self.buffer[pos + 1..] {
            *b = 0;
        }

        let n = self.size() - suffix.len();
        if self.size() - pos - 1 < suffix.len() {
            compress(&self.buffer);
            let mut block = Block::<Self>::default();
            block[n..].copy_from_slice(suffix);
            compress(&block);
        } else {
            self.buffer[n..].copy_from_slice(suffix);
            compress(&self.buffer);
        }
        self.set_pos_unchecked(0)
    }

    /// Pad message with 0x80, zeros and 64-bit message length using
    /// big-endian byte order.
    #[inline]
    pub fn len64_padding_be(&mut self, data_len: u64, compress: impl FnMut(&Block<Self>)) {
        self.digest_pad(0x80, &data_len.to_be_bytes(), compress);
    }

    /// Pad message with 0x80, zeros and 64-bit message length using
    /// little-endian byte order.
    #[inline]
    pub fn len64_padding_le(&mut self, data_len: u64, compress: impl FnMut(&Block<Self>)) {
        self.digest_pad(0x80, &data_len.to_le_bytes(), compress);
    }

    /// Pad message with 0x80, zeros and 128-bit message length using
    /// big-endian byte order.
    #[inline]
    pub fn len128_padding_be(&mut self, data_len: u128, compress: impl FnMut(&Block<Self>)) {
        self.digest_pad(0x80, &data_len.to_be_bytes(), compress);
    }

    /// Serialize buffer into a byte array.
    #[inline]
    pub fn serialize(&self) -> Block<Self> {
        let mut res = self.buffer.clone();
        let pos = self.get_pos();
        // zeroize "garbage" data
        for b in res[pos..BS::USIZE - 1].iter_mut() {
            *b = 0;
        }
        res
    }

pub fn get_data(&self) -> &[u8]

Return slice of data stored inside the buffer.

Examples found in repository ?

src/lib.rs (line 311)

    pub fn serialize(&self) -> BlockP1<BS>
    where
        BS: Add<B1>,
        Add1<BS>: ArrayLength<u8>,
    {
        let mut res = BlockP1::<BS>::default();
        res[0] = self.pos;
        let data = self.get_data();
        res[1..][..data.len()].copy_from_slice(data);
        res
    }

pub fn set(&mut self, buf: Block<Self>, pos: usize)

Set buffer content and cursor position.

Panics

If pos is bigger or equal to block size.

pub fn size(&self) -> usize

Return size of the internal buffer in bytes.

Examples found in repository ?

src/lib.rs (line 122)

    pub fn digest_blocks(&mut self, mut input: &[u8], mut compress: impl FnMut(&[Block<Self>])) {
        let pos = self.get_pos();
        // using `self.remaining()` for some reason
        // prevents panic elimination
        let rem = self.size() - pos;
        let n = input.len();
        // Note that checking condition `pos + n < BlockSize` is
        // equivalent to checking `n < rem`, where `rem` is equal
        // to `BlockSize - pos`. Using the latter allows us to work
        // around compiler accounting for possible overflow of
        // `pos + n` which results in it inserting unreachable
        // panic branches. Using `unreachable_unchecked` in `get_pos`
        // we convince compiler that `BlockSize - pos` never underflows.
        if K::invariant(n, rem) {
            // double slicing allows to remove panic branches
            self.buffer[pos..][..n].copy_from_slice(input);
            self.set_pos_unchecked(pos + n);
            return;
        }
        if pos != 0 {
            let (left, right) = input.split_at(rem);
            input = right;
            self.buffer[pos..].copy_from_slice(left);
            compress(slice::from_ref(&self.buffer));
        }

        let (blocks, leftover) = K::split_blocks(input);
        if !blocks.is_empty() {
            compress(blocks);
        }

        let n = leftover.len();
        self.buffer[..n].copy_from_slice(leftover);
        self.set_pos_unchecked(n);
    }

    /// Reset buffer by setting cursor position to zero.
    #[inline(always)]
    pub fn reset(&mut self) {
        self.set_pos_unchecked(0);
    }

    /// Pad remaining data with zeros and return resulting block.
    #[inline(always)]
    pub fn pad_with_zeros(&mut self) -> Block<Self> {
        let pos = self.get_pos();
        let mut res = self.buffer.clone();
        res[pos..].iter_mut().for_each(|b| *b = 0);
        self.set_pos_unchecked(0);
        res
    }

    /// Return current cursor position.
    #[inline(always)]
    pub fn get_pos(&self) -> usize {
        let pos = K::get_pos(&self.buffer, &self.pos);
        if !K::invariant(pos, BS::USIZE) {
            debug_assert!(false);
            // SAFETY: `pos` never breaks the invariant
            unsafe {
                core::hint::unreachable_unchecked();
            }
        }
        pos
    }

    /// Return slice of data stored inside the buffer.
    #[inline(always)]
    pub fn get_data(&self) -> &[u8] {
        &self.buffer[..self.get_pos()]
    }

    /// Set buffer content and cursor position.
    ///
    /// # Panics
    /// If `pos` is bigger or equal to block size.
    #[inline]
    pub fn set(&mut self, buf: Block<Self>, pos: usize) {
        assert!(K::invariant(pos, BS::USIZE));
        self.buffer = buf;
        self.set_pos_unchecked(pos);
    }

    /// Return size of the internal buffer in bytes.
    #[inline(always)]
    pub fn size(&self) -> usize {
        BS::USIZE
    }

    /// Return number of remaining bytes in the internal buffer.
    #[inline(always)]
    pub fn remaining(&self) -> usize {
        self.size() - self.get_pos()
    }

    #[inline(always)]
    fn set_pos_unchecked(&mut self, pos: usize) {
        debug_assert!(K::invariant(pos, BS::USIZE));
        K::set_pos(&mut self.buffer, &mut self.pos, pos)
    }
}

impl<BS: BlockSizes> BlockBuffer<BS, Eager> {
    /// Compress remaining data after padding it with `delim`, zeros and
    /// the `suffix` bytes. If there is not enough unused space, `compress`
    /// will be called twice.
    ///
    /// # Panics
    /// If suffix length is bigger than block size.
    #[inline(always)]
    pub fn digest_pad(&mut self, delim: u8, suffix: &[u8], mut compress: impl FnMut(&Block<Self>)) {
        if suffix.len() > BS::USIZE {
            panic!("suffix is too long");
        }
        let pos = self.get_pos();
        self.buffer[pos] = delim;
        for b in &mut self.buffer[pos + 1..] {
            *b = 0;
        }

        let n = self.size() - suffix.len();
        if self.size() - pos - 1 < suffix.len() {
            compress(&self.buffer);
            let mut block = Block::<Self>::default();
            block[n..].copy_from_slice(suffix);
            compress(&block);
        } else {
            self.buffer[n..].copy_from_slice(suffix);
            compress(&self.buffer);
        }
        self.set_pos_unchecked(0)
    }

pub fn remaining(&self) -> usize

Return number of remaining bytes in the internal buffer.

impl<BS: BlockSizes> BlockBuffer<BS, Eager>

pub fn digest_pad(
 &mut self,
 delim: u8,
 suffix: &[u8],
 compress: impl FnMut(&Block<Self>)
)

Compress remaining data after padding it with delim, zeros and the suffix bytes. If there is not enough unused space, compress will be called twice.

Panics

If suffix length is bigger than block size.

Examples found in repository ?

src/lib.rs (line 255)

    pub fn len64_padding_be(&mut self, data_len: u64, compress: impl FnMut(&Block<Self>)) {
        self.digest_pad(0x80, &data_len.to_be_bytes(), compress);
    }

    /// Pad message with 0x80, zeros and 64-bit message length using
    /// little-endian byte order.
    #[inline]
    pub fn len64_padding_le(&mut self, data_len: u64, compress: impl FnMut(&Block<Self>)) {
        self.digest_pad(0x80, &data_len.to_le_bytes(), compress);
    }

    /// Pad message with 0x80, zeros and 128-bit message length using
    /// big-endian byte order.
    #[inline]
    pub fn len128_padding_be(&mut self, data_len: u128, compress: impl FnMut(&Block<Self>)) {
        self.digest_pad(0x80, &data_len.to_be_bytes(), compress);
    }

pub fn len64_padding_be(
 &mut self,
 data_len: u64,
 compress: impl FnMut(&Block<Self>)
)

Pad message with 0x80, zeros and 64-bit message length using big-endian byte order.

pub fn len64_padding_le(
 &mut self,
 data_len: u64,
 compress: impl FnMut(&Block<Self>)
)

Pad message with 0x80, zeros and 64-bit message length using little-endian byte order.

pub fn len128_padding_be(
 &mut self,
 data_len: u128,
 compress: impl FnMut(&Block<Self>)
)

Pad message with 0x80, zeros and 128-bit message length using big-endian byte order.

pub fn serialize(&self) -> Block<Self>

Serialize buffer into a byte array.

pub fn deserialize(buffer: &Block<Self>) -> Result<Self, Error>

Deserialize buffer from a byte array.

impl<BS: BlockSizes> BlockBuffer<BS, Lazy>

pub fn serialize(&self) -> GenericArray<u8, Add1<BS>>where
BS: Add<B1>,
Add1<BS>: ArrayLength<u8>,

Serialize buffer into a byte array.

pub fn deserialize(buffer: &GenericArray<u8, Add1<BS>>) -> Result<Self, Error>where
BS: Add<B1>,
Add1<BS>: ArrayLength<u8>,

Deserialize buffer from a byte array.

Trait Implementations§

impl<BS: BlockSizes, K: BufferKind> BlockSizeUser for BlockBuffer<BS, K>

type BlockSize = BS

Size of the block in bytes.

fn block_size() -> usize

Return block size in bytes.

impl<BS: BlockSizes, K: BufferKind> Clone for BlockBuffer<BS, K>

fn clone(&self) -> Self

Returns a copy of the value. Read more

1.0.0 · source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more

impl<BS: Debug + BlockSizes, K: Debug + BufferKind> Debug for BlockBuffer<BS, K>where
K::Pos: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more

impl<BS: BlockSizes, K: BufferKind> Default for BlockBuffer<BS, K>

fn default() -> Self

Returns the “default value” for a type. Read more

Auto Trait Implementations§

impl<BS, K> RefUnwindSafe for BlockBuffer<BS, K>where
<BS as ArrayLength<u8>>::ArrayType: RefUnwindSafe,
<K as Sealed>::Pos: RefUnwindSafe,

impl<BS, K> Send for BlockBuffer<BS, K>where
<K as Sealed>::Pos: Send,

impl<BS, K> Sync for BlockBuffer<BS, K>where
<K as Sealed>::Pos: Sync,

impl<BS, K> Unpin for BlockBuffer<BS, K>where
<BS as ArrayLength<u8>>::ArrayType: Unpin,
<K as Sealed>::Pos: Unpin,

impl<BS, K> UnwindSafe for BlockBuffer<BS, K>where
<BS as ArrayLength<u8>>::ArrayType: UnwindSafe,
<K as Sealed>::Pos: UnwindSafe,

Blanket Implementations§

impl<T> Any for Twhere
T: 'static + ?Sized,

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

impl<T> Borrow<T> for Twhere
T: ?Sized,

const: unstable · source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for Twhere
T: ?Sized,

const: unstable · source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

impl<T> From<T> for T

const: unstable · source§

fn from(t: T) -> T

Returns the argument unchanged.

impl<T, U> Into for Twhere
U: From<T>,

const: unstable · source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

impl<T> Same<T> for T

type Output = T

Should always be Self

impl<T, U> TryFrom for Twhere
U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

const: unstable · source§

fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>

Performs the conversion.

impl<T, U> TryInto for Twhere
U: TryFrom<T>,