Files
craft-anything/crates/formats/tests/car_tree_completeness.rs
Afloat f57fa23780 Disclose incomplete asset catalog tree reads (R3.12) (#1603)
A truncated asset catalog tree or node header could give no entries and no warning, and apple_assets_list then reported a complete empty listing; other interrupted tree walks kept what they read but called the result complete. Tree completeness is now tracked through the headers, child and leaf links, missing blocks and walk limits. Readable entries are kept, and an incomplete tree marks coverage partial, sets tree_incomplete and says so in the summary. Legal empty trees still read as complete.
2026-11-11 12:36:40 +07:00

196 lines
7.1 KiB
Rust

use craft_anything_formats::car;
use craft_anything_testkit::apple::{BomWriter, assets_car};
fn u32_be(data: &[u8], at: usize) -> u32 {
u32::from_be_bytes(data[at..at + 4].try_into().unwrap())
}
fn tree_ids(data: &[u8], name: &str) -> (u32, u32) {
let bom = car::parse_bom(data).unwrap();
let id = bom.vars.iter().find(|(key, _)| key == name).unwrap().1;
(id, u32_be(bom.block(data, id).unwrap(), 8))
}
fn block_offset(data: &[u8], id: u32) -> usize {
car::parse_bom(data).unwrap().blocks[id as usize].0 as usize
}
fn set_block_length(data: &mut [u8], id: u32, length: u32) {
let field = u32_be(data, 16) as usize + 8 + id as usize * 8;
data[field..field + 4].copy_from_slice(&length.to_be_bytes());
}
fn assert_partial(data: &[u8], renditions: usize) {
let catalog = car::parse(data).unwrap();
assert_eq!(catalog.renditions.len(), renditions);
assert!(!catalog.warnings.is_empty(), "a short tree must not be silently empty");
assert_eq!(serde_json::to_value(catalog).unwrap()["tree_incomplete"], true);
}
#[test]
fn a_short_tree_header_is_not_an_empty_catalog() {
for length in 4..12 {
let mut data = assets_car();
let (tree, _) = tree_ids(&data, "RENDITIONS");
set_block_length(&mut data, tree, length);
assert_partial(&data, 0);
}
}
#[test]
fn a_short_node_header_is_not_an_empty_leaf() {
for length in 0..12 {
let mut data = assets_car();
let (_, leaf) = tree_ids(&data, "RENDITIONS");
set_block_length(&mut data, leaf, length);
assert_partial(&data, 0);
}
}
#[test]
fn an_interior_node_requires_its_declared_first_child() {
for null_child in [false, true] {
let mut data = assets_car();
let (_, node) = tree_ids(&data, "RENDITIONS");
let at = block_offset(&data, node);
data[at..at + 2].copy_from_slice(&0u16.to_be_bytes());
data[at + 2..at + 4].copy_from_slice(&1u16.to_be_bytes());
if null_child {
data[at + 12..at + 16].fill(0);
} else {
set_block_length(&mut data, node, 12);
}
assert_partial(&data, 0);
}
}
#[test]
fn a_declared_tree_with_a_missing_block_is_disclosed() {
let mut data = assets_car();
let (tree, _) = tree_ids(&data, "RENDITIONS");
let field = u32_be(&data, 16) as usize + 4 + tree as usize * 8;
data[field..field + 4].copy_from_slice(&u32::MAX.to_be_bytes());
assert_partial(&data, 0);
}
#[test]
fn partial_leaf_entries_remain_available() {
let mut data = assets_car();
let (_, leaf) = tree_ids(&data, "RENDITIONS");
set_block_length(&mut data, leaf, 20); // Header and one of two entries.
assert_partial(&data, 1);
}
#[test]
fn a_forward_link_cycle_retains_entries_and_marks_the_tree_incomplete() {
let mut data = assets_car();
let (_, leaf) = tree_ids(&data, "RENDITIONS");
let at = block_offset(&data, leaf);
data[at + 4..at + 8].copy_from_slice(&leaf.to_be_bytes());
assert_partial(&data, 2);
}
#[test]
fn a_forward_link_to_an_interior_node_is_not_read_as_another_leaf() {
let mut data = assets_car();
let (_, leaf) = tree_ids(&data, "RENDITIONS");
let (_, interior) = tree_ids(&data, "FACETKEYS");
let at = block_offset(&data, leaf);
data[at + 4..at + 8].copy_from_slice(&interior.to_be_bytes());
let at = block_offset(&data, interior);
data[at..at + 2].fill(0);
assert_partial(&data, 2);
}
#[test]
fn incomplete_facet_trees_are_disclosed_even_with_complete_renditions() {
let mut data = assets_car();
let (_, leaf) = tree_ids(&data, "FACETKEYS");
set_block_length(&mut data, leaf, 1);
assert_partial(&data, 2);
}
#[test]
fn complete_empty_trees_and_null_roots_remain_complete() {
for null_root in [false, true] {
let mut data = assets_car();
let (tree, leaf) = tree_ids(&data, "RENDITIONS");
let bom = car::parse_bom(&data).unwrap();
let header = bom.vars.iter().find(|(name, _)| name == "CARHEADER").unwrap().1;
let at = block_offset(&data, header);
data[at + 16..at + 20].fill(0);
if null_root {
let at = block_offset(&data, tree);
data[at + 8..at + 12].fill(0);
} else {
let at = block_offset(&data, leaf);
data[at + 2..at + 4].fill(0);
set_block_length(&mut data, leaf, 12);
}
let catalog = car::parse(&data).unwrap();
assert!(catalog.renditions.is_empty());
assert!(catalog.warnings.is_empty());
assert_ne!(serde_json::to_value(catalog).unwrap()["tree_incomplete"], true);
}
}
#[test]
fn ordinary_metadata_warnings_are_not_tree_truncation() {
let mut writer = BomWriter::new();
writer.var("APPEARANCEKEYS", b"metadata".to_vec());
let catalog = car::parse(&writer.finish()).unwrap();
assert!(catalog.warnings.iter().any(|warning| warning.contains("is not a tree")));
assert!(catalog.warnings.iter().any(|warning| warning.contains("CARHEADER")));
assert_ne!(serde_json::to_value(catalog).unwrap()["tree_incomplete"], true);
}
#[test]
fn a_complete_catalog_keeps_its_renditions_and_facets() {
let catalog = car::parse(&assets_car()).unwrap();
assert_eq!(catalog.renditions.len(), 2);
assert_eq!(catalog.facets.len(), 2);
assert_eq!(catalog.renditions[0].name.as_deref(), Some("AppIcon.png"));
assert_eq!(catalog.renditions[1].name.as_deref(), Some("Logo@2x.png"));
assert!(catalog.warnings.is_empty());
assert_ne!(serde_json::to_value(catalog).unwrap()["tree_incomplete"], true);
}
#[test]
fn the_entry_limit_only_reports_truncation_when_entries_remain() {
const LIMIT: usize = 1_000_000;
for total in [LIMIT, LIMIT + 1] {
let mut writer = BomWriter::new();
let key = writer.block(b"key".to_vec());
let value = writer.block(b"value".to_vec());
let first_leaf = value + 1;
let mut leaf_id = first_leaf;
let mut remaining = total;
while remaining != 0 {
let count = remaining.min(u16::MAX as usize);
remaining -= count;
let mut leaf = Vec::with_capacity(12 + 8 * count);
leaf.extend_from_slice(&1u16.to_be_bytes());
leaf.extend_from_slice(&(count as u16).to_be_bytes());
leaf.extend_from_slice(&(if remaining == 0 { 0 } else { leaf_id + 1 }).to_be_bytes());
leaf.extend_from_slice(&0u32.to_be_bytes());
for _ in 0..count {
leaf.extend_from_slice(&value.to_be_bytes());
leaf.extend_from_slice(&key.to_be_bytes());
}
assert_eq!(writer.block(leaf), leaf_id);
leaf_id += 1;
}
let mut header = b"tree".to_vec();
for number in [1u32, first_leaf, 4096, total as u32] {
header.extend_from_slice(&number.to_be_bytes());
}
header.push(0);
writer.var("RENDITIONS", header);
let data = writer.finish();
let bom = car::parse_bom(&data).unwrap();
let mut warnings = Vec::new();
assert_eq!(bom.tree(&data, "RENDITIONS", &mut warnings).len(), LIMIT);
assert_eq!(warnings.is_empty(), total == LIMIT);
}
}