use alloc::string::{String, ToString};
use alloc::vec;
use alloc::vec::Vec;
use core::fmt;
use tc_zeroize::Zeroize;
use crate::TryDigest;
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[non_exhaustive]
pub enum PrehashError {
InputTooLong {
limit: usize,
attempted: usize,
},
IncorrectLength {
expected: usize,
actual: usize,
},
}
impl fmt::Display for PrehashError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
PrehashError::InputTooLong { limit, attempted } => write!(
f,
"prehash input too long: limit is {limit} bytes, attempted {attempted} bytes"
),
PrehashError::IncorrectLength { expected, actual } => write!(
f,
"incorrect prehash length: expected {expected} bytes, got {actual} bytes"
),
}
}
}
impl core::error::Error for PrehashError {}
#[derive(Clone)]
pub struct Prehash {
name: String,
buffer: Vec<u8>,
position: usize,
}
impl Prehash {
pub fn new(name: impl Into<String>, digest_size: usize) -> Self {
Self {
name: name.into(),
buffer: vec![0; digest_size],
position: 0,
}
}
pub fn for_digest<D: TryDigest + fmt::Display + ?Sized>(digest: &D) -> Self {
Self::new(digest.to_string(), digest.digest_size())
}
pub fn len(&self) -> usize {
self.position
}
pub fn is_empty(&self) -> bool {
self.position == 0
}
}
impl TryDigest for Prehash {
type Error = PrehashError;
fn digest_size(&self) -> usize {
self.buffer.len()
}
fn byte_length(&self) -> usize {
self.buffer.len()
}
fn try_update(&mut self, input: &[u8]) -> Result<(), Self::Error> {
if input.len() > self.buffer.len() - self.position {
return Err(PrehashError::InputTooLong {
limit: self.buffer.len(),
attempted: self.position.saturating_add(input.len()),
});
}
let end = self.position + input.len();
self.buffer[self.position..end].copy_from_slice(input);
self.position = end;
Ok(())
}
fn try_do_final(&mut self, output: &mut [u8]) -> Result<usize, Self::Error> {
let expected = self.buffer.len();
assert!(
output.len() >= expected,
"output buffer shorter than the {expected}-byte digest"
);
let actual = self.position;
if actual != expected {
self.try_reset()?;
return Err(PrehashError::IncorrectLength { expected, actual });
}
output[..expected].copy_from_slice(&self.buffer);
self.try_reset()?;
Ok(expected)
}
fn try_reset(&mut self) -> Result<(), Self::Error> {
self.buffer[..self.position].zeroize();
self.position = 0;
Ok(())
}
}
impl Drop for Prehash {
fn drop(&mut self) {
self.buffer.zeroize();
}
}
impl fmt::Debug for Prehash {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("Prehash")
.field("name", &self.name)
.field("digest_size", &self.buffer.len())
.field("position", &self.position)
.finish()
}
}
impl fmt::Display for Prehash {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(&self.name)
}
}