use crate::error::Error;
use base64::{engine::general_purpose::STANDARD as BASE64, Engine as _};
use sha2::{Digest, Sha256};
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Chunk {
pub index: usize,
pub offset: u64,
pub size: u64,
pub expected_hash: [u8; 32],
}
impl Chunk {
pub fn new(
index: usize,
offset: u64,
size: u64,
expected_hash: [u8; 32],
) -> Self {
Self {
index,
offset,
size,
expected_hash,
}
}
pub fn range_header_value(&self) -> String {
format!("bytes={}-{}", self.offset, self.offset + self.size - 1)
}
pub fn compute_hash(payload: &[u8]) -> [u8; 32] {
let mut hasher = Sha256::new();
hasher.update(payload);
hasher.finalize().into()
}
pub fn decode_base64_hashes(
raw_hash_str: &str,
) -> Result<Vec<[u8; 32]>, Error> {
let mut digests = Vec::new();
for token in raw_hash_str.split_whitespace() {
let bytes = BASE64
.decode(token)
.map_err(|e| Error::Base64Decode(e.to_string()))?;
if bytes.len() != 32 {
return Err(Error::InvalidHashSize(bytes.len()));
}
let mut hash_arr = [0u8; 32];
hash_arr.copy_from_slice(&bytes);
digests.push(hash_arr);
}
Ok(digests)
}
pub fn verify(&self, payload: &[u8]) -> bool {
if payload.len() as u64 != self.size {
return false;
}
Self::compute_hash(payload) == self.expected_hash
}
}