use tc_zeroize::Zeroize;
#[derive(Clone)]
pub(crate) struct MdBuffer<const N: usize> {
block: [u8; N],
offset: usize,
byte_count: u64,
}
impl<const N: usize> MdBuffer<N> {
pub(crate) const fn new() -> Self {
MdBuffer {
block: [0; N],
offset: 0,
byte_count: 0,
}
}
pub(crate) fn byte_count(&self) -> u64 {
self.byte_count
}
pub(crate) fn update(&mut self, mut input: &[u8], mut compress: impl FnMut(&[u8; N])) {
self.byte_count = self.byte_count.wrapping_add(input.len() as u64);
if self.offset != 0 {
let take = (N - self.offset).min(input.len());
self.block[self.offset..self.offset + take].copy_from_slice(&input[..take]);
self.offset += take;
input = &input[take..];
if self.offset == N {
compress(&self.block);
self.offset = 0;
}
}
while input.len() >= N {
let (block, rest) = input.split_at(N);
compress(block.try_into().expect("split_at(N) yields N bytes"));
input = rest;
}
if !input.is_empty() {
self.block[..input.len()].copy_from_slice(input);
self.offset = input.len();
}
}
pub(crate) fn finish(&mut self, length_field: &[u8], mut compress: impl FnMut(&[u8; N])) {
debug_assert!(
length_field.len() < N,
"length field must fit within a block"
);
self.push(0x80, &mut compress);
while self.offset != N - length_field.len() {
self.push(0, &mut compress);
}
for &byte in length_field {
self.push(byte, &mut compress);
}
}
fn push(&mut self, byte: u8, compress: &mut impl FnMut(&[u8; N])) {
self.block[self.offset] = byte;
self.offset += 1;
if self.offset == N {
compress(&self.block);
self.offset = 0;
}
}
}
impl<const N: usize> Zeroize for MdBuffer<N> {
fn zeroize(&mut self) {
self.block.zeroize();
self.offset.zeroize();
self.byte_count.zeroize();
}
}
impl<const N: usize> Drop for MdBuffer<N> {
fn drop(&mut self) {
self.zeroize();
}
}
#[cfg(test)]
mod tests {
use alloc::vec::Vec;
use super::*;
fn collect64(feed: &[&[u8]]) -> Vec<[u8; 64]> {
let mut buf = MdBuffer::<64>::new();
let mut blocks: Vec<[u8; 64]> = Vec::new();
for chunk in feed {
buf.update(chunk, |b| blocks.push(*b));
}
let bit_len = buf.byte_count() << 3;
buf.finish(&bit_len.to_be_bytes(), |b| blocks.push(*b));
blocks
}
#[test]
fn an_empty_message_pads_to_one_block() {
let blocks = collect64(&[b""]);
assert_eq!(blocks.len(), 1);
let b = blocks[0];
assert_eq!(b[0], 0x80);
assert!(b[1..].iter().all(|&x| x == 0)); }
#[test]
fn padding_follows_the_message_and_the_length_ends_the_block() {
let blocks = collect64(&[b"abc"]);
assert_eq!(blocks.len(), 1);
let b = blocks[0];
assert_eq!(&b[..3], b"abc");
assert_eq!(b[3], 0x80);
assert!(b[4..56].iter().all(|&x| x == 0));
assert_eq!(&b[56..64], &[0, 0, 0, 0, 0, 0, 0, 0x18]);
}
#[test]
fn padding_spills_into_a_second_block_when_the_length_does_not_fit() {
let msg = [0x61u8; 56];
let blocks = collect64(&[&msg]);
assert_eq!(blocks.len(), 2);
assert_eq!(&blocks[0][..56], &msg[..]);
assert_eq!(blocks[0][56], 0x80);
assert!(blocks[0][57..].iter().all(|&x| x == 0));
assert!(blocks[1][..56].iter().all(|&x| x == 0));
assert_eq!(&blocks[1][56..64], &[0, 0, 0, 0, 0, 0, 0x01, 0xC0]);
}
#[test]
fn chunked_input_produces_the_same_blocks_as_whole_input() {
let msg: Vec<u8> = (0..130).map(|i| i as u8).collect();
let whole = collect64(&[&msg]);
let chunked = collect64(&[&msg[..1], &msg[1..64], &msg[64..70], &msg[70..]]);
assert_eq!(whole, chunked);
assert_eq!(whole.len(), 3);
}
#[test]
fn zeroize_wipes_the_buffered_bytes_offset_and_count() {
let mut buf = MdBuffer::<64>::new();
buf.update(&[0xa5; 70], |_| {});
assert!(buf.block[..6].iter().all(|&x| x == 0xa5));
assert_eq!((buf.offset, buf.byte_count), (6, 70));
buf.zeroize();
assert!(buf.block.iter().all(|&x| x == 0));
assert_eq!((buf.offset, buf.byte_count), (0, 0));
}
#[test]
fn a_128_byte_block_pads_an_empty_message_to_one_block() {
let mut buf = MdBuffer::<128>::new();
let mut blocks: Vec<[u8; 128]> = Vec::new();
let bit_len = (buf.byte_count() as u128) << 3;
buf.finish(&bit_len.to_be_bytes(), |b| blocks.push(*b));
assert_eq!(blocks.len(), 1);
assert_eq!(blocks[0][0], 0x80);
assert!(blocks[0][1..].iter().all(|&x| x == 0)); }
}