use std::{fs, path::Path};
use crate::{Error, Result};
const MAGIC: &[u8; 8] = b"FBZ2IDX\0";
const VERSION: u32 = 1;
const CHECKSUM_LEN: usize = 32;
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct BlockIndex {
pub compressed_start_bit: u64,
pub compressed_end_bit: u64,
pub decoded_start: u64,
pub decoded_len: u64,
pub expected_crc: u32,
pub stream: u64,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct StreamIndex {
pub compressed_header_byte: u64,
pub block_size_100k: u8,
pub first_block: u64,
pub block_count: u64,
pub decoded_start: u64,
pub decoded_len: u64,
pub eos_bit: u64,
pub expected_stream_crc: u32,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Index {
pub source_len: u64,
pub source_hash: [u8; 32],
pub decoded_len: u64,
pub streams: Vec<StreamIndex>,
pub blocks: Vec<BlockIndex>,
}
impl Index {
pub(crate) fn new(source: &[u8], decoded_len: u64, streams: Vec<StreamIndex>, blocks: Vec<BlockIndex>) -> Self {
Self { source_len: source.len() as u64, source_hash: *blake3::hash(source).as_bytes(), decoded_len, streams, blocks }
}
pub fn to_bytes(&self) -> Vec<u8> {
let mut out = Vec::with_capacity(76 + self.streams.len() * 53 + self.blocks.len() * 44 + CHECKSUM_LEN);
out.extend_from_slice(MAGIC);
put_u32(&mut out, VERSION);
put_u64(&mut out, self.source_len);
out.extend_from_slice(&self.source_hash);
put_u64(&mut out, self.decoded_len);
put_u64(&mut out, self.streams.len() as u64);
put_u64(&mut out, self.blocks.len() as u64);
for stream in &self.streams {
put_u64(&mut out, stream.compressed_header_byte);
out.push(stream.block_size_100k);
put_u64(&mut out, stream.first_block);
put_u64(&mut out, stream.block_count);
put_u64(&mut out, stream.decoded_start);
put_u64(&mut out, stream.decoded_len);
put_u64(&mut out, stream.eos_bit);
put_u32(&mut out, stream.expected_stream_crc);
}
for block in &self.blocks {
put_u64(&mut out, block.compressed_start_bit);
put_u64(&mut out, block.compressed_end_bit);
put_u64(&mut out, block.decoded_start);
put_u64(&mut out, block.decoded_len);
put_u32(&mut out, block.expected_crc);
put_u64(&mut out, block.stream);
}
let checksum = blake3::hash(&out);
out.extend_from_slice(checksum.as_bytes());
out
}
pub fn from_bytes(encoded: &[u8], source: &[u8]) -> Result<Self> {
if encoded.len() < CHECKSUM_LEN {
return Err(invalid("truncated header"));
}
let (payload, checksum) = encoded.split_at(encoded.len() - CHECKSUM_LEN);
if blake3::hash(payload).as_bytes() != checksum {
return Err(invalid("payload checksum mismatch"));
}
let mut reader = IndexReader::new(payload);
if reader.take(8)? != MAGIC {
return Err(invalid("bad magic"));
}
if reader.u32()? != VERSION {
return Err(invalid("unsupported version"));
}
let source_len = reader.u64()?;
let source_hash: [u8; 32] = reader.take(32)?.try_into().unwrap();
let decoded_len = reader.u64()?;
let stream_count = reader.usize("stream count")?;
let block_count = reader.usize("block count")?;
if source_len != source.len() as u64 || source_hash != *blake3::hash(source).as_bytes() {
return Err(invalid("source identity mismatch"));
}
let required = stream_count
.checked_mul(53)
.and_then(|size| block_count.checked_mul(44).and_then(|blocks| size.checked_add(blocks)))
.ok_or_else(|| invalid("record counts overflow"))?;
if reader.remaining() != required {
return Err(invalid("record counts do not match payload length"));
}
let mut streams = Vec::with_capacity(stream_count);
for _ in 0..stream_count {
streams.push(StreamIndex {
compressed_header_byte: reader.u64()?,
block_size_100k: reader.byte()?,
first_block: reader.u64()?,
block_count: reader.u64()?,
decoded_start: reader.u64()?,
decoded_len: reader.u64()?,
eos_bit: reader.u64()?,
expected_stream_crc: reader.u32()?,
});
}
let mut blocks = Vec::with_capacity(block_count);
for _ in 0..block_count {
blocks.push(BlockIndex {
compressed_start_bit: reader.u64()?,
compressed_end_bit: reader.u64()?,
decoded_start: reader.u64()?,
decoded_len: reader.u64()?,
expected_crc: reader.u32()?,
stream: reader.u64()?,
});
}
let index = Self { source_len, source_hash, decoded_len, streams, blocks };
index.validate()?;
Ok(index)
}
pub fn save(&self, path: impl AsRef<Path>) -> Result<()> {
fs::write(path, self.to_bytes()).map_err(Error::from)
}
pub fn load(path: impl AsRef<Path>, source: &[u8]) -> Result<Self> {
Self::from_bytes(&fs::read(path)?, source)
}
fn validate(&self) -> Result<()> {
let source_bits = self.source_len.checked_mul(8).ok_or_else(|| invalid("source length overflow"))?;
let mut decoded = 0_u64;
for (number, block) in self.blocks.iter().enumerate() {
if block.decoded_start != decoded || block.decoded_len == 0 {
return Err(invalid("block decoded offsets are not contiguous"));
}
if block.compressed_start_bit >= block.compressed_end_bit || block.compressed_end_bit > source_bits {
return Err(invalid("block compressed range is invalid"));
}
if block.stream as usize >= self.streams.len() {
return Err(invalid("block stream number is out of range"));
}
decoded = decoded.checked_add(block.decoded_len).ok_or_else(|| invalid("decoded offset overflow"))?;
if number > 0 && self.blocks[number - 1].compressed_start_bit >= block.compressed_start_bit {
return Err(invalid("block compressed offsets are not increasing"));
}
}
if decoded != self.decoded_len {
return Err(invalid("decoded size does not match block records"));
}
let mut first_block = 0_u64;
let mut stream_decoded = 0_u64;
for (number, stream) in self.streams.iter().enumerate() {
if !(1..=9).contains(&stream.block_size_100k)
|| stream.first_block != first_block
|| stream.decoded_start != stream_decoded
|| stream.eos_bit > source_bits
{
return Err(invalid("stream record is inconsistent"));
}
let end = stream.first_block.checked_add(stream.block_count).ok_or_else(|| invalid("stream block count overflow"))?;
if end as usize > self.blocks.len() {
return Err(invalid("stream block range is out of bounds"));
}
for block in &self.blocks[stream.first_block as usize..end as usize] {
if block.stream != number as u64 {
return Err(invalid("block belongs to the wrong stream"));
}
}
first_block = end;
stream_decoded = stream_decoded.checked_add(stream.decoded_len).ok_or_else(|| invalid("stream size overflow"))?;
}
if first_block as usize != self.blocks.len() || stream_decoded != self.decoded_len {
return Err(invalid("stream records do not cover decoded data"));
}
Ok(())
}
}
fn invalid(message: impl Into<String>) -> Error {
Error::InvalidIndex(message.into())
}
fn put_u32(out: &mut Vec<u8>, value: u32) {
out.extend_from_slice(&value.to_le_bytes());
}
fn put_u64(out: &mut Vec<u8>, value: u64) {
out.extend_from_slice(&value.to_le_bytes());
}
struct IndexReader<'a> {
data: &'a [u8],
pos: usize,
}
impl<'a> IndexReader<'a> {
fn new(data: &'a [u8]) -> Self {
Self { data, pos: 0 }
}
fn remaining(&self) -> usize {
self.data.len() - self.pos
}
fn take(&mut self, count: usize) -> Result<&'a [u8]> {
let end = self.pos.checked_add(count).ok_or_else(|| invalid("offset overflow"))?;
let value = self.data.get(self.pos..end).ok_or_else(|| invalid("truncated payload"))?;
self.pos = end;
Ok(value)
}
fn byte(&mut self) -> Result<u8> {
Ok(self.take(1)?[0])
}
fn u32(&mut self) -> Result<u32> {
Ok(u32::from_le_bytes(self.take(4)?.try_into().unwrap()))
}
fn u64(&mut self) -> Result<u64> {
Ok(u64::from_le_bytes(self.take(8)?.try_into().unwrap()))
}
fn usize(&mut self, name: &str) -> Result<usize> {
usize::try_from(self.u64()?).map_err(|_| invalid(format!("{name} does not fit this platform")))
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn empty_index_round_trip_and_source_binding() {
let source = b"BZh9";
let index = Index::new(source, 0, Vec::new(), Vec::new());
let encoded = index.to_bytes();
assert_eq!(Index::from_bytes(&encoded, source).unwrap(), index);
assert!(matches!(Index::from_bytes(&encoded, b"BZh8"), Err(Error::InvalidIndex(_))));
}
#[test]
fn rejects_tampered_payload() {
let mut encoded = Index::new(b"BZh9", 0, Vec::new(), Vec::new()).to_bytes();
encoded[0] ^= 1;
assert!(matches!(Index::from_bytes(&encoded, b"BZh9"), Err(Error::InvalidIndex(_))));
}
}