use crate::bytes::{get_u32, put_u32, put_u64};
use crate::crc32c;
pub const CSUM_FIELD_LEN: usize = 32;
pub const CHECKSUM_COVERED_FROM: usize = CSUM_FIELD_LEN;
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub struct ChecksumType(u16);
impl ChecksumType {
pub const CRC32C: Self = Self(0);
pub const XXHASH64: Self = Self(1);
pub const SHA256: Self = Self(2);
pub const BLAKE2B: Self = Self(3);
#[must_use]
pub const fn value(self) -> u16 {
self.0
}
#[must_use]
pub const fn from_value(value: u16) -> Self {
Self(value)
}
#[must_use]
pub const fn name(self) -> Option<&'static str> {
Some(match self {
Self::CRC32C => "crc32c",
Self::XXHASH64 => "xxhash64",
Self::SHA256 => "sha256",
Self::BLAKE2B => "blake2b",
_ => return None,
})
}
#[must_use]
pub const fn digest_len(self) -> Option<usize> {
Some(match self {
Self::CRC32C => 4,
Self::XXHASH64 => 8,
Self::SHA256 | Self::BLAKE2B => 32,
_ => return None,
})
}
#[must_use]
pub fn field(self, covered: &[u8]) -> Option<[u8; CSUM_FIELD_LEN]> {
let mut field = [0u8; CSUM_FIELD_LEN];
match self {
Self::CRC32C => put_u32(&mut field, 0, crc32c_over(covered)),
Self::XXHASH64 => put_u64(&mut field, 0, crate::digest::xxh64(0, covered)),
Self::SHA256 => field = crate::digest::sha256(covered),
Self::BLAKE2B => field = crate::digest::blake2b::<CSUM_FIELD_LEN>(covered),
_ => return None,
}
Some(field)
}
#[must_use]
pub fn holds(self, object: &[u8]) -> bool {
assert!(
object.len() > CHECKSUM_COVERED_FROM,
"a checksummed object is longer than the field holding its checksum: got {} bytes",
object.len()
);
self.field(&object[CHECKSUM_COVERED_FROM..])
.is_some_and(|field| object[..CSUM_FIELD_LEN] == field)
}
}
#[must_use]
pub fn checksum(object: &[u8]) -> u32 {
assert!(
object.len() > CHECKSUM_COVERED_FROM,
"a checksummed object is longer than the field holding its checksum: got {} bytes",
object.len()
);
crc32c_over(&object[CHECKSUM_COVERED_FROM..])
}
#[must_use]
pub fn crc32c_over(bytes: &[u8]) -> u32 {
crc32c(!0, bytes) ^ !0
}
pub fn seal(object: &mut [u8]) {
let digest = checksum(object);
put_u32(object, 0, digest);
object[4..CSUM_FIELD_LEN].fill(0);
}
#[must_use]
pub fn stored_crc32c(object: &[u8]) -> u32 {
assert!(
object.len() >= CSUM_FIELD_LEN,
"a checksummed object holds a whole checksum field: got {} bytes",
object.len()
);
get_u32(object, 0)
}
#[must_use]
pub fn padding_is_clear(object: &[u8], digest_len: usize) -> bool {
assert!(
object.len() >= CSUM_FIELD_LEN,
"a checksummed object holds a whole checksum field: got {} bytes",
object.len()
);
object[digest_len.min(CSUM_FIELD_LEN)..CSUM_FIELD_LEN]
.iter()
.all(|&b| b == 0)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn the_recipe_is_the_standalone_crc_of_everything_past_the_field() {
let mut object = [0u8; 64];
object[CHECKSUM_COVERED_FROM..CHECKSUM_COVERED_FROM + 9].copy_from_slice(b"123456789");
object[..4].copy_from_slice(&0xdead_beefu32.to_le_bytes());
let over_all = crc32c(!0, &object[CHECKSUM_COVERED_FROM..]) ^ !0;
assert_eq!(checksum(&object), over_all);
object[..4].copy_from_slice(&0u32.to_le_bytes());
assert_eq!(checksum(&object), over_all);
}
#[test]
fn the_covered_range_ends_where_the_object_does() {
let object = [0u8; 4096];
assert_ne!(checksum(&object), checksum(&object[..2048]));
}
#[test]
fn a_stored_checksum_is_the_first_four_bytes_and_the_rest_are_padding() {
let mut object = [0u8; 64];
object[..4].copy_from_slice(&0x836b_4a11u32.to_le_bytes());
assert_eq!(stored_crc32c(&object), 0x836b_4a11);
assert!(padding_is_clear(&object, 4));
object[10] = 1;
assert!(!padding_is_clear(&object, 4));
assert_eq!(
stored_crc32c(&object),
0x836b_4a11,
"the digest is unaffected"
);
}
#[test]
fn every_algorithm_the_format_defines_is_named_and_sized_and_no_other_is() {
for (ty, name, len) in [
(ChecksumType::CRC32C, "crc32c", 4),
(ChecksumType::XXHASH64, "xxhash64", 8),
(ChecksumType::SHA256, "sha256", 32),
(ChecksumType::BLAKE2B, "blake2b", 32),
] {
assert_eq!(ty.name(), Some(name));
assert_eq!(ty.digest_len(), Some(len));
}
let unknown = ChecksumType::from_value(4);
assert_eq!(unknown.name(), None);
assert_eq!(
unknown.digest_len(),
None,
"a length nothing defined is not a length"
);
assert_eq!(unknown.value(), 4);
}
}