use std::io::{self, Read};
use crate::hex::Sha3Digest;
use crate::Sha3_512Kernel;
const IO_BUF_SIZE: usize = 8 * 1024;
pub fn hash_reader<R: Read>(reader: R) -> io::Result<Sha3Digest> {
let mut wrapper = Sha3Reader::new(reader);
wrapper.consume_all()?;
Ok(wrapper.finalize())
}
pub fn hash_file<P: AsRef<std::path::Path>>(path: P) -> io::Result<Sha3Digest> {
let file = std::fs::File::open(path)?;
let reader = io::BufReader::new(file);
hash_reader(reader)
}
pub struct Sha3Reader<R: Read> {
inner: R,
hasher: Sha3_512Kernel,
buf: [u8; IO_BUF_SIZE],
bytes_consumed: u64,
}
impl<R: Read> Sha3Reader<R> {
pub fn new(reader: R) -> Self {
Self {
inner: reader,
hasher: Sha3_512Kernel::new(),
buf: [0u8; IO_BUF_SIZE],
bytes_consumed: 0,
}
}
pub fn consume_chunk(&mut self) -> io::Result<usize> {
let n = self.inner.read(&mut self.buf)?;
if n > 0 {
self.hasher.update(&self.buf[..n]);
self.bytes_consumed += n as u64;
}
Ok(n)
}
pub fn consume_all(&mut self) -> io::Result<u64> {
loop {
let n = self.consume_chunk()?;
if n == 0 {
break;
}
}
Ok(self.bytes_consumed)
}
pub fn finalize(&mut self) -> Sha3Digest {
Sha3Digest::new(self.hasher.finalize())
}
pub fn bytes_consumed(&self) -> u64 {
self.bytes_consumed
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::io::Cursor;
#[test]
fn test_hash_reader_empty() {
let digest = hash_reader(Cursor::new(b"")).unwrap();
let mut hasher = Sha3_512Kernel::new();
let expected = Sha3Digest::new(hasher.hash(b""));
assert_eq!(digest, expected);
}
#[test]
fn test_hash_reader_matches_direct() {
let data = b"The quick brown fox jumps over the lazy dog";
let digest = hash_reader(Cursor::new(data)).unwrap();
let mut hasher = Sha3_512Kernel::new();
let expected = Sha3Digest::new(hasher.hash(data));
assert_eq!(digest, expected);
}
#[test]
fn test_hash_reader_large() {
let data = vec![0xCDu8; 100_000];
let digest = hash_reader(Cursor::new(&data)).unwrap();
let mut hasher = Sha3_512Kernel::new();
let expected = Sha3Digest::new(hasher.hash(&data));
assert_eq!(digest, expected);
}
#[test]
fn test_sha3_reader_bytes_consumed() {
let data = vec![0x42u8; 12345];
let mut reader = Sha3Reader::new(Cursor::new(&data));
reader.consume_all().unwrap();
assert_eq!(reader.bytes_consumed(), 12345);
}
}