345 lines
10 KiB
Rust
345 lines
10 KiB
Rust
|
//! Fixed size buffer for block processing of data.
|
||
|
|
#![no_std]
|
||
|
|
#![doc(
|
||
|
|
html_logo_url = "https://raw.githubusercontent.com/RustCrypto/media/6ee8e381/logo.svg",
|
||
|
|
html_favicon_url = "https://raw.githubusercontent.com/RustCrypto/media/6ee8e381/logo.svg"
|
||
|
|
)]
|
||
|
|
#![warn(missing_docs, rust_2018_idioms)]
|
||
|
|
|
||
|
|
pub use generic_array;
|
||
|
|
|
||
|
|
use core::{fmt, marker::PhantomData, slice};
|
||
|
|
use generic_array::{
|
||
|
|
typenum::{IsLess, Le, NonZero, U256},
|
||
|
|
ArrayLength, GenericArray,
|
||
|
|
};
|
||
|
|
|
||
|
|
mod sealed;
|
||
|
|
|
||
|
|
/// Block on which `BlockBuffer` operates.
|
||
|
|
pub type Block<BlockSize> = GenericArray<u8, BlockSize>;
|
||
|
|
|
||
|
|
/// Trait for buffer kinds.
|
||
|
|
pub trait BufferKind: sealed::Sealed {}
|
||
|
|
|
||
|
|
/// Eager block buffer kind, which guarantees that buffer position
|
||
|
|
/// always lies in the range of `0..BlockSize`.
|
||
|
|
#[derive(Copy, Clone, Debug, Default)]
|
||
|
|
pub struct Eager {}
|
||
|
|
|
||
|
|
/// Lazy block buffer kind, which guarantees that buffer position
|
||
|
|
/// always lies in the range of `0..=BlockSize`.
|
||
|
|
#[derive(Copy, Clone, Debug, Default)]
|
||
|
|
pub struct Lazy {}
|
||
|
|
|
||
|
|
impl BufferKind for Eager {}
|
||
|
|
impl BufferKind for Lazy {}
|
||
|
|
|
||
|
|
/// Eager block buffer.
|
||
|
|
pub type EagerBuffer<B> = BlockBuffer<B, Eager>;
|
||
|
|
/// Lazy block buffer.
|
||
|
|
pub type LazyBuffer<B> = BlockBuffer<B, Lazy>;
|
||
|
|
|
||
|
|
/// Block buffer error.
|
||
|
|
#[derive(Copy, Clone, Eq, PartialEq, Debug)]
|
||
|
|
pub struct Error;
|
||
|
|
|
||
|
|
impl fmt::Display for Error {
|
||
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
|
||
|
|
f.write_str("Block buffer error")
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Buffer for block processing of data.
|
||
|
|
#[derive(Debug)]
|
||
|
|
pub struct BlockBuffer<BlockSize, Kind>
|
||
|
|
where
|
||
|
|
BlockSize: ArrayLength<u8> + IsLess<U256>,
|
||
|
|
Le<BlockSize, U256>: NonZero,
|
||
|
|
Kind: BufferKind,
|
||
|
|
{
|
||
|
|
buffer: Block<BlockSize>,
|
||
|
|
pos: u8,
|
||
|
|
_pd: PhantomData<Kind>,
|
||
|
|
}
|
||
|
|
|
||
|
|
impl<BlockSize, Kind> Default for BlockBuffer<BlockSize, Kind>
|
||
|
|
where
|
||
|
|
BlockSize: ArrayLength<u8> + IsLess<U256>,
|
||
|
|
Le<BlockSize, U256>: NonZero,
|
||
|
|
Kind: BufferKind,
|
||
|
|
{
|
||
|
|
fn default() -> Self {
|
||
|
|
Self {
|
||
|
|
buffer: Default::default(),
|
||
|
|
pos: 0,
|
||
|
|
_pd: PhantomData,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
impl<BlockSize, Kind> Clone for BlockBuffer<BlockSize, Kind>
|
||
|
|
where
|
||
|
|
BlockSize: ArrayLength<u8> + IsLess<U256>,
|
||
|
|
Le<BlockSize, U256>: NonZero,
|
||
|
|
Kind: BufferKind,
|
||
|
|
{
|
||
|
|
fn clone(&self) -> Self {
|
||
|
|
Self {
|
||
|
|
buffer: self.buffer.clone(),
|
||
|
|
pos: self.pos,
|
||
|
|
_pd: PhantomData,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
impl<BlockSize, Kind> BlockBuffer<BlockSize, Kind>
|
||
|
|
where
|
||
|
|
BlockSize: ArrayLength<u8> + IsLess<U256>,
|
||
|
|
Le<BlockSize, U256>: NonZero,
|
||
|
|
Kind: BufferKind,
|
||
|
|
{
|
||
|
|
/// Create new buffer from slice.
|
||
|
|
///
|
||
|
|
/// # Panics
|
||
|
|
/// If slice length is not valid for used buffer kind.
|
||
|
|
#[inline(always)]
|
||
|
|
pub fn new(buf: &[u8]) -> Self {
|
||
|
|
Self::try_new(buf).unwrap()
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Create new buffer from slice.
|
||
|
|
///
|
||
|
|
/// Returns an error if slice length is not valid for used buffer kind.
|
||
|
|
#[inline(always)]
|
||
|
|
pub fn try_new(buf: &[u8]) -> Result<Self, Error> {
|
||
|
|
let pos = buf.len();
|
||
|
|
if !Kind::invariant(pos, BlockSize::USIZE) {
|
||
|
|
return Err(Error);
|
||
|
|
}
|
||
|
|
let mut buffer = Block::<BlockSize>::default();
|
||
|
|
buffer[..pos].copy_from_slice(buf);
|
||
|
|
Ok(Self {
|
||
|
|
buffer,
|
||
|
|
pos: pos as u8,
|
||
|
|
_pd: PhantomData,
|
||
|
|
})
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Digest data in `input` in blocks of size `BlockSize` using
|
||
|
|
/// the `compress` function, which accepts slice of blocks.
|
||
|
|
#[inline]
|
||
|
|
pub fn digest_blocks(
|
||
|
|
&mut self,
|
||
|
|
mut input: &[u8],
|
||
|
|
mut compress: impl FnMut(&[Block<BlockSize>]),
|
||
|
|
) {
|
||
|
|
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 Kind::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) = Kind::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) -> &mut Block<BlockSize> {
|
||
|
|
let pos = self.get_pos();
|
||
|
|
self.buffer[pos..].iter_mut().for_each(|b| *b = 0);
|
||
|
|
self.set_pos_unchecked(0);
|
||
|
|
&mut self.buffer
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Return current cursor position.
|
||
|
|
#[inline(always)]
|
||
|
|
pub fn get_pos(&self) -> usize {
|
||
|
|
let pos = self.pos as usize;
|
||
|
|
if !Kind::invariant(pos, BlockSize::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<BlockSize>, pos: usize) {
|
||
|
|
assert!(Kind::invariant(pos, BlockSize::USIZE));
|
||
|
|
self.buffer = buf;
|
||
|
|
self.set_pos_unchecked(pos);
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Return size of the internall buffer in bytes.
|
||
|
|
#[inline(always)]
|
||
|
|
pub fn size(&self) -> usize {
|
||
|
|
BlockSize::USIZE
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Return number of remaining bytes in the internall 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!(Kind::invariant(pos, BlockSize::USIZE));
|
||
|
|
self.pos = pos as u8;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
impl<BlockSize> BlockBuffer<BlockSize, Eager>
|
||
|
|
where
|
||
|
|
BlockSize: ArrayLength<u8> + IsLess<U256>,
|
||
|
|
Le<BlockSize, U256>: NonZero,
|
||
|
|
{
|
||
|
|
/// Set `data` to generated blocks.
|
||
|
|
#[inline]
|
||
|
|
pub fn set_data(
|
||
|
|
&mut self,
|
||
|
|
mut data: &mut [u8],
|
||
|
|
mut process_blocks: impl FnMut(&mut [Block<BlockSize>]),
|
||
|
|
) {
|
||
|
|
let pos = self.get_pos();
|
||
|
|
let r = self.remaining();
|
||
|
|
let n = data.len();
|
||
|
|
if pos != 0 {
|
||
|
|
if n < r {
|
||
|
|
// double slicing allows to remove panic branches
|
||
|
|
data.copy_from_slice(&self.buffer[pos..][..n]);
|
||
|
|
self.set_pos_unchecked(pos + n);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
let (left, right) = data.split_at_mut(r);
|
||
|
|
data = right;
|
||
|
|
left.copy_from_slice(&self.buffer[pos..]);
|
||
|
|
}
|
||
|
|
|
||
|
|
let (blocks, leftover) = to_blocks_mut(data);
|
||
|
|
process_blocks(blocks);
|
||
|
|
|
||
|
|
let n = leftover.len();
|
||
|
|
if n != 0 {
|
||
|
|
let mut block = Default::default();
|
||
|
|
process_blocks(slice::from_mut(&mut block));
|
||
|
|
leftover.copy_from_slice(&block[..n]);
|
||
|
|
self.buffer = block;
|
||
|
|
}
|
||
|
|
self.set_pos_unchecked(n);
|
||
|
|
}
|
||
|
|
|
||
|
|
/// 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<BlockSize>),
|
||
|
|
) {
|
||
|
|
if suffix.len() > BlockSize::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::<BlockSize>::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<BlockSize>)) {
|
||
|
|
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<BlockSize>)) {
|
||
|
|
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<BlockSize>)) {
|
||
|
|
self.digest_pad(0x80, &data_len.to_be_bytes(), compress);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Split message into mutable slice of parallel blocks, blocks, and leftover bytes.
|
||
|
|
#[inline(always)]
|
||
|
|
fn to_blocks_mut<N: ArrayLength<u8>>(data: &mut [u8]) -> (&mut [Block<N>], &mut [u8]) {
|
||
|
|
let nb = data.len() / N::USIZE;
|
||
|
|
let (left, right) = data.split_at_mut(nb * N::USIZE);
|
||
|
|
let p = left.as_mut_ptr() as *mut Block<N>;
|
||
|
|
// SAFETY: we guarantee that `blocks` does not point outside of `data`, and `p` is valid for
|
||
|
|
// mutation
|
||
|
|
let blocks = unsafe { slice::from_raw_parts_mut(p, nb) };
|
||
|
|
(blocks, right)
|
||
|
|
}
|