#[cfg(test)]
use super::encode_block_frame;
use super::{BlockFrameDescriptor, BlockFrameReader};
use crate::checked::{read_u16_le, read_u32_le, read_u64_le};
use crate::compression_frame_manifest::{
decode_compression_frame_manifest, CompressionFrameManifest, CompressionFrameSlice,
};
use crate::creation_options::FormatMode;
use crate::crypto::{open_with_nonce, seal_with_random_nonce, strong_checksum};
use crate::page::{
page_size_for_stored_len, physical_page_size_from_page_slice, DEFAULT_DATA_PAGE_BYTES,
PAGE_HEADER_LEN, PAGE_MAGIC,
};
use crate::page_buffer::ZeroizingBytes;
use crate::storage::{Storage, StorageBackend};
use crate::{Error, LockboxId, Result};
use sha2::{Digest, Sha256};
const VERSION: u16 = 3;
const CLEAR: u16 = 1;
const UNPADDED: u16 = 2;
const MAX_METADATA: usize = 1024 * 1024 + BlockFrameDescriptor::ENCODED_LEN;
#[derive(Clone, Copy)]
pub(crate) struct PageIdentity {
pub(crate) archive: LockboxId,
pub(crate) page_id: u64,
pub(crate) sequence: u64,
pub(crate) mode: FormatMode,
}
pub(crate) struct EncodedBlockPage {
descriptor: BlockFrameDescriptor,
bytes: ZeroizingBytes,
}
impl std::fmt::Debug for EncodedBlockPage {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("EncodedBlockPage")
.field("len", &self.bytes.len())
.finish_non_exhaustive()
}
}
impl EncodedBlockPage {
pub(crate) fn prepare(
identity: PageIdentity,
frame_id: u64,
compression: u8,
logical_len: u64,
stored: &[u8],
slices: Vec<CompressionFrameSlice>,
key: &[u8],
) -> Result<Self> {
let (descriptor, bytes) = encode_prepared(
identity,
frame_id,
compression,
logical_len,
stored,
slices,
key,
)?;
Ok(Self {
descriptor,
bytes: ZeroizingBytes::new(bytes),
})
}
pub(crate) fn descriptor(&self) -> &BlockFrameDescriptor {
&self.descriptor
}
pub(crate) fn bytes(&self) -> &[u8] {
&self.bytes
}
}
fn metadata_aad(identity: PageIdentity, header: &[u8]) -> Vec<u8> {
let mut aad = b"revault-native-block-page-v1\0".to_vec();
aad.extend_from_slice(identity.archive.as_bytes());
aad.extend_from_slice(&identity.mode.0.to_le_bytes());
aad.extend_from_slice(&header[..32]);
aad.extend_from_slice(&header[44..64]);
aad
}
fn metadata_digest(aad: &[u8], body: &[u8]) -> [u8; 32] {
let mut hash = Sha256::new();
hash.update(aad);
hash.update(body);
hash.finalize().into()
}
fn frame_key(key: &[u8]) -> zeroize::Zeroizing<[u8; 32]> {
zeroize::Zeroizing::new(
key.try_into()
.unwrap_or_else(|_| crate::crypto::derive_page_content_key(key)),
)
}
#[cfg(test)]
pub(crate) fn encode(
identity: PageIdentity,
frame_id: u64,
input: &[u8],
slices: Vec<CompressionFrameSlice>,
key: &[u8],
) -> Result<(BlockFrameDescriptor, Vec<u8>)> {
if identity.page_id == 0 {
return Err(Error::CorruptRecord);
}
let (descriptor, packet) = encode_block_frame(
identity.archive,
frame_id,
identity.mode,
input,
&*frame_key(key),
)?;
encode_packet(identity, descriptor, packet, slices, key)
}
pub(crate) fn encode_prepared(
identity: PageIdentity,
frame_id: u64,
compression: u8,
logical_len: u64,
stored: &[u8],
slices: Vec<CompressionFrameSlice>,
key: &[u8],
) -> Result<(BlockFrameDescriptor, Vec<u8>)> {
if identity.page_id == 0 {
return Err(Error::CorruptRecord);
}
let (descriptor, packet) = super::encode_stored_block_frame(
identity.archive,
frame_id,
identity.mode,
compression,
logical_len,
stored,
&*frame_key(key),
)?;
encode_packet(identity, descriptor, packet, slices, key)
}
fn encode_packet(
identity: PageIdentity,
descriptor: BlockFrameDescriptor,
packet: Vec<u8>,
slices: Vec<CompressionFrameSlice>,
key: &[u8],
) -> Result<(BlockFrameDescriptor, Vec<u8>)> {
let packet = ZeroizingBytes::new(packet);
let manifest = CompressionFrameManifest {
compression_frame_id: descriptor.frame_id,
compression: descriptor.compression,
compression_frame_len: descriptor.logical_len,
compressed_len: descriptor.stored_len,
compression_frame_digest: descriptor.index_commitment,
slices,
};
let manifest_bytes = ZeroizingBytes::new(
crate::compression_frame_manifest::encode_compression_frame_manifest_sensitive(
&manifest,
!identity.mode.plaintext(),
)?,
);
decode_compression_frame_manifest(&manifest_bytes)?;
let descriptor_bytes = descriptor.encode()?;
let capacity = descriptor_bytes
.len()
.checked_add(manifest_bytes.len())
.ok_or(Error::CorruptRecord)?;
let mut metadata = ZeroizingBytes::new(Vec::with_capacity(capacity));
metadata.extend_from_slice(&descriptor_bytes);
metadata.extend_from_slice(&manifest_bytes);
let mut compression = identity.mode.options().compression;
if compression != crate::Compression::None && !identity.mode.unpadded() {
let prefix_len = PAGE_HEADER_LEN + 9 + if identity.mode.plaintext() { 32 } else { 16 };
let minimum_used = prefix_len
.checked_add(packet.len())
.ok_or(Error::CorruptRecord)?;
let raw_allocation = minimum_used
.checked_add(metadata.len())
.and_then(|len| page_size_for_stored_len(len, DEFAULT_DATA_PAGE_BYTES).ok());
let minimum_allocation =
page_size_for_stored_len(minimum_used, DEFAULT_DATA_PAGE_BYTES).ok();
if raw_allocation.is_some() && raw_allocation == minimum_allocation {
compression = crate::Compression::None;
}
}
let (codec, stored) = crate::compression::encode_with_compression_sensitive(
&metadata,
compression,
!identity.mode.plaintext(),
);
let stored = ZeroizingBytes::new(stored);
let capacity = 9usize
.checked_add(stored.len())
.ok_or(Error::CorruptRecord)?;
let mut body = ZeroizingBytes::new(Vec::with_capacity(capacity));
body.push(codec);
body.extend_from_slice(&(metadata.len() as u64).to_le_bytes());
body.extend_from_slice(&stored);
let metadata_len = body.len() + if identity.mode.plaintext() { 32 } else { 16 };
let body_len = metadata_len
.checked_add(packet.len())
.ok_or(Error::CorruptRecord)?;
let used_len = PAGE_HEADER_LEN
.checked_add(body_len)
.ok_or(Error::CorruptRecord)?;
if used_len > DEFAULT_DATA_PAGE_BYTES {
return Err(Error::CorruptRecord);
}
let physical_len = if identity.mode.unpadded() {
used_len
} else {
page_size_for_stored_len(used_len, DEFAULT_DATA_PAGE_BYTES)?
};
let flags = if identity.mode.plaintext() { CLEAR } else { 0 }
| if identity.mode.unpadded() {
UNPADDED
} else {
0
};
let mut header = [0u8; PAGE_HEADER_LEN];
header[..8].copy_from_slice(PAGE_MAGIC);
header[8..10].copy_from_slice(&VERSION.to_le_bytes());
header[10..12].copy_from_slice(&flags.to_le_bytes());
header[12..16].copy_from_slice(&(PAGE_HEADER_LEN as u32).to_le_bytes());
header[16..24].copy_from_slice(&identity.page_id.to_le_bytes());
header[24..32].copy_from_slice(&identity.sequence.to_le_bytes());
header[44..48].copy_from_slice(&(body_len as u32).to_le_bytes());
header[48..56].copy_from_slice(&(physical_len as u64).to_le_bytes());
header[56..64].copy_from_slice(&(metadata_len as u64).to_le_bytes());
let aad = metadata_aad(identity, &header);
let (nonce, protected) = if identity.mode.plaintext() {
let mut protected = metadata_digest(&aad, &body).to_vec();
protected.extend_from_slice(&body);
([0; 12], protected)
} else {
seal_with_random_nonce(&body, key, &aad)?
};
let protected = ZeroizingBytes::new(protected);
header[32..44].copy_from_slice(&nonce);
let digest = strong_checksum(&header[..64]);
header[64..].copy_from_slice(&digest);
let mut page = ZeroizingBytes::new(vec![0; physical_len]);
page[..PAGE_HEADER_LEN].copy_from_slice(&header);
page[PAGE_HEADER_LEN..PAGE_HEADER_LEN + metadata_len].copy_from_slice(&protected);
page[PAGE_HEADER_LEN + metadata_len..used_len].copy_from_slice(&packet);
Ok((descriptor, std::mem::take(&mut *page)))
}
struct Metadata {
descriptor: BlockFrameDescriptor,
manifest: CompressionFrameManifest,
packet_offset: u64,
packet_len: usize,
physical_len: usize,
storage_len: u64,
}
#[derive(Debug)]
pub(crate) struct ScannedBlockPage {
#[cfg(test)]
pub(crate) offset: u64,
pub(crate) page_id: u64,
pub(crate) sequence: u64,
pub(crate) physical_len: usize,
pub(crate) descriptor: BlockFrameDescriptor,
#[cfg(test)]
pub(crate) manifest: CompressionFrameManifest,
}
pub(crate) fn is_native_header(bytes: &[u8]) -> bool {
bytes.get(..8) == Some(PAGE_MAGIC.as_slice())
&& bytes.get(8..10) == Some(VERSION.to_le_bytes().as_slice())
}
pub(crate) fn scan(
bytes: &[u8],
offset: usize,
archive: LockboxId,
mode: FormatMode,
key: &[u8],
) -> Result<ScannedBlockPage> {
let header = bytes
.get(
offset
..offset
.checked_add(PAGE_HEADER_LEN)
.ok_or(Error::CorruptRecord)?,
)
.ok_or(Error::Truncated)?;
let identity = PageIdentity {
archive,
mode,
page_id: read_u64_le(&header[16..24])?,
sequence: read_u64_le(&header[24..32])?,
};
let physical_len = validate_header(header, identity)?;
let page = bytes
.get(
offset
..offset
.checked_add(physical_len)
.ok_or(Error::CorruptRecord)?,
)
.ok_or(Error::Truncated)?;
let storage = StorageBackend::memory(page.to_vec());
let metadata = read_metadata(&storage, 0, identity, key)?;
let frame = BlockFrameReader::open_with_validated_len(
&metadata.descriptor,
&storage,
metadata.packet_offset,
metadata.packet_len,
&*frame_key(key),
metadata.storage_len,
)?;
let _verified = ZeroizingBytes::new(frame.read(0..metadata.descriptor.logical_len)?);
Ok(ScannedBlockPage {
#[cfg(test)]
offset: offset as u64,
page_id: identity.page_id,
sequence: identity.sequence,
physical_len,
descriptor: metadata.descriptor,
#[cfg(test)]
manifest: metadata.manifest,
})
}
fn read_metadata(
storage: &StorageBackend,
offset: u64,
identity: PageIdentity,
key: &[u8],
) -> Result<Metadata> {
let storage_len = storage.current_len()?;
let mut header = [0; PAGE_HEADER_LEN];
storage.read_at_into(offset, &mut header)?;
let physical_len = validate_header(&header, identity)?;
let required_end = offset
.checked_add(physical_len as u64)
.ok_or(Error::Truncated)?;
if required_end > storage_len {
return Err(Error::Truncated);
}
let body_len = read_u32_le(&header[44..48])? as usize;
let metadata_len =
usize::try_from(read_u64_le(&header[56..64])?).map_err(|_| Error::CorruptRecord)?;
if !(9 + 16..=MAX_METADATA + 9 + 32).contains(&metadata_len) || metadata_len > body_len {
return Err(Error::CorruptRecord);
}
let mut protected = ZeroizingBytes::new(vec![0; metadata_len]);
storage.read_at_into(
offset
.checked_add(PAGE_HEADER_LEN as u64)
.ok_or(Error::CorruptRecord)?,
&mut protected,
)?;
let aad = metadata_aad(identity, &header);
let body = ZeroizingBytes::new(if identity.mode.plaintext() {
if header[32..44].iter().any(|byte| *byte != 0)
|| protected.len() < 32
|| protected[..32] != metadata_digest(&aad, &protected[32..])
{
return Err(Error::CorruptRecord);
}
protected[32..].to_vec()
} else {
open_with_nonce(&protected, key, &header[32..44], &aad)?
});
if body.len() < 9 {
return Err(Error::CorruptRecord);
}
let logical_len = read_u64_le(&body[1..9])?;
if logical_len > MAX_METADATA as u64
|| logical_len < BlockFrameDescriptor::ENCODED_LEN as u64
|| (identity.mode.options().compression == crate::Compression::None
&& body[0] != crate::compression::COMPRESSION_NONE)
{
return Err(Error::CorruptRecord);
}
let metadata = ZeroizingBytes::new(crate::compression::decode_compression_frame(
body[0],
&body[9..],
logical_len,
)?);
let descriptor = BlockFrameDescriptor::decode(
&metadata[..BlockFrameDescriptor::ENCODED_LEN],
identity.archive,
identity.mode,
)?;
let manifest =
decode_compression_frame_manifest(&metadata[BlockFrameDescriptor::ENCODED_LEN..])?;
if manifest.compression_frame_id != descriptor.frame_id
|| manifest.compression != descriptor.compression
|| manifest.compression_frame_len != descriptor.logical_len
|| manifest.compressed_len != descriptor.stored_len
|| manifest.compression_frame_digest != descriptor.index_commitment
|| body_len - metadata_len != descriptor.physical_len()?
{
return Err(Error::CorruptRecord);
}
let storage_len = storage.current_len()?;
if required_end > storage_len {
return Err(Error::Truncated);
}
Ok(Metadata {
descriptor,
manifest,
packet_offset: offset
.checked_add((PAGE_HEADER_LEN + metadata_len) as u64)
.ok_or(Error::CorruptRecord)?,
packet_len: body_len - metadata_len,
physical_len,
storage_len,
})
}
fn validate_header(header: &[u8], identity: PageIdentity) -> Result<usize> {
let physical_len = physical_page_size_from_page_slice(header)?;
FormatMode::parse(identity.mode.0)?;
let expected_flags = if identity.mode.plaintext() { CLEAR } else { 0 }
| if identity.mode.unpadded() {
UNPADDED
} else {
0
};
if identity.mode.0 == 0
|| header.len() != PAGE_HEADER_LEN
|| read_u16_le(&header[8..10])? != VERSION
|| read_u16_le(&header[10..12])? != expected_flags
|| read_u32_le(&header[12..16])? as usize != PAGE_HEADER_LEN
|| identity.page_id == 0
|| read_u64_le(&header[16..24])? != identity.page_id
|| read_u64_le(&header[24..32])? != identity.sequence
|| header[64..] != strong_checksum(&header[..64])
{
return Err(Error::CorruptRecord);
}
Ok(physical_len)
}
pub(crate) struct Reader<'a> {
frame: BlockFrameReader<'a>,
manifest: std::sync::Arc<CompressionFrameManifest>,
}
pub(crate) fn validate_chunk_reference(
archive: LockboxId,
mode: FormatMode,
total_len: u64,
chunk: &crate::file_chunk::FileChunk,
) -> Result<PageIdentity> {
let reference = chunk.block_frame.as_ref().ok_or(Error::CorruptRecord)?;
let descriptor = &reference.descriptor;
let [segment] = chunk.segments.as_slice() else {
return Err(Error::CorruptRecord);
};
if descriptor.archive != archive
|| descriptor.mode != mode
|| descriptor.frame_id != chunk.compression_frame_id
|| descriptor.compression != chunk.compression
|| descriptor.logical_len != chunk.compression_frame_len
|| descriptor.stored_len != chunk.compressed_len
|| descriptor.index_commitment != chunk.compression_frame_digest
|| segment.segment_offset != 0
|| segment.segment_len != chunk.compressed_len
|| chunk
.file_offset
.checked_add(chunk.len)
.is_none_or(|end| end > total_len)
|| chunk
.compression_frame_offset
.checked_add(chunk.len)
.is_none_or(|end| end > descriptor.logical_len)
{
return Err(Error::CorruptRecord);
}
Ok(PageIdentity {
archive,
mode,
page_id: segment.object_id,
sequence: reference.sequence,
})
}
pub(crate) fn read_recovery_chunk(
bytes: &[u8],
archive: LockboxId,
mode: FormatMode,
total_len: u64,
chunk: &crate::file_chunk::FileChunk,
key: &[u8],
) -> Result<Vec<u8>> {
let identity = validate_chunk_reference(archive, mode, total_len, chunk)?;
let segment = &chunk.segments[0];
let offset = usize::try_from(segment.page_offset).map_err(|_| Error::CorruptRecord)?;
let header = bytes
.get(
offset
..offset
.checked_add(PAGE_HEADER_LEN)
.ok_or(Error::CorruptRecord)?,
)
.ok_or(Error::Truncated)?;
let physical_len = validate_header(header, identity)?;
if physical_len as u64 != segment.page_len {
return Err(Error::CorruptRecord);
}
let page = bytes
.get(
offset
..offset
.checked_add(physical_len)
.ok_or(Error::CorruptRecord)?,
)
.ok_or(Error::Truncated)?;
let storage = StorageBackend::memory(page.to_vec());
let descriptor = &chunk
.block_frame
.as_ref()
.ok_or(Error::CorruptRecord)?
.descriptor;
let reader = Reader::open(&storage, 0, identity, descriptor, physical_len, key)?;
reader.validate_slice(chunk, total_len)?;
let mut decoded = ZeroizingBytes::new(reader.read(0..descriptor.logical_len)?);
let start =
usize::try_from(chunk.compression_frame_offset).map_err(|_| Error::CorruptRecord)?;
let len = usize::try_from(chunk.len).map_err(|_| Error::CorruptRecord)?;
let end = start.checked_add(len).ok_or(Error::CorruptRecord)?;
if end > decoded.len() {
return Err(Error::CorruptRecord);
}
decoded.copy_within(start..end, 0);
zeroize::Zeroize::zeroize(&mut decoded[len..]);
decoded.truncate(len);
Ok(std::mem::take(&mut *decoded))
}
impl<'a> Reader<'a> {
pub(crate) fn write_revision(&self) -> u64 {
self.frame.write_revision
}
pub(crate) fn slices(&self) -> &[CompressionFrameSlice] {
&self.manifest.slices
}
pub(crate) fn validate_slice(
&self,
chunk: &crate::file_chunk::FileChunk,
expected_total_len: u64,
) -> Result<()> {
if self
.manifest
.slice_for(
&chunk.stored_path,
chunk.file_offset,
chunk.compression_frame_offset,
chunk.len,
)
.is_none_or(|slice| slice.total_len != 0 && slice.total_len != expected_total_len)
{
return Err(Error::CorruptRecord);
}
Ok(())
}
pub(crate) fn open(
storage: &'a StorageBackend,
offset: u64,
identity: PageIdentity,
expected: &BlockFrameDescriptor,
expected_page_len: usize,
key: &[u8],
) -> Result<Self> {
let metadata = read_metadata(storage, offset, identity, key)?;
if metadata.descriptor != *expected || metadata.physical_len != expected_page_len {
return Err(Error::CorruptRecord);
}
let mut frame = BlockFrameReader::open_with_validated_len(
&metadata.descriptor,
storage,
metadata.packet_offset,
metadata.packet_len,
&*frame_key(key),
metadata.storage_len,
)?;
frame.require_extent(
offset
.checked_add(metadata.physical_len as u64)
.ok_or(Error::CorruptRecord)?,
);
Ok(Self {
frame,
manifest: std::sync::Arc::new(metadata.manifest),
})
}
pub(crate) fn read(&self, range: std::ops::Range<u64>) -> Result<Vec<u8>> {
self.frame.read(range)
}
pub(crate) fn read_with_cache(
&self,
range: std::ops::Range<u64>,
cache: &std::cell::RefCell<crate::page_cache::PageCache>,
) -> Result<Vec<u8>> {
let descriptor = &self.frame.descriptor;
if descriptor.compression != crate::compression::COMPRESSION_NONE
|| self.manifest.slices.len() <= 1
|| range.is_empty()
{
return self.read(range);
}
descriptor.stored_range(range.clone())?;
let size = super::BLOCK_BYTES as u64;
let ordinal = (range.start / size) as usize;
if range.start / size != (range.end - 1) / size {
return self.read(range);
}
let start = ordinal as u64 * size;
let end = (start + size).min(descriptor.logical_len);
let offset = self
.frame
.offset
.checked_add(descriptor.stored_range(start..end)?.start as u64)
.ok_or(Error::CorruptRecord)?;
let cached = cache.borrow_mut().native_block(
offset,
descriptor,
ordinal,
self.frame.required_end,
self.frame.write_revision,
);
let block = if let Some(block) = cached {
block
} else {
let mut data = ZeroizingBytes::new(self.read(start..end)?);
self.ensure_current()?;
cache.borrow_mut().insert_native_block(
offset,
crate::page_cache::CachedNativeBlock {
descriptor: descriptor.clone(),
ordinal,
required_end: self.frame.required_end,
data: std::mem::take(&mut *data),
},
self.frame.write_revision,
)
};
let from = (range.start - start) as usize;
let to = from + (range.end - range.start) as usize;
let mut out = ZeroizingBytes::new(
block
.data
.get(from..to)
.ok_or(Error::CorruptRecord)?
.to_vec(),
);
self.ensure_current()?;
Ok(std::mem::take(&mut *out))
}
pub(crate) fn read_aligned_raw_into(
&self,
range: std::ops::Range<u64>,
out: &mut [u8],
) -> Result<bool> {
self.frame.read_aligned_raw_into(range, out)
}
pub(crate) fn ensure_current(&self) -> Result<()> {
self.frame.ensure_current()
}
}
#[derive(Debug)]
pub(crate) struct CachedReader {
reference: crate::file_chunk::BlockFrameReference,
segment: crate::file_chunk::CompressionFrameSegment,
revision: u64,
offset: u64,
required_end: u64,
hashes: std::sync::Arc<[[u8; 32]]>,
manifest: std::sync::Arc<CompressionFrameManifest>,
}
impl CachedReader {
pub(crate) fn weight(&self) -> u64 {
(std::mem::size_of::<Self>()
+ std::mem::size_of::<CompressionFrameManifest>()
+ self.hashes.len() * 32
+ 4 * std::mem::size_of::<usize>()
+ self.manifest.slices.capacity() * std::mem::size_of::<CompressionFrameSlice>()
+ self
.manifest
.slices
.iter()
.map(|s| s.path.as_str().len())
.sum::<usize>()) as u64
}
pub(crate) fn bind<'a>(
&self,
storage: &'a StorageBackend,
chunk: &crate::file_chunk::FileChunk,
total_len: u64,
key: &[u8],
) -> Result<Reader<'a>> {
if chunk.block_frame.as_deref() != Some(&self.reference)
|| chunk.segments.as_slice() != std::slice::from_ref(&self.segment)
{
return Err(Error::CorruptRecord);
}
let descriptor = &self.reference.descriptor;
let frame = BlockFrameReader {
write_revision: self.revision,
descriptor: descriptor.clone(),
storage,
offset: self.offset,
required_end: self.required_end,
hashes: self.hashes.clone(),
cipher: if descriptor.mode.plaintext() {
None
} else {
Some(descriptor.index_cipher(&*frame_key(key))?)
},
};
frame.ensure_current()?;
let reader = Reader {
frame,
manifest: self.manifest.clone(),
};
reader.validate_slice(chunk, total_len)?;
Ok(reader)
}
}
impl Reader<'_> {
pub(crate) fn cache_entry(&self, chunk: &crate::file_chunk::FileChunk) -> Result<CachedReader> {
self.ensure_current()?;
let [segment] = chunk.segments.as_slice() else {
return Err(Error::CorruptRecord);
};
Ok(CachedReader {
reference: chunk
.block_frame
.as_deref()
.ok_or(Error::CorruptRecord)?
.clone(),
segment: segment.clone(),
revision: self.frame.write_revision,
offset: self.frame.offset,
required_end: self.frame.required_end,
hashes: self.frame.hashes.clone(),
manifest: self.manifest.clone(),
})
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::{
Compression, EncryptionMode, LockboxFormatOptions, LockboxPath, SigningMode, SizePadding,
};
#[test]
fn metadata_codec_skips_only_compression_that_cannot_save_padded_space() {
let input = vec![37; 4096];
let key = [9; 32];
for encryption in [EncryptionMode::None, EncryptionMode::ChaCha20Poly1305] {
for signing in [SigningMode::None, SigningMode::Owner] {
for size_padding in [SizePadding::Default, SizePadding::None] {
for count in [1, 128] {
let mode = FormatMode::new(LockboxFormatOptions {
encryption,
signing,
size_padding,
compression: Compression::default(),
});
let identity = PageIdentity {
archive: LockboxId::new_random().unwrap(),
mode,
page_id: 3,
sequence: 7,
};
let slice_len = input.len() / count;
let slices = (0..count)
.map(|index| CompressionFrameSlice {
path: LockboxPath::new(format!("/folder/file-{index:03}")).unwrap(),
permissions: 0o600,
total_len: slice_len as u64,
file_offset: 0,
compression_frame_offset: (index * slice_len) as u64,
len: slice_len as u64,
})
.collect();
let (descriptor, page) = encode(identity, 2, &input, slices, &key).unwrap();
let metadata_len = read_u64_le(&page[56..64]).unwrap() as usize;
let protection_len = if mode.plaintext() { 32 } else { 16 };
let protected = &page[PAGE_HEADER_LEN..PAGE_HEADER_LEN + metadata_len];
let body = ZeroizingBytes::new(if mode.plaintext() {
protected[32..].to_vec()
} else {
open_with_nonce(
protected,
&key,
&page[32..44],
&metadata_aad(identity, &page[..PAGE_HEADER_LEN]),
)
.unwrap()
});
let logical_len = read_u64_le(&body[1..9]).unwrap();
let metadata = ZeroizingBytes::new(
crate::compression::decode_compression_frame(
body[0],
&body[9..],
logical_len,
)
.unwrap(),
);
let (old_codec, old_stored) = crate::compression::encode_with_compression(
&metadata,
Compression::default(),
);
assert_ne!(
old_codec,
crate::compression::COMPRESSION_NONE,
"fixture must offer logical compression savings"
);
let packet_len =
read_u32_le(&page[44..48]).unwrap() as usize - metadata_len;
let previous_used =
PAGE_HEADER_LEN + 9 + protection_len + old_stored.len() + packet_len;
let previous_physical = if mode.unpadded() {
previous_used
} else {
page_size_for_stored_len(previous_used, DEFAULT_DATA_PAGE_BYTES)
.unwrap()
};
assert_eq!(
page.len(),
previous_physical,
"codec selection must preserve the allocation"
);
assert_eq!(
body[0],
if !mode.unpadded() && count == 1 {
crate::compression::COMPRESSION_NONE
} else {
old_codec
}
);
let physical_len = page.len();
let storage = StorageBackend::memory(page);
let reader =
Reader::open(&storage, 0, identity, &descriptor, physical_len, &key)
.unwrap();
assert_eq!(reader.read(0..input.len() as u64).unwrap(), input);
}
}
}
}
}
#[test]
fn native_scanning_skips_embedded_legacy_records_and_keeps_following_pages() {
use crate::page::{PageObject, PageObjectKind};
use crate::{Encryption, Lockbox, LockboxCreateOptions, Signing};
for size_padding in [SizePadding::Default, SizePadding::None] {
let archive = Lockbox::create_in_memory_with_options(LockboxCreateOptions {
compression: Compression::None,
size_padding,
..LockboxCreateOptions::new(Encryption::None, Signing::None)
})
.unwrap();
let mut bytes = archive.to_bytes();
let header = crate::file_format::read_header(&bytes).unwrap();
let object = PageObject::new(PageObjectKind::FileData, 777, vec![1, 2, 3]);
let objects = vec![object];
let page_len = crate::page::page_size_for_encoded_objects_with_format(
&objects,
header.format_mode,
)
.unwrap();
let embedded = crate::page::encode_page_with_format(
page_len,
header.lockbox_id,
778,
779,
&[0; 32],
&objects,
header.format_mode,
)
.unwrap();
let identity = PageIdentity {
archive: header.lockbox_id,
mode: header.format_mode,
page_id: 900,
sequence: 901,
};
let (_, native) = encode(
identity,
899,
&embedded,
vec![CompressionFrameSlice {
path: LockboxPath::new("/contains-page-magic").unwrap(),
permissions: 0o640,
total_len: embedded.len() as u64,
file_offset: 0,
compression_frame_offset: 0,
len: embedded.len() as u64,
}],
&[0; 32],
)
.unwrap();
let offset = bytes.len();
bytes.extend_from_slice(&native);
let following = bytes.len();
bytes.extend_from_slice(&embedded);
let scan = crate::page::scan_page_records(&bytes, header.lockbox_id, &[0; 32]);
assert_eq!(scan.corrupt_records, 0);
assert_eq!(scan.native_pages.len(), 1);
assert_eq!(scan.native_pages[0].offset, offset as u64);
let records = scan
.records
.iter()
.filter(|record| record.object_id == 777)
.collect::<Vec<_>>();
assert_eq!(
records.len(),
1,
"native content must not produce phantom legacy records"
);
assert_eq!(records[0].offset, following as u64);
}
}
fn identity(encrypted: bool, signed: bool, compressed: bool, unpadded: bool) -> PageIdentity {
PageIdentity {
archive: LockboxId::from_bytes([71; 16]),
page_id: 41,
sequence: 43,
mode: FormatMode::new(LockboxFormatOptions {
encryption: if encrypted {
EncryptionMode::ChaCha20Poly1305
} else {
EncryptionMode::None
},
signing: if signed {
SigningMode::Owner
} else {
SigningMode::None
},
compression: if compressed {
Compression::default()
} else {
Compression::None
},
size_padding: if unpadded {
SizePadding::None
} else {
SizePadding::Default
},
}),
}
}
fn slices(len: usize) -> Vec<CompressionFrameSlice> {
let first = len / 3;
vec![
CompressionFrameSlice {
path: LockboxPath::new("/first.bin").unwrap(),
permissions: 0o640,
total_len: first as u64,
file_offset: 0,
compression_frame_offset: 0,
len: first as u64,
},
CompressionFrameSlice {
path: LockboxPath::new("/nested/second.bin").unwrap(),
permissions: 0o600,
total_len: (len - first + 17) as u64,
file_offset: 17,
compression_frame_offset: first as u64,
len: (len - first) as u64,
},
]
}
#[test]
fn block_page_roundtrips_recovery_manifest_and_padding_in_all_modes() {
for encrypted in [false, true] {
for signed in [false, true] {
for compressed in [false, true] {
for unpadded in [false, true] {
let identity = identity(encrypted, signed, compressed, unpadded);
for len in [0, 128, 65539] {
let input: Vec<_> = (0..len).map(|n| (n % 251) as u8).collect();
let slices = slices(len);
let (descriptor, page) =
encode(identity, 31, &input, slices.clone(), &[53; 32]).unwrap();
let used =
PAGE_HEADER_LEN + read_u32_le(&page[44..48]).unwrap() as usize;
if unpadded {
assert_eq!(page.len(), used);
} else {
assert_eq!(page.len() % 1024, 0);
assert!(page.len() >= used);
}
assert!(page[used..].iter().all(|byte| *byte == 0));
assert_eq!(
physical_page_size_from_page_slice(&page).unwrap(),
page.len()
);
assert!(crate::page::decode_page_with_format(
&page,
identity.archive,
&[53; 32],
identity.mode
)
.is_err());
let mut bytes = vec![79; 317];
bytes.extend_from_slice(&page);
bytes.extend_from_slice(&[83; 211]);
let storage = StorageBackend::memory(bytes);
let metadata =
read_metadata(&storage, 317, identity, &[53; 32]).unwrap();
assert_eq!(metadata.manifest.slices, slices);
assert_eq!(metadata.descriptor, descriptor);
let reader = Reader::open(
&storage,
317,
identity,
&descriptor,
page.len(),
&[53; 32],
)
.unwrap();
assert_eq!(reader.manifest.slices, slices);
assert_eq!(reader.read(0..len as u64).unwrap(), input);
for slice in &slices {
let start = slice.compression_frame_offset;
assert_eq!(
reader.read(start..start + slice.len).unwrap(),
input[start as usize..(start + slice.len) as usize]
);
}
assert_eq!(reader.read(0..0).unwrap(), b"");
assert!(Reader::open(
&storage,
317,
identity,
&descriptor,
page.len() + 1,
&[53; 32]
)
.is_err());
let mut wrong = descriptor.clone();
wrong.frame_id += 1;
assert!(Reader::open(
&storage,
317,
identity,
&wrong,
page.len(),
&[53; 32]
)
.is_err());
assert_eq!(storage.read_at(0, 317).unwrap(), vec![79; 317]);
assert_eq!(
storage.read_at(317 + page.len() as u64, 211).unwrap(),
vec![83; 211]
);
}
}
}
}
}
}
#[test]
fn block_page_rejects_header_metadata_and_extent_corruption_before_use() {
for encrypted in [false, true] {
for unpadded in [false, true] {
let identity = identity(encrypted, false, false, unpadded);
let (descriptor, page) =
encode(identity, 31, &[37; 32769], slices(32769), &[53; 32]).unwrap();
for byte in [8, 10, 12, 16, 24, 32, 44, 48, 56, 64, PAGE_HEADER_LEN] {
let mut corrupt = page.clone();
corrupt[byte] ^= 1;
if byte < 64 {
let digest = strong_checksum(&corrupt[..64]);
corrupt[64..96].copy_from_slice(&digest);
}
assert!(
Reader::open(
&StorageBackend::memory(corrupt),
0,
identity,
&descriptor,
page.len(),
&[53; 32]
)
.is_err(),
"byte {byte}"
);
}
let mut huge = page.clone();
huge[56..64].copy_from_slice(&u64::MAX.to_le_bytes());
let digest = strong_checksum(&huge[..64]);
huge[64..96].copy_from_slice(&digest);
assert!(
read_metadata(&StorageBackend::memory(huge), 0, identity, &[53; 32]).is_err()
);
let truncated = StorageBackend::memory(page[..page.len() - 1].to_vec());
assert!(
Reader::open(&truncated, 0, identity, &descriptor, page.len(), &[53; 32])
.is_err()
);
if encrypted {
assert!(Reader::open(
&StorageBackend::memory(page.clone()),
0,
identity,
&descriptor,
page.len(),
&[54; 32]
)
.is_err());
assert!(!page
.windows(b"/nested/second.bin".len())
.any(|w| w == b"/nested/second.bin"));
}
let mut swapped = identity;
swapped.mode.0 ^= 2;
assert!(
read_metadata(&StorageBackend::memory(page), 0, swapped, &[53; 32]).is_err()
);
}
}
}
#[test]
fn block_page_cached_reader_rejects_lost_padding_and_corrupt_recovery_data() {
let root = std::env::temp_dir().join(format!(
"revault-block-page-{}-{}",
std::process::id(),
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_nanos()
));
std::fs::create_dir(&root).unwrap();
for encrypted in [false, true] {
let identity = identity(encrypted, false, false, false);
let (descriptor, page) =
encode(identity, 31, &[37; 128], slices(128), &[53; 32]).unwrap();
let used = PAGE_HEADER_LEN + read_u32_le(&page[44..48]).unwrap() as usize;
assert!(page.len() > used);
let path = root.join(format!("{encrypted}"));
let storage = StorageBackend::create_file(&path, &page).unwrap();
let reader =
Reader::open(&storage, 0, identity, &descriptor, page.len(), &[53; 32]).unwrap();
assert_eq!(reader.read(0..128).unwrap(), [37; 128]);
let cache = std::cell::RefCell::new(crate::page_cache::PageCache::new(
crate::CacheLimit::Bytes(65536),
));
assert_eq!(reader.read_with_cache(0..13, &cache).unwrap(), [37; 13]);
assert_eq!(cache.borrow().stats().entries, 1);
assert_eq!(reader.read_with_cache(1..14, &cache).unwrap(), [37; 13]);
assert_eq!(cache.borrow().stats().hits, 1);
let mut damaged = storage.clone();
damaged.truncate(page.len() as u64 - 1).unwrap();
assert!(reader.read(0..1).is_err());
assert!(reader.read(0..0).is_err());
assert!(reader.read_with_cache(0..13, &cache).is_err());
assert!(reader.read_with_cache(0..0, &cache).is_err());
let mut damaged = page;
let metadata = read_metadata(
&StorageBackend::memory(damaged.clone()),
0,
identity,
&[53; 32],
)
.unwrap();
damaged[metadata.packet_offset as usize + descriptor.index_len().unwrap()] ^= 1;
let storage = StorageBackend::memory(damaged);
let metadata = read_metadata(&storage, 0, identity, &[53; 32]).unwrap();
let frame = BlockFrameReader::open(
&metadata.descriptor,
&storage,
metadata.packet_offset,
metadata.packet_len,
&[53; 32],
)
.unwrap();
assert!(frame.read(0..128).is_err());
let reader = Reader::open(
&storage,
0,
identity,
&descriptor,
storage.len().unwrap() as usize,
&[53; 32],
)
.unwrap();
cache.borrow_mut().clear();
assert!(reader.read_with_cache(0..13, &cache).is_err());
assert_eq!(
cache.borrow().stats().entries,
0,
"corrupt blocks cannot enter the cache"
);
}
std::fs::remove_dir_all(root).unwrap();
}
#[test]
fn block_page_rejects_invalid_manifest_and_rechecksummed_metadata_bombs() {
let identity = identity(false, false, false, true);
let mut invalid = slices(128);
invalid[0].len = 129;
assert!(encode(identity, 31, &[37; 128], invalid, &[53; 32]).is_err());
let mut invalid = slices(128);
invalid[0].permissions = u32::MAX;
assert!(encode(identity, 31, &[37; 128], invalid, &[53; 32]).is_err());
let (descriptor, mut page) =
encode(identity, 31, &[37; 128], slices(128), &[53; 32]).unwrap();
let metadata_len = read_u64_le(&page[56..64]).unwrap() as usize;
let body_start = PAGE_HEADER_LEN + 32;
page[body_start + 1..body_start + 9].copy_from_slice(&u64::MAX.to_le_bytes());
let aad = metadata_aad(identity, &page[..PAGE_HEADER_LEN]);
let digest = metadata_digest(&aad, &page[body_start..PAGE_HEADER_LEN + metadata_len]);
page[PAGE_HEADER_LEN..body_start].copy_from_slice(&digest);
let page_len = page.len();
assert!(Reader::open(
&StorageBackend::memory(page),
0,
identity,
&descriptor,
page_len,
&[53; 32]
)
.is_err());
}
}