use crate::error::{BlobError, Result};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum ContainerError {
Unsupported,
Corrupt,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
#[non_exhaustive]
pub enum ChunkCompression {
#[default]
None,
Zstd {
level: i32,
},
}
pub(crate) const TAG_RAW: u8 = 0x00;
pub(crate) const TAG_ZSTD: u8 = 0x01;
pub(crate) const TAG_SEALED: u8 = 0x02;
pub(crate) const MAX_UNPACKED: usize = 16 * 1024 * 1024;
pub(crate) fn pack(bytes: &[u8], compression: ChunkCompression) -> Result<Vec<u8>> {
match compression {
ChunkCompression::None => {
let mut out = Vec::with_capacity(1 + bytes.len());
out.push(TAG_RAW);
out.extend_from_slice(bytes);
Ok(out)
}
#[cfg(feature = "zstd")]
ChunkCompression::Zstd { level } => {
let compressed = zstd::bulk::compress(bytes, level)?;
if compressed.len() + 5 > bytes.len() {
return pack(bytes, ChunkCompression::None);
}
let mut out = Vec::with_capacity(5 + compressed.len());
out.push(TAG_ZSTD);
out.extend_from_slice(&(bytes.len() as u32).to_le_bytes());
out.extend_from_slice(&compressed);
Ok(out)
}
#[cfg(not(feature = "zstd"))]
ChunkCompression::Zstd { .. } => Err(BlobError::MalformedMessage(
"zstd compression requested but zblob was built without the `zstd` feature".into(),
)),
}
}
pub(crate) fn try_unpack(packed: &[u8]) -> std::result::Result<Vec<u8>, ContainerError> {
match packed.split_first() {
Some((&TAG_RAW, rest)) => {
if rest.len() > MAX_UNPACKED {
return Err(ContainerError::Corrupt);
}
Ok(rest.to_vec())
}
Some((&TAG_ZSTD, rest)) => {
if rest.len() < 4 {
return Err(ContainerError::Corrupt);
}
let (len_bytes, frame) = rest.split_at(4);
let declared = u32::from_le_bytes(len_bytes.try_into().expect("4 bytes")) as usize;
if declared > MAX_UNPACKED {
return Err(ContainerError::Corrupt);
}
#[cfg(feature = "zstd")]
{
let out =
zstd::bulk::decompress(frame, declared).map_err(|_| ContainerError::Corrupt)?;
if out.len() != declared {
return Err(ContainerError::Corrupt);
}
Ok(out)
}
#[cfg(not(feature = "zstd"))]
{
let _ = frame;
Err(ContainerError::Unsupported)
}
}
Some((&TAG_SEALED, _)) => Err(ContainerError::Unsupported), _ => Err(ContainerError::Corrupt),
}
}
pub(crate) fn unpack(packed: &[u8]) -> Result<Vec<u8>> {
try_unpack(packed).map_err(|e| match e {
ContainerError::Unsupported => BlobError::MalformedMessage(
"chunk container uses a format this build does not support (missing cargo feature?)"
.into(),
),
ContainerError::Corrupt => BlobError::MalformedMessage("malformed chunk container".into()),
})
}
#[cfg(test)]
mod properties {
use super::*;
use proptest::prelude::*;
proptest! {
#[test]
fn unpacking_never_exceeds_the_ceiling(
tag in any::<u8>(),
body in prop::collection::vec(any::<u8>(), 0..4096),
) {
let mut framed = vec![tag];
framed.extend_from_slice(&body);
if let Ok(out) = try_unpack(&framed) {
prop_assert!(out.len() <= MAX_UNPACKED);
}
}
}
#[test]
fn the_raw_ceiling_is_exact() {
let ok = vec![0u8; MAX_UNPACKED];
let mut framed = vec![TAG_RAW];
framed.extend_from_slice(&ok);
assert!(
try_unpack(&framed).is_ok(),
"a frame at the ceiling is fine"
);
framed.push(0);
assert!(
try_unpack(&framed).is_err(),
"a frame over the ceiling must be refused"
);
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn raw_roundtrip() {
let data = b"hello chunk";
let packed = pack(data, ChunkCompression::None).unwrap();
assert_eq!(packed[0], TAG_RAW);
assert_eq!(unpack(&packed).unwrap(), data);
}
#[test]
fn garbage_frames_rejected() {
assert!(unpack(&[]).is_err());
assert!(unpack(&[0x42, 1, 2, 3]).is_err());
assert!(unpack(&[TAG_ZSTD, 1, 2]).is_err()); }
#[cfg(feature = "zstd")]
#[test]
fn zstd_roundtrip_and_bailout() {
let text = vec![b'a'; 100_000];
let packed = pack(&text, ChunkCompression::Zstd { level: 3 }).unwrap();
assert_eq!(packed[0], TAG_ZSTD);
assert!(packed.len() < text.len() / 10);
assert_eq!(unpack(&packed).unwrap(), text);
let mut random = Vec::with_capacity(50_000);
let mut x = 0x12345u64;
for _ in 0..50_000 {
x ^= x << 13;
x ^= x >> 7;
x ^= x << 17;
random.push((x & 0xff) as u8);
}
let packed = pack(&random, ChunkCompression::Zstd { level: 3 }).unwrap();
assert_eq!(packed[0], TAG_RAW, "incompressible data must stay raw");
assert_eq!(unpack(&packed).unwrap(), random);
}
#[cfg(feature = "zstd")]
#[test]
fn oversized_declaration_rejected() {
let mut packed = pack(&vec![b'x'; 1000], ChunkCompression::Zstd { level: 3 }).unwrap();
assert_eq!(packed[0], TAG_ZSTD);
packed[1..5].copy_from_slice(&(u32::MAX).to_le_bytes());
assert!(unpack(&packed).is_err());
}
#[cfg(not(feature = "zstd"))]
#[test]
fn zstd_unavailable_without_feature() {
assert!(pack(b"x", ChunkCompression::Zstd { level: 3 }).is_err());
let fake = [TAG_ZSTD, 4, 0, 0, 0, 1, 2, 3];
assert!(unpack(&fake).is_err());
}
}