Craft Anything: understand how any software works, and craft your own.
Rust
More format parsers keep to their declared lengths and refuse impossible values (#986)
BFlat60409b684c80
diff --git a/crates/engine/src/tools/apple_tools.rs b/crates/engine/src/tools/apple_tools.rsindex ceb789e3..8d172c59 100644--- a/crates/engine/src/tools/apple_tools.rs+++ b/crates/engine/src/tools/apple_tools.rs@@ -502,7 +502,8 @@ fn check_hashes(slice: &[u8], sig_bytes: &[u8], sig: &codesign::Signature, cd: &if hs == 0 || hs > 64 || cd.page_size == 0 {return json!({"checked": false, "reason": "unsupported hash size or page size"});}- let base = cd.offset.saturating_add(cd.hash_offset as usize);+ let base = cd.hash_offset as usize;+ let cd_bytes = cd.offset.checked_add(cd.length as usize).and_then(|end| sig_bytes.get(cd.offset..end.min(sig_bytes.len()))).unwrap_or_default();let page = usize::try_from(cd.page_size).unwrap_or(4096);let limit = usize::try_from(cd.code_limit).unwrap_or(usize::MAX).min(slice.len());let mut matched = 0u64;@@ -516,7 +517,8 @@ fn check_hashes(slice: &[u8], sig_bytes: &[u8], sig: &codesign::Signature, cd: &continue;}let end = start.saturating_add(page).min(limit);- let (Some(data), Some(stored)) = (slice.get(start..end), sig_bytes.get(base.saturating_add(i * hs)..base.saturating_add(i * hs + hs))) else {+ let stored = i.checked_mul(hs).and_then(|n| base.checked_add(n)).and_then(|at| cd_bytes.get(at..at.checked_add(hs)?));+ let (Some(data), Some(stored)) = (slice.get(start..end), stored) else {missing += 1;continue;};@@ -540,8 +542,11 @@ fn check_hashes(slice: &[u8], sig_bytes: &[u8], sig: &codesign::Signature, cd: &if slot > i64::from(cd.special_slots) {continue;}- let stored = sig_bytes.get(base.saturating_sub(slot as usize * hs)..base.saturating_sub(slot as usize * hs).saturating_add(hs));- let Some(stored) = stored else { continue };+ let stored = (slot as usize).checked_mul(hs).and_then(|n| base.checked_sub(n)).and_then(|at| cd_bytes.get(at..at.checked_add(hs)?));+ let Some(stored) = stored else {+ special.push(json!({"slot": -slot, "what": what, "status": "not-checked", "stored": null}));+ continue;+ };let zero = stored.iter().all(|&x| x == 0);let actual: Option<Vec<u8>> = match slot {2 | 5 | 7 => blob_for(slot as u32).map(<[u8]>::to_vec),@@ -592,6 +597,7 @@ fn apple_signature_show(ctx: &mut Ctx<'_>, params: Value) -> Result<ToolOutput,ToolError::new(ErrorCode::NotSupported, "the code signature lies outside the file").with_remediation("The file may be truncated; check it is complete.")})?;let sig = codesign::parse(sig_bytes).map_err(|e| format_err(e, "a code signature"))?;+ let sig_bytes = sig_bytes.get(..(sig.length as usize).min(sig_bytes.len())).unwrap_or_default();let checks: Vec<Value> = sig.code_directories.iter()@@ -1375,6 +1381,7 @@ fn apple_dylibs_resolve(ctx: &mut Ctx<'_>, params: Value) -> Result<ToolOutput,mod tests {use super::super::native_common::test_support::{call, call_err, engine_with};use crate::Engine;+ use craft_anything_formats::codesign;use craft_anything_testkit::apple as fx;use serde_json::json;@@ -1425,6 +1432,118 @@ mod tests {assert_eq!(u["result"]["signed"], false);}+ fn signature_file(signature: &[u8]) -> Vec<u8> {+ // One load command fits in the fixture's 64-byte header area.+ let command: Vec<u8> = [0x1du32, 16, 64, signature.len() as u32].into_iter().flat_map(u32::to_le_bytes).collect();+ let mut bytes = fx::macho_min(fx::CPU_X86_64, 2, &[command], &[]);+ assert_eq!(bytes.len(), 64);+ bytes.extend_from_slice(signature);+ bytes+ }++ #[test]+ fn signature_special_slots_ignore_bytes_past_superblob() {+ let mut signature = fx::code_signature_blob();+ let parsed = codesign::parse(&signature).unwrap();+ let entitlements = parsed.blobs.iter().find(|b| b.slot == 5).unwrap();+ // Retain the child's header, but leave its payload outside the declared signature.+ signature[4..8].copy_from_slice(&(entitlements.offset + 8).to_be_bytes());+ let e = engine_with("short-signature", &signature_file(&signature));+ let r = call(&e, "apple_signature_show", json!({}));+ assert!(r["result"]["entitlements"].is_null());+ let special = r["result"]["hash_checks"][0]["result"]["special_slots"].as_array().unwrap();+ assert_eq!(special.iter().find(|s| s["what"] == "entitlements").unwrap()["status"], "not-checked");++ // The same complete child is still checked when it lies inside the declared extent.+ signature[4..8].copy_from_slice(&parsed.length.to_be_bytes());+ let e = engine_with("complete-signature", &signature_file(&signature));+ let r = call(&e, "apple_signature_show", json!({}));+ assert_eq!(r["result"]["entitlements"]["com.apple.security.network.client"], true);+ let special = r["result"]["hash_checks"][0]["result"]["special_slots"].as_array().unwrap();+ assert_eq!(special.iter().find(|s| s["what"] == "entitlements").unwrap()["status"], "mismatch");+ }++ #[test]+ fn signature_stored_hashes_ignore_bytes_past_superblob() {+ let mut signature = fx::assemble_superblob(&[(0, fx::code_directory_blob())]);+ let parsed = codesign::parse(&signature).unwrap();+ let cd = &parsed.code_directories[0];+ let hash_offset = parsed.length - cd.offset as u32;+ signature[cd.offset + 16..cd.offset + 20].copy_from_slice(&hash_offset.to_be_bytes());+ signature[cd.offset + 24..cd.offset + 28].copy_from_slice(&0u32.to_be_bytes());+ // LC_CODE_SIGNATURE includes these bytes; the superblob does not.+ signature.extend_from_slice(&[0; 32]);+ let e = engine_with("external-page-hash", &signature_file(&signature));+ let r = call(&e, "apple_signature_show", json!({}));+ let checks = &r["result"]["hash_checks"][0]["result"];+ assert_eq!(checks["pages_unchecked"], 1);+ assert_eq!(checks["pages_matched"], 0);+ assert!(checks["pages_mismatched"].as_array().unwrap().is_empty());+ }++ #[test]+ fn signature_missing_special_hashes_are_reported() {+ let mut signature = fx::assemble_superblob(&[(0, fx::code_directory_blob())]);+ let parsed = codesign::parse(&signature).unwrap();+ let cd = &parsed.code_directories[0];+ let special_slots = 7u32;+ let missing_bytes = special_slots * u32::from(cd.hash_size);+ let hash_offset = parsed.length - cd.offset as u32 + missing_bytes;+ signature[cd.offset + 16..cd.offset + 20].copy_from_slice(&hash_offset.to_be_bytes());+ signature[cd.offset + 24..cd.offset + 28].copy_from_slice(&special_slots.to_be_bytes());+ signature[cd.offset + 28..cd.offset + 32].copy_from_slice(&0u32.to_be_bytes());+ // Stored special hashes start at the superblob's end, inside LC_CODE_SIGNATURE only.+ signature.resize(signature.len() + missing_bytes as usize, 0);+ let e = engine_with("external-special-hashes", &signature_file(&signature));+ let r = call(&e, "apple_signature_show", json!({}));+ let checks = &r["result"]["hash_checks"][0]["result"];+ assert_eq!(checks["checked"], true);+ let special = checks["special_slots"].as_array().unwrap();+ let expected = [(-1, "info-plist"), (-2, "requirements"), (-5, "entitlements"), (-7, "der-entitlements"), (-3, "resources")];+ assert_eq!(special.len(), expected.len());+ for (slot, what) in expected {+ let entry = special.iter().find(|s| s["slot"] == slot).unwrap();+ assert_eq!(entry, &json!({"slot": slot, "what": what, "status": "not-checked", "stored": null}));+ }+ }++ #[test]+ fn signature_stored_hashes_stay_inside_code_directory() {+ let mut signature = fx::code_signature_blob();+ let parsed = codesign::parse(&signature).unwrap();+ let cd = &parsed.code_directories[0];+ let hash_offset = cd.length + u32::from(cd.hash_size);+ // Both stored hashes lie beyond the CodeDirectory, inside the complete superblob.+ assert!(cd.offset + hash_offset as usize + usize::from(cd.hash_size) <= signature.len());+ signature[cd.offset + 16..cd.offset + 20].copy_from_slice(&hash_offset.to_be_bytes());+ signature[cd.offset + 24..cd.offset + 28].copy_from_slice(&1u32.to_be_bytes());+ let e = engine_with("hashes-past-code-directory", &signature_file(&signature));+ let r = call(&e, "apple_signature_show", json!({}));+ let checks = &r["result"]["hash_checks"][0]["result"];+ assert_eq!(checks["checked"], true);+ assert_eq!(checks["pages_unchecked"], 1);+ assert_eq!(checks["pages_matched"], 0);+ assert!(checks["pages_mismatched"].as_array().unwrap().is_empty());+ assert_eq!(checks["special_slots"], json!([{"slot": -1, "what": "info-plist", "status": "not-checked", "stored": null}]));+ }++ #[test]+ fn signature_special_hashes_cannot_precede_code_directory() {+ let mut signature = fx::code_signature_blob();+ let parsed = codesign::parse(&signature).unwrap();+ let cd = &parsed.code_directories[0];+ // Absolute subtraction would stay inside the superblob but precede this CodeDirectory.+ assert!(cd.offset >= usize::from(cd.hash_size));+ signature[cd.offset + 16..cd.offset + 20].copy_from_slice(&0u32.to_be_bytes());+ signature[cd.offset + 24..cd.offset + 28].copy_from_slice(&1u32.to_be_bytes());+ signature[cd.offset + 28..cd.offset + 32].copy_from_slice(&0u32.to_be_bytes());+ let e = engine_with("hash-before-code-directory", &signature_file(&signature));+ let r = call(&e, "apple_signature_show", json!({}));+ let checks = &r["result"]["hash_checks"][0]["result"];+ assert_eq!(checks["checked"], true);+ assert_eq!(checks["special_slots"], json!([{"slot": -1, "what": "info-plist", "status": "not-checked", "stored": null}]));+ }+#[test]fn signature_cms_is_verified() {// A Mach-O whose CMS genuinely signs its CodeDirectory verifies cryptographically.diff --git a/crates/formats/src/ai_model.rs b/crates/formats/src/ai_model.rsindex 587d3b2f..624d56bb 100644--- a/crates/formats/src/ai_model.rs+++ b/crates/formats/src/ai_model.rs@@ -184,6 +184,9 @@ fn shorten(s: String) -> (String, bool) {}fn element_count(shape: &[u64]) -> (u64, bool) {+ if shape.contains(&0) {+ return (0, false);+ }let mut n: u64 = 1;for d in shape {match n.checked_mul(*d) {diff --git a/crates/formats/src/apk_sign.rs b/crates/formats/src/apk_sign.rsindex d26aca13..8a0c5939 100644--- a/crates/formats/src/apk_sign.rs+++ b/crates/formats/src/apk_sign.rs@@ -4,10 +4,19 @@use crate::bytes::Reader;use serde::Serialize;+use std::collections::BTreeMap;const MAGIC: &[u8; 16] = b"APK Sig Block 42";+const EOCD_SEARCH: usize = 22 + 0xffff;+const CD_HEADER_LEN: usize = 46;+// Enough boundaries for a full classic ZIP directory plus the search window's allowance.+// Keep cache allocation independent of the input payload size, including each directory's start.+const MAX_DIRECTORY_BOUNDARIES: usize = EOCD_SEARCH + u16::MAX as usize;const MAX_PAIRS: usize = 256;const MAX_ITEMS: usize = 64;+// One block has at most MAX_PAIRS * (1 + MAX_ITEMS) probe records. Bound both record+// maps together, independently of file size and the number of candidate block extents.+const MAX_PROBE_RECORDS: usize = EOCD_SEARCH;/// Most certificate bytes kept per certificate.const MAX_CERT: usize = 64 * 1024;@@ -96,16 +105,143 @@ pub struct SigningBlock {pub warnings: Vec<String>,}-fn find_eocd(data: &[u8]) -> Option<usize> {- let from = data.len().saturating_sub(22 + 0xffff);+fn signing_block_extent(r: &Reader<'_>, cd: usize) -> Option<(usize, u64)> {+ if r.slice(cd.checked_sub(16)?, 16)? != MAGIC {+ return None;+ }+ let size = r.u64_le(cd.checked_sub(24)?)?;+ let total = usize::try_from(size).ok()?.checked_add(8)?;+ Some((cd.checked_sub(total)?, size))+}++#[derive(Default)]+struct DirectoryPrefix {+ boundaries: Vec<usize>,+ stopped: bool,+}++impl DirectoryPrefix {+ fn push(&mut self, boundary: usize, capacity_left: &mut usize) -> Option<()> {+ if self.boundaries.len() == self.boundaries.capacity() {+ let additional = self.boundaries.capacity().max(1).min(*capacity_left);+ if additional == 0 {+ return None;+ }+ let before = self.boundaries.capacity();+ self.boundaries.try_reserve_exact(additional).ok()?;+ *capacity_left = capacity_left.checked_sub(self.boundaries.capacity().checked_sub(before)?)?;+ }+ self.boundaries.push(boundary);+ Some(())+ }+}++struct DirectoryCache {+ prefixes: BTreeMap<usize, DirectoryPrefix>,+ capacity_left: usize,+}++impl DirectoryCache {+ fn new() -> Self {+ Self { prefixes: BTreeMap::new(), capacity_left: MAX_DIRECTORY_BOUNDARIES }+ }++ /// `None` means a scan-wide work or cache limit ran out; `Some(false)` means bad framing.+ fn framed(&mut self, r: &Reader<'_>, cd: usize, size: usize, count: u16, records_left: &mut usize) -> Option<bool> {+ if usize::from(count) > size / CD_HEADER_LEN {+ return Some(false);+ }+ let Some(end) = cd.checked_add(size) else { return Some(false) };+ if r.slice(cd, size).is_none() {+ return Some(false);+ }+ let prefix = self.prefixes.entry(cd).or_default();+ if prefix.boundaries.is_empty() {+ prefix.push(cd, &mut self.capacity_left)?;+ }+ // Only new header visits consume work. Inspect the immutable input, not this candidate's+ // declared size: a short candidate must not poison a later request for a longer prefix.+ while prefix.boundaries.len() <= usize::from(count) && !prefix.stopped {+ let pos = *prefix.boundaries.last()?;+ if pos >= end {+ return Some(false);+ }+ *records_left = records_left.checked_sub(1)?;+ if let Some(next) = directory_record_end(r, pos) {+ prefix.push(next, &mut self.capacity_left)?;+ } else {+ prefix.stopped = true;+ }+ }+ let Some(pos) = prefix.boundaries.get(usize::from(count)).copied().filter(|pos| *pos <= end) else { return Some(false) };+ if pos == end {+ return Some(true);+ }+ // The candidate's exact size still permits only one optional digital-signature record.+ let Some(tail) = r.slice(pos, end - pos) else { return Some(false) };+ let tail_reader = Reader::new(tail);+ Some(tail_reader.slice(0, 4) == Some(b"PK\x05\x05") && tail_reader.u16_le(4).is_some_and(|len| usize::from(len).checked_add(6) == Some(tail.len())))+ }+}++fn directory_record_end(r: &Reader<'_>, pos: usize) -> Option<usize> {+ let header = Reader::new(r.slice(pos, CD_HEADER_LEN)?);+ if header.slice(0, 4) != Some(b"PK\x01\x02") {+ return None;+ }+ let len = [28, 30, 32].into_iter().try_fold(CD_HEADER_LEN, |len, field| len.checked_add(usize::from(header.u16_le(field)?)))?;+ r.slice(pos, len)?;+ pos.checked_add(len)+}++struct EocdCandidate {+ offset: usize,+ directory: usize,+ has_signer: bool,+ ambiguous: bool,+}++fn find_eocd(data: &[u8]) -> Option<EocdCandidate> {+ // One input-sized pass plus the search window's allowance, shared by every candidate's+ // directory records, signing-block pairs and signer records.+ let records_left = (data.len() / CD_HEADER_LEN).checked_add(EOCD_SEARCH)?;+ find_eocd_with_budget(data, records_left)+}++fn find_eocd_with_budget(data: &[u8], mut records_left: usize) -> Option<EocdCandidate> {+ let r = Reader::new(data);+ let from = data.len().saturating_sub(EOCD_SEARCH);let mut i = data.len().checked_sub(22)?;- while i >= from {- if data.get(i..i + 4) == Some(b"PK\x05\x06") {- return Some(i);+ // Empty or unreadable blocks must not hide recoverable signers. Among equally readable+ // candidates, retain the lowest offset and report distinct readable blocks as ambiguous.+ let mut found: Option<EocdCandidate> = None;+ let mut ambiguous = false;+ let mut directories = DirectoryCache::new();+ let mut probes = ProbeCache::new();+ loop {+ if let Some(end) = r.slice(i, 22).map(Reader::new)+ && end.slice(0, 4) == Some(b"PK\x05\x06")+ && end.u16_le(20).is_some_and(|n| usize::from(n) == data.len() - i - 22)+ && let Some(cd) = end.u32_le(16).and_then(|n| usize::try_from(n).ok())+ && let Some(size) = end.u32_le(12).and_then(|n| usize::try_from(n).ok())+ && cd.checked_add(size) == Some(i)+ && let Some((start, _)) = signing_block_extent(&r, cd)+ && let Some(count) = end.u16_le(10)+ && directories.framed(&r, cd, size, count, &mut records_left)?+ {+ let has_signer = probes.has_readable_signer(&r, start, cd, &mut records_left)?;+ if let Some(previous) = &found {+ ambiguous |= previous.has_signer && has_signer && previous.directory != cd;+ }+ if has_signer || found.as_ref().is_none_or(|previous| !previous.has_signer) {+ found = Some(EocdCandidate { offset: i, directory: cd, has_signer, ambiguous });+ }}- i = i.checked_sub(1)?;+ if i == from {+ return found;+ }+ i -= 1;}- None}struct Lp<'a> {@@ -139,6 +275,123 @@ impl<'a> Lp<'a> {}}+#[derive(Clone, Copy)]+struct PairProbe {+ end: usize,+ // A recognized pair is unprobed until its complete value fits a candidate's extent.+ readable: Option<bool>,+}++impl PairProbe {+ fn read(r: &Reader<'_>, pos: usize) -> Option<Self> {+ let len = usize::try_from(r.u64_le(pos)?).ok()?;+ let body = pos.checked_add(8)?;+ if len < 4 || r.slice(body, len).is_none() {+ return None;+ }+ let readable = if matches!(r.u32_le(body)?, V2_ID | V3_ID | V31_ID) { None } else { Some(false) };+ Some(Self { end: body.checked_add(len)?, readable })+ }+}++#[derive(Clone, Copy)]+struct SignerProbe {+ end: usize,+ readable: bool,+}++impl SignerProbe {+ fn read(r: &Reader<'_>, pos: usize) -> Option<Self> {+ let len = usize::try_from(r.u32_le(pos)?).ok()?;+ let body = pos.checked_add(4)?;+ let item = Lp { data: r.slice(body, len)? };+ // parse_signer requires only the signed-data LP; all later fields are optional.+ Some(Self { end: body.checked_add(len)?, readable: item.at(0).is_some() })+ }+}++struct ProbeCache {+ pairs: BTreeMap<usize, Option<PairProbe>>,+ items: BTreeMap<usize, Option<SignerProbe>>,+ slots_left: usize,+}++impl ProbeCache {+ fn new() -> Self {+ Self { pairs: BTreeMap::new(), items: BTreeMap::new(), slots_left: MAX_PROBE_RECORDS }+ }++ fn spend(&mut self, records_left: &mut usize) -> Option<()> {+ let remaining = records_left.checked_sub(1)?;+ self.slots_left = self.slots_left.checked_sub(1)?;+ *records_left = remaining;+ Some(())+ }++ /// Cache physical records, not candidate decisions. Several block starts may reach the+ /// same pair, and different pairs' signer sequences may reach the same length prefix.+ fn sequence_has_signer(&mut self, r: &Reader<'_>, mut pos: usize, end: usize, records_left: &mut usize) -> Option<bool> {+ for _ in 0..MAX_ITEMS {+ if pos >= end {+ break;+ }+ let step = if let Some(step) = self.items.get(&pos) {+ *step+ } else {+ self.spend(records_left)?;+ let step = SignerProbe::read(r, pos);+ self.items.insert(pos, step);+ step+ };+ let Some(step) = step.filter(|step| step.end <= end) else { break };+ if step.readable {+ return Some(true);+ }+ pos = step.end;+ }+ Some(false)+ }++ /// None means the shared work or cache limit ran out, never that an unprobed signer is absent.+ fn has_readable_signer(&mut self, r: &Reader<'_>, start: usize, cd: usize, records_left: &mut usize) -> Option<bool> {+ let Some(pairs_end) = cd.checked_sub(24) else { return Some(false) };+ let Some(mut pos) = start.checked_add(8) else { return Some(false) };+ for _ in 0..MAX_PAIRS {+ if pos >= pairs_end {+ break;+ }+ let step = if let Some(step) = self.pairs.get(&pos) {+ *step+ } else {+ self.spend(records_left)?;+ let step = PairProbe::read(r, pos);+ self.pairs.insert(pos, step);+ step+ };+ let Some(step) = step.filter(|step| step.end <= pairs_end) else { break };+ let readable = if let Some(readable) = step.readable {+ readable+ } else {+ let value_at = pos.checked_add(12)?;+ let value = r.slice(value_at, step.end.checked_sub(value_at)?)?;+ let readable = if let Some((signers, _)) = (Lp { data: value }).at(0) {+ let first = value_at.checked_add(4)?;+ self.sequence_has_signer(r, first, first.checked_add(signers.len())?, records_left)?+ } else {+ false+ };+ self.pairs.insert(pos, Some(PairProbe { end: step.end, readable: Some(readable) }));+ readable+ };+ if readable {+ return Some(true);+ }+ pos = step.end;+ }+ Some(false)+ }+}+fn hex(b: &[u8]) -> String {b.iter().take(128).map(|x| format!("{x:02x}")).collect()}@@ -212,15 +465,12 @@ fn parse_signer(scheme: &'static str, s: &[u8], warnings: &mut Vec<String>) -> Opub fn parse(data: &[u8]) -> Option<SigningBlock> {let r = Reader::new(data);let eocd = find_eocd(data)?;- let cd = r.u32_le(eocd + 16)? as usize;- let magic_at = cd.checked_sub(16)?;- if r.slice(magic_at, 16)? != MAGIC {- return None;- }- let size_footer = r.u64_le(cd.checked_sub(24)?)?;- let total = usize::try_from(size_footer).ok()?.checked_add(8)?;- let start = cd.checked_sub(total)?;+ let cd = r.u32_le(eocd.offset + 16)? as usize;+ let (start, size_footer) = signing_block_extent(&r, cd)?;let mut block = SigningBlock { offset: start as u64, size: size_footer, ..SigningBlock::default() };+ if eocd.ambiguous {+ block.warnings.push("multiple ZIP end records contain readable APK signers; signing metadata is ambiguous".into());+ }if r.u64_le(start) != Some(size_footer) {block.warnings.push("the block's two size fields disagree".into());}@@ -262,6 +512,205 @@ mod tests {use super::*;use craft_anything_testkit::android as fx;+ #[test]+ fn directory_candidates_reuse_scanned_headers() {+ let mut zip = craft_anything_testkit::electron::zip_stored(&[("a", b"a"), ("b", b"b")]);+ let eocd = zip.len() - 22;+ let cd = Reader::new(&zip).u32_le(eocd + 16).unwrap() as usize;+ zip.extend_from_slice(&[0; CD_HEADER_LEN]);+ let r = Reader::new(&zip);+ let mut cache = DirectoryCache::new();+ let mut records_left = 3;+ assert_eq!(cache.framed(&r, cd, eocd - cd, 1, &mut records_left), Some(false));+ assert_eq!(records_left, 2);+ assert_eq!(cache.framed(&r, cd, eocd - cd, 2, &mut records_left), Some(true));+ assert_eq!(records_left, 1);+ assert_eq!(cache.framed(&r, cd, zip.len() - cd, 3, &mut records_left), Some(false));+ assert_eq!(records_left, 0);+ assert_eq!(cache.framed(&r, cd, zip.len() - cd, 3, &mut records_left), Some(false));+ assert_eq!(cache.framed(&r, cd, eocd - cd, 2, &mut records_left), Some(true));+ assert_eq!(records_left, 0);+ }++ #[test]+ fn directory_cache_keeps_sizes_and_offsets_separate() {+ let zip = craft_anything_testkit::electron::zip_stored(&[("a", b"a"), ("b", b"b")]);+ let r = Reader::new(&zip);+ let cd = r.u32_le(zip.len() - 6).unwrap() as usize;+ let record_len = CD_HEADER_LEN + 1;+ let mut cache = DirectoryCache::new();+ let mut records_left = 1;+ assert_eq!(cache.framed(&r, cd, CD_HEADER_LEN, 1, &mut records_left), Some(false));+ assert_eq!(records_left, 0);+ assert_eq!(cache.framed(&r, cd, record_len, 1, &mut records_left), Some(true));+ assert_eq!(cache.framed(&r, cd + record_len, record_len, 1, &mut records_left), None);+ records_left = 1;+ assert_eq!(cache.framed(&r, cd + record_len, record_len, 1, &mut records_left), Some(true));+ assert_eq!(records_left, 0);+ }++ #[test]+ fn directory_cache_rechecks_optional_signature_tails() {+ let zip = craft_anything_testkit::electron::zip_stored(&[("a", b"a"), ("b", b"b")]);+ let eocd = zip.len() - 22;+ let cd = Reader::new(&zip).u32_le(eocd + 16).unwrap() as usize;+ let mut directory = zip[cd..eocd].to_vec();+ let headers_len = directory.len();+ directory.extend_from_slice(b"PK\x05\x05\x03\x00sig");+ let signed_len = directory.len();+ directory.push(0);+ let r = Reader::new(&directory);+ let mut cache = DirectoryCache::new();+ let mut records_left = 2;+ assert_eq!(cache.framed(&r, 0, signed_len, 2, &mut records_left), Some(true));+ assert_eq!(cache.framed(&r, 0, headers_len, 2, &mut records_left), Some(true));+ assert_eq!(cache.framed(&r, 0, signed_len - 1, 2, &mut records_left), Some(false));+ assert_eq!(cache.framed(&r, 0, directory.len(), 2, &mut records_left), Some(false));+ assert_eq!(records_left, 0);+ }++ #[test]+ fn directory_cache_capacity_includes_each_start() {+ let bytes = [0; 2];+ let r = Reader::new(&bytes);+ let mut cache = DirectoryCache::new();+ cache.capacity_left = 2;+ let mut records_left = 0;+ assert_eq!(cache.framed(&r, 0, 0, 0, &mut records_left), Some(true));+ assert_eq!(cache.framed(&r, 1, 0, 0, &mut records_left), Some(true));+ assert_eq!(cache.capacity_left, 0);+ assert_eq!(cache.framed(&r, 2, 0, 0, &mut records_left), None);+ assert_eq!(cache.framed(&r, 0, 0, 0, &mut records_left), Some(true));+ assert_eq!(cache.prefixes.values().map(|prefix| prefix.boundaries.capacity()).sum::<usize>(), 2);+ assert_eq!(records_left, 0);+ }++ #[test]+ fn eocd_lookup_rejects_an_exhausted_record_budget() {+ let apk = fx::notes_apk();+ let eocd = apk.len() - 22;+ let count = usize::from(Reader::new(&apk).u16_le(eocd + 10).unwrap());+ assert!(count > 0);+ assert_eq!(find_eocd_with_budget(&apk, count + 2).map(|candidate| candidate.offset), Some(eocd));+ assert!(find_eocd_with_budget(&apk, count + 1).is_none());+ assert!(find_eocd_with_budget(&apk, count - 1).is_none());+ }++ fn lp(value: &[u8]) -> Vec<u8> {+ let mut out = (value.len() as u32).to_le_bytes().to_vec();+ out.extend_from_slice(value);+ out+ }++ fn probe_fixture(pairs: &[(u32, Vec<u8>)]) -> Vec<u8> {+ let mut body = Vec::new();+ for (id, value) in pairs {+ body.extend_from_slice(&((value.len() + 4) as u64).to_le_bytes());+ body.extend_from_slice(&id.to_le_bytes());+ body.extend_from_slice(value);+ }+ let size = (body.len() + 24) as u64;+ let mut block = size.to_le_bytes().to_vec();+ block.extend_from_slice(&body);+ block.extend_from_slice(&size.to_le_bytes());+ block.extend_from_slice(MAGIC);+ fx::with_signing_block(&craft_anything_testkit::electron::zip_stored(&[]), &block)+ }++ fn assert_probe_matches_parser(pairs: &[(u32, Vec<u8>)], expected: bool) {+ let apk = probe_fixture(pairs);+ let mut records_left = EOCD_SEARCH;+ assert_eq!(ProbeCache::new().has_readable_signer(&Reader::new(&apk), 0, apk.len() - 22, &mut records_left), Some(expected));+ assert_eq!(!parse(&apk).unwrap().signers.is_empty(), expected);+ }++ #[test]+ fn signer_probe_reuses_records_across_candidate_extents() {+ let apk = fx::notes_apk();+ let r = Reader::new(&apk);+ let cd = r.u32_le(apk.len() - 6).unwrap() as usize;+ let (start, _) = signing_block_extent(&r, cd).unwrap();+ let first = start + 8;+ let full = first + 8 + usize::try_from(r.u64_le(first).unwrap()).unwrap() + 24;+ let mut cache = ProbeCache::new();+ let mut remaining = 2;+ assert_eq!(cache.has_readable_signer(&r, start, full - 1, &mut remaining), Some(false));+ assert_eq!(remaining, 1);+ assert_eq!(cache.has_readable_signer(&r, start, full, &mut remaining), Some(true));+ assert_eq!(remaining, 0);+ for _ in 0..300 {+ assert_eq!(cache.has_readable_signer(&r, start, full - 1, &mut remaining), Some(false));+ assert_eq!(cache.has_readable_signer(&r, start, cd, &mut remaining), Some(true));+ }+ assert_eq!((cache.pairs.len(), cache.items.len()), (1, 1));+ }++ #[test]+ fn cached_signer_items_respect_each_sequence_end() {+ let bytes = lp(&lp(&[]));+ let r = Reader::new(&bytes);+ let mut cache = ProbeCache::new();+ let mut remaining = 1;+ assert_eq!(cache.sequence_has_signer(&r, 0, bytes.len() - 1, &mut remaining), Some(false));+ assert_eq!(remaining, 0);+ assert_eq!(cache.sequence_has_signer(&r, 0, bytes.len(), &mut remaining), Some(true));+ assert_eq!(cache.sequence_has_signer(&r, 0, bytes.len() - 1, &mut remaining), Some(false));+ assert_eq!(cache.items.len(), 1);+ }++ #[test]+ fn an_unprobed_pair_is_not_marked_unreadable_when_resources_run_out() {+ let apk = fx::notes_apk();+ let r = Reader::new(&apk);+ let cd = r.u32_le(apk.len() - 6).unwrap() as usize;+ let (start, _) = signing_block_extent(&r, cd).unwrap();+ let mut cache = ProbeCache::new();+ cache.slots_left = 1;+ let mut remaining = 2;+ assert_eq!(cache.has_readable_signer(&r, start, cd, &mut remaining), None);+ assert_eq!(remaining, 1);+ assert_eq!((cache.pairs.len(), cache.items.len()), (1, 0));+ cache.slots_left = 1;+ assert_eq!(cache.has_readable_signer(&r, start, cd, &mut remaining), Some(true));+ assert_eq!(remaining, 0);+ assert_eq!(cache.slots_left, 0);+ }++ #[test]+ fn signer_probe_matches_the_parsers_recovery_boundaries() {+ let readable = lp(&lp(&lp(&[])));+ let bad_item = lp(&[u32::MAX.to_le_bytes().to_vec(), lp(&lp(&[]))].concat());+ for id in [V2_ID, V3_ID, V31_ID] {+ assert_probe_matches_parser(&[(id, lp(&lp(&[])))], false);+ assert_probe_matches_parser(&[(id, readable.clone())], true);+ assert_probe_matches_parser(&[(id, lp(&[lp(&[]), lp(&lp(&[]))].concat()))], true);+ assert_probe_matches_parser(&[(id, bad_item.clone())], false);+ }+ assert_probe_matches_parser(&[(V2_ID, vec![0xff; 4]), (V3_ID, readable.clone())], true);+ assert_probe_matches_parser(&[(V2_ID, bad_item), (V31_ID, readable)], true);+ }++ #[test]+ fn signer_probe_obeys_the_parsers_item_and_pair_limits() {+ let mut signers = lp(&[]).repeat(MAX_ITEMS);+ signers.extend_from_slice(&lp(&lp(&[])));+ assert_probe_matches_parser(&[(V2_ID, lp(&signers))], false);+ let mut pairs = vec![(0x1357_2468, Vec::new()); MAX_PAIRS];+ pairs.push((V2_ID, lp(&lp(&lp(&[])))));+ assert_probe_matches_parser(&pairs, false);++ // Reuse the ordinary limit fixture for many independent probe requests.+ let apk = probe_fixture(&pairs);+ let reader = Reader::new(&apk);+ let mut cache = ProbeCache::new();+ let mut remaining = MAX_PAIRS;+ for _ in 0..300 {+ assert_eq!(cache.has_readable_signer(&reader, 0, apk.len() - 22, &mut remaining), Some(false));+ }+ assert_eq!(remaining, 0);+ assert_eq!(cache.pairs.len(), MAX_PAIRS);+ }+#[test]fn reads_v2_and_v3_signers() {let apk = fx::notes_apk();diff --git a/crates/formats/src/codesign.rs b/crates/formats/src/codesign.rsindex 825943fb..a1e2b5b4 100644--- a/crates/formats/src/codesign.rs+++ b/crates/formats/src/codesign.rs@@ -191,6 +191,9 @@ pub fn parse(data: &[u8]) -> Result<Signature, FormatError> {}let length = r.u32_be(4).ok_or_else(|| FormatError::Truncated("superblob header".into()))?;let count = r.u32_be(8).ok_or_else(|| FormatError::Truncated("superblob header".into()))? as usize;+ if length < 12 {+ return Err(FormatError::Malformed("superblob length is smaller than its header".into()));+ }let mut sig = Signature {length,blobs: Vec::new(),@@ -209,6 +212,7 @@ pub fn parse(data: &[u8]) -> Result<Signature, FormatError> {if count > MAX_BLOBS {sig.warnings.push(format!("{count} blobs listed; reading {MAX_BLOBS}"));}+ let r = Reader::new(r.slice(0, (length as usize).min(data.len())).unwrap_or(&[]));for i in 0..count.min(MAX_BLOBS) {let (Some(slot), Some(off)) = (r.u32_be(12 + i * 8), r.u32_be(16 + i * 8)) else {sig.warnings.push("blob index cut short".into());@@ -216,7 +220,7 @@ pub fn parse(data: &[u8]) -> Result<Signature, FormatError> {};let o = off as usize;let bmagic = r.u32_be(o);- let blen = r.u32_be(o + 4);+ let blen = o.checked_add(4).and_then(|at| r.u32_be(at));sig.blobs.push(BlobIndex { slot, slot_name: slot_name(slot), magic: bmagic.map(|m| format!("{m:#x}")).unwrap_or_default(), offset: off, length: blen });let (Some(bmagic), Some(blen)) = (bmagic, blen) else {sig.warnings.push(format!("blob {i} lies outside the signature"));diff --git a/crates/formats/src/decompress.rs b/crates/formats/src/decompress.rsindex 78bbb6f1..ace03390 100644--- a/crates/formats/src/decompress.rs+++ b/crates/formats/src/decompress.rs@@ -96,6 +96,42 @@ pub fn lzma(input: &[u8], max_out: u64) -> Result<Vec<u8>, DecompressError> {}}+/// Decode a complete LZMA piece with properties but no size header, bounding its dictionary and output.+pub(crate) fn lzma_raw_complete(input: &[u8], out_len: u32) -> Result<Vec<u8>, DecompressError> {+ let cap = usize::try_from(out_len).map_err(|_| DecompressError::TooLarge)?;+ if cap > isize::MAX as usize {+ return Err(DecompressError::TooLarge);+ }+ let (properties, stream) = input.split_at_checked(5).ok_or(DecompressError::Truncated)?;+ let [property, d0, d1, d2, d3] = <[u8; 5]>::try_from(properties).map_err(|_| DecompressError::Truncated)?;+ // No match can reach farther back than the entire output. Keep the decoder's minimum window,+ // but avoid oversized dictionary arithmetic on 32-bit targets before its memory limit is checked.+ let dictionary = u32::from_le_bytes([d0, d1, d2, d3]).max(4096).min(out_len.max(4096));+ let [d0, d1, d2, d3] = dictionary.to_le_bytes();+ let properties = [property, d0, d1, d2, d3];+ let decode = |size: Option<u64>| {+ let options =+ lzma_rs::decompress::Options { unpacked_size: lzma_rs::decompress::UnpackedSize::UseProvided(size), memlimit: Some(cap), ..Default::default() };+ let mut out = CapWrite::new(cap);+ let mut cursor = io::Cursor::new(properties).chain(io::Cursor::new(stream));+ match lzma_rs::lzma_decompress_with_options(&mut cursor, &mut out, &options) {+ Ok(()) if cursor.get_ref().1.position() == stream.len() as u64 => Ok(out.buf),+ Ok(()) => Err(DecompressError::Corrupt),+ Err(_) if out.exceeded => Err(DecompressError::TooLarge),+ Err(lzma_rs::error::Error::HeaderTooShort(_)) => Err(DecompressError::Truncated),+ Err(_) => Err(DecompressError::Corrupt),+ }+ };+ let output = decode(None)?;+ if output.len() == cap {+ return Ok(output);+ }+ // A zero range code at EOF can precede the last zero literals in a stream without an end marker.+ // Retry a short result with its known size only after completion succeeded; never recover a failed probe.+ drop(output);+ decode(Some(u64::from(out_len)))+}+/// Decompress a bzip2 stream, producing at most `max_out` bytes.pub fn bzip2(input: &[u8], max_out: u64) -> Result<Vec<u8>, DecompressError> {read_capped(bzip2_rs::DecoderReader::new(input), cap_of(max_out))diff --git a/crates/formats/src/dos.rs b/crates/formats/src/dos.rsindex 1a3dc209..e7252b67 100644--- a/crates/formats/src/dos.rs+++ b/crates/formats/src/dos.rs@@ -80,9 +80,10 @@ pub fn parse_mz(data: &[u8]) -> Result<MzImage, FormatError> {problems.push(format!("entry {cs:04x}:{ip:04x} is outside the {load_module_size}-byte load module"));}let mut relocations = Vec::new();+ let header = Reader::new(r.slice(0, (header_bytes as usize).min(data.len())).unwrap_or(&[]));for i in 0..usize::from(nrelocs) {let o = usize::from(lfarlc) + i * 4;- let (Some(off), Some(seg)) = (r.u16_le(o), r.u16_le(o + 2)) else {+ let (Some(off), Some(seg)) = (header.u16_le(o), header.u16_le(o + 2)) else {problems.push(format!("relocation table cut short after {i} of {nrelocs} entries"));break;};diff --git a/crates/formats/src/dotnet/meta.rs b/crates/formats/src/dotnet/meta.rsindex b0ca1129..2ec3ddd6 100644--- a/crates/formats/src/dotnet/meta.rs+++ b/crates/formats/src/dotnet/meta.rs@@ -557,9 +557,8 @@ impl<'a> Metadata<'a> {pub fn user_string(&self, idx: u32, max: usize) -> Option<String> {let (len, n) = compressed_u32(self.us, idx as usize)?;let bytes = Reader::new(self.us).slice((idx as usize).checked_add(n)?, len as usize)?;- let chars = bytes.len() / 2;- let units: Vec<u16> = (0..chars.min(max)).filter_map(|i| Reader::new(bytes).u16_le(i * 2)).collect();- Some(String::from_utf16_lossy(&units))+ let units = bytes.as_chunks::<2>().0.iter().map(|unit| u16::from_le_bytes(*unit));+ Some(char::decode_utf16(units).take(max).map(|ch| ch.unwrap_or(char::REPLACEMENT_CHARACTER)).collect())}/// The range of child rows `[start, end)` a list column gives, resolved through the pointerdiff --git a/crates/formats/src/elf.rs b/crates/formats/src/elf.rsindex 868b37cc..c0c0a26a 100644--- a/crates/formats/src/elf.rs+++ b/crates/formats/src/elf.rs@@ -12,6 +12,7 @@ use std::collections::BTreeMap;const MAX_PHDRS: usize = 4096;const MAX_DYN: usize = 65_536;const MAX_NOTES: usize = 100_000;+const MAX_FILE_MAPPINGS: usize = 65_536;/// Endian/class-aware reads over an ELF image.#[derive(Clone, Copy)]@@ -971,16 +972,24 @@ pub fn parse_core(data: &[u8]) -> Result<CoreDump, FormatError> {core.signal = Some(SigInfo { signo, name: signal_name(signo), code, errno, fault_addr: fault, meaning: signal_meaning(signo, code) });}0x4649_4c45 => {- let count = usize::try_from(d.word(0).unwrap_or(0)).unwrap_or(0).min(65_536);+ let declared = d.word(0).unwrap_or(0);+ let count = usize::try_from(declared).unwrap_or(usize::MAX);let page = d.word(ws).unwrap_or(4096);let table = 2 * ws;- let mut names_off = table.saturating_add(count.saturating_mul(3 * ws));- for i in 0..count {- let o = table + i * 3 * ws;- let (Some(s), Some(en), Some(po)) = (d.word(o), d.word(o + ws), d.word(o + 2 * ws)) else { break };- let path = d.r.cstr(names_off, 4096).unwrap_or_default();- names_off = names_off.saturating_add(path.len() + 1);- core.mapped_files.push(MappedFile { start: s, end: en, file_offset: po.saturating_mul(page), path });+ let names_off = count.checked_mul(3 * ws).and_then(|bytes| table.checked_add(bytes)).filter(|&off| off <= desc.len());+ if let Some(mut names_off) = names_off {+ if count > MAX_FILE_MAPPINGS {+ core.warnings.push(format!("NT_FILE lists {declared} mappings; reading the first {MAX_FILE_MAPPINGS}"));+ }+ for i in 0..count.min(MAX_FILE_MAPPINGS) {+ let o = table + i * 3 * ws;+ let (Some(s), Some(en), Some(po)) = (d.word(o), d.word(o + ws), d.word(o + 2 * ws)) else { break };+ let path = d.r.cstr(names_off, 4096).unwrap_or_default();+ names_off = names_off.saturating_add(path.len() + 1);+ core.mapped_files.push(MappedFile { start: s, end: en, file_offset: po.saturating_mul(page), path });+ }+ } else {+ core.warnings.push("NT_FILE mapping table runs past the note; skipped its mappings".into());}}6 => {diff --git a/crates/formats/src/go.rs b/crates/formats/src/go.rsindex a4c04575..8ed4aaa3 100644--- a/crates/formats/src/go.rs+++ b/crates/formats/src/go.rs@@ -11,7 +11,8 @@ use crate::bytes::Reader;use crate::{FormatError, hex_addr};use object::{Object, ObjectSection, ObjectSegment};use serde::Serialize;-use std::collections::BTreeMap;+use std::cmp::Reverse;+use std::collections::{BTreeMap, BinaryHeap};/// Largest input we parse (256 MiB).pub const MAX_INPUT: usize = 256 << 20;@@ -659,43 +660,78 @@ fn pcln_header(r: &Reader<'_>, off: usize) -> Option<(&'static str, bool, u8, u8fn find_pclntab(file: &object::File<'_>, data: &[u8], container: &str, text_va: Option<u64>, warnings: &mut Vec<String>) -> Option<GoPclntab> {let r = Reader::new(data);let want = if container == "macho" { "__gopclntab" } else { ".gopclntab" };+ let mut named_section = None;+ let mut partial = None;if let Some(s) = file.sections().find(|s| s.name().ok() == Some(want))&& let Some((fo, fs)) = s.file_range()&& let Ok(off) = usize::try_from(fo){- if let Some(t) = read_pclntab(&r, off, usize::try_from(fs).unwrap_or(0), "section", Some(want.to_string()), text_va) {- return Some(t);+ let size = usize::try_from(fs).unwrap_or(usize::MAX);+ named_section = Some((off, off.saturating_add(size).min(data.len())));+ match read_pclntab(&r, off, size, "section", Some(want.to_string()), text_va) {+ Some(t) if t.declared_functions == 0 || !t.functions.is_empty() => return Some(t),+ Some(t) => partial = Some(t),+ None => warnings.push(format!("{want} is present but could not be read within its declared section")),}- warnings.push(format!("{want} is present but its header is not one we know"));}+ // Index file-backed extents once; candidates advance monotonically through them.+ let mut ranges: Vec<_> = file+ .sections()+ .filter_map(|s| {+ let (off, size) = s.file_range()?;+ let start = usize::try_from(off).ok()?;+ let size = usize::try_from(size).unwrap_or(usize::MAX);+ let end = start.saturating_add(size).min(data.len());+ (start < end).then_some((start, end))+ })+ .collect();+ ranges.sort_unstable();+ let mut ranges = ranges.into_iter().peekable();+ let mut active_ends = BinaryHeap::new();// Scan for a header with plausible fields (PE files and stripped section tables).let mut i = 0usize;let mut tries = 0usize;while i.checked_add(8).is_some_and(|e| e <= data.len()) && tries < 4096 {- let hay = data.get(i..)?;- let pos = hay.windows(4).position(|w| matches!(w, [0xfb | 0xfa | 0xf0 | 0xf1, 0xff, 0xff, 0xff] | [0xff, 0xff, 0xff, 0xfb | 0xfa | 0xf0 | 0xf1]))?;- let at = i.checked_add(pos)?;+ let Some(hay) = data.get(i..) else { break };+ let pos = hay.windows(4).position(|w| matches!(w, [0xfb | 0xfa | 0xf0 | 0xf1, 0xff, 0xff, 0xff] | [0xff, 0xff, 0xff, 0xfb | 0xfa | 0xf0 | 0xf1]));+ let Some(pos) = pos else { break };+ let Some(at) = i.checked_add(pos) else { break };tries += 1;+ while ranges.peek().is_some_and(|&(start, _)| start <= at) {+ let Some((_, end)) = ranges.next() else { break };+ if end > at {+ active_ends.push(Reverse(end));+ }+ }+ while active_ends.peek().is_some_and(|&Reverse(end)| end <= at) {+ active_ends.pop();+ }+ // Overlapping sections all constrain a candidate; retain zero-size named bounds too.+ let end = active_ends.peek().map_or(data.len(), |&Reverse(end)| end);+ let end = named_section.filter(|&(start, end)| at == start || (at >= start && at < end)).map_or(end, |(_, named_end)| end.min(named_end));+ let size = end.saturating_sub(at);if pcln_header(&r, at).is_some()- && let Some(t) = read_pclntab(&r, at, data.len() - at, "scan", None, text_va)+ && let Some(t) = read_pclntab(&r, at, size, "scan", None, text_va)&& !t.functions.is_empty(){return Some(t);}- i = at.checked_add(1)?;+ let Some(next) = at.checked_add(1) else { break };+ i = next;}- None+ partial}fn read_pclntab(r: &Reader<'_>, base: usize, size: usize, located_by: &'static str, section: Option<String>, text_va: Option<u64>) -> Option<GoPclntab> {- let (layout, big, quantum, ps) = pcln_header(r, base)?;+ let end = base.checked_add(size)?.min(r.len());+ let r = Reader::new(r.slice(0, end)?);+ let (layout, big, quantum, ps) = pcln_header(&r, base)?;let psz = usize::from(ps);- let word = |off: usize| -> Option<u64> { uint(r, base.checked_add(off)?, ps, big) };+ let word = |off: usize| -> Option<u64> { uint(&r, base.checked_add(off)?, ps, big) };let u32at = |off: usize| -> Option<u32> {let o = base.checked_add(off)?;if big { r.u32_be(o) } else { r.u32_le(o) }};- let end = base.saturating_add(size).min(r.len());let in_table = |abs: usize| abs < end;let mut warnings = Vec::new();let nfunc = word(8)?;@@ -709,7 +745,9 @@ fn read_pclntab(r: &Reader<'_>, base: usize, size: usize, located_by: &'static sif !in_table(abs) {return None;}- let s = r.cstr(abs, MAX_NAME)?;+ let bytes = r.slice(abs, (end - abs).min(MAX_NAME + 1))?;+ let length = bytes.iter().position(|&byte| byte == 0)?;+ let s = r.cstr(abs, length)?;(!s.is_empty()).then_some(s)};match layout {@@ -792,6 +830,197 @@ mod tests {use super::*;use craft_anything_testkit::formats as fx;+ #[test]+ fn pclntab_entries_cannot_borrow_bytes_after_the_section() {+ for data in [fx::pclntab_120(0x1000, &[("main.main", 0)]), fx::pclntab_116(0x1000, &[("main.main", 0)])] {+ let r = Reader::new(&data);+ let field = if r.u32_le(0) == Some(0xffff_fff1) { 64 } else { 56 };+ let functab = r.u64_le(field).unwrap() as usize;+ assert!(read_pclntab(&r, 0, functab + 4, "section", None, None).is_none());+ let complete = read_pclntab(&r, 0, data.len(), "section", None, None).unwrap();+ assert_eq!(complete.functions[0].name, "main.main");+ }+ }++ #[test]+ fn pclntab_names_must_terminate_inside_the_section() {+ let mut data = fx::pclntab_120(0x1000, &[("main.main", 0)]);+ let name = data.len();+ data[32..40].copy_from_slice(&(name as u64).to_le_bytes());+ data.extend_from_slice(b"main.outside\0");+ let r = Reader::new(&data);+ let partial = read_pclntab(&r, 0, name + 4, "section", None, None).unwrap();+ assert!(partial.functions.is_empty());+ assert!(!partial.warnings.is_empty());+ let complete = read_pclntab(&r, 0, data.len(), "section", None, None).unwrap();+ assert_eq!(complete.functions[0].name, "main.outside");+ }++ fn pclntab_section(data: &[u8]) -> (usize, usize, usize) {+ let r = Reader::new(data);+ let header = r.u64_le(40).unwrap() as usize + 2 * 64;+ (header, r.u64_le(header + 24).unwrap() as usize, r.u64_le(header + 32).unwrap() as usize)+ }++ #[test]+ fn pclntab_scan_does_not_widen_a_rejected_named_section() {+ let original = fx::go_elf();+ let (header, start, _) = pclntab_section(&original);+ let functab = Reader::new(&original).u64_le(start + 64).unwrap() as usize;+ for size in [functab + 4, 0] {+ let mut data = original.clone();+ data[header + 32..header + 40].copy_from_slice(&(size as u64).to_le_bytes());+ let report = inspect(&data, None).unwrap();+ assert!(report.pclntab.is_none(), "declared size={size}");+ assert!(functions(&data).is_empty(), "declared size={size}");+ }+ }++ #[test]+ fn pclntab_scan_keeps_the_named_section_end_for_interior_headers() {+ let mut data = fx::go_elf();+ let (header, start, size) = pclntab_section(&data);+ let table = data[start..start + size].to_vec();+ let functab = Reader::new(&table).u64_le(64).unwrap() as usize;+ data[start..start + 8].fill(0);+ data[start + 8..start + 8 + size].copy_from_slice(&table);+ data[header + 32..header + 40].copy_from_slice(&((size + 8) as u64).to_le_bytes());+ let complete = inspect(&data, None).unwrap().pclntab.unwrap();+ assert_eq!(complete.located_by, "scan");+ assert_eq!(complete.functions.len(), fx::GO_FUNCS.len());++ data[header + 32..header + 40].copy_from_slice(&((8 + functab + 4) as u64).to_le_bytes());+ assert!(inspect(&data, None).unwrap().pclntab.is_none());+ assert!(functions(&data).is_empty());+ }++ fn named_pclntab_with_unreadable_names(interior: bool) -> (Vec<u8>, usize, GoPclntab) {+ let mut data = fx::go_elf();+ let (header, start, size) = pclntab_section(&data);+ let recovered = start + size;+ let mut end = recovered;+ if interior {+ let table = data[start..recovered].to_vec();+ data[recovered..recovered + size].copy_from_slice(&table);+ end += size;+ }+ // The name base is inside the section, but no complete name follows it.+ data[end] = b'x';+ data[start + 32..start + 40].copy_from_slice(&((end - start) as u64).to_le_bytes());+ data[header + 32..header + 40].copy_from_slice(&((end + 1 - start) as u64).to_le_bytes());+ let partial = read_pclntab(&Reader::new(&data), start, end + 1 - start, "section", Some(".gopclntab".into()), None).unwrap();+ assert_eq!(partial.declared_functions, fx::GO_FUNCS.len() as u64);+ assert!(partial.functions.is_empty());+ assert!(!partial.warnings.is_empty());+ (data, recovered, partial)+ }++ #[test]+ fn pclntab_scan_recovers_after_an_unreadable_named_table() {+ let (data, interior, _) = named_pclntab_with_unreadable_names(true);+ let recovered = inspect(&data, None).unwrap().pclntab.unwrap();+ assert_eq!(recovered.located_by, "scan");+ assert_eq!(recovered.offset, interior as u64);+ let expected: Vec<_> = fx::GO_FUNCS.iter().map(|(name, off)| GoFunction { name: (*name).to_string(), entry: fx::GO_TEXT_VA + *off }).collect();+ assert_eq!(recovered.functions, expected);+ assert!(recovered.warnings.is_empty());+ assert_eq!(functions(&data), recovered.functions);+ }++ #[test]+ fn pclntab_scan_preserves_an_unreadable_named_table_without_replacement() {+ let (data, _, partial) = named_pclntab_with_unreadable_names(false);+ assert_eq!(inspect(&data, None).unwrap().pclntab, Some(partial));+ assert!(functions(&data).is_empty());+ }++ #[test]+ fn pclntab_scan_respects_unnamed_section_entry_bounds() {+ let mut data = fx::go_elf();+ let (header, start, _) = pclntab_section(&data);+ data[header..header + 4].fill(0);+ // A rejected header in .text must stop constraining candidates after that section.+ let prefix = data[start..start + 8].to_vec();+ data[0x1000..0x1008].copy_from_slice(&prefix);+ let complete = inspect(&data, None).unwrap().pclntab.unwrap();+ assert_eq!(complete.located_by, "scan");+ let expected: Vec<_> = fx::GO_FUNCS.iter().map(|(name, off)| GoFunction { name: (*name).to_string(), entry: fx::GO_TEXT_VA + *off }).collect();+ assert_eq!(complete.functions, expected);++ let functab = Reader::new(&data).u64_le(start + 64).unwrap() as usize;+ data[header + 32..header + 40].copy_from_slice(&((functab + 4) as u64).to_le_bytes());+ assert!(inspect(&data, None).unwrap().pclntab.is_none());+ assert!(functions(&data).is_empty());+ }++ #[test]+ fn pclntab_scan_requires_names_to_end_inside_unnamed_sections() {+ let mut data = fx::go_elf();+ let (header, start, size) = pclntab_section(&data);+ let r = Reader::new(&data);+ let names = r.u64_le(start + 32).unwrap() as usize;+ let functab = r.u64_le(start + 64).unwrap() as usize;+ let names = data[start + names..start + functab].to_vec();+ data[start + size..start + size + names.len()].copy_from_slice(&names);+ data[start + 32..start + 40].copy_from_slice(&(size as u64).to_le_bytes());+ data[header..header + 4].fill(0);+ data[header + 32..header + 40].copy_from_slice(&((size + names.len()) as u64).to_le_bytes());+ // Keep the enclosing PT_LOAD consistent with the extended section.+ let mapped_size = (start + size + names.len() - 0x1000) as u64;+ data[0x60..0x68].copy_from_slice(&mapped_size.to_le_bytes());+ data[0x68..0x70].copy_from_slice(&mapped_size.to_le_bytes());+ let complete = inspect(&data, None).unwrap().pclntab.unwrap();+ assert_eq!(complete.located_by, "scan");+ let expected: Vec<_> = fx::GO_FUNCS.iter().map(|(name, off)| GoFunction { name: (*name).to_string(), entry: fx::GO_TEXT_VA + *off }).collect();+ assert_eq!(complete.functions, expected);++ let first_name_len = fx::GO_FUNCS[0].0.len();+ assert_eq!(data[start + size + first_name_len], 0);+ data[header + 32..header + 40].copy_from_slice(&((size + first_name_len) as u64).to_le_bytes());+ assert!(inspect(&data, None).unwrap().pclntab.is_none());+ assert!(functions(&data).is_empty());+ }++ #[test]+ fn pclntab_scan_uses_the_shortest_overlapping_section_end() {+ let mut original = fx::go_elf();+ let (header, start, size) = pclntab_section(&original);+ let text_header = header - 64;+ let text_start = Reader::new(&original).u64_le(text_header + 24).unwrap() as usize;+ original[header..header + 4].fill(0);+ original[text_header + 32..text_header + 40].copy_from_slice(&((start + size - text_start) as u64).to_le_bytes());+ let complete = inspect(&original, None).unwrap().pclntab.unwrap();+ assert_eq!(complete.located_by, "scan");+ assert_eq!(complete.functions.len(), fx::GO_FUNCS.len());++ let functab = Reader::new(&original).u64_le(start + 64).unwrap() as usize;+ for (section, section_start) in [(header, start), (text_header, text_start)] {+ let mut data = original.clone();+ let size = start + functab + 4 - section_start;+ data[section + 32..section + 40].copy_from_slice(&(size as u64).to_le_bytes());+ assert!(inspect(&data, None).unwrap().pclntab.is_none());+ assert!(functions(&data).is_empty());+ }+ }++ #[test]+ fn pclntab_scan_keeps_whole_file_fallback_outside_known_sections() {+ for stripped in [false, true] {+ let mut data = fx::go_elf();+ let (header, _, _) = pclntab_section(&data);+ data[header..header + 4].fill(0);+ data[header + 32..header + 40].fill(0);+ if stripped {+ data[40..48].fill(0); // e_shoff+ data[60..64].fill(0); // e_shnum and e_shstrndx+ }+ let complete = inspect(&data, None).unwrap().pclntab.unwrap();+ assert_eq!(complete.located_by, "scan");+ let expected: Vec<_> = fx::GO_FUNCS.iter().map(|(name, off)| GoFunction { name: (*name).to_string(), entry: fx::GO_TEXT_VA + *off }).collect();+ assert_eq!(complete.functions, expected);+ }+ }+#[test]fn elf_inline_buildinfo_and_pclntab_120() {let r = inspect(&fx::go_elf(), None).unwrap();diff --git a/crates/formats/src/macho.rs b/crates/formats/src/macho.rsindex f9c9b31f..e4e323a9 100644--- a/crates/formats/src/macho.rs+++ b/crates/formats/src/macho.rs@@ -144,6 +144,23 @@ fn platform_name(p: u32) -> &'static str {}}+/// Fixed bytes required before decoding a known load command's fields.+pub(crate) fn load_command_min_size(cmd: u32) -> usize {+ match cmd {+ 0x1 => 56,+ 0x2 | 0x1b | 0x2c | 0x32 | 0x8000_0028 => 24,+ 0x5 => 16,+ 0xb => 80,+ 0xc | 0xd | 0x20 | 0x8000_0018 | 0x8000_001f | 0x8000_0023 => 24,+ 0xe | 0xf | 0x12 | 0x13 | 0x14 | 0x15 | 0x27 | 0x8000_001c => 12,+ 0x19 => 72,+ 0x1d | 0x1e | 0x24 | 0x25 | 0x26 | 0x29 | 0x2a | 0x2b | 0x2e | 0x2f | 0x30 | 0x8000_0033 | 0x8000_0034 => 16,+ 0x21 => 20,+ 0x22 | 0x8000_0022 => 48,+ _ => 8,+ }+}+fn nibble_version(v: u32) -> String {format!("{}.{}.{}", v >> 16, (v >> 8) & 0xff, v & 0xff)}@@ -161,8 +178,13 @@ pub fn enrich(data: &[u8], b: &mut Binary) {return;}let ncmds = r.u32_le(16).unwrap_or(0) as usize;+ let sizeofcmds = r.u32_le(20).unwrap_or(0) as usize;let header_flags = r.u32_le(24).unwrap_or(0);- let mut pos = if is64 { 32 } else { 28 };+ let mut pos: usize = if is64 { 32 } else { 28 };+ let limit = pos.saturating_add(sizeofcmds).min(data.len());+ if sizeofcmds > data.len().saturating_sub(pos) {+ b.warnings.push("sizeofcmds runs past the end of the file".into());+ }let mut sections = Vec::new();let mut segments = Vec::new();let mut symtab = None;@@ -173,6 +195,10 @@ pub fn enrich(data: &[u8], b: &mut Binary) {let mut cmds_json = Vec::new();let mut libs = Vec::new();for _ in 0..ncmds.min(MAX_CMDS) {+ if pos.checked_add(8).is_none_or(|end| end > limit) {+ b.warnings.push("load command header runs past sizeofcmds; stopped".into());+ break;+ }let (Some(cmd), Some(size)) = (r.u32_le(pos), r.u32_le(pos + 4)) else {b.warnings.push("load commands cut short".into());break;@@ -182,12 +208,23 @@ pub fn enrich(data: &[u8], b: &mut Binary) {b.warnings.push("a load command has a size below 8; stopped".into());break;}+ let Some(end) = pos.checked_add(size).filter(|&end| end <= limit) else {+ b.warnings.push("a load command runs past sizeofcmds; stopped".into());+ break;+ };if cmds_json.len() < 512 {cmds_json.push(json!({"cmd": load_command_name(cmd), "size": size}));}+ let minimum = load_command_min_size(cmd);+ if size < minimum {+ b.warnings.push(format!("{} needs at least {minimum} bytes; skipped its fields", load_command_name(cmd)));+ pos = end;+ continue;+ }+ let r = Reader::new(data.get(..end).unwrap_or(&[]));let str_at = |field: usize| -> Option<String> {let o = r.u32_le(pos + field)? as usize;- if o >= size {+ if o < minimum || o >= size {return None;}r.cstr(pos + o, size - o)@@ -200,11 +237,12 @@ pub fn enrich(data: &[u8], b: &mut Binary) {let fileoff = if cmd == 0x19 { r.u64_le(pos + fo) } else { r.u32_le(pos + fo).map(u64::from) }.unwrap_or(0);segments.push(MSegment { name, vmaddr, fileoff });let nsects = r.u32_le(pos + ns).unwrap_or(0) as usize;- for i in 0..nsects.min(256) {+ let complete = (size - sh) / shsize;+ if nsects > complete {+ b.warnings.push("segment section headers run past the load command; reading complete headers".into());+ }+ for i in 0..nsects.min(256).min(complete) {let o = pos + sh + i * shsize;- if o + shsize > pos + size {- break;- }let (addr, sz, flags_o) = if cmd == 0x19 {(r.u64_le(o + 32), r.u64_le(o + 40), 64)} else {@@ -283,10 +321,7 @@ pub fn enrich(data: &[u8], b: &mut Binary) {}_ => {}}- pos = match pos.checked_add(size) {- Some(p) => p,- None => break,- };+ pos = end;}b.libraries = libs;if b.mitigations.code_signature.is_none() {@@ -309,15 +344,24 @@ pub fn enrich(data: &[u8], b: &mut Binary) {}// Function starts: ULEB deltas from the start of __TEXT.if let (Some((off, size)), Some(t)) = (fstarts, &text) {- let mut o = off as usize;+ let start = off as usize;let end = (off as usize).saturating_add(size as usize).min(data.len());+ let starts = Reader::new(data.get(start..end).unwrap_or(&[]));+ let mut o = 0;let mut addr = t.vmaddr;- while o < end && b.function_starts.len() < 2_000_000 {- let Some((delta, n)) = r.uleb128(o) else { break };+ while o < starts.len() && b.function_starts.len() < 2_000_000 {+ let Some((delta, n)) = starts.uleb128(o) else {+ b.warnings.push("function-start delta is cut short or invalid".into());+ break;+ };if delta == 0 {break;}- addr = addr.wrapping_add(delta);+ let Some(next) = addr.checked_add(delta) else {+ b.warnings.push("function-start address overflows".into());+ break;+ };+ addr = next;b.function_starts.push(addr);o += n;}diff --git a/crates/formats/src/macho_deps.rs b/crates/formats/src/macho_deps.rsindex 931adc13..b23b112c 100644--- a/crates/formats/src/macho_deps.rs+++ b/crates/formats/src/macho_deps.rs@@ -5,7 +5,7 @@use crate::FormatError;use crate::bytes::Reader;-use crate::macho::{cpu_name, fat_slices, load_command_name};+use crate::macho::{cpu_name, fat_slices, load_command_min_size, load_command_name};use serde::Serialize;use serde_json::{Value as Json, json};@@ -331,18 +331,35 @@ pub fn parse_thin(data: &[u8]) -> Result<MachoDeps, FormatError> {out.warnings.push(format!("{ncmds} load commands; reading the first {MAX_CMDS}"));}for index in 0..ncmds.min(MAX_CMDS) {+ if pos.checked_add(8).is_none_or(|end| end > limit) {+ out.warnings.push(format!("load command {index} header runs past sizeofcmds; stopped"));+ break;+ }let (Some(cmd), Some(size)) = (e.u32(pos), e.u32(pos + 4)) else {out.warnings.push(format!("load command {index} is cut short"));break;};let sz = size as usize;- if sz < 8 || pos.saturating_add(sz) > data.len() {+ if sz < 8 {out.warnings.push(format!("load command {index} has a bad size {size}; stopped"));break;}+ let Some(end) = pos.checked_add(sz).filter(|&end| end <= limit) else {+ out.warnings.push(format!("load command {index} runs past sizeofcmds; stopped"));+ break;+ };+ let name = extra_name(cmd);+ let minimum = load_command_min_size(cmd);+ if sz < minimum {+ out.warnings.push(format!("load command {index} ({name}) needs at least {minimum} bytes; skipped its fields"));+ out.commands.push(LoadCommand { index, cmd: name, offset: pos, size, detail: json!({"error": "fixed command fields are cut short"}) });+ pos = end;+ continue;+ }+ let e = E { r: Reader::new(data.get(..end).unwrap_or(&[])), be };let str_at = |field: usize| -> Option<String> {let o = e.u32(pos + field)? as usize;- if o < 8 || o >= sz {+ if o < minimum || o >= sz {return None;}e.r.cstr(pos + o, sz - o)@@ -355,7 +372,6 @@ pub fn parse_thin(data: &[u8]) -> Result<MachoDeps, FormatError> {compatibility_version: version(e.u32(pos + 20).unwrap_or(0)),})};- let name = extra_name(cmd);let detail = match cmd {0xc | 0x20 | 0x8000_0018 | 0x8000_001f | 0x8000_0023 => {let kind = match cmd {@@ -415,7 +431,11 @@ pub fn parse_thin(data: &[u8]) -> Result<MachoDeps, FormatError> {}0x32 => {let ntools = e.u32(pos + 20).unwrap_or(0) as usize;- let tools: Vec<String> = (0..ntools.min(32))+ let complete = (sz - 24) / 8;+ if ntools > complete {+ out.warnings.push(format!("load command {index} build tools are cut short"));+ }+ let tools: Vec<String> = (0..ntools.min(32).min(complete)).filter_map(|i| {let t = e.u32(pos + 24 + i * 8)?;let v = e.u32(pos + 28 + i * 8)?;@@ -497,9 +517,13 @@ pub fn parse_thin(data: &[u8]) -> Result<MachoDeps, FormatError> {let initprot = e.u32(pos + prot_o).unwrap_or(0);let nsects = e.u32(pos + ns_o).unwrap_or(0) as usize;let mut names = Vec::new();- for i in 0..nsects.min(256) {+ let complete = (sz - sh) / shsize;+ if nsects > complete {+ out.warnings.push(format!("load command {index} section headers are cut short"));+ }+ for i in 0..nsects.min(256).min(complete) {let o = pos + sh + i * shsize;- if o + shsize > pos + sz || out.sections.len() >= MAX_SECTIONS {+ if out.sections.len() >= MAX_SECTIONS {break;}let (addr, size, offset) = if wide {@@ -529,13 +553,7 @@ pub fn parse_thin(data: &[u8]) -> Result<MachoDeps, FormatError> {_ => Json::Null,};out.commands.push(LoadCommand { index, cmd: name, offset: pos, size, detail });- pos = match pos.checked_add(sz) {- Some(p) => p,- None => break,- };- }- if pos > limit {- out.warnings.push("load commands run past sizeofcmds".into());+ pos = end;}Ok(out)}diff --git a/crates/formats/src/pcap.rs b/crates/formats/src/pcap.rsindex 80990839..d82dc8fe 100644--- a/crates/formats/src/pcap.rs+++ b/crates/formats/src/pcap.rs@@ -12,7 +12,7 @@ use serde::Serialize;use std::collections::{BTreeMap, BTreeSet, HashMap};use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};-/// Most frames read from one capture.+/// Most frames and rejected simple packet blocks read from one capture.pub const MAX_PACKETS: u64 = 5_000_000;/// Most flows tracked; later flows are counted but get no id.pub const MAX_FLOWS: usize = 100_000;@@ -89,6 +89,8 @@ pub struct Capture<'a> {/// The walk stopped at `MAX_PACKETS`.pub truncated: bool,count: u64,+ rejected_simple_blocks: u64,+ rejected_simple_reported: bool,}fn rd_u16(r: &Reader<'_>, le: bool, off: usize) -> Option<u16> {@@ -126,6 +128,8 @@ impl<'a> Capture<'a> {warnings: Vec::new(),truncated: false,count: 0,+ rejected_simple_blocks: 0,+ rejected_simple_reported: false,};let classic = |le: bool, nanos: bool| -> Result<(Kind, String, Interface), FormatError> {let major = rd_u16(&r, le, 4).ok_or_else(|| FormatError::Truncated("pcap header".into()))?;@@ -168,6 +172,26 @@ impl<'a> Capture<'a> {None}+ fn packet_limit_reached(&mut self) -> bool {+ if self.count.saturating_add(self.rejected_simple_blocks) < MAX_PACKETS {+ return false;+ }+ if !self.truncated && self.pos < self.data.len() {+ self.truncated = true;+ self.warnings.push(format!("stopped after {MAX_PACKETS} packet records"));+ }+ true+ }++ fn report_rejected_simple_blocks(&mut self) {+ if self.rejected_simple_blocks > 0 && !self.rejected_simple_reported {+ let n = self.rejected_simple_blocks;+ let suffix = if n == 1 { "" } else { "s" };+ self.warnings.push(format!("skipped {n} simple packet block{suffix} with inconsistent captured lengths"));+ self.rejected_simple_reported = true;+ }+ }+fn ts(&self, iface: usize, units: u64) -> Option<u64> {let (base, exp) = self.interfaces.get(iface).map(|i| i.tsresol).unwrap_or((10, 6));let offset_s = self.interfaces.get(iface).map(|i| i.tsoffset).unwrap_or(0);@@ -211,6 +235,9 @@ impl<'a> Capture<'a> {fn next_ng(&mut self, mut le: bool) -> Option<Frame<'a>> {loop {+ if self.packet_limit_reached() {+ return None;+ }let r = Reader::new(self.data);let p = self.pos;if p >= self.data.len() {@@ -312,7 +339,11 @@ impl<'a> Capture<'a> {let iface = self.section_base;let snap = self.interfaces.get(iface).map(|i| i.snaplen).filter(|&s| s > 0).unwrap_or(u32::MAX);let room = body_end.saturating_sub(body + 4);- let cap = (orig.min(snap) as usize).min(room);+ let cap = orig.min(snap) as usize;+ if cap.checked_add(3).map(|n| n & !3) != Some(room) {+ self.rejected_simple_blocks += 1;+ continue;+ }let Some(data) = r.slice(body + 4, cap) else { continue };if iface >= self.interfaces.len() {continue;@@ -338,17 +369,18 @@ impl<'a> Iterator for Capture<'a> {type Item = Frame<'a>;fn next(&mut self) -> Option<Frame<'a>> {- if self.count >= MAX_PACKETS {- if !self.truncated && self.pos < self.data.len() {- self.truncated = true;- self.warnings.push(format!("stopped after {MAX_PACKETS} frames"));+ let frame = if self.packet_limit_reached() {+ None+ } else {+ match self.kind {+ Kind::Classic { le, nanos } => self.next_classic(le, nanos),+ Kind::Ng { le } => self.next_ng(le),}- return None;- }- match self.kind {- Kind::Classic { le, nanos } => self.next_classic(le, nanos),- Kind::Ng { le } => self.next_ng(le),+ };+ if frame.is_none() {+ self.report_rejected_simple_blocks();}+ frame}}@@ -535,7 +567,12 @@ pub fn decode(link_type: u32, data: &[u8]) -> Decoded {}12 | 14 | 101 | 228 | 229 => {d.protocols.push("raw");- (r.u8(0).map(|b| if b >> 4 == 6 { 0x86dd } else { 0x0800 }), 0)+ let ethertype = match link_type {+ 228 => Some(0x0800),+ 229 => Some(0x86dd),+ _ => r.u8(0).map(|b| if b >> 4 == 6 { 0x86dd } else { 0x0800 }),+ };+ (ethertype, 0)}_ => {d.note = Some(format!("link type {link_type} ({}) is not decoded", link_name(link_type)));@@ -560,11 +597,15 @@ fn ipv4(p: &[u8], d: &mut Decoded) {return;};let ihl = usize::from(vihl & 0x0f) * 4;- let (Some(src), Some(dst)) = (r.slice(12, 4), r.slice(16, 4)) else { return };- if vihl >> 4 != 4 || ihl < 20 {+ if vihl >> 4 != 4 || ihl < 20 || usize::from(total) < ihl {d.note = Some("not a valid IPv4 header".into());return;}+ if r.slice(0, ihl).is_none() {+ d.note = Some("IPv4 header cut short".into());+ return;+ }+ let (Some(src), Some(dst)) = (r.slice(12, 4), r.slice(16, 4)) else { return };d.protocols.push("ipv4");let ip4 = |b: &[u8]| {IpAddr::V4(Ipv4Addr::new(@@ -576,7 +617,7 @@ fn ipv4(p: &[u8], d: &mut Decoded) {};let fragment = frag & 0x1fff != 0;d.ip = Some(IpInfo { version: 4, src: ip4(src), dst: ip4(dst), protocol: proto, ttl, fragment });- let end = usize::from(total).clamp(ihl, p.len().max(ihl));+ let end = usize::from(total).min(p.len());let body = p.get(ihl..end).unwrap_or(&[]);if fragment {d.note = Some("IPv4 fragment (transport header is in the first fragment)".into());@@ -591,6 +632,10 @@ fn ipv6(p: &[u8], d: &mut Decoded) {d.note = Some("IPv6 header cut short".into());return;};+ if r.u8(0).is_none_or(|version| version >> 4 != 6) {+ d.note = Some("not a valid IPv6 header".into());+ return;+ }d.protocols.push("ipv6");let ip6 = |b: &[u8]| IpAddr::V6(Ipv6Addr::from(<[u8; 16]>::try_from(b).unwrap_or([0; 16])));let end = (40 + usize::from(plen)).min(p.len());@@ -616,6 +661,9 @@ fn ipv6(p: &[u8], d: &mut Decoded) {next = n;fragment = fo & 0xfff8 != 0;off += 8;+ if fragment {+ break;+ }}51 => {let (Some(n), Some(l)) = (payload_reader.u8(off), payload_reader.u8(off + 1)) else { break };@@ -756,14 +804,29 @@ pub fn qtype_name(t: u16) -> String {}}-/// A (possibly compressed) DNS name at `off`; returns the name and the offset after it.-fn dns_name(msg: &[u8], mut off: usize) -> Option<(String, usize)> {+fn dns_sd_service_label(label: &[u8]) -> bool {+ let Some(name) = label.strip_prefix(b"_") else { return false };+ // RFC 6763 §7 / RFC 6335 §5.1, excluding the leading underscore.+ (1..=15).contains(&name.len())+ && name.first().is_some_and(u8::is_ascii_alphanumeric)+ && name.last().is_some_and(u8::is_ascii_alphanumeric)+ && name.iter().all(|c| c.is_ascii_alphanumeric() || *c == b'-')+ && name.iter().any(u8::is_ascii_alphabetic)+ && !name.windows(2).any(|pair| pair == b"--")+}++/// A DNS name, the offset after it, and whether its wire labels name a DNS-SD instance.+fn dns_name(msg: &[u8], mut off: usize) -> Option<(String, usize, bool)> {let mut out = String::new();+ // Count the expanded wire name, including label lengths and the terminating root.+ let mut wire_len = 1usize;let mut after: Option<usize> = None;+ let mut labels = 0;+ let mut service_instance = false;for _ in 0..128 {let len = *msg.get(off)?;match len {- 0 => return Some((if out.is_empty() { ".".into() } else { out }, after.unwrap_or(off + 1))),+ 0 => return Some((if out.is_empty() { ".".into() } else { out }, after.unwrap_or(off + 1), labels >= 4 && service_instance)),l if l & 0xc0 == 0xc0 => {let ptr = usize::from(u16::from_be_bytes([l & 0x3f, *msg.get(off + 1)?]));after.get_or_insert(off + 2);@@ -774,13 +837,22 @@ fn dns_name(msg: &[u8], mut off: usize) -> Option<(String, usize)> {}l if l < 64 => {let label = msg.get(off + 1..off + 1 + usize::from(l))?;+ wire_len += 1 + label.len();+ if wire_len > 255 {+ return None;+ }+ // Match Instance / _service / _tcp|_udp / Domain before rendering:+ // a literal dot inside one wire label is not a label boundary.+ match labels {+ 1 => service_instance = dns_sd_service_label(label),+ 2 => service_instance &= label.eq_ignore_ascii_case(b"_tcp") || label.eq_ignore_ascii_case(b"_udp"),+ _ => {}+ }+ labels += 1;if !out.is_empty() {out.push('.');}out.extend(label.iter().map(|&c| if c.is_ascii_graphic() { char::from(c) } else { '?' }));- if out.len() > 255 {- return None;- }off += 1 + usize::from(l);}_ => return None,@@ -789,22 +861,26 @@ fn dns_name(msg: &[u8], mut off: usize) -> Option<(String, usize)> {None}+/// Decode a bounded set of DNS questions and answer/prerequisite records from one message.+/// Preserve complete entries before malformed data and mark the message incomplete.fn dns(msg: &[u8], d: &mut Decoded, label: &'static str) {let r = Reader::new(msg);let (Some(id), Some(flags), Some(qd), Some(an)) = (r.u16_be(0), r.u16_be(2), r.u16_be(4), r.u16_be(6)) else { return };+ let opcode = (flags >> 11) & 0xf;// Sanity: opcode 0–6 and no absurd counts, so random payload on port 53 isn't misread.- if (flags >> 11) & 0xf > 6 || qd > 64 || qd == 0 && an == 0 {+ if opcode > 6 || qd > 64 || qd == 0 && an == 0 {return;}d.protocols.push(label);let mut out = Dns { id, response: flags & 0x8000 != 0, rcode: (flags & 0xf) as u8, questions: Vec::new(), answers: Vec::new(), incomplete: false };let mut off = 12usize;for _ in 0..qd {- let Some((name, next)) = dns_name(msg, off) else {+ let Some((name, next, _)) = dns_name(msg, off) else {out.incomplete = true;break;};- let Some(qt) = r.u16_be(next) else {+ // The class is not displayed, but both two-byte fields must be present.+ let (Some(qt), Some(_class)) = (r.u16_be(next), r.u16_be(next + 2)) else {out.incomplete = true;break;};@@ -813,11 +889,11 @@ fn dns(msg: &[u8], d: &mut Decoded, label: &'static str) {}if !out.incomplete {for _ in 0..an.min(64) {- let Some((name, next)) = dns_name(msg, off) else {+ let Some((name, next, service_instance)) = dns_name(msg, off) else {out.incomplete = true;break;};- let (Some(rt), Some(ttl), Some(rdlen)) = (r.u16_be(next), r.u32_be(next + 4), r.u16_be(next + 8)) else {+ let (Some(rt), Some(class), Some(ttl), Some(rdlen)) = (r.u16_be(next), r.u16_be(next + 2), r.u32_be(next + 4), r.u16_be(next + 8)) else {out.incomplete = true;break;};@@ -835,31 +911,54 @@ fn dns(msg: &[u8], d: &mut Decoded, label: &'static str) {).to_string(),(28, 16) => Ipv6Addr::from(<[u8; 16]>::try_from(rd).unwrap_or([0; 16])).to_string(),- (2 | 5 | 12, _) => dns_name(msg, rd_off).map(|(n, _)| n).unwrap_or_default(),- (15, _) => dns_name(msg, rd_off + 2).map(|(n, _)| n).unwrap_or_default(),+ (2 | 5 | 12 | 15, _) => {+ // RFC 2136 prerequisites can name an RRset without carrying its value.+ if rd.is_empty() && opcode == 5 && matches!(class, 254 | 255) && ttl == 0 {+ String::new()+ } else {+ let end = rd_off + rd.len();+ let start = rd_off + if rt == 15 { 2 } else { 0 };+ // Keep earlier bytes available to compression pointers, but the encoded+ // name itself must fit the record and account for all of its RDATA.+ let Some((name, _, _)) = dns_name(msg.get(..end).unwrap_or(&[]), start).filter(|(_, after, _)| *after == end) else {+ out.incomplete = true;+ break;+ };+ name+ }+ }(16, _) => {- // RFC 1035 §3.3.14: one TXT RDATA holds any number of+ // RFC 1035 §3.3.14: one TXT RDATA holds one or more// length-prefixed character strings, and a zero-length// string does not end the record. Consumers join them all// (RFC 7208 §3.3), so keep every string instead of the// first one and skip the rest of the RDATA.let mut txt = String::new();let mut pos = 0;+ // UPDATE's answer section holds prerequisites. ANY/NONE+ // prerequisites use empty RDATA and zero TTL (RFC 2136 §2.4).+ let empty_prerequisite = opcode == 5 && matches!(class, 254 | 255) && ttl == 0;+ // DNS-SD receivers treat empty RDATA as an empty string+ // (RFC 6763 §6.1), for both multicast and unicast DNS.+ let empty_service_txt = opcode == 0 && service_instance;+ out.incomplete |= rd.is_empty() && !empty_prerequisite && !empty_service_txt;while let Some(&len) = rd.get(pos) {let len = usize::from(len);- let end = (pos + 1).saturating_add(len).min(rd.len());- match rd.get(pos + 1..end) {- Some(part) => {- txt.push_str(&String::from_utf8_lossy(part));- pos = end;- }- None => break,- }+ let end = pos + 1 + len;+ let Some(part) = rd.get(pos + 1..end) else {+ out.incomplete = true;+ break;+ };+ txt.push_str(&String::from_utf8_lossy(part));+ pos = end;}txt}(_, n) => format!("<{n} bytes>"),};+ if out.incomplete {+ break;+ }out.answers.push(DnsAnswer { name, rtype: qtype_name(rt), ttl, value });off = rd_off + usize::from(rdlen);}@@ -896,12 +995,21 @@ fn tcp_app(p: &[u8], d: &mut Decoded) {&& METHODS.contains(&m)&& v.starts_with("HTTP/1."){- let lower = String::from_utf8_lossy(head).to_ascii_lowercase();- let host = lower.find("\r\nhost:").and_then(|i| {- let start = i + 7;- let raw = String::from_utf8_lossy(head.get(start..)?).into_owned();- Some(raw.split("\r\n").next().unwrap_or("").trim().to_string())- });+ let mut remaining = head.get(line_end + 2..).unwrap_or(&[]);+ let mut host = None;+ while let Some(end) = remaining.windows(2).position(|w| w == b"\r\n") {+ let field = remaining.get(..end).unwrap_or(&[]);+ if field.is_empty() {+ break;+ }+ if let Some(colon) = field.iter().position(|&b| b == b':')+ && field.get(..colon).is_some_and(|name| name.eq_ignore_ascii_case(b"host"))+ {+ host = field.get(colon + 1..).map(|value| String::from_utf8_lossy(value).trim().to_string());+ break;+ }+ remaining = remaining.get(end + 2..).unwrap_or(&[]);+ }d.protocols.push("http");d.http = Some(Http { kind: "request", method: Some(m.to_string()), target: Some(strip_userinfo(t)), status: None, version: v.to_string(), host });return;@@ -1270,8 +1378,9 @@ pub fn summarize(data: &[u8], cancelled: &dyn Fn() -> bool) -> Result<Summary, Frow.packets_b_to_a += 1;row.bytes_b_to_a += u64::from(f.original_len);}- if f.ts_ns.is_some() {- row.last_ts_ns = f.ts_ns;+ if let Some(t) = f.ts_ns {+ row.first_ts_ns = Some(row.first_ts_ns.map_or(t, |first| first.min(t)));+ row.last_ts_ns = Some(row.last_ts_ns.map_or(t, |last| last.max(t)));}for app in d.protocols.iter().skip_while(|p| !matches!(**p, "tcp" | "udp")).skip(1) {row.applications.insert(app);@@ -1352,6 +1461,55 @@ mod tests {use super::*;use craft_anything_testkit::pcap::{dns_query, eth, ipv4_pkt, pcap, pcapng, sample_frames, udp};+ #[test]+ fn rejected_simple_packets_count_toward_the_scan_limit() {+ let mut data = pcapng(&[]);+ let rejected = craft_anything_testkit::pcap::block(3, &1u32.to_le_bytes());+ for _ in 0..3 {+ data.extend(&rejected);+ }+ let mut cap = Capture::new(&data).unwrap();+ // Reach the boundary without allocating millions of preceding valid frames.+ cap.count = MAX_PACKETS - 2;+ assert!(cap.next().is_none());+ assert!(cap.truncated);+ assert_eq!(cap.pos, data.len() - rejected.len());+ assert_eq!(cap.warnings.len(), 2);+ assert!(cap.warnings.iter().any(|w| w.contains("2 simple packet blocks")));+ assert!(cap.next().is_none());+ assert_eq!(cap.warnings.len(), 2);+ }++ #[test]+ fn rejected_simple_packets_at_eof_do_not_report_a_truncated_scan() {+ let mut data = pcapng(&[]);+ let rejected = craft_anything_testkit::pcap::block(3, &1u32.to_le_bytes());+ for _ in 0..2 {+ data.extend(&rejected);+ }+ let mut cap = Capture::new(&data).unwrap();+ cap.count = MAX_PACKETS - 2;+ assert!(cap.next().is_none());+ assert!(!cap.truncated);+ assert_eq!(cap.warnings.len(), 1);+ assert!(cap.warnings[0].contains("2 simple packet blocks"));+ }++ #[test]+ fn valid_and_rejected_simple_packets_share_the_scan_limit() {+ let mut data = pcapng(&[]);+ data.extend(craft_anything_testkit::pcap::block(3, &1u32.to_le_bytes()));+ let valid = craft_anything_testkit::pcap::block(3, &0u32.to_le_bytes());+ data.extend(&valid);+ data.extend(&valid);+ let mut cap = Capture::new(&data).unwrap();+ cap.count = MAX_PACKETS - 2;+ assert_eq!(cap.next().unwrap().number, MAX_PACKETS - 1);+ assert!(cap.next().is_none());+ assert!(cap.truncated);+ assert_eq!(cap.pos, data.len() - valid.len());+ }+#[test]fn tcp_cut_inside_header_keeps_ports() {// Ports sit in the first 4 bytes; a cut later in the header must not drop them (as UDP).diff --git a/crates/formats/src/pe.rs b/crates/formats/src/pe.rsindex 177c2562..94945656 100644--- a/crates/formats/src/pe.rs+++ b/crates/formats/src/pe.rs@@ -89,16 +89,20 @@ pub fn headers(data: &[u8]) -> Result<PeHeaders, FormatError> {let opt_size = usize::from(t(r.u16_le(coff + 16))?);let characteristics = t(r.u16_le(coff + 18))?;let opt = coff + 20;- let magic = r.u16_le(opt).ok_or_else(|| FormatError::Truncated("optional header".into()))?;+ let optional = Reader::new(r.slice(opt, opt_size).ok_or_else(|| FormatError::Truncated("optional header".into()))?);+ let magic = optional.u16_le(0).ok_or_else(|| FormatError::Truncated("optional header".into()))?;let pe32_plus = match magic {0x20b => true,0x10b => false,m => return Err(FormatError::Malformed(format!("optional header magic {m:#x}"))),};- let image_base = if pe32_plus { r.u64_le(opt + 24) } else { r.u32_le(opt + 28).map(u64::from) }.unwrap_or(0);- let (dd, count_off) = if pe32_plus { (opt + 112, opt + 108) } else { (opt + 96, opt + 92) };- let count = (r.u32_le(count_off).unwrap_or(0) as usize).min(16);- let data_dirs = (0..count).map(|i| (r.u32_le(dd + i * 8).unwrap_or(0), r.u32_le(dd + i * 8 + 4).unwrap_or(0))).collect();+ let (dd, count_off) = if pe32_plus { (112, 108) } else { (96, 92) };+ if opt_size < dd {+ return Err(FormatError::Truncated("fixed optional header fields".into()));+ }+ let image_base = if pe32_plus { optional.u64_le(24) } else { optional.u32_le(28).map(u64::from) }.unwrap_or(0);+ let count = (optional.u32_le(count_off).unwrap_or(0) as usize).min(16).min((opt_size - dd) / 8);+ let data_dirs = (0..count).map(|i| (optional.u32_le(dd + i * 8).unwrap_or(0), optional.u32_le(dd + i * 8 + 4).unwrap_or(0))).collect();let sh = opt + opt_size;let mut sections = Vec::new();for i in 0..nsections.min(96) {@@ -121,10 +125,10 @@ pub fn headers(data: &[u8]) -> Result<PeHeaders, FormatError> {characteristics,pe32_plus,image_base,- entry_rva: r.u32_le(opt + 16).unwrap_or(0),- subsystem: r.u16_le(opt + 68).unwrap_or(0),- dll_characteristics: r.u16_le(opt + 70).unwrap_or(0),- linker: (r.u8(opt + 2).unwrap_or(0), r.u8(opt + 3).unwrap_or(0)),+ entry_rva: optional.u32_le(16).unwrap_or(0),+ subsystem: optional.u16_le(68).unwrap_or(0),+ dll_characteristics: optional.u16_le(70).unwrap_or(0),+ linker: (optional.u8(2).unwrap_or(0), optional.u8(3).unwrap_or(0)),data_dirs,sections,})@@ -726,9 +730,42 @@ fn utf16_at(r: &Reader<'_>, off: usize, units: usize) -> Option<String> {pub fn parse_resources(data: &[u8], max_entries: usize) -> Result<Resources, FormatError> {let h = headers(data)?;let mut res = Resources::default();- let Some((rva, _size)) = h.dir(2) else { return Ok(res) };+ let Some((rva, size)) = h.dir(2) else { return Ok(res) };let base = h.rva_to_offset(rva).ok_or_else(|| FormatError::Malformed("resource directory is not in the file".into()))?;- let r = Reader::new(data);+ let available = data.get(base..).ok_or_else(|| FormatError::Truncated("resource directory".into()))?;+ // Keep resource metadata inside the initial RVA mapping.+ let next_section_distance = |count: usize| {+ h.sections+ .iter()+ .take(count)+ .filter(|s| s.virtual_size.max(s.raw_size) > 0)+ .filter_map(|s| s.rva.checked_sub(rva))+ .filter(|&distance| distance > 0)+ .min()+ .unwrap_or(u32::MAX)+ };+ let mapped_len = match h.sections.iter().enumerate().find(|(_, s)| rva.checked_sub(s.rva).is_some_and(|delta| delta < s.virtual_size.max(s.raw_size))) {+ Some((index, s)) => rva.checked_sub(s.rva).and_then(|delta| s.raw_size.checked_sub(delta)).map(|len| len.min(next_section_distance(index))),+ None => {+ let first = h.sections.iter().map(|s| s.raw_offset).filter(|&o| o > 0).min().unwrap_or(u32::MAX);+ first.checked_sub(rva).map(|len| len.min(next_section_distance(h.sections.len())))+ }+ }+ .map(u64::from)+ .and_then(|len| {+ let address_end = u64::from(u32::MAX) + 1;+ let remaining_rvas = address_end.checked_sub(u64::from(rva))?;+ let remaining_offsets = address_end.checked_sub(u64::try_from(base).ok()?)?;+ usize::try_from(len.min(remaining_rvas).min(remaining_offsets)).ok()+ })+ .ok_or_else(|| FormatError::Malformed("resource directory is not in the file".into()))?;+ if size as usize > available.len() {+ res.warnings.push("resource directory runs past the end of the file; reading the available bytes".into());+ }+ if size as usize > mapped_len {+ res.warnings.push("resource directory runs past its mapped extent; reading the available bytes".into());+ }+ let r = Reader::new(available.get(..(size as usize).min(mapped_len).min(available.len())).unwrap_or(&[]));let mut visited = BTreeSet::new();// (dir offset relative to base, depth, path)type Path = Vec<(Option<u32>, String)>;@@ -738,19 +775,31 @@ pub fn parse_resources(data: &[u8], max_entries: usize) -> Result<Resources, Forres.warnings.push("resource directory loops or nests too deep; skipped a branch".into());continue;}- let at = base.saturating_add(dir);+ let at = dir;let (Some(named), Some(ids)) = (r.u16_le(at + 12), r.u16_le(at + 14)) else {res.warnings.push("resource directory cut short".into());continue;};let n = usize::from(named) + usize::from(ids);- for i in (0..n).rev() {+ let complete = r.len().saturating_sub(at + 16) / 8;+ if n > complete {+ res.warnings.push("resource directory entries cut short".into());+ }+ for i in (0..n.min(complete)).rev() {let e = at + 16 + i * 8;let (Some(name), Some(target)) = (r.u32_le(e), r.u32_le(e + 4)) else { break };let label = if name & 0x8000_0000 != 0 {- let so = base.saturating_add((name & 0x7fff_ffff) as usize);- let len = usize::from(r.u16_le(so).unwrap_or(0));- (None, utf16_at(&r, so + 2, len).unwrap_or_default())+ let so = (name & 0x7fff_ffff) as usize;+ let Some(label) = r.u16_le(so).and_then(|len| {+ let start = so.checked_add(2)?;+ let units = usize::from(len);+ r.slice(start, units.checked_mul(2)?)?;+ utf16_at(&r, start, units)+ }) else {+ res.warnings.push("resource name runs past the directory; skipped an entry".into());+ continue;+ };+ (None, label)} else {(Some(name), name.to_string())};@@ -763,7 +812,11 @@ pub fn parse_resources(data: &[u8], max_entries: usize) -> Result<Resources, Forres.truncated = true;continue;}- let de = base.saturating_add(target as usize);+ let de = target as usize;+ if r.slice(de, 16).is_none() {+ res.warnings.push("resource data entry runs past the directory; skipped an entry".into());+ continue;+ }let (Some(drva), Some(dsize)) = (r.u32_le(de), r.u32_le(de + 4)) else { continue };let (type_id, type_label) = p.first().cloned().unwrap_or((None, String::new()));let type_name = match type_id {diff --git a/crates/formats/src/pixels.rs b/crates/formats/src/pixels.rsindex abddc93e..8a204dc2 100644--- a/crates/formats/src/pixels.rs+++ b/crates/formats/src/pixels.rs@@ -5,6 +5,9 @@use crate::bptc;use crate::common::FormatError;+/// Default RGBA output budget: 256 MiB, matching the texture exporters' 8192×8192 pixel limit.+pub const DEFAULT_MAX_RGBA_BYTES: u64 = 256 << 20;+/// How a texture's pixels are laid out.#[derive(Debug, Clone, Copy, PartialEq, Eq)]pub enum Layout {@@ -157,20 +160,40 @@ fn blocks(out: &mut [u8], w: usize, h: usize, texels: impl Iterator<Item = [[u8;}/// Decode a `width`×`height` picture (`data` starts with it) into RGBA, rows in stored order.+///+/// Caps the output at [`DEFAULT_MAX_RGBA_BYTES`]; use [`decode_with_limit`] for a different budget.pub fn decode(layout: Layout, width: u32, height: u32, data: &[u8]) -> Result<Vec<u8>, FormatError> {+ decode_with_limit(layout, width, height, data, DEFAULT_MAX_RGBA_BYTES)+}++/// Decode into RGBA, allowing at most `max_bytes` of output.+///+/// The budget applies to RGBA bytes, not the encoded input, and is checked before reading pixels+/// or reserving the output. Output reservation failures are reported as [`FormatError::TooLarge`].+pub fn decode_with_limit(layout: Layout, width: u32, height: u32, data: &[u8], max_bytes: u64) -> Result<Vec<u8>, FormatError> {let need = size(layout, width, height).ok_or_else(|| FormatError::TooLarge(format!("a {width}×{height} picture")))?;- let data = data.get(..need).ok_or_else(|| FormatError::Truncated(format!("{} bytes of pixels, {need} needed", data.len())))?;let (w, h) = (width as usize, height as usize);+ let out_len = w+ .checked_mul(h)+ .and_then(|pixels| pixels.checked_mul(4))+ .filter(|bytes| *bytes <= isize::MAX as usize)+ .ok_or_else(|| FormatError::TooLarge(format!("a {width}×{height} RGBA picture")))?;+ if out_len as u64 > max_bytes {+ return Err(FormatError::TooLarge(format!("a {width}×{height} RGBA picture exceeds {max_bytes} bytes")));+ }+ let data = data.get(..need).ok_or_else(|| FormatError::Truncated(format!("{} bytes of pixels, {need} needed", data.len())))?;if w == 0 || h == 0 {return Err(FormatError::Malformed("an empty picture".into()));}- let mut out = vec![0u8; w * h * 4];+ let mut out: Vec<u8> = Vec::new();+ out.try_reserve_exact(out_len).map_err(|_| FormatError::TooLarge(format!("a {width}×{height} RGBA picture")))?;+ out.resize(out_len, 0);let mut put = |px: &mut dyn Iterator<Item = [u8; 4]>| {for (dst, p) in out.as_chunks_mut::<4>().0.iter_mut().zip(px) {*dst = p;}};- let u16s = |d: &[u8]| -> Vec<u16> { d.as_chunks::<2>().0.iter().map(|b| u16::from_le_bytes(*b)).collect() };+ let u16s = data.as_chunks::<2>().0.iter().map(|b| u16::from_le_bytes(*b));match layout {Layout::Alpha8 => put(&mut data.iter().map(|a| [255, 255, 255, *a])),Layout::R8 => put(&mut data.iter().map(|r| [*r, *r, *r, 255])),@@ -178,9 +201,9 @@ pub fn decode(layout: Layout, width: u32, height: u32, data: &[u8]) -> Result<VeLayout::Rgba32 => put(&mut data.as_chunks::<4>().0.iter().copied()),Layout::Argb32 => put(&mut data.as_chunks::<4>().0.iter().map(|[a, r, g, b]| [*r, *g, *b, *a])),Layout::Bgra32 => put(&mut data.as_chunks::<4>().0.iter().map(|[b, g, r, a]| [*r, *g, *b, *a])),- Layout::Rgb565 => put(&mut u16s(data).into_iter().map(rgb565)),- Layout::Rgba4444 => put(&mut u16s(data).into_iter().map(|v| nibbles(v, [12, 8, 4, 0]))),- Layout::Argb4444 => put(&mut u16s(data).into_iter().map(|v| nibbles(v, [8, 4, 0, 12]))),+ Layout::Rgb565 => put(&mut u16s.map(rgb565)),+ Layout::Rgba4444 => put(&mut u16s.map(|v| nibbles(v, [12, 8, 4, 0]))),+ Layout::Argb4444 => put(&mut u16s.map(|v| nibbles(v, [8, 4, 0, 12]))),Layout::Dxt1 => blocks(&mut out, w, h, data.as_chunks::<8>().0.iter().map(|b| dxt_texels(b, true))),Layout::Dxt5 => blocks(&mut out, w, h, data.as_chunks::<16>().0.iter().map(dxt5)),Layout::Bc4 => blocks(&mut out, w, h, data.as_chunks::<8>().0.iter().map(bc4)),diff --git a/crates/formats/src/pyc.rs b/crates/formats/src/pyc.rsindex e8dab2ce..68c3c230 100644--- a/crates/formats/src/pyc.rs+++ b/crates/formats/src/pyc.rs@@ -374,6 +374,12 @@ impl<'a> Marshal<'a> {let (digit_pairs, _) = raw.as_chunks::<2>();for (i, pair) in digit_pairs.iter().enumerate() {let digit = i64::from(u16::from_le_bytes(*pair));+ if digit > 0x7fff {+ return Err(bad("a long integer digit exceeds 15 bits"));+ }+ if i + 1 == digits && digit == 0 {+ return Err(bad("a long integer has a zero leading digit"));+ }let shift = u32::try_from(i).ok().and_then(|i| i.checked_mul(15)).filter(|s| *s < 62);value = value.and_then(|v| {let shift = shift?;diff --git a/crates/formats/src/unity_bundle.rs b/crates/formats/src/unity_bundle.rsindex 2608507a..1932df66 100644--- a/crates/formats/src/unity_bundle.rs+++ b/crates/formats/src/unity_bundle.rs@@ -101,13 +101,20 @@ pub fn header(data: &[u8], file_len: u64) -> Result<Header, FormatError> {if format_version >= 7 {at = at.div_ceil(16) * 16;}- let (table_offset, mut data_offset) =- if flags & 0x80 != 0 { (file_len.saturating_sub(u64::from(table_size)), at) } else { (at, at + u64::from(table_size)) };+ let bad_extent = || FormatError::Malformed("the bundle size or block table doesn't fit the file".into());+ if size < at || size > file_len || table_uncompressed_size > MAX_TABLE {+ return Err(bad_extent());+ }+ let table_at_end = flags & 0x80 != 0;+ let table_offset = if table_at_end { size.checked_sub(u64::from(table_size)).ok_or_else(bad_extent)? } else { at };+ let table_end = table_offset.checked_add(u64::from(table_size)).ok_or_else(bad_extent)?;+ let mut data_offset = if table_at_end { at } else { table_end };if flags & 0x200 != 0 {- data_offset = data_offset.div_ceil(16) * 16;+ data_offset = data_offset.checked_next_multiple_of(16).ok_or_else(bad_extent)?;}- if table_offset + u64::from(table_size) > file_len || table_uncompressed_size > MAX_TABLE {- return Err(FormatError::Malformed("the block table doesn't fit the file".into()));+ let data_end = if table_at_end { table_offset } else { size };+ if table_offset < at || table_end > size || data_offset > data_end {+ return Err(bad_extent());}Ok(Header { format_version, unity_version, unity_revision, size, flags, table_offset, table_size, table_uncompressed_size, data_offset })}@@ -115,19 +122,26 @@ pub fn header(data: &[u8], file_len: u64) -> Result<Header, FormatError> {/// Decompress one piece of a bundle with compression `kind` (the low six bits of a flags field).pub fn decompress(kind: u32, input: &[u8], out_len: u32) -> Result<Vec<u8>, FormatError> {let bad = |e: decompress::DecompressError| FormatError::Malformed(format!("a {} block: {e}", compression_name(kind)));- match kind {+ let bad_size = |actual: usize| FormatError::Malformed(format!("a {} block has {actual} decoded bytes, expected {out_len}", compression_name(kind)));+ if kind == 0 && input.len() != out_len as usize {+ return Err(bad_size(input.len()));+ }+ let output = match kind {0 => Ok(input.to_vec()),- // Unity's LZMA is the 5 property bytes and the stream; the `.lzma` form adds the size.+ // Unity stores the properties and stream without a size header; check its end before trusting out_len.1 => {- let props = input.get(..5).ok_or_else(|| FormatError::Truncated("LZMA properties".into()))?;- let mut alone = props.to_vec();- alone.extend_from_slice(&u64::from(out_len).to_le_bytes());- alone.extend_from_slice(&input[5..]);- decompress::lzma(&alone, u64::from(out_len)).map_err(bad)+ if input.len() < 5 {+ return Err(FormatError::Truncated("LZMA properties".into()));+ }+ decompress::lzma_raw_complete(input, out_len).map_err(bad)}2 | 3 => decompress::lz4_block(input, out_len as usize).map_err(bad),n => Err(FormatError::Unsupported(format!("compression {n}"))),+ }?;+ if output.len() != out_len as usize {+ return Err(bad_size(output.len()));}+ Ok(output)}/// Read the block table (`table` as stored in the file).diff --git a/crates/formats/src/unity_serialized.rs b/crates/formats/src/unity_serialized.rsindex 103571d6..4e098eda 100644--- a/crates/formats/src/unity_serialized.rs+++ b/crates/formats/src/unity_serialized.rs@@ -193,7 +193,12 @@ pub fn metadata(data: &[u8], h: &Header) -> Result<Metadata, FormatError> {if v == 15 || v == 16 {c.u8("stripped")?;}- objects.push(Object { path_id, class_id, offset: h.data_offset.saturating_add(start), size });+ let offset = h+ .data_offset+ .checked_add(start)+ .filter(|offset| offset.checked_add(u64::from(size)).is_some_and(|end| end <= h.file_size))+ .ok_or_else(|| FormatError::Malformed(format!("object {path_id} lies outside the file")))?;+ objects.push(Object { path_id, class_id, offset, size });}for _ in 0..c.count("script references", 12)? {c.i32("script file")?;diff --git a/crates/formats/src/unreal_iostore.rs b/crates/formats/src/unreal_iostore.rsindex 2244d793..5e868047 100644--- a/crates/formats/src/unreal_iostore.rs+++ b/crates/formats/src/unreal_iostore.rs@@ -124,6 +124,7 @@ pub fn header(data: &[u8]) -> Result<Header, FormatError> {let hash_seeds = c.u32("perfect hash seeds")?;let partition_size = c.u64("partition size")?;let without_hash = c.u32("chunks without perfect hash")?;+ c.take(44, "reserved header fields")?;let flags = Flags { compressed: bits & 1 != 0, encrypted: bits & 2 != 0, signed: bits & 4 != 0, indexed: bits & 8 != 0 };Ok(Header {version,@@ -204,9 +205,10 @@ impl Toc {fn stored(&self, chunk: usize) -> (u64, String) {let Some(&(offset, length)) = self.chunks.get(chunk) else { return (0, "none".into()) };let size = u64::from(self.header.block_size.max(1));- let first = (offset / size) as usize;- let count = length.div_ceil(size) as usize;- let blocks = self.blocks.get(first..first.saturating_add(count).min(self.blocks.len())).unwrap_or_default();+ let Some(end) = offset.checked_add(length).filter(|_| length != 0) else { return (0, "none".into()) };+ let Ok(first) = usize::try_from(offset / size) else { return (0, "none".into()) };+ let end = end.div_ceil(size).min(self.blocks.len() as u64) as usize;+ let blocks = self.blocks.get(first..end).unwrap_or_default();(blocks.iter().map(|b| u64::from(b.compressed_size)).sum(), blocks.first().map_or_else(|| "none".into(), |b| self.method(b.method)))}}diff --git a/crates/formats/src/unreal_pak.rs b/crates/formats/src/unreal_pak.rsindex 3f145b88..0e2fe0ba 100644--- a/crates/formats/src/unreal_pak.rs+++ b/crates/formats/src/unreal_pak.rs@@ -35,6 +35,7 @@ pub struct Footer {/// The key's GUID (all zero when the default key, or none, is used), from version 7.pub encryption_key_guid: Option<String>,/// Compression method names by index (index 0 means "none"; these are 1, 2, …), from version 8.+ /// Empty slots before a later name stay in place; unused trailing slots are omitted.pub compression_methods: Vec<String>,/// How many method name slots the footer has: 4 in the first version-8 paks (Unreal 4.22),/// whose entries store the method index in one byte, else 5.@@ -128,10 +129,18 @@ impl<'a> Cur<'a> {if chars > MAX_STRING {return Err(FormatError::Malformed(format!("{what} is {chars} characters long")));}+ let no_terminator = || FormatError::Malformed(format!("{what} has no terminating NUL"));let s = if n >= 0 {- String::from_utf8_lossy(self.take(chars, what)?).into_owned()+ let b = self.take(chars, what)?;+ if chars != 0 && b.last() != Some(&0) {+ return Err(no_terminator());+ }+ String::from_utf8_lossy(b).into_owned()} else {let b = self.take(chars * 2, what)?;+ if !b.ends_with(&[0, 0]) {+ return Err(no_terminator());+ }String::from_utf16_lossy(&b.as_chunks::<2>().0.iter().map(|c| u16::from_le_bytes(*c)).collect::<Vec<_>>())};Ok(s.trim_end_matches('\0').to_string())@@ -170,6 +179,7 @@ pub fn footer(tail: &[u8], file_len: u64) -> Result<Footer, FormatError> {method_slots += 1;let name = String::from_utf8_lossy(name).trim_end_matches('\0').to_string();if !name.is_empty() {+ compression_methods.resize_with(method_slots - 1, String::new);compression_methods.push(name);}}@@ -199,7 +209,7 @@ fn record_size(footer: &Footer, compressed: bool, blocks: usize) -> u64 {fn method_name(footer: &Footer, index: u32) -> String {match index {0 => "none".into(),- n => footer.compression_methods.get(n as usize - 1).cloned().unwrap_or_else(|| format!("method {n}")),+ n => footer.compression_methods.get(n as usize - 1).filter(|name| !name.is_empty()).cloned().unwrap_or_else(|| format!("method {n}")),}}diff --git a/crates/formats/src/zip.rs b/crates/formats/src/zip.rsindex 55ca5001..4fc8c385 100644--- a/crates/formats/src/zip.rs+++ b/crates/formats/src/zip.rs@@ -96,31 +96,61 @@ pub fn looks_like_zip(data: &[u8]) -> bool {pub fn parse(data: &[u8], max_entries: usize) -> Result<ZipArchive, ZipError> {let r = Reader::new(data);let eocd = find_eocd(data).ok_or(ZipError::NotZip)?;+ let mut disk = u32::from(r.u16_le(eocd + 4).ok_or(ZipError::Truncated("end record"))?);+ let mut directory_disk = u32::from(r.u16_le(eocd + 6).ok_or(ZipError::Truncated("end record"))?);+ let mut disk_entries = u64::from(r.u16_le(eocd + 8).ok_or(ZipError::Truncated("end record"))?);+ if !matches!(disk, 0 | 0xffff) || !matches!(directory_disk, 0 | 0xffff) {+ return Err(ZipError::Unsupported("multi-volume ZIP archives".into()));+ }let mut total = u64::from(r.u16_le(eocd + 10).ok_or(ZipError::Truncated("end record"))?);let mut cd_size = u64::from(r.u32_le(eocd + 12).ok_or(ZipError::Truncated("end record"))?);let mut cd_offset = u64::from(r.u32_le(eocd + 16).ok_or(ZipError::Truncated("end record"))?);let mut zip64 = false;let mut eocd_record_start = eocd as u64;- if total == 0xffff || cd_size == 0xffff_ffff || cd_offset == 0xffff_ffff {+ if total == 0xffff || disk_entries == 0xffff || disk == 0xffff || directory_disk == 0xffff || cd_size == 0xffff_ffff || cd_offset == 0xffff_ffff {// ZIP64 locator sits right before the classic record.if let Some(loc) = eocd.checked_sub(20)&& r.slice(loc, 4) == Some(b"PK\x06\x07"){+ if r.u32_le(loc + 4) != Some(0) || r.u32_le(loc + 16) != Some(1) {+ return Err(ZipError::Unsupported("multi-volume ZIP archives".into()));+ }let rec = r.u64_le(loc + 8).ok_or(ZipError::Truncated("zip64 locator"))?;let rec = usize::try_from(rec).map_err(|_| ZipError::Corrupt("zip64 record offset".into()))?;if r.slice(rec, 4) == Some(b"PK\x06\x06") {- total = r.u64_le(rec + 32).ok_or(ZipError::Truncated("zip64 record"))?;- cd_size = r.u64_le(rec + 40).ok_or(ZipError::Truncated("zip64 record"))?;- cd_offset = r.u64_le(rec + 48).ok_or(ZipError::Truncated("zip64 record"))?;+ disk = r.u32_le(rec + 16).ok_or(ZipError::Truncated("zip64 record"))?;+ directory_disk = r.u32_le(rec + 20).ok_or(ZipError::Truncated("zip64 record"))?;+ let zip64_disk_entries = r.u64_le(rec + 24).ok_or(ZipError::Truncated("zip64 record"))?;+ let zip64_total = r.u64_le(rec + 32).ok_or(ZipError::Truncated("zip64 record"))?;+ if (disk_entries != 0xffff && disk_entries != zip64_disk_entries) || (total != 0xffff && total != zip64_total) {+ return Err(ZipError::Unsupported("multi-volume ZIP archives".into()));+ }+ disk_entries = zip64_disk_entries;+ total = zip64_total;+ let zip64_cd_size = r.u64_le(rec + 40).ok_or(ZipError::Truncated("zip64 record"))?;+ let zip64_cd_offset = r.u64_le(rec + 48).ok_or(ZipError::Truncated("zip64 record"))?;+ if (cd_size != 0xffff_ffff && cd_size != zip64_cd_size) || (cd_offset != 0xffff_ffff && cd_offset != zip64_cd_offset) {+ return Err(ZipError::Corrupt("ZIP64 and classic directory bounds disagree".into()));+ }+ cd_size = zip64_cd_size;+ cd_offset = zip64_cd_offset;zip64 = true;eocd_record_start = rec as u64;}}}+ if disk != 0 || directory_disk != 0 || disk_entries != total {+ return Err(ZipError::Unsupported("multi-volume ZIP archives".into()));+ }// Self-extracting archives: the directory sits later than it claims by the stub length.let expected_end = cd_offset.checked_add(cd_size).ok_or_else(|| ZipError::Corrupt("directory bounds overflow".into()))?;let prefix = eocd_record_start.saturating_sub(expected_end);let start = usize::try_from(cd_offset.saturating_add(prefix)).map_err(|_| ZipError::Corrupt("directory offset".into()))?;+ let directory_end = (start as u64)+ .checked_add(cd_size)+ .filter(|&end| end <= eocd_record_start)+ .and_then(|end| usize::try_from(end).ok())+ .ok_or_else(|| ZipError::Corrupt("directory extends into its end record".into()))?;let mut entries = Vec::new();let mut pos = start;let mut truncated = false;@@ -130,6 +160,9 @@ pub fn parse(data: &[u8], max_entries: usize) -> Result<ZipArchive, ZipError> {truncated = true;break;}+ if pos.checked_add(46).is_none_or(|end| end > directory_end) {+ return Err(ZipError::Truncated("directory entry"));+ }if r.slice(pos, 4) != Some(b"PK\x01\x02") {if entries.is_empty() {return Err(ZipError::Corrupt(format!("no central directory header at offset {pos}")));@@ -145,17 +178,23 @@ pub fn parse(data: &[u8], max_entries: usize) -> Result<ZipArchive, ZipError> {let name_len = usize::from(r.u16_le(pos + 28).ok_or(ZipError::Truncated("directory entry"))?);let extra_len = usize::from(r.u16_le(pos + 30).ok_or(ZipError::Truncated("directory entry"))?);let comment_len = usize::from(r.u16_le(pos + 32).ok_or(ZipError::Truncated("directory entry"))?);+ let entry_end = pos+ .checked_add(46 + name_len + extra_len + comment_len)+ .filter(|&end| end <= directory_end)+ .ok_or(ZipError::Truncated("directory entry fields"))?;let host = r.slice(pos + 5, 1).and_then(|b| b.first().copied()).unwrap_or(0);let unix_mode = if host == 3 { r.u32_le(pos + 38).map(|a| a >> 16) } else { None };let mut local = u64::from(r.u32_le(pos + 42).ok_or(ZipError::Truncated("directory entry"))?);+ let mut entry_disk = u32::from(r.u16_le(pos + 34).ok_or(ZipError::Truncated("directory entry"))?);let name_bytes = r.slice(pos + 46, name_len).ok_or(ZipError::Truncated("entry name"))?;let extra = r.slice(pos + 46 + name_len, extra_len).ok_or(ZipError::Truncated("entry extra fields"))?;// Each extra field owns its payload: ZIP64 values cannot borrow a following field's bytes.- let needs_zip64 = usize_ == 0xffff_ffff || csize == 0xffff_ffff || local == 0xffff_ffff;+ let needs_zip64 = usize_ == 0xffff_ffff || csize == 0xffff_ffff || local == 0xffff_ffff || entry_disk == 0xffff;let mut found_zip64 = false;let mut x = 0usize;let er = Reader::new(extra);- while x < extra.len() {+ // Trailing bytes too short for a field header are padding, not truncation.+ while x.saturating_add(4) <= extra.len() {let id = er.u16_le(x).ok_or(ZipError::Truncated("extra field header"))?;let len = usize::from(er.u16_le(x + 2).ok_or(ZipError::Truncated("extra field header"))?);let body = x + 4;@@ -173,6 +212,10 @@ pub fn parse(data: &[u8], max_entries: usize) -> Result<ZipArchive, ZipError> {}if local == 0xffff_ffff {local = values.u64_le(f).ok_or(ZipError::Truncated("zip64 local header offset"))?;+ f += 8;+ }+ if entry_disk == 0xffff {+ entry_disk = values.u32_le(f).ok_or(ZipError::Truncated("zip64 entry disk"))?;}found_zip64 = true;break;@@ -182,6 +225,9 @@ pub fn parse(data: &[u8], max_entries: usize) -> Result<ZipArchive, ZipError> {if needs_zip64 && !found_zip64 {return Err(ZipError::Corrupt("missing ZIP64 extended information".into()));}+ if entry_disk != 0 {+ return Err(ZipError::Unsupported("multi-volume ZIP archives".into()));+ }let name = decode_name(name_bytes, flags).replace('\\', "/");entries.push(ZipEntry {is_dir: name.ends_with('/'),@@ -196,7 +242,7 @@ pub fn parse(data: &[u8], max_entries: usize) -> Result<ZipArchive, ZipError> {unix_mode,});seen += 1;- pos = pos.checked_add(46 + name_len + extra_len + comment_len).ok_or_else(|| ZipError::Corrupt("directory overflow".into()))?;+ pos = entry_end;}Ok(ZipArchive { entries, declared_entries: total, truncated, zip64, prefix_bytes: prefix })}diff --git a/crates/formats/tests/apk_sign_directory_bounds.rs b/crates/formats/tests/apk_sign_directory_bounds.rsnew file mode 100644index 00000000..6dc2f70c--- /dev/null+++ b/crates/formats/tests/apk_sign_directory_bounds.rs@@ -0,0 +1,128 @@+use craft_anything_formats::apk_sign;+use craft_anything_testkit::{+ android::{certificate_der, notes_apk, signed_apk, signing_block, with_signing_block},+ electron::zip_stored,+};++fn apk(files: &[(&str, &[u8])]) -> Vec<u8> {+ with_signing_block(&zip_stored(files), &signing_block(&certificate_der("Craft Test", "Craft Org")))+}++fn directory(bytes: &[u8]) -> (usize, usize, usize) {+ let eocd = bytes.len() - 22;+ let size = u32::from_le_bytes(bytes[eocd + 12..eocd + 16].try_into().unwrap()) as usize;+ let start = u32::from_le_bytes(bytes[eocd + 16..eocd + 20].try_into().unwrap()) as usize;+ (start, size, eocd)+}++fn append_directory_tail(bytes: &[u8], tail: &[u8]) -> Vec<u8> {+ let (_, size, eocd) = directory(bytes);+ let mut out = bytes.to_vec();+ out.splice(eocd..eocd, tail.iter().copied());+ let new_eocd = eocd + tail.len();+ out[new_eocd + 12..new_eocd + 16].copy_from_slice(&((size + tail.len()) as u32).to_le_bytes());+ out+}++#[test]+fn ordinary_apks_keep_their_signers() {+ for bytes in [notes_apk(), signed_apk(false)] {+ let found = apk_sign::parse(&bytes).unwrap();+ assert_eq!(found.signers.len(), 2);+ assert!(found.warnings.is_empty(), "{:?}", found.warnings);+ }+}++#[test]+fn an_empty_directory_keeps_the_signing_block() {+ let bytes = apk(&[]);+ let (start, size, eocd) = directory(&bytes);+ assert_eq!((start, size), (eocd, 0));+ let found = apk_sign::parse(&bytes).unwrap();+ assert_eq!(found.entries.len(), 3);+ assert_eq!(found.signers.len(), 2);+ assert!(found.warnings.is_empty());+}++#[test]+fn the_declared_directory_extent_must_end_at_eocd() {+ let bytes = apk(&[("entry.txt", b"payload")]);+ let (_, size, eocd) = directory(&bytes);+ for declared_size in [size as u32 - 1, size as u32 + 1, u32::MAX] {+ let mut changed = bytes.clone();+ changed[eocd + 12..eocd + 16].copy_from_slice(&declared_size.to_le_bytes());+ assert!(apk_sign::parse(&changed).is_none(), "directory size {declared_size}");+ }+}++#[test]+fn the_declared_record_count_must_match_the_directory() {+ let bytes = apk(&[("a.txt", b"a"), ("b.txt", b"b")]);+ let (_, _, eocd) = directory(&bytes);+ for count in [0u16, 1, 3, u16::MAX] {+ let mut changed = bytes.clone();+ changed[eocd + 8..eocd + 10].copy_from_slice(&count.to_le_bytes());+ changed[eocd + 10..eocd + 12].copy_from_slice(&count.to_le_bytes());+ assert!(apk_sign::parse(&changed).is_none(), "record count {count}");+ }+}++#[test]+fn variable_fields_cannot_extend_beyond_the_directory() {+ let bytes = apk(&[("entry.txt", b"payload")]);+ let (start, _, _) = directory(&bytes);+ for field in [28, 30, 32] {+ let mut changed = bytes.clone();+ changed[start + field..start + field + 2].copy_from_slice(&u16::MAX.to_le_bytes());+ assert!(apk_sign::parse(&changed).is_none(), "length field {field}");+ }+}++#[test]+fn a_truncated_directory_record_is_not_accepted() {+ let bytes = apk(&[("entry.txt", b"payload")]);+ let (start, size, eocd) = directory(&bytes);+ for kept in 0..size {+ let mut changed = bytes.clone();+ changed.drain(start + kept..eocd);+ let new_eocd = start + kept;+ changed[new_eocd + 12..new_eocd + 16].copy_from_slice(&(kept as u32).to_le_bytes());+ assert!(apk_sign::parse(&changed).is_none(), "directory truncated to {kept} bytes");+ }+}++#[test]+fn ordinary_extra_fields_and_file_comments_keep_the_signers() {+ let bytes = apk(&[("entry.txt", b"payload")]);+ let expected = apk_sign::parse(&bytes).unwrap();+ let (start, _, _) = directory(&bytes);+ let extra = [0xfe, 0xca, 2, 0, 7, 9];+ let comment = b"file comment";+ let mut fields = extra.to_vec();+ fields.extend_from_slice(comment);+ let mut changed = append_directory_tail(&bytes, &fields);+ changed[start + 30..start + 32].copy_from_slice(&(extra.len() as u16).to_le_bytes());+ changed[start + 32..start + 34].copy_from_slice(&(comment.len() as u16).to_le_bytes());+ assert_eq!(apk_sign::parse(&changed), Some(expected));+}++#[test]+fn one_complete_directory_digital_signature_is_allowed() {+ let bytes = apk(&[("entry.txt", b"payload")]);+ let expected = apk_sign::parse(&bytes).unwrap();+ let tail = b"PK\x05\x05\x03\0sig";+ assert_eq!(apk_sign::parse(&append_directory_tail(&bytes, tail)), Some(expected));+}++#[test]+fn directory_digital_signatures_must_be_complete_and_unique() {+ let bytes = apk(&[("entry.txt", b"payload")]);+ let tail = b"PK\x05\x05\x03\0sig";+ for kept in 1..tail.len() {+ assert!(apk_sign::parse(&append_directory_tail(&bytes, &tail[..kept])).is_none(), "signature truncated to {kept} bytes");+ }+ let mut repeated = tail.to_vec();+ repeated.extend_from_slice(tail);+ assert!(apk_sign::parse(&append_directory_tail(&bytes, &repeated)).is_none());+ assert!(apk_sign::parse(&append_directory_tail(&bytes, b"padding")).is_none());+}diff --git a/crates/formats/tests/apk_sign_eocd_comment_boundary.rs b/crates/formats/tests/apk_sign_eocd_comment_boundary.rsnew file mode 100644index 00000000..e78cd257--- /dev/null+++ b/crates/formats/tests/apk_sign_eocd_comment_boundary.rs@@ -0,0 +1,290 @@+use craft_anything_formats::apk_sign;+use craft_anything_testkit::android::notes_apk;++#[test]+fn an_eocd_marker_inside_the_comment_does_not_hide_the_signature() {+ for fake_comment_length in [0u16, 1] {+ let mut apk = notes_apk();+ let original = apk_sign::parse(&apk).unwrap();+ let eocd = apk.len() - 22;+ assert_eq!(&apk[eocd..eocd + 4], b"PK\x05\x06");++ let mut comment = vec![0; 22];+ comment[..4].copy_from_slice(b"PK\x05\x06");+ comment[20..22].copy_from_slice(&fake_comment_length.to_le_bytes());+ apk[eocd + 20..eocd + 22].copy_from_slice(&(comment.len() as u16).to_le_bytes());+ apk.extend_from_slice(&comment);++ let found = apk_sign::parse(&apk).expect("the original EOCD still frames the APK");+ assert_eq!(found.offset, original.offset);+ assert_eq!(found.entries.len(), original.entries.len());+ assert_eq!(found.signers.len(), original.signers.len());+ }+}++#[test]+fn an_incomplete_eocd_comment_is_not_accepted() {+ let mut apk = notes_apk();+ let len = apk.len();+ apk[len - 2..].copy_from_slice(&1u16.to_le_bytes());+ assert!(apk_sign::parse(&apk).is_none());+}++#[test]+fn an_eocd_marker_in_a_signing_block_value_does_not_hide_the_signature() {+ for points_to_real_directory in [false, true] {+ let mut apk = notes_apk();+ let original = apk_sign::parse(&apk).unwrap();+ let eocd = apk.len() - 22;+ let cd = u32::from_le_bytes(apk[eocd + 16..eocd + 20].try_into().unwrap()) as usize;+ let pair_at = cd - 24;+ let marker_at = pair_at + 12;+ let added = 8 + 4 + 22;+ let new_cd = cd + added;++ let mut value = vec![0; 22];+ value[..4].copy_from_slice(b"PK\x05\x06");+ let fake_cd = if points_to_real_directory { new_cd as u32 } else { 0 };+ value[16..20].copy_from_slice(&fake_cd.to_le_bytes());+ let comment_len = u16::try_from(apk.len() + added - marker_at - 22).unwrap();+ value[20..22].copy_from_slice(&comment_len.to_le_bytes());+ let mut pair = 26u64.to_le_bytes().to_vec();+ pair.extend_from_slice(&0x1357_2468u32.to_le_bytes());+ pair.extend_from_slice(&value);+ apk.splice(pair_at..pair_at, pair);++ let size = original.size + added as u64;+ let start = original.offset as usize;+ apk[start..start + 8].copy_from_slice(&size.to_le_bytes());+ apk[new_cd - 24..new_cd - 16].copy_from_slice(&size.to_le_bytes());+ apk[eocd + added + 16..eocd + added + 20].copy_from_slice(&(new_cd as u32).to_le_bytes());++ let found = apk_sign::parse(&apk).expect("a marker inside an unknown signing-block value is not the ZIP record");+ assert_eq!((found.offset, found.size), (original.offset, size));+ assert_eq!(&found.entries[..original.entries.len()], &original.entries);+ assert_eq!(found.entries.len(), original.entries.len() + 1);+ assert_eq!(found.entries.last().unwrap().id, "0x13572468");+ assert_eq!(found.signers, original.signers);+ assert!(found.warnings.is_empty());+ }+}++#[test]+fn a_signing_block_and_eocd_inside_the_comment_do_not_replace_the_original() {+ let mut apk = notes_apk();+ let original = apk_sign::parse(&apk).unwrap();+ let eocd = apk.len() - 22;+ let mut comment = 24u64.to_le_bytes().to_vec();+ comment.extend_from_slice(&24u64.to_le_bytes());+ comment.extend_from_slice(b"APK Sig Block 42");+ let fake_cd = apk.len() + comment.len();+ let mut fake_eocd = vec![0; 22];+ fake_eocd[..4].copy_from_slice(b"PK\x05\x06");+ fake_eocd[16..20].copy_from_slice(&(fake_cd as u32).to_le_bytes());+ comment.extend_from_slice(&fake_eocd);+ apk[eocd + 20..eocd + 22].copy_from_slice(&(comment.len() as u16).to_le_bytes());+ apk.extend_from_slice(&comment);+ assert_eq!(apk_sign::parse(&apk).unwrap(), original);+}++#[test]+fn recoverable_size_and_pair_damage_still_returns_signing_evidence() {+ let original_bytes = notes_apk();+ let original = apk_sign::parse(&original_bytes).unwrap();+ let start = original.offset as usize;+ let mut size_mismatch = original_bytes.clone();+ size_mismatch[start..start + 8].copy_from_slice(&(original.size + 1).to_le_bytes());+ let found = apk_sign::parse(&size_mismatch).expect("header size disagreement is reported as a warning");+ assert_eq!(found.signers, original.signers);+ assert_eq!(found.entries, original.entries);+ assert!(found.warnings.iter().any(|w| w.contains("size fields disagree")));++ let mut bad_pair = original_bytes;+ let third_pair = start + 8 + original.entries.iter().take(2).map(|entry| entry.size as usize + 12).sum::<usize>();+ bad_pair[third_pair..third_pair + 8].copy_from_slice(&original.size.to_le_bytes());+ let found = apk_sign::parse(&bad_pair).expect("a malformed later pair keeps the preceding signers");+ assert_eq!(found.signers, original.signers);+ assert_eq!(found.entries.len(), 2);+ assert!(found.warnings.iter().any(|w| w.contains("malformed id-value pair")));+}++fn block_with_pairs(pairs: &[(u32, Vec<u8>)]) -> Vec<u8> {+ let mut body = Vec::new();+ for (id, value) in pairs {+ body.extend_from_slice(&((value.len() + 4) as u64).to_le_bytes());+ body.extend_from_slice(&id.to_le_bytes());+ body.extend_from_slice(value);+ }+ let size = (body.len() + 24) as u64;+ let mut block = size.to_le_bytes().to_vec();+ block.extend_from_slice(&body);+ block.extend_from_slice(&size.to_le_bytes());+ block.extend_from_slice(b"APK Sig Block 42");+ block+}++fn empty_eocd(offset: usize, comment_len: usize) -> Vec<u8> {+ let mut end = vec![0; 22];+ end[..4].copy_from_slice(b"PK\x05\x06");+ end[16..20].copy_from_slice(&u32::try_from(offset).unwrap().to_le_bytes());+ end[20..22].copy_from_slice(&u16::try_from(comment_len).unwrap().to_le_bytes());+ end+}++fn signed_zip(entries: &[(&str, &[u8])]) -> Vec<u8> {+ use craft_anything_testkit::{android, electron::zip_stored};+ android::with_signing_block(&zip_stored(entries), &android::signing_block(&android::certificate_der("Craft Test", "Craft Org")))+}++fn with_nested_candidate(mut apk: Vec<u8>, fake_block: &[u8]) -> (Vec<u8>, apk_sign::SigningBlock) {+ let mut expected = apk_sign::parse(&apk).unwrap();+ let eocd = apk.len() - 22;+ let cd = u32::from_le_bytes(apk[eocd + 16..eocd + 20].try_into().unwrap()) as usize;+ let pair_at = cd - 24;+ let marker_at = pair_at + 12 + fake_block.len();+ let added = 12 + fake_block.len() + 22;+ let mut value = fake_block.to_vec();+ value.extend_from_slice(&empty_eocd(marker_at, apk.len() + added - marker_at - 22));+ let mut pair = ((value.len() + 4) as u64).to_le_bytes().to_vec();+ pair.extend_from_slice(&0x1357_2468u32.to_le_bytes());+ pair.extend_from_slice(&value);+ apk.splice(pair_at..pair_at, pair);++ expected.size += added as u64;+ expected.entries.push(apk_sign::BlockEntry { id: "0x13572468".into(), name: "unknown", size: value.len() as u64 });+ let start = expected.offset as usize;+ let new_cd = cd + added;+ apk[start..start + 8].copy_from_slice(&expected.size.to_le_bytes());+ apk[new_cd - 24..new_cd - 16].copy_from_slice(&expected.size.to_le_bytes());+ apk[eocd + added + 16..eocd + added + 20].copy_from_slice(&(new_cd as u32).to_le_bytes());+ (apk, expected)+}++fn assert_nested_candidate_keeps_signers(fake_block: &[u8]) {+ for apk in [notes_apk(), signed_zip(&[])] {+ let (apk, expected) = with_nested_candidate(apk, fake_block);+ assert_eq!(apk_sign::parse(&apk).unwrap(), expected);+ }+}++#[test]+fn an_empty_block_inside_a_pair_cannot_hide_readable_signers() {+ assert_nested_candidate_keeps_signers(&block_with_pairs(&[]));+}++#[test]+fn an_unknown_pair_block_inside_a_pair_cannot_hide_readable_signers() {+ assert_nested_candidate_keeps_signers(&block_with_pairs(&[(0x2468_1357, vec![1, 2, 3, 4])]));+}++#[test]+fn an_unreadable_signature_pair_cannot_hide_readable_signers() {+ assert_nested_candidate_keeps_signers(&block_with_pairs(&[(apk_sign::V2_ID, vec![0; 4])]));+}++#[test]+fn a_framed_unknown_pair_spanning_the_original_directory_does_not_hide_signers() {+ let mut apk = signed_zip(&[("pad", &[0; 64])]);+ let original = apk_sign::parse(&apk).unwrap();+ let len = apk.len();+ let start = 30 + "pad".len();+ let size = (len + 16 - start) as u64;+ apk[start..start + 8].copy_from_slice(&size.to_le_bytes());+ apk[start + 8..start + 16].copy_from_slice(&((len - start - 16) as u64).to_le_bytes());+ apk[start + 16..start + 20].copy_from_slice(&0x1357_2468u32.to_le_bytes());+ apk[len - 2..].copy_from_slice(&46u16.to_le_bytes());+ apk.extend_from_slice(&size.to_le_bytes());+ apk.extend_from_slice(b"APK Sig Block 42");+ apk.extend_from_slice(&empty_eocd(len + 24, 0));++ assert_eq!(apk_sign::parse(&apk).unwrap(), original);+}++#[test]+fn different_readable_signing_blocks_report_ambiguous_metadata() {+ use craft_anything_testkit::android;+ let mut apk = notes_apk();+ let original = apk_sign::parse(&apk).unwrap();+ let eocd = apk.len() - 22;+ let other = android::signing_block(&android::certificate_der("Other Signer", "Craft Org"));+ let mut comment = other;+ comment.extend_from_slice(&empty_eocd(apk.len() + comment.len(), 0));+ apk[eocd + 20..eocd + 22].copy_from_slice(&(comment.len() as u16).to_le_bytes());+ apk.extend_from_slice(&comment);++ let found = apk_sign::parse(&apk).unwrap();+ assert_eq!((found.offset, found.size), (original.offset, original.size));+ assert_eq!(found.entries, original.entries);+ assert_eq!(found.signers, original.signers);+ assert!(found.warnings.iter().any(|warning| warning.contains("signing metadata is ambiguous")));+}++#[test]+fn a_single_empty_signing_block_remains_readable() {+ let apk = craft_anything_testkit::android::with_signing_block(&craft_anything_testkit::electron::zip_stored(&[]), &block_with_pairs(&[]));+ let found = apk_sign::parse(&apk).unwrap();+ assert_eq!((found.offset, found.size), (0, 24));+ assert!(found.entries.is_empty());+ assert!(found.signers.is_empty());+ assert!(found.warnings.is_empty());+}++#[test]+fn comment_candidates_cannot_spend_the_genuine_directory_budget_repeatedly() {+ let names: Vec<_> = (0..32).map(|index| format!("entry-{index}")).collect();+ let entries: Vec<_> = names.iter().map(|name| (name.as_str(), b"x".as_slice())).collect();+ let mut apk = signed_zip(&entries);+ let original = apk_sign::parse(&apk).unwrap();+ assert_eq!(original.signers.len(), 2);+ let eocd = apk.len() - 22;+ let cd = u32::from_le_bytes(apk[eocd + 16..eocd + 20].try_into().unwrap()) as usize;+ let count = u16::from_le_bytes(apk[eocd + 10..eocd + 12].try_into().unwrap());+ let candidates = usize::from(u16::MAX) / 22;+ let comment_len = candidates * 22;+ let mut fake = apk[eocd..].to_vec();+ fake[8..10].copy_from_slice(&(count + 1).to_le_bytes());+ fake[10..12].copy_from_slice(&(count + 1).to_le_bytes());+ apk[eocd + 20..eocd + 22].copy_from_slice(&u16::try_from(comment_len).unwrap().to_le_bytes());+ for index in 0..candidates {+ fake[12..16].copy_from_slice(&u32::try_from(apk.len() - cd).unwrap().to_le_bytes());+ fake[20..22].copy_from_slice(&u16::try_from(comment_len - (index + 1) * 22).unwrap().to_le_bytes());+ apk.extend_from_slice(&fake);+ }+ // Every fake reaches the same real headers, then fails on the genuine EOCD. Rewalking+ // that prefix for each comment candidate would spend the entire scan-wide allowance.+ assert!(candidates * (usize::from(count) + 1) > apk.len() / 46 + 22 + usize::from(u16::MAX));+ assert_eq!(apk_sign::parse(&apk).expect("comment candidates must reuse directory boundaries"), original);+}++#[test]+fn framed_comment_candidates_reuse_signer_probes_before_the_genuine_eocd() {+ const CANDIDATES: usize = 300;+ let mut apk = notes_apk();+ let original = apk_sign::parse(&apk).unwrap();+ assert_eq!(original.signers.len(), 2);+ let shared_start = apk.len();++ // Put a readable signer last: its sequence contains one signer with an empty signed-data field.+ let mut pairs = vec![(0x1357_2468, Vec::new()); 255];+ pairs.push((apk_sign::V2_ID, vec![8, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0]));+ let block = block_with_pairs(&pairs);+ apk.extend_from_slice(&block[..block.len() - 24]);+ for index in 0..CANDIDATES {+ // Each footer points back to the same 256 physical pairs. Its empty directory meets+ // its EOCD exactly; the remaining footer/EOCD pairs constitute its ZIP comment.+ let size = (apk.len() - shared_start + 16) as u64;+ apk.extend_from_slice(&size.to_le_bytes());+ apk.extend_from_slice(b"APK Sig Block 42");+ let directory = apk.len();+ apk.extend_from_slice(&empty_eocd(directory, (CANDIDATES - index - 1) * (24 + 22)));+ }+ let comment_len = u16::try_from(apk.len() - shared_start).unwrap();+ apk[shared_start - 2..shared_start].copy_from_slice(&comment_len.to_le_bytes());+ assert!(CANDIDATES * pairs.len() > apk.len() / 46 + 22 + usize::from(u16::MAX));++ let found = apk_sign::parse(&apk).expect("repeated probes must leave enough work to read the genuine block");+ assert_eq!((found.offset, found.size), (original.offset, original.size));+ assert_eq!(found.signers, original.signers);+ // The warning proves a comment candidate reached a readable signer, rather than failing directory framing.+ assert!(found.warnings.iter().any(|warning| warning.contains("signing metadata is ambiguous")));+}diff --git a/crates/formats/tests/codesign_superblob_length_boundary.rs b/crates/formats/tests/codesign_superblob_length_boundary.rsnew file mode 100644index 00000000..b9f89704--- /dev/null+++ b/crates/formats/tests/codesign_superblob_length_boundary.rs@@ -0,0 +1,39 @@+use craft_anything_formats::codesign;+use craft_anything_testkit::apple;++#[test]+fn a_blob_outside_the_declared_signature_cannot_supply_cms_data() {+ let mut data = Vec::new();+ for value in [0xfade_0cc0u32, 20, 1, 0x10000, 20, 0xfade_0b01, 9] {+ data.extend_from_slice(&value.to_be_bytes());+ }+ data.push(1);++ let signature = codesign::parse(&data).unwrap();+ assert_eq!(signature.cms_signature_bytes, None);+ assert!(signature.ad_hoc);+ assert!(!signature.warnings.is_empty());++ let length = data.len() as u32;+ data[4..8].copy_from_slice(&length.to_be_bytes());+ let complete = codesign::parse(&data).unwrap();+ assert_eq!(complete.cms_signature_bytes, Some(1));+ assert!(!complete.ad_hoc);+}++#[test]+fn the_blob_index_must_fit_within_the_declared_signature() {+ let mut data = apple::code_signature_blob();+ data[4..8].copy_from_slice(&12u32.to_be_bytes());+ let signature = codesign::parse(&data).unwrap();+ assert!(signature.blobs.is_empty());+ assert!(signature.code_directories.is_empty());+ assert!(!signature.warnings.is_empty());+}++#[test]+fn a_signature_length_smaller_than_its_header_is_rejected() {+ let mut data = apple::code_signature_blob();+ data[4..8].copy_from_slice(&8u32.to_be_bytes());+ assert!(codesign::parse(&data).is_err());+}diff --git a/crates/formats/tests/dns_question_class.rs b/crates/formats/tests/dns_question_class.rsnew file mode 100644index 00000000..609fa9af--- /dev/null+++ b/crates/formats/tests/dns_question_class.rs@@ -0,0 +1,55 @@+use craft_anything_formats::pcap::{decode, summarize};+use craft_anything_testkit::pcap::{dns_query, eth, ipv4_pkt, pcap, udp};++fn packet(message: &[u8]) -> Vec<u8> {+ eth(0x0800, &ipv4_pkt(17, [192, 0, 2, 1], [192, 0, 2, 2], &udp(51000, 53, message)))+}++/// Neither a missing class nor a one-byte class can complete a DNS question.+#[test]+fn a_question_missing_any_class_byte_is_incomplete() {+ let complete = dns_query();+ for missing in [1, 2] {+ let message = &complete[..complete.len() - missing];+ let dns = decode(1, &packet(message)).dns.unwrap();+ assert!(dns.incomplete, "missing {missing} class bytes");+ assert!(dns.questions.is_empty(), "a question needs both type and class");+ }+}++#[test]+fn complete_questions_survive_before_a_truncated_question() {+ let mut message = dns_query();+ message[4..6].copy_from_slice(&2u16.to_be_bytes());+ message.extend([0xc0, 12, 0, 28, 0]); // compressed name, AAAA, one class byte++ let dns = decode(1, &packet(&message)).dns.unwrap();+ assert!(dns.incomplete);+ assert_eq!(dns.questions.len(), 1);+ assert_eq!(dns.questions[0].name, "example.com");+ assert_eq!(dns.questions[0].qtype, "A");+}++#[test]+fn incomplete_questions_do_not_enter_the_query_inventory() {+ let mut message = dns_query();+ message.pop();+ let summary = summarize(&pcap(&[packet(&message)]), &|| false).unwrap();+ assert_eq!(summary.packets, 1);+ assert!(summary.dns_queries.is_empty());+}++/// Class validation requires both bytes without restricting valid class values.+#[test]+fn complete_class_fields_are_accepted() {+ for class in [1u16, 3, 255] {+ let mut message = dns_query();+ message.truncate(message.len() - 2);+ message.extend(class.to_be_bytes());+ let dns = decode(1, &packet(&message)).dns.unwrap();+ assert!(!dns.incomplete);+ assert_eq!(dns.questions.len(), 1);+ assert_eq!(dns.questions[0].name, "example.com");+ assert_eq!(dns.questions[0].qtype, "A");+ }+}diff --git a/crates/formats/tests/dns_rdata_names.rs b/crates/formats/tests/dns_rdata_names.rsnew file mode 100644index 00000000..88b7315b--- /dev/null+++ b/crates/formats/tests/dns_rdata_names.rs@@ -0,0 +1,184 @@+use craft_anything_formats::pcap::{decode, summarize};+use craft_anything_testkit::pcap::{dns_query, eth, ipv4_pkt, pcap, udp};++fn response(record_type: u16, rdata: &[u8], declared_length: usize) -> Vec<u8> {+ let mut message = dns_query();+ message[2..4].copy_from_slice(&0x8180u16.to_be_bytes());+ message[6..8].copy_from_slice(&1u16.to_be_bytes());+ message.extend([0xc0, 12]); // owner points to the question's name+ message.extend(record_type.to_be_bytes());+ message.extend(1u16.to_be_bytes());+ message.extend(60u32.to_be_bytes());+ message.extend((declared_length as u16).to_be_bytes());+ message.extend(rdata);+ message+}++fn packet(message: &[u8]) -> Vec<u8> {+ eth(0x0800, &ipv4_pkt(17, [192, 0, 2, 2], [192, 0, 2, 1], &udp(53, 51000, message)))+}++/// Truncated literal names and compression pointers must stay inside RDLENGTH.+#[test]+fn answer_names_cannot_borrow_bytes_past_rdata() {+ for record_type in [2, 5, 12, 15] {+ for name in [b"\x04fake\x07example\x00".as_slice(), &[0xc0, 12]] {+ let mut rdata = if record_type == 15 { vec![0, 10] } else { Vec::new() };+ let prefix = rdata.len();+ rdata.extend(name);+ for declared in [prefix, prefix + name.len() - 1] {+ let dns = decode(1, &packet(&response(record_type, &rdata, declared))).dns.unwrap();+ assert!(dns.incomplete, "type {record_type}, declared length {declared}");+ assert!(dns.answers.is_empty(), "a name must be wholly encoded in its record");+ }+ }+ }+}++/// An incomplete pointer is malformed, rather than a successful empty answer.+#[test]+fn malformed_name_rdata_is_not_reported_as_an_empty_answer() {+ for record_type in [2, 5, 12, 15] {+ let rdata = if record_type == 15 { vec![0, 10, 0xc0] } else { vec![0xc0] };+ let dns = decode(1, &packet(&response(record_type, &rdata, rdata.len()))).dns.unwrap();+ assert!(dns.incomplete);+ assert!(dns.answers.is_empty());+ }+}++/// An MX name cannot borrow either of its required preference bytes from trailing data.+#[test]+fn an_mx_exchange_cannot_skip_a_missing_preference() {+ for declared in [0, 1] {+ let dns = decode(1, &packet(&response(15, &[0, 10, 0xc0, 12], declared))).dns.unwrap();+ assert!(dns.incomplete);+ assert!(dns.answers.is_empty());+ }+}++/// A terminator before the declared boundary must not hide unused RDATA bytes.+#[test]+fn a_name_must_account_for_all_of_its_rdata() {+ for record_type in [2, 5, 12, 15] {+ let rdata = if record_type == 15 { vec![0, 10, 0, 0xaa] } else { vec![0, 0xaa] };+ let dns = decode(1, &packet(&response(record_type, &rdata, rdata.len()))).dns.unwrap();+ assert!(dns.incomplete);+ assert!(dns.answers.is_empty());+ }+}++/// Literal, root, backward-pointer and label-plus-pointer names remain valid controls.+#[test]+fn complete_and_compressed_names_remain_supported() {+ for record_type in [2, 5, 12, 15] {+ for (name, expected) in [+ (b"\x04mail\x07example\x00".as_slice(), "mail.example"),+ (&[0xc0, 12], "example.com"),+ (b"\x03www\xc0\x0c".as_slice(), "www.example.com"),+ (&[0], "."),+ ] {+ let mut rdata = if record_type == 15 { vec![0, 10] } else { Vec::new() };+ rdata.extend(name);+ let dns = decode(1, &packet(&response(record_type, &rdata, rdata.len()))).dns.unwrap();+ assert!(!dns.incomplete, "type {record_type}, name {expected}");+ assert_eq!(dns.answers.len(), 1);+ assert_eq!(dns.answers[0].value, expected);+ }+ }+}++#[test]+fn names_outside_rdata_do_not_enter_the_answer_inventory() {+ let message = response(5, b"\x04fake\x07example\x00", 0);+ let summary = summarize(&pcap(&[packet(&message)]), &|| false).unwrap();+ assert_eq!(summary.packets, 1);+ assert!(summary.dns_answers.is_empty());+}++#[test]+fn earlier_answers_survive_before_a_malformed_name() {+ let mut message = response(1, &[192, 0, 2, 3], 4);+ message[6..8].copy_from_slice(&2u16.to_be_bytes());+ let malformed = response(5, b"\x04fake\x07example\x00", 0);+ message.extend(&malformed[dns_query().len()..]);++ let dns = decode(1, &packet(&message)).dns.unwrap();+ assert!(dns.incomplete);+ assert_eq!(dns.answers.len(), 1);+ assert_eq!(dns.answers[0].rtype, "A");+ assert_eq!(dns.answers[0].value, "192.0.2.3");+}++fn prerequisite_message(flags: u16, record_type: u16, class: u16, ttl: u32, rdata: &[u8]) -> Vec<u8> {+ let mut message = vec![0, 1];+ message.extend(flags.to_be_bytes());+ message.extend([0, 1, 0, 2, 0, 0, 0, 0]);+ message.extend(b"\x07example\x04test\0");+ message.extend([0, 6, 0, 1]); // One Zone record, SOA/IN.+ message.extend(b"\x05first\xc0\x0c");+ message.extend(record_type.to_be_bytes());+ message.extend(class.to_be_bytes());+ message.extend(ttl.to_be_bytes());+ message.extend((rdata.len() as u16).to_be_bytes());+ message.extend(rdata);+ // A different owner lets this value-dependent prerequisite coexist with CLASS NONE above.+ message.extend(b"\x05after\xc0\x0c");+ message.extend([0, 1, 0, 1, 0, 0, 0, 0, 0, 4, 192, 0, 2, 4]);+ message+}++#[test]+fn empty_update_name_prerequisites_preserve_the_following_record() {+ for record_type in [2, 5, 12, 15] {+ for class in [254, 255] {+ let dns = decode(1, &packet(&prerequisite_message(0x2800, record_type, class, 0, &[]))).dns.unwrap();+ assert!(!dns.incomplete, "type {record_type}, class {class}");+ assert_eq!(dns.answers.len(), 2);+ assert_eq!(dns.answers[0].value, "");+ assert_eq!(dns.answers[1].name, "after.example.test");+ assert_eq!(dns.answers[1].value, "192.0.2.4");+ }+ }+}++#[test]+fn empty_name_rdata_is_rejected_outside_legal_update_prerequisites() {+ let cases = [(0x8180, 254, 0), (0x8180, 255, 0), (0x2000, 254, 0), (0x2000, 255, 0), (0x2800, 1, 0), (0x2800, 254, 1), (0x2800, 255, 1)];+ for record_type in [2, 5, 12, 15] {+ for (flags, class, ttl) in cases {+ let dns = decode(1, &packet(&prerequisite_message(flags, record_type, class, ttl, &[]))).dns.unwrap();+ assert!(dns.incomplete, "type {record_type}, flags {flags:#x}, class {class}, TTL {ttl}");+ assert!(dns.answers.is_empty());+ }+ }+}++#[test]+fn update_name_rdata_still_requires_complete_exact_encoding() {+ for record_type in [2, 5, 12, 15] {+ for class in [1, 254, 255] {+ for name in [&[0xc0][..], &[0, 0xaa]] {+ let mut rdata = if record_type == 15 { vec![0, 10] } else { Vec::new() };+ rdata.extend(name);+ let dns = decode(1, &packet(&prerequisite_message(0x2800, record_type, class, 0, &rdata))).dns.unwrap();+ assert!(dns.incomplete, "type {record_type}, class {class}, name {name:?}");+ assert!(dns.answers.is_empty());+ }+ }+ }+}++#[test]+fn value_dependent_update_name_prerequisites_keep_their_values() {+ for record_type in [2, 5, 12, 15] {+ for (name, expected) in [(&[0][..], "."), (&[0xc0, 12], "example.test")] {+ let mut rdata = if record_type == 15 { vec![0, 0] } else { Vec::new() };+ rdata.extend(name);+ let dns = decode(1, &packet(&prerequisite_message(0x2800, record_type, 1, 0, &rdata))).dns.unwrap();+ assert!(!dns.incomplete, "type {record_type}, name {expected}");+ assert_eq!(dns.answers.len(), 2);+ assert_eq!(dns.answers[0].value, expected);+ assert_eq!(dns.answers[1].value, "192.0.2.4");+ }+ }+}diff --git a/crates/formats/tests/dos_relocation_header_boundary.rs b/crates/formats/tests/dos_relocation_header_boundary.rsnew file mode 100644index 00000000..c84a5d0a--- /dev/null+++ b/crates/formats/tests/dos_relocation_header_boundary.rs@@ -0,0 +1,36 @@+use craft_anything_formats::dos;+use craft_anything_testkit::dos_mz;++#[test]+fn relocation_records_cannot_extend_into_the_load_module() {+ let mut data = dos_mz();+ data[8..10].copy_from_slice(&2u16.to_le_bytes());+ let parsed = dos::parse_mz(&data).unwrap();+ assert_eq!(parsed.header_bytes, 32);+ assert_eq!(parsed.relocations.len(), 1);+ assert_eq!(parsed.relocations[0].offset, 3);+ assert!(!parsed.problems.is_empty());+}++#[test]+fn a_partial_relocation_does_not_borrow_the_module_start() {+ let mut data = dos_mz();+ data[6..8].copy_from_slice(&1u16.to_le_bytes());+ data[8..10].copy_from_slice(&2u16.to_le_bytes());+ data[24..26].copy_from_slice(&30u16.to_le_bytes());+ let parsed = dos::parse_mz(&data).unwrap();+ assert!(parsed.relocations.is_empty());+ assert!(!parsed.problems.is_empty());+}++#[test]+fn relocation_records_ending_at_the_header_boundary_are_preserved() {+ let original = dos::parse_mz(&dos_mz()).unwrap();+ assert_eq!(original.relocations.len(), 2);+ let mut data = dos_mz();+ data[6..8].copy_from_slice(&1u16.to_le_bytes());+ data[8..10].copy_from_slice(&2u16.to_le_bytes());+ let parsed = dos::parse_mz(&data).unwrap();+ assert_eq!(parsed.relocations.len(), 1);+ assert_eq!(parsed.relocations[0], original.relocations[0]);+}diff --git a/crates/formats/tests/dotnet_user_string_surrogate_limit.rs b/crates/formats/tests/dotnet_user_string_surrogate_limit.rsnew file mode 100644index 00000000..b6def8c6--- /dev/null+++ b/crates/formats/tests/dotnet_user_string_surrogate_limit.rs@@ -0,0 +1,43 @@+use craft_anything_formats::dotnet::meta::Metadata;++fn metadata_with_user_string(units: &[u16]) -> Vec<u8> {+ let mut heap = vec![0, (units.len() * 2 + 1) as u8];+ for unit in units {+ heap.extend_from_slice(&unit.to_le_bytes());+ }+ heap.push(0);+ let mut data = vec![0; 72];+ data[..4].copy_from_slice(b"BSJB");+ data[4..6].copy_from_slice(&1u16.to_le_bytes());+ data[12..16].copy_from_slice(&4u32.to_le_bytes());+ data[16..19].copy_from_slice(b"v4\0");+ data[22..24].copy_from_slice(&2u16.to_le_bytes());+ data[24..28].copy_from_slice(&48u32.to_le_bytes());+ data[28..32].copy_from_slice(&24u32.to_le_bytes());+ data[32..35].copy_from_slice(b"#~\0");+ data[36..40].copy_from_slice(&72u32.to_le_bytes());+ data[40..44].copy_from_slice(&(heap.len() as u32).to_le_bytes());+ data[44..48].copy_from_slice(b"#US\0");+ data.extend_from_slice(&heap);+ data+}++#[test]+fn the_character_limit_preserves_complete_surrogate_pairs() {+ let units: Vec<u16> = "\u{1f600}A\u{1f642}".encode_utf16().collect();+ let data = metadata_with_user_string(&units);+ let metadata = Metadata::parse(&data).unwrap();+ assert_eq!(metadata.user_string(1, 1).as_deref(), Some("\u{1f600}"));+ assert_eq!(metadata.user_string(1, 2).as_deref(), Some("\u{1f600}A"));+ assert_eq!(metadata.user_string(1, 3).as_deref(), Some("\u{1f600}A\u{1f642}"));+ assert_eq!(metadata.user_string(1, 0).as_deref(), Some(""));+}++#[test]+fn unpaired_surrogates_still_decode_lossily_without_consuming_the_next_character() {+ let data = metadata_with_user_string(&[0xd800, 0x0041, 0xdc00]);+ let metadata = Metadata::parse(&data).unwrap();+ assert_eq!(metadata.user_string(1, 1).as_deref(), Some("\u{fffd}"));+ assert_eq!(metadata.user_string(1, 2).as_deref(), Some("\u{fffd}A"));+ assert_eq!(metadata.user_string(1, 3).as_deref(), Some("\u{fffd}A\u{fffd}"));+}diff --git a/crates/formats/tests/elf_core_file_name_count_cap.rs b/crates/formats/tests/elf_core_file_name_count_cap.rsnew file mode 100644index 00000000..04e24c62--- /dev/null+++ b/crates/formats/tests/elf_core_file_name_count_cap.rs@@ -0,0 +1,56 @@+use craft_anything_formats::elf;+use craft_anything_testkit::elf64_core;++fn core_with_files(declared: u64, rows: usize) -> Vec<u8> {+ let mut desc = Vec::new();+ desc.extend_from_slice(&declared.to_le_bytes());+ desc.extend_from_slice(&4096u64.to_le_bytes());+ for row in 0..rows {+ let start = (row as u64 + 1) * 4096;+ desc.extend_from_slice(&start.to_le_bytes());+ desc.extend_from_slice(&(start + 4096).to_le_bytes());+ desc.extend_from_slice(&0u64.to_le_bytes());+ }+ for _ in 0..rows {+ desc.extend_from_slice(b"/sample\0");+ }+ let mut note = Vec::new();+ note.extend_from_slice(&5u32.to_le_bytes());+ note.extend_from_slice(&(desc.len() as u32).to_le_bytes());+ note.extend_from_slice(&0x4649_4c45u32.to_le_bytes());+ note.extend_from_slice(b"CORE\0\0\0\0");+ note.extend_from_slice(&desc);+ let mut core = elf64_core(0, 0);+ let offset = core.len() as u64;+ core[0x48..0x50].copy_from_slice(&offset.to_le_bytes());+ core[0x60..0x68].copy_from_slice(&(note.len() as u64).to_le_bytes());+ core[0x68..0x70].copy_from_slice(&(note.len() as u64).to_le_bytes());+ core.extend_from_slice(¬e);+ core+}++#[test]+fn capping_mappings_does_not_move_the_filename_table() {+ let count = 65_537;+ let core = elf::parse_core(&core_with_files(count as u64, count)).unwrap();+ assert_eq!(core.mapped_files.len(), 65_536);+ assert!(core.mapped_files.iter().all(|mapping| mapping.path == "/sample"));+ assert_eq!(core.mapped_files[0].start, 4096);+ assert_eq!(core.mapped_files[65_535].start, 65_536 * 4096);+}++#[test]+fn an_impossible_declared_table_cannot_supply_filename_bytes() {+ let core = elf::parse_core(&core_with_files(u64::MAX, 1)).unwrap();+ assert!(core.mapped_files.is_empty());+ assert!(core.warnings.iter().any(|warning| warning.contains("NT_FILE")));+}++#[test]+fn a_small_complete_mapping_table_is_unchanged() {+ let core = elf::parse_core(&core_with_files(2, 2)).unwrap();+ assert_eq!(core.mapped_files.len(), 2);+ assert_eq!(core.mapped_files[0].path, "/sample");+ assert_eq!(core.mapped_files[1].path, "/sample");+ assert_eq!(core.mapped_files[1].start, 8192);+}diff --git a/crates/formats/tests/iostore_complete_header.rs b/crates/formats/tests/iostore_complete_header.rsnew file mode 100644index 00000000..7a89a5e8--- /dev/null+++ b/crates/formats/tests/iostore_complete_header.rs@@ -0,0 +1,19 @@+use craft_anything_formats::{FormatError, unreal_iostore};++#[test]+fn all_reserved_header_bytes_must_be_present() {+ let fixture = craft_anything_testkit::games::unreal_utoc(9, u32::MAX);+ for len in 0..unreal_iostore::HEADER_SIZE {+ assert!(matches!(unreal_iostore::header(&fixture[..len]), Err(FormatError::Truncated(_))), "a {len}-byte header is incomplete");+ }+}++#[test]+fn complete_headers_read_for_each_supported_version() {+ let mut fixture = craft_anything_testkit::games::unreal_utoc(9, u32::MAX);+ for version in 1..=unreal_iostore::MAX_VERSION {+ fixture[16] = version;+ let h = unreal_iostore::header(&fixture[..unreal_iostore::HEADER_SIZE]).unwrap();+ assert_eq!((h.version, h.chunk_count, h.block_count, h.block_size), (version, 3, 4, 65536));+ }+}diff --git a/crates/formats/tests/iostore_unaligned_chunk_blocks.rs b/crates/formats/tests/iostore_unaligned_chunk_blocks.rsnew file mode 100644index 00000000..1b8c0878--- /dev/null+++ b/crates/formats/tests/iostore_unaligned_chunk_blocks.rs@@ -0,0 +1,28 @@+use craft_anything_formats::unreal_iostore;++fn file_for_chunk(offset: u64, length: u64) -> unreal_iostore::File {+ let mut toc = unreal_iostore::toc(&craft_anything_testkit::games::unreal_utoc(9, u32::MAX)).unwrap();+ toc.chunks[0] = (offset, length);+ for (i, block) in toc.blocks.iter_mut().enumerate() {+ block.compressed_size = 10 * (i as u32 + 1);+ block.method = u8::from(i != 0);+ }+ unreal_iostore::files(&toc, 10).unwrap().1.into_iter().find(|file| file.chunk == 0).unwrap()+}++#[test]+fn unaligned_chunks_count_every_block_their_bytes_touch() {+ for (offset, length, stored) in [(65535, 2, 30), (1, 65536, 30), (65535, 65538, 60), (65537, 65536, 50)] {+ let file = file_for_chunk(offset, length);+ assert_eq!((file.size, file.stored_size), (length, stored), "offset {offset}, length {length}");+ assert_eq!(file.compression, if offset < 65536 { "none" } else { "Oodle" });+ }+}++#[test]+fn aligned_empty_and_exact_boundary_chunks_keep_their_sizes() {+ for (offset, length, stored) in [(0, 65536, 10), (65536, 65536, 20), (65535, 1, 10), (1, 65535, 10), (65535, 0, 0)] {+ let file = file_for_chunk(offset, length);+ assert_eq!((file.size, file.stored_size), (length, stored), "offset {offset}, length {length}");+ }+}diff --git a/crates/formats/tests/macho_function_starts_payload_boundary.rs b/crates/formats/tests/macho_function_starts_payload_boundary.rsnew file mode 100644index 00000000..de05cfc2--- /dev/null+++ b/crates/formats/tests/macho_function_starts_payload_boundary.rs@@ -0,0 +1,56 @@+use craft_anything_formats::binary::{Arch, Binary};+use craft_anything_formats::macho;++fn function_starts(payload: &[u8], following: &[u8], base: u64) -> Binary {+ let mut data = vec![0; 120];+ data[..4].copy_from_slice(&0xfeed_facfu32.to_le_bytes());+ data[16..20].copy_from_slice(&2u32.to_le_bytes());+ data[20..24].copy_from_slice(&88u32.to_le_bytes());+ data[32..36].copy_from_slice(&0x19u32.to_le_bytes());+ data[36..40].copy_from_slice(&72u32.to_le_bytes());+ data[40..46].copy_from_slice(b"__TEXT");+ data[56..64].copy_from_slice(&base.to_le_bytes());+ data[104..108].copy_from_slice(&0x26u32.to_le_bytes());+ data[108..112].copy_from_slice(&16u32.to_le_bytes());+ data[112..116].copy_from_slice(&120u32.to_le_bytes());+ data[116..120].copy_from_slice(&(payload.len() as u32).to_le_bytes());+ data.extend_from_slice(payload);+ data.extend_from_slice(following);+ let mut binary = Binary::raw(Arch::X86_64, 0, 0, 0);+ macho::enrich(&data, &mut binary);+ binary+}++#[test]+fn a_function_delta_cannot_finish_in_adjacent_payload_bytes() {+ let binary = function_starts(&[0x80], &[0x01], 0x1000);+ assert!(binary.function_starts.is_empty());+ assert!(!binary.warnings.is_empty());+}++#[test]+fn complete_deltas_before_a_cut_off_one_are_preserved() {+ let binary = function_starts(&[4, 0x80], &[0x01], 0x1000);+ assert_eq!(binary.function_starts, [0x1004]);+}++#[test]+fn function_addresses_do_not_wrap_on_overflow() {+ let binary = function_starts(&[5, 0], &[], u64::MAX - 4);+ assert!(binary.function_starts.is_empty());+ assert!(!binary.warnings.is_empty());+}++#[test]+fn complete_starts_before_an_overflowing_delta_are_preserved() {+ let binary = function_starts(&[4, 1, 0], &[], u64::MAX - 4);+ assert_eq!(binary.function_starts, [u64::MAX]);+ assert!(!binary.warnings.is_empty());+}++#[test]+fn complete_multibyte_deltas_and_the_terminator_are_preserved() {+ let binary = function_starts(&[0x80, 0x01, 0x10, 0], &[0x7f], 0x1000);+ assert_eq!(binary.function_starts, [0x1080, 0x1090]);+ assert!(binary.warnings.is_empty());+}diff --git a/crates/formats/tests/macho_load_command_framing.rs b/crates/formats/tests/macho_load_command_framing.rsnew file mode 100644index 00000000..1caf7e4f--- /dev/null+++ b/crates/formats/tests/macho_load_command_framing.rs@@ -0,0 +1,93 @@+use craft_anything_formats::binary::{Arch, Binary};+use craft_anything_formats::{macho, macho_deps};+use craft_anything_testkit::apple;++fn enriched(data: &[u8]) -> Binary {+ let mut binary = Binary::raw(Arch::X86_64, 0, 0, 0);+ macho::enrich(data, &mut binary);+ binary+}++#[test]+fn a_short_command_cannot_borrow_fields_from_the_next_command() {+ let mut short = apple::lc_build_version();+ short.truncate(8);+ short[4..8].copy_from_slice(&8u32.to_le_bytes());+ let data = apple::macho_min(apple::CPU_X86_64, 2, &[short, apple::lc_uuid()], &[]);+ let dependencies = macho_deps::parse_thin(&data).unwrap();+ assert!(dependencies.build_versions.is_empty());+ assert!(dependencies.uuid.is_some(), "a later complete command remains readable");+ assert!(!dependencies.warnings.is_empty());+ let binary = enriched(&data);+ assert!(!binary.info.contains_key("platform"));+ assert!(!binary.warnings.is_empty());+}++#[test]+fn commands_must_fit_in_sizeofcmds_even_when_the_file_has_more_bytes() {+ for size in [0u32, 4, 24] {+ let mut data = apple::macho_min(apple::CPU_X86_64, 2, &[apple::lc_build_version()], &[]);+ data[20..24].copy_from_slice(&size.to_le_bytes());+ assert!(macho_deps::parse_thin(&data).unwrap().build_versions.is_empty(), "size={size}");+ assert!(!enriched(&data).info.contains_key("platform"), "size={size}");+ }+}++#[test]+fn build_tools_cannot_be_read_from_the_next_command() {+ let mut build = apple::lc_build_version();+ build.truncate(24);+ build[4..8].copy_from_slice(&24u32.to_le_bytes());+ let data = apple::macho_min(apple::CPU_X86_64, 2, &[build, apple::lc_uuid()], &[]);+ let dependencies = macho_deps::parse_thin(&data).unwrap();+ assert_eq!(dependencies.build_versions.len(), 1);+ assert_eq!(dependencies.build_versions[0].platform, "macos");+ assert!(dependencies.build_versions[0].tools.is_empty());+ assert!(dependencies.uuid.is_some());+}++/// One complete section header followed by a build command, with two sections declared.+fn segment_with_an_incomplete_section_array() -> Vec<u8> {+ let mut data = apple::macho_min(apple::CPU_X86_64, 2, &[apple::lc_build_version()], &[("__text", &[0; 4])]);+ data[32 + 64..32 + 68].copy_from_slice(&2u32.to_le_bytes());+ data+}++#[test]+fn dependency_sections_cannot_be_read_from_the_next_command() {+ let parsed = macho_deps::parse_thin(&segment_with_an_incomplete_section_array()).unwrap();+ assert_eq!(parsed.sections.len(), 1);+ assert_eq!(parsed.sections[0].sectname, "__text");+ assert!(parsed.warnings.iter().any(|warning| warning.contains("section headers are cut short")));+ assert_eq!(parsed.build_versions.len(), 1, "a later complete command remains readable");+ assert_eq!(parsed.build_versions[0].platform, "macos");+ assert_eq!(parsed.build_versions[0].tools, ["ld 907.0.0"]);+}++#[test]+fn enriched_sections_cannot_be_read_from_the_next_command() {+ let binary = enriched(&segment_with_an_incomplete_section_array());+ let sections = binary.details["sections"].as_array().unwrap();+ assert_eq!(sections.len(), 1);+ assert_eq!(sections[0]["name"], "__text");+ assert!(binary.warnings.iter().any(|warning| warning.contains("section headers run past the load command")));+ assert_eq!(binary.info.get("platform").map(String::as_str), Some("macos"), "a later complete command remains readable");+}++#[test]+fn complete_build_commands_are_read_in_both_byte_orders() {+ let data = apple::macho_min(apple::CPU_X86_64, 2, &[apple::lc_build_version()], &[]);+ assert_eq!(enriched(&data).info.get("platform").map(String::as_str), Some("macos"));+ for big in [false, true] {+ let mut bytes = data.clone();+ if big {+ for word in bytes.as_chunks_mut::<4>().0 {+ word.reverse();+ }+ }+ let parsed = macho_deps::parse_thin(&bytes).unwrap();+ assert_eq!(parsed.build_versions[0].platform, "macos");+ assert_eq!(parsed.build_versions[0].tools, ["ld 907.0.0"]);+ assert!(parsed.warnings.is_empty());+ }+}diff --git a/crates/formats/tests/pcap_dns_name_limit.rs b/crates/formats/tests/pcap_dns_name_limit.rsnew file mode 100644index 00000000..f16c8938--- /dev/null+++ b/crates/formats/tests/pcap_dns_name_limit.rs@@ -0,0 +1,151 @@+use craft_anything_formats::pcap::{Dns, decode};+use craft_anything_testkit::pcap::{ipv4_pkt, udp};++fn query(last: usize, compressed: bool) -> Dns {+ let mut msg = vec![0, 1, 1, 0, 0, if compressed { 2 } else { 1 }, 0, 0, 0, 0, 0, 0];+ for len in [63, 63, 63, last] {+ msg.push(len as u8);+ msg.extend(vec![b'a'; len]);+ }+ msg.extend([0, 0, 1, 0, 1]);+ if compressed {+ msg.extend([0xc0, 12, 0, 1, 0, 1]);+ }+ decode(101, &ipv4_pkt(17, [1; 4], [2; 4], &udp(100, 53, &msg))).dns.unwrap()+}++#[test]+fn label_lengths_and_the_root_octet_count_towards_the_dns_limit() {+ for last in [62, 63] {+ let dns = query(last, false);+ assert!(dns.incomplete);+ assert!(dns.questions.is_empty());+ }+}++#[test]+fn a_255_octet_name_is_valid_in_plain_and_compressed_form() {+ for compressed in [false, true] {+ let dns = query(61, compressed);+ assert!(!dns.incomplete);+ assert_eq!(dns.questions.len(), if compressed { 2 } else { 1 });+ assert_eq!(dns.questions[0].name.len(), 253);+ }+}++fn prefixed_pointer(last: usize, answer_type: Option<u16>) -> Dns {+ let mut msg = vec![0, 1, 0x81, 0x80, 0, if answer_type.is_some() { 1 } else { 2 }, 0, u8::from(answer_type.is_some()), 0, 0, 0, 0];+ for len in [63, 63, 63, last] {+ msg.push(len as u8);+ msg.extend(vec![b'a'; len]);+ }+ msg.extend([0, 0, 1, 0, 1]);+ if let Some(rtype) = answer_type {+ msg.extend([0xc0, 12]);+ msg.extend(rtype.to_be_bytes());+ msg.extend([0, 1, 0, 0, 0, 0, 0, if rtype == 15 { 6 } else { 4 }]);+ if rtype == 15 {+ msg.extend([0, 10]);+ }+ }+ msg.extend([1, b'x', 0xc0, 12]);+ if answer_type.is_none() {+ msg.extend([0, 1, 0, 1]);+ }+ decode(101, &ipv4_pkt(17, [1; 4], [2; 4], &udp(100, 53, &msg))).dns.unwrap()+}++#[test]+fn a_literal_prefix_and_pointer_cannot_exceed_the_question_name_limit() {+ let dns = prefixed_pointer(61, None);+ assert!(dns.incomplete);+ assert_eq!(dns.questions.len(), 1);+}++#[test]+fn invalid_name_rdata_is_incomplete_instead_of_an_empty_answer() {+ for rtype in [2, 5, 12, 15] {+ let dns = prefixed_pointer(61, Some(rtype));+ assert!(dns.incomplete, "record type {rtype}");+ assert_eq!(dns.questions.len(), 1);+ assert!(dns.answers.is_empty(), "record type {rtype}");+ }+}++#[test]+fn a_prefixed_pointer_at_255_octets_remains_valid() {+ let dns = prefixed_pointer(59, None);+ assert!(!dns.incomplete);+ assert_eq!(dns.questions.len(), 2);+ for rtype in [2, 5, 12, 15] {+ let dns = prefixed_pointer(59, Some(rtype));+ assert!(!dns.incomplete, "record type {rtype}");+ assert_eq!(dns.answers.len(), 1);+ assert_eq!(dns.answers[0].value.len(), 253);+ }+}++fn name_rdata_then_a(flags: u16, class: u16, ttl: u32, rtype: u16, rdata: &[u8]) -> Dns {+ let mut msg = vec![0, 1];+ msg.extend(flags.to_be_bytes());+ msg.extend([0, 1, 0, 2, 0, 0, 0, 0]);+ msg.extend(b"\x07example\x04test\0");+ msg.extend([0, 6, 0, 1]); // Zone: SOA/IN for UPDATE requests.+ msg.extend([3, b'o', b'n', b'e', 0xc0, 12]);+ msg.extend(rtype.to_be_bytes());+ msg.extend(class.to_be_bytes());+ msg.extend(ttl.to_be_bytes());+ msg.extend((rdata.len() as u16).to_be_bytes());+ msg.extend(rdata);+ // A different owner keeps the two UPDATE prerequisites independent.+ msg.extend([4, b'n', b'e', b'x', b't', 0xc0, 12, 0, 1, 0, 1, 0, 0, 0, 0, 0, 4, 203, 0, 113, 1]);+ decode(101, &ipv4_pkt(17, [1; 4], [2; 4], &udp(100, 53, &msg))).dns.unwrap()+}++#[test]+fn empty_update_name_prerequisites_preserve_the_following_record() {+ for rtype in [2, 5, 12, 15] {+ for class in [254, 255] {+ let dns = name_rdata_then_a(0x2800, class, 0, rtype, &[]);+ assert!(!dns.incomplete, "type {rtype}, class {class}");+ assert_eq!(dns.answers.len(), 2);+ assert_eq!(dns.answers[0].value, "");+ assert_eq!(dns.answers[1].value, "203.0.113.1");+ }+ }+}++#[test]+fn empty_name_rdata_is_rejected_outside_legal_update_prerequisites() {+ let cases = [(0x8180, 254, 0), (0x8180, 255, 0), (0x2000, 254, 0), (0x2000, 255, 0), (0x2800, 1, 0), (0x2800, 254, 1), (0x2800, 255, 1)];+ for rtype in [2, 5, 12, 15] {+ for (flags, class, ttl) in cases {+ let dns = name_rdata_then_a(flags, class, ttl, rtype, &[]);+ assert!(dns.incomplete, "type {rtype}, flags {flags:#x}, class {class}, TTL {ttl}");+ assert!(dns.answers.is_empty());+ }+ }+}++#[test]+fn a_cut_rdata_pointer_cannot_borrow_the_following_owner() {+ for rtype in [2, 5, 12, 15] {+ let mut rdata = if rtype == 15 { vec![0, 10] } else { Vec::new() };+ rdata.push(0xc0); // The next owner's length would complete a pointer to the header's zero byte.+ let dns = name_rdata_then_a(0x8180, 1, 0, rtype, &rdata);+ assert!(dns.incomplete, "type {rtype}");+ assert!(dns.answers.is_empty());+ }+}++#[test]+fn root_name_rdata_remains_valid() {+ for rtype in [2, 5, 12, 15] {+ let rdata = if rtype == 15 { vec![0, 0, 0] } else { vec![0] };+ let dns = name_rdata_then_a(0x8180, 1, 0, rtype, &rdata);+ assert!(!dns.incomplete, "type {rtype}");+ assert_eq!(dns.answers.len(), 2);+ assert_eq!(dns.answers[0].value, ".");+ assert_eq!(dns.answers[1].value, "203.0.113.1");+ }+}diff --git a/crates/formats/tests/pcap_dns_txt_lengths.rs b/crates/formats/tests/pcap_dns_txt_lengths.rsnew file mode 100644index 00000000..a90207b2--- /dev/null+++ b/crates/formats/tests/pcap_dns_txt_lengths.rs@@ -0,0 +1,196 @@+use craft_anything_formats::pcap::{Dns, decode};+use craft_anything_testkit::pcap::{ipv4_pkt, udp};++fn response(data: &[u8]) -> Dns {+ let mut msg = vec![0, 1, 0x81, 0x80, 0, 0, 0, 1, 0, 0, 0, 0];+ msg.extend([0, 0, 16, 0, 1, 0, 0, 0, 60]);+ msg.extend((data.len() as u16).to_be_bytes());+ msg.extend(data);+ decode(101, &ipv4_pkt(17, [1; 4], [2; 4], &udp(53, 100, &msg))).dns.unwrap()+}++fn prerequisites(flags: u16, class: u16, ttl: u32, data: &[u8]) -> Dns {+ let mut msg = vec![0, 1];+ msg.extend(flags.to_be_bytes());+ msg.extend([0, 1, 0, 2, 0, 0, 0, 0]);+ // UPDATE's zone section has the question layout: example.test, SOA, IN.+ msg.extend(b"\x07example\x04test\x00\x00\x06\x00\x01");+ msg.extend([0xc0, 12, 0, 16]);+ msg.extend(class.to_be_bytes());+ msg.extend(ttl.to_be_bytes());+ msg.extend((data.len() as u16).to_be_bytes());+ msg.extend(data);+ // Different owners let NONE and value-dependent prerequisites hold together.+ // The following TXT record must also survive.+ msg.extend(b"\x05after");+ msg.extend([0xc0, 12, 0, 16, 0, 1, 0, 0, 0, 0, 0, 3, 2, b'o', b'k']);+ decode(101, &ipv4_pkt(17, [1; 4], [2; 4], &udp(100, 53, &msg))).dns.unwrap()+}++fn named_txt(owner: &[&[u8]], data: &[u8], port: u16, flags: u16, class: u16, ttl: u32, compressed: bool) -> Dns {+ let mut name = Vec::new();+ for label in owner {+ name.push(u8::try_from(label.len()).unwrap());+ name.extend(*label);+ }+ name.push(0);+ let mut msg = vec![0, 1];+ msg.extend(flags.to_be_bytes());+ msg.extend([0, 1, 0, 2, 0, 0, 0, 0]);+ msg.extend(&name);+ msg.extend([0, 16, 0, 1]);+ if compressed {+ msg.extend([0xc0, 12]);+ } else {+ msg.extend(&name);+ }+ msg.extend([0, 16]);+ msg.extend(class.to_be_bytes());+ msg.extend(ttl.to_be_bytes());+ msg.extend(u16::try_from(data.len()).unwrap().to_be_bytes());+ msg.extend(data);+ // The next answer must survive an empty DNS-SD TXT record.+ msg.extend([0xc0, 12, 0, 1, 0, 1, 0, 0, 0, 60, 0, 4, 127, 0, 0, 1]);+ decode(101, &ipv4_pkt(17, [1; 4], [2; 4], &udp(port, 100, &msg))).dns.unwrap()+}++fn assert_empty_txt_and_following_answer(dns: Dns) {+ assert!(!dns.incomplete);+ assert_eq!(dns.answers.len(), 2);+ assert_eq!(dns.answers[0].rtype, "TXT");+ assert_eq!(dns.answers[0].value, "");+ assert_eq!(dns.answers[1].value, "127.0.0.1");+}++#[test]+fn empty_dns_sd_txt_preserves_following_answers() {+ let multicast: &[&[u8]] = &[b"Printer", b"_ipp", b"_tcp", b"local"];+ let unicast: &[&[u8]] = &[b"Printer", b"_ipp", b"_tcp", b"example", b"test"];+ for (port, owner) in [(5353, multicast), (53, unicast)] {+ assert_empty_txt_and_following_answer(named_txt(owner, &[], port, 0x8400, 1, 60, false));+ }+}++#[test]+fn empty_dns_sd_txt_is_valid_in_mdns_known_answers_and_cache_flush_records() {+ let owner: &[&[u8]] = &[b"Printer", b"_ipp", b"_tcp", b"local"];+ // Queries may contain known answers; the cache-flush bit belongs to CLASS.+ for (flags, class) in [(0, 1), (0x8400, 0x8001)] {+ assert_empty_txt_and_following_answer(named_txt(owner, &[], 5353, flags, class, 60, false));+ }+}++#[test]+fn dns_sd_owner_preserves_wire_labels_case_and_compression() {+ let owner: &[&[u8]] = &[b"Printer.with dots", b"_Ab-12", b"_UdP", b"example", b"test"];+ for compressed in [false, true] {+ assert_empty_txt_and_following_answer(named_txt(owner, &[], 53, 0x8180, 1, 60, compressed));+ }+}++#[test]+fn other_empty_txt_owners_are_not_dns_sd_instances() {+ let owners: &[&[&[u8]]] = &[+ &[b"Printer", b"local"],+ &[b"Printer._ipp._tcp", b"local"],+ &[b"Printer", b"_ipp._tcp", b"_tcp", b"local"],+ &[b"_ipp", b"_tcp", b"local"],+ &[b"Printer", b"_ipp", b"_tcp"],+ &[b"Printer", b"_ipp", b"_other", b"local"],+ &[b"Printer", b"_123", b"_tcp", b"local"],+ &[b"Printer", b"_bad--name", b"_tcp", b"local"],+ ];+ for owner in owners {+ let dns = named_txt(owner, &[], 5353, 0x8400, 1, 60, false);+ assert!(dns.incomplete, "owner {owner:?}");+ assert!(dns.answers.is_empty());+ }+}++#[test]+fn dns_sd_txt_still_rejects_truncated_nonempty_strings() {+ let owner: &[&[u8]] = &[b"Printer", b"_ipp", b"_tcp", b"local"];+ for data in [&b"\x02x"[..], &b"\x00\x04x"[..]] {+ let dns = named_txt(owner, data, 5353, 0x8400, 0x8001, 60, true);+ assert!(dns.incomplete);+ assert!(dns.answers.is_empty());+ }+}++#[test]+fn dns_sd_owner_does_not_relax_update_prerequisite_classes() {+ let owner: &[&[u8]] = &[b"Printer", b"_ipp", b"_tcp", b"example", b"test"];+ let dns = named_txt(owner, &[], 53, 5 << 11, 1, 0, true);+ assert!(dns.incomplete);+ assert!(dns.answers.is_empty());+ for class in [254, 255] {+ assert_empty_txt_and_following_answer(named_txt(owner, &[], 53, 5 << 11, class, 0, true));+ }+}++#[test]+fn empty_update_prerequisites_preserve_following_records() {+ for class in [254, 255] {+ let dns = prerequisites(5 << 11, class, 0, &[]);+ assert!(!dns.incomplete, "class {class}");+ assert_eq!(dns.answers.len(), 2);+ assert_eq!(dns.answers[0].name, "example.test");+ assert_eq!(dns.answers[0].value, "");+ assert_eq!(dns.answers[1].name, "after.example.test");+ assert_eq!(dns.answers[1].value, "ok");+ }+}++#[test]+fn empty_txt_rdata_requires_update_and_a_prerequisite_class() {+ assert!(response(&[]).incomplete);+ for (flags, class, ttl) in [(0x8180, 254, 0), (0x8180, 255, 0), (5 << 11, 1, 0), (5 << 11, 254, 60), (5 << 11, 255, 60)] {+ let dns = prerequisites(flags, class, ttl, &[]);+ assert!(dns.incomplete, "flags {flags:#x}, class {class}, ttl {ttl}");+ assert!(dns.answers.is_empty());+ }+ for opcode in [1, 2, 3, 4, 6] {+ for class in [254, 255] {+ let dns = prerequisites(opcode << 11, class, 0, &[]);+ assert!(dns.incomplete, "opcode {opcode}, class {class}");+ assert!(dns.answers.is_empty());+ }+ }+}++#[test]+fn update_prerequisite_classes_do_not_allow_truncated_strings() {+ for class in [254, 255] {+ let dns = prerequisites(5 << 11, class, 0, b"\x02x");+ assert!(dns.incomplete);+ assert!(dns.answers.is_empty());+ }+}++#[test]+fn truncated_txt_strings_are_not_complete_answers() {+ for data in [&b"\x05abc"[..], &b"\x02ok\x04x"[..], &b"\x01"[..]] {+ let dns = response(data);+ assert!(dns.incomplete);+ assert!(dns.answers.is_empty());+ }+}++#[test]+fn empty_and_multiple_complete_strings_remain_valid() {+ for (data, expected) in [(&b"\x00"[..], ""), (&b"\x00\x02ok\x01!"[..], "ok!")] {+ let dns = response(data);+ assert!(!dns.incomplete);+ assert_eq!(dns.answers[0].value, expected);+ }+}++#[test]+fn value_dependent_update_accepts_an_empty_character_string() {+ let dns = prerequisites(5 << 11, 1, 0, b"\x00");+ assert!(!dns.incomplete);+ assert_eq!(dns.answers.len(), 2);+ assert_eq!(dns.answers[0].value, "");+ assert_eq!(dns.answers[1].name, "after.example.test");+ assert_eq!(dns.answers[1].value, "ok");+}diff --git a/crates/formats/tests/pcap_flow_time_range.rs b/crates/formats/tests/pcap_flow_time_range.rsnew file mode 100644index 00000000..96b6c128--- /dev/null+++ b/crates/formats/tests/pcap_flow_time_range.rs@@ -0,0 +1,36 @@+use craft_anything_formats::pcap::summarize;+use craft_anything_testkit::pcap::{block, eth, ipv4_pkt, pcap, pcapng, udp};++fn frame() -> Vec<u8> {+ eth(0x0800, &ipv4_pkt(17, [1; 4], [2; 4], &udp(100, 200, b"body")))+}++#[test]+fn out_of_order_flow_packets_keep_the_earliest_and_latest_timestamps() {+ let f = frame();+ let mut capture = pcap(&[f.clone(), f.clone(), f.clone()]);+ for (i, seconds) in [30u32, 10, 20].into_iter().enumerate() {+ let at = 24 + i * (16 + f.len());+ capture[at..at + 4].copy_from_slice(&seconds.to_le_bytes());+ }+ let summary = summarize(&capture, &|| false).unwrap();+ let flow = &summary.flows[0];+ assert_eq!(flow.first_ts_ns, summary.first_ts_ns);+ assert_eq!(flow.last_ts_ns, summary.last_ts_ns);+ assert_eq!(flow.first_frame, 1);+}++#[test]+fn a_timestamped_packet_fills_a_flow_started_by_a_simple_packet() {+ let f = frame();+ let headers = pcapng(&[]);+ let mut simple = (f.len() as u32).to_le_bytes().to_vec();+ simple.extend(&f);+ let mut capture = headers.clone();+ capture.extend(block(3, &simple));+ capture.extend(&pcapng(&[f])[headers.len()..]);+ let summary = summarize(&capture, &|| false).unwrap();+ assert!(summary.first_ts_ns.is_some());+ assert_eq!(summary.flows[0].first_ts_ns, summary.first_ts_ns);+ assert_eq!(summary.flows[0].last_ts_ns, summary.last_ts_ns);+}diff --git a/crates/formats/tests/pcap_http_host_boundary.rs b/crates/formats/tests/pcap_http_host_boundary.rsnew file mode 100644index 00000000..13b6955d--- /dev/null+++ b/crates/formats/tests/pcap_http_host_boundary.rs@@ -0,0 +1,24 @@+use craft_anything_formats::pcap::{Http, decode};+use craft_anything_testkit::pcap::{ipv4_pkt, tcp};++fn request(data: &[u8]) -> Http {+ decode(101, &ipv4_pkt(6, [1; 4], [2; 4], &tcp(100, 80, 0x18, data))).http.unwrap()+}++#[test]+fn a_host_shaped_line_in_the_body_is_not_a_request_header() {+ let http = request(b"POST / HTTP/1.1\r\nContent-Length: 22\r\n\r\nbody\r\nHost: forged.test\r\n");+ assert!(http.host.is_none());+}++#[test]+fn invalid_utf8_before_host_does_not_shift_header_byte_offsets() {+ let http = request(b"GET / HTTP/1.1\r\nX-Data: \xff\r\nHoSt:\tReal.test \t\r\n\r\n");+ assert_eq!(http.host.as_deref(), Some("Real.test"));+}++#[test]+fn host_requires_a_complete_header_line_and_keeps_its_spelling() {+ assert!(request(b"GET / HTTP/1.1\r\nHost: cut").host.is_none());+ assert_eq!(request(b"GET / HTTP/1.1\r\nHost: Real.test\r\n\r\n").host.as_deref(), Some("Real.test"));+}diff --git a/crates/formats/tests/pcap_ipv4_lengths.rs b/crates/formats/tests/pcap_ipv4_lengths.rsnew file mode 100644index 00000000..21f1f6ea--- /dev/null+++ b/crates/formats/tests/pcap_ipv4_lengths.rs@@ -0,0 +1,57 @@+use craft_anything_formats::pcap::decode;+use craft_anything_testkit::pcap::{ipv4_pkt, udp};++#[test]+fn incomplete_ipv4_base_headers_explain_why_decoding_stopped() {+ let packet = ipv4_pkt(17, [1; 4], [2; 4], &[]);+ for captured in 10..20 {+ let decoded = decode(101, &packet[..captured]);+ assert!(decoded.ip.is_none(), "captured {captured} bytes");+ assert!(decoded.transport.is_none(), "captured {captured} bytes");+ assert_eq!(decoded.note.as_deref(), Some("IPv4 header cut short"), "captured {captured} bytes");+ }+}++#[test]+fn an_ipv4_total_length_cannot_be_shorter_than_its_header() {+ for total in [0u16, 19, 23] {+ let mut packet = ipv4_pkt(17, [1, 2, 3, 4], [5, 6, 7, 8], &udp(100, 200, b"body"));+ packet[0] = 0x46;+ packet[2..4].copy_from_slice(&total.to_be_bytes());+ let decoded = decode(101, &packet);+ assert!(decoded.ip.is_none());+ assert!(decoded.transport.is_none());+ assert!(decoded.note.is_some());+ }+}++#[test]+fn missing_ipv4_options_do_not_form_a_complete_ip_header() {+ let mut packet = ipv4_pkt(17, [1; 4], [2; 4], &[]);+ packet[0] = 0x46;+ packet[2..4].copy_from_slice(&24u16.to_be_bytes());+ let decoded = decode(101, &packet);+ assert!(decoded.ip.is_none());+ assert!(decoded.note.is_some());+}++#[test]+fn complete_options_and_truncated_transport_keep_their_valid_fields() {+ let body = udp(100, 200, b"body");+ let mut payload = vec![0; 4];+ payload.extend(body);+ let mut packet = ipv4_pkt(17, [1; 4], [2; 4], &payload);+ packet[0] = 0x46;+ assert_eq!(decode(101, &packet).transport.unwrap().payload_len, 4);+ packet.truncate(34);+ let decoded = decode(101, &packet);+ assert!(decoded.ip.is_some());+ let transport = decoded.transport.unwrap();+ assert_eq!(transport.src_port, Some(100));+ assert_eq!(transport.dst_port, Some(200));+ assert_eq!(transport.payload_len, 2);+ packet.truncate(28);+ let decoded = decode(101, &packet);+ assert!(decoded.ip.is_some());+ assert_eq!(decoded.transport.unwrap().src_port, Some(100));+}diff --git a/crates/formats/tests/pcap_ipv6_fragments.rs b/crates/formats/tests/pcap_ipv6_fragments.rsnew file mode 100644index 00000000..8f82257d--- /dev/null+++ b/crates/formats/tests/pcap_ipv6_fragments.rs@@ -0,0 +1,40 @@+use craft_anything_formats::pcap::decode;+use craft_anything_testkit::pcap::{eth, udp};++fn packet(offset: u16, next: u8, payload: &[u8]) -> Vec<u8> {+ let mut ip = vec![0u8; 40];+ ip[0] = 0x60;+ ip[4..6].copy_from_slice(&((8 + payload.len()) as u16).to_be_bytes());+ ip[6] = 44;+ ip.extend([next, 0]);+ ip.extend(offset.to_be_bytes());+ ip.extend([0; 4]);+ ip.extend(payload);+ eth(0x86dd, &ip)+}++#[test]+fn a_noninitial_fragment_cannot_reset_its_offset_from_payload_bytes() {+ let mut payload = vec![17, 0, 0, 0, 0, 0, 0, 0];+ payload.extend(udp(100, 200, b"body"));+ let decoded = decode(1, &packet(8, 44, &payload));+ assert!(decoded.ip.unwrap().fragment);+ assert!(decoded.transport.is_none());+ assert!(!decoded.protocols.contains(&"udp"));+}++#[test]+fn noninitial_fragment_bytes_cannot_change_the_recorded_protocol() {+ let decoded = decode(1, &packet(8, 60, &[17, 0, 0, 0, 0, 0, 0, 0]));+ assert_eq!(decoded.ip.unwrap().protocol, 60);+ assert!(decoded.transport.is_none());+}++#[test]+fn initial_and_atomic_fragments_still_decode_transport_headers() {+ for offset in [0, 1] {+ let decoded = decode(1, &packet(offset, 17, &udp(100, 200, b"body")));+ assert!(!decoded.ip.unwrap().fragment);+ assert_eq!(decoded.transport.unwrap().payload_len, 4);+ }+}diff --git a/crates/formats/tests/pcap_ipv6_version.rs b/crates/formats/tests/pcap_ipv6_version.rsnew file mode 100644index 00000000..4e4b25dc--- /dev/null+++ b/crates/formats/tests/pcap_ipv6_version.rs@@ -0,0 +1,53 @@+use craft_anything_formats::pcap::decode;+use craft_anything_testkit::pcap::{eth, ipv4_pkt};++fn raw_packets() -> (Vec<u8>, Vec<u8>) {+ let ipv4 = ipv4_pkt(17, [1; 4], [2; 4], &[0; 20]);+ let mut ipv6 = vec![0u8; 40];+ ipv6[0] = 0x60;+ ipv6[6] = 59;+ (ipv4, ipv6)+}++#[test]+fn explicit_raw_link_types_reject_the_other_ip_version() {+ let (ipv4, ipv6) = raw_packets();+ for (link_type, packet) in [(228, &ipv6), (229, &ipv4)] {+ let decoded = decode(link_type, packet);+ assert!(decoded.ip.is_none(), "link type {link_type}");+ assert!(decoded.transport.is_none(), "link type {link_type}");+ assert!(decoded.note.is_some(), "link type {link_type}");+ }+}++#[test]+fn matching_raw_link_types_and_generic_raw_packets_remain_readable() {+ let (ipv4, ipv6) = raw_packets();+ assert_eq!(decode(228, &ipv4).ip.unwrap().version, 4);+ assert_eq!(decode(229, &ipv6).ip.unwrap().version, 6);+ for link_type in [12, 14, 101] {+ assert_eq!(decode(link_type, &ipv4).ip.unwrap().version, 4);+ assert_eq!(decode(link_type, &ipv6).ip.unwrap().version, 6);+ }+}++#[test]+fn an_ethernet_type_does_not_replace_the_ipv6_version_check() {+ for version in [0, 4, 5, 7, 15] {+ let mut packet = [0u8; 40];+ packet[0] = version << 4;+ packet[6] = 59;+ let decoded = decode(1, ð(0x86dd, &packet));+ assert!(decoded.ip.is_none(), "version {version}");+ assert!(decoded.transport.is_none());+ assert!(decoded.note.is_some());+ }+}++#[test]+fn ipv6_version_keeps_traffic_class_bits() {+ let mut packet = [0u8; 40];+ packet[0] = 0x6f;+ packet[6] = 59;+ assert_eq!(decode(1, ð(0x86dd, &packet)).ip.unwrap().version, 6);+}diff --git a/crates/formats/tests/pcapng_simple_payload.rs b/crates/formats/tests/pcapng_simple_payload.rsnew file mode 100644index 00000000..c61f6c70--- /dev/null+++ b/crates/formats/tests/pcapng_simple_payload.rs@@ -0,0 +1,62 @@+use craft_anything_formats::pcap::Capture;+use craft_anything_testkit::pcap::{block, pcapng};++fn capture(original: u32, snaplen: u32, payload: &[u8]) -> Vec<u8> {+ let mut out = pcapng(&[]);+ out[40..44].copy_from_slice(&snaplen.to_le_bytes());+ let mut body = original.to_le_bytes().to_vec();+ body.extend(payload);+ out.extend(block(3, &body));+ out+}++#[test]+fn a_simple_packet_cannot_silently_shorten_its_declared_capture() {+ let data = capture(10, 0, &[1, 2, 3, 4]);+ let mut cap = Capture::new(&data).unwrap();+ assert!(cap.next().is_none());+ assert!(!cap.warnings.is_empty());+}++#[test]+fn a_simple_packet_cannot_have_unexplained_extra_payload() {+ let data = capture(1, 0, &[1; 8]);+ let mut cap = Capture::new(&data).unwrap();+ assert!(cap.next().is_none());+ assert!(!cap.warnings.is_empty());+}++#[test]+fn snaplen_truncation_and_alignment_padding_are_preserved() {+ for (original, snaplen) in [(3, 0), (10, 3)] {+ let data = capture(original, snaplen, &[1, 2, 3]);+ let mut cap = Capture::new(&data).unwrap();+ let packet = cap.next().unwrap();+ assert_eq!(packet.data, [1, 2, 3]);+ assert_eq!(packet.original_len, original);+ assert!(cap.next().is_none());+ assert!(cap.warnings.is_empty());+ }+}++#[test]+fn rejected_simple_packets_share_one_warning_and_preserve_later_frames() {+ let mut data = pcapng(&[]);+ let rejected = block(3, &1u32.to_le_bytes());+ for _ in 0..128 {+ data.extend(&rejected);+ }+ let mut valid = 3u32.to_le_bytes().to_vec();+ valid.extend([1, 2, 3]);+ data.extend(block(3, &valid));+ let mut cap = Capture::new(&data).unwrap();+ let frame = cap.next().unwrap();+ assert_eq!(frame.number, 1);+ assert_eq!(frame.data, [1, 2, 3]);+ assert!(cap.next().is_none());+ assert!(!cap.truncated);+ assert_eq!(cap.warnings.len(), 1);+ assert!(cap.warnings[0].contains("128 simple packet blocks"));+ assert!(cap.next().is_none());+ assert_eq!(cap.warnings.len(), 1);+}diff --git a/crates/formats/tests/pe_optional_header_framing.rs b/crates/formats/tests/pe_optional_header_framing.rsnew file mode 100644index 00000000..a75c9d23--- /dev/null+++ b/crates/formats/tests/pe_optional_header_framing.rs@@ -0,0 +1,61 @@+use craft_anything_formats::pe;++fn image(plus: bool, optional_size: usize, declared_dirs: u32) -> Vec<u8> {+ let opt = 0x98;+ let fixed = if plus { 112 } else { 96 };+ let mut data = vec![0; opt + optional_size.max(fixed) + 64];+ data[..2].copy_from_slice(b"MZ");+ data[0x3c..0x40].copy_from_slice(&0x80u32.to_le_bytes());+ data[0x80..0x84].copy_from_slice(b"PE\0\0");+ data[0x94..0x96].copy_from_slice(&(optional_size as u16).to_le_bytes());+ data[opt..opt + 2].copy_from_slice(&(if plus { 0x20bu16 } else { 0x10b }).to_le_bytes());+ data[opt + 68..opt + 70].copy_from_slice(&3u16.to_le_bytes());+ data[opt + fixed - 4..opt + fixed].copy_from_slice(&declared_dirs.to_le_bytes());+ data+}++#[test]+fn required_optional_header_fields_cannot_be_borrowed_from_the_section_table() {+ for plus in [false, true] {+ for size in [0, 2, 70, if plus { 111 } else { 95 }] {+ assert!(pe::headers(&image(plus, size, 16)).is_err(), "plus={plus}, size={size}");+ }+ }+}++#[test]+fn directory_count_is_bounded_by_complete_entries_in_the_optional_header() {+ for plus in [false, true] {+ let fixed = if plus { 112 } else { 96 };+ for available in [0, 7, 8, 15] {+ let mut data = image(plus, fixed + available, 16);+ data[0x98 + fixed..0x98 + fixed + 16].fill(0x55);+ let parsed = pe::headers(&data).unwrap();+ assert_eq!(parsed.data_dirs.len(), available / 8, "plus={plus}, available={available}");+ if available >= 8 {+ assert_eq!(parsed.data_dirs[0], (0x5555_5555, 0x5555_5555), "plus={plus}, available={available}");+ }+ }+ }+}++#[test]+fn zero_or_one_directory_and_unused_optional_bytes_are_valid() {+ for plus in [false, true] {+ let fixed = if plus { 112 } else { 96 };+ for dirs in [0u32, 1] {+ for padding in [0, 12] {+ let size = fixed + dirs as usize * 8 + padding;+ let mut data = image(plus, size, dirs);+ data[0x86..0x88].copy_from_slice(&1u16.to_le_bytes());+ let section = 0x98 + size;+ data[section..section + 5].copy_from_slice(b".test");+ let parsed = pe::headers(&data).unwrap();+ assert_eq!(parsed.pe32_plus, plus);+ assert_eq!(parsed.subsystem, 3);+ assert_eq!(parsed.data_dirs.len(), dirs as usize);+ assert_eq!(parsed.sections[0].name, ".test");+ }+ }+ }+}diff --git a/crates/formats/tests/pe_resource_directory_boundary.rs b/crates/formats/tests/pe_resource_directory_boundary.rsnew file mode 100644index 00000000..1d26d037--- /dev/null+++ b/crates/formats/tests/pe_resource_directory_boundary.rs@@ -0,0 +1,280 @@+use craft_anything_formats::pe;+use craft_anything_testkit::packed::{pe_rcdata, pe_section};++fn set_directory_size(data: &mut [u8], size: u32) {+ let headers = pe::headers(data).unwrap();+ let dirs = headers.pe_offset + 24 + if headers.pe32_plus { 112 } else { 96 };+ data[dirs + 20..dirs + 24].copy_from_slice(&size.to_le_bytes());+}++#[test]+fn resource_subdirectories_cannot_escape_the_directory_size() {+ let mut data = pe_rcdata("inside", b"payload");+ set_directory_size(&mut data, 24);+ let resources = pe::parse_resources(&data, 10).unwrap();+ assert!(resources.entries.is_empty());+ assert!(!resources.warnings.is_empty());+}++#[test]+fn a_resource_name_cannot_be_read_from_bytes_after_the_directory() {+ let mut data = pe_rcdata("outside", b"payload");+ set_directory_size(&mut data, 0x60);+ let resources = pe::parse_resources(&data, 10).unwrap();+ assert!(resources.entries.is_empty());+ assert!(!resources.warnings.is_empty());+}++#[test]+fn a_partial_resource_data_entry_is_not_reported_as_complete() {+ for size in [0x50, 0x54, 0x57] {+ let mut data = pe_rcdata("inside", b"payload");+ let headers = pe::headers(&data).unwrap();+ let root = headers.rva_to_offset(headers.dir(2).unwrap().0).unwrap();+ data[root + 0x28..root + 0x2c].copy_from_slice(&7u32.to_le_bytes());+ set_directory_size(&mut data, size);+ let resources = pe::parse_resources(&data, 10).unwrap();+ assert!(resources.entries.is_empty(), "size={size}");+ assert!(!resources.warnings.is_empty());+ }+}++#[test]+fn resource_payloads_still_use_their_own_rva() {+ let mut data = pe_rcdata("inside", b"payload");+ set_directory_size(&mut data, 0x60 + 2 + 6 * 2);+ let resources = pe::parse_resources(&data, 10).unwrap();+ assert_eq!(resources.entries.len(), 1);+ let entry = &resources.entries[0];+ assert_eq!(entry.name, "inside");+ assert_eq!(entry.size, 7);+ let off = entry.file_offset.unwrap() as usize;+ assert_eq!(&data[off..off + 7], b"payload");+ assert!(resources.warnings.is_empty());+}++fn resource_with_long_name() -> Vec<u8> {+ let data = pe_rcdata("inside", b"payload");+ let headers = pe::headers(&data).unwrap();+ let (rva, size) = headers.dir(2).unwrap();+ let root = headers.rva_to_offset(rva).unwrap();+ let mut resource = data[root..root + size as usize].to_vec();+ let name_at = (resource.len() + 1) & !1;+ resource.resize(name_at, 0);+ resource.extend(4097u16.to_le_bytes());+ for _ in 0..4096 {+ resource.extend(u16::from(b'x').to_le_bytes());+ }+ resource.extend(u16::from(b'z').to_le_bytes());+ resource[0x28..0x2c].copy_from_slice(&(0x8000_0000 | name_at as u32).to_le_bytes());+ // Rebuild the section so its raw and virtual extents contain the complete name.+ let mut data = pe_section(".rsrc", &resource);+ let headers = pe::headers(&data).unwrap();+ let dirs = headers.pe_offset + 24 + if headers.pe32_plus { 112 } else { 96 };+ data[dirs + 16..dirs + 20].copy_from_slice(&rva.to_le_bytes());+ set_directory_size(&mut data, resource.len() as u32);+ data+}++#[test]+fn a_long_resource_name_must_fit_its_full_declared_span() {+ let mut data = resource_with_long_name();+ let headers = pe::headers(&data).unwrap();+ let (rva, size) = headers.dir(2).unwrap();+ let last_unit = headers.rva_to_offset(rva + size - 2).unwrap();+ set_directory_size(&mut data, size - 2);+ // The last unit remains mapped and present in the file, outside the declared directory.+ assert_eq!(&data[last_unit..last_unit + 2], b"z\0");+ let resources = pe::parse_resources(&data, 10).unwrap();+ assert!(resources.entries.is_empty());+ assert!(resources.warnings.iter().any(|warning| warning == "resource name runs past the directory; skipped an entry"));+}++#[test]+fn a_long_resource_name_cannot_cross_the_mapped_raw_extent() {+ for delta in [0u32, 32] {+ let mut data = resource_with_long_name();+ let headers = pe::headers(&data).unwrap();+ let (rva, size) = headers.dir(2).unwrap();+ let root = headers.rva_to_offset(rva).unwrap();+ let section = &headers.sections[0];+ let optional_size = u16::from_le_bytes(data[headers.pe_offset + 20..headers.pe_offset + 22].try_into().unwrap());+ let section_at = headers.pe_offset + 24 + usize::from(optional_size);+ // Keep the resource at the same file offset, either at the section start or inside it.+ data[section_at + 8..section_at + 12].copy_from_slice(&(section.virtual_size + delta).to_le_bytes());+ data[section_at + 12..section_at + 16].copy_from_slice(&(section.rva - delta).to_le_bytes());+ data[section_at + 16..section_at + 20].copy_from_slice(&(delta + size - 2).to_le_bytes());+ data[section_at + 20..section_at + 24].copy_from_slice(&(section.raw_offset - delta).to_le_bytes());+ let mapped = pe::headers(&data).unwrap();+ let last_rva = rva + size - 2;+ let last_unit = root + size as usize - 2;+ assert_eq!(mapped.rva_to_offset(rva), Some(root));+ assert_eq!(rva - mapped.sections[0].rva, delta);+ assert!(last_rva - mapped.sections[0].rva < mapped.sections[0].virtual_size);+ assert_eq!(mapped.rva_to_offset(last_rva), None);+ assert_eq!(&data[last_unit..last_unit + 2], b"z\0");+ let resources = pe::parse_resources(&data, 10).unwrap();+ assert!(resources.entries.is_empty(), "delta={delta}");+ assert!(resources.warnings.iter().any(|warning| warning == "resource name runs past the directory; skipped an entry"), "delta={delta}");+ }+}++#[test]+fn resource_metadata_in_the_header_prefix_still_parses() {+ let mut data = pe_rcdata("inside", b"payload");+ let headers = pe::headers(&data).unwrap();+ let root = headers.rva_to_offset(headers.dir(2).unwrap().0).unwrap();+ let header_rva = 0x300u32;+ let metadata_size = 0x60 + 2 + 6 * 2;+ assert!(header_rva as usize + metadata_size <= headers.sections[0].raw_offset as usize);+ assert_eq!(headers.rva_to_offset(header_rva), Some(header_rva as usize));+ // Move only metadata into header padding; its payload keeps the original section RVA.+ data.copy_within(root..root + metadata_size, header_rva as usize);+ let dirs = headers.pe_offset + 24 + if headers.pe32_plus { 112 } else { 96 };+ data[dirs + 16..dirs + 20].copy_from_slice(&header_rva.to_le_bytes());+ set_directory_size(&mut data, metadata_size as u32);+ let resources = pe::parse_resources(&data, 10).unwrap();+ assert_eq!(resources.entries.len(), 1);+ let entry = &resources.entries[0];+ assert_eq!(entry.name, "inside");+ assert_eq!(entry.size, 7);+ let off = entry.file_offset.unwrap() as usize;+ assert_eq!(&data[off..off + 7], b"payload");+ assert!(resources.warnings.is_empty());+}++/// Add one mapping candidate without moving the original section's bytes.+fn add_mapping_section(mut data: Vec<u8>, first: bool, rva: u32, virtual_size: u32, raw_size: u32) -> Vec<u8> {+ let headers = pe::headers(&data).unwrap();+ assert_eq!(headers.sections.len(), 1);+ let optional_size = u16::from_le_bytes(data[headers.pe_offset + 20..headers.pe_offset + 22].try_into().unwrap());+ let section_at = headers.pe_offset + 24 + usize::from(optional_size);+ assert!(section_at + 80 <= headers.sections[0].raw_offset as usize);+ if first {+ data.copy_within(section_at..section_at + 40, section_at + 40);+ }+ let added = section_at + if first { 0 } else { 40 };+ data[added..added + 40].fill(0);+ data[added..added + 5].copy_from_slice(b".next");+ data[added + 8..added + 12].copy_from_slice(&virtual_size.to_le_bytes());+ data[added + 12..added + 16].copy_from_slice(&rva.to_le_bytes());+ data[added + 16..added + 20].copy_from_slice(&raw_size.to_le_bytes());+ data[added + 20..added + 24].copy_from_slice(&headers.sections[0].raw_offset.to_le_bytes());+ data[headers.pe_offset + 6..headers.pe_offset + 8].copy_from_slice(&2u16.to_le_bytes());+ data+}++#[test]+fn resource_metadata_obeys_section_table_priority() {+ let metadata_size = 0x60 + 2 + 6 * 2;+ let last_unit = metadata_size - 2;+ for (first, virtual_size, raw_size, distance, rejected) in [+ (true, 2, 2, last_unit, true),+ (true, 2, 0, last_unit, true),+ (true, 0, 2, last_unit, true),+ (false, 2, 2, last_unit, false),+ (true, 0, 0, last_unit, false),+ (true, 2, 2, metadata_size, false),+ ] {+ let mut data = pe_rcdata("inside", b"payload");+ set_directory_size(&mut data, metadata_size);+ let headers = pe::headers(&data).unwrap();+ let rva = headers.dir(2).unwrap().0;+ let root = headers.rva_to_offset(rva).unwrap();+ let data = add_mapping_section(data, first, rva + distance, virtual_size, raw_size);+ let mapped = pe::headers(&data).unwrap();+ assert_eq!(mapped.rva_to_offset(rva), Some(root));+ assert_eq!(mapped.rva_to_offset(rva + last_unit) != Some(root + last_unit as usize), rejected);+ let resources = pe::parse_resources(&data, 10).unwrap();+ if rejected {+ assert!(resources.entries.is_empty());+ assert!(resources.warnings.iter().any(|warning| warning == "resource name runs past the directory; skipped an entry"));+ } else {+ assert_eq!(resources.entries.len(), 1);+ assert_eq!(resources.entries[0].name, "inside");+ let off = resources.entries[0].file_offset.unwrap() as usize;+ assert_eq!(&data[off..off + 7], b"payload");+ assert!(resources.warnings.is_empty());+ }+ }+}++#[test]+fn header_resource_metadata_stops_at_section_mapping_changes() {+ let metadata_size = 0x60 + 2 + 6 * 2;+ let last_unit = metadata_size - 2;+ for (virtual_size, raw_size, distance, rejected) in+ [(2, 2, last_unit, true), (2, 0, last_unit, true), (0, 0, last_unit, false), (2, 2, metadata_size, false)]+ {+ let mut data = pe_rcdata("inside", b"payload");+ let headers = pe::headers(&data).unwrap();+ let root = headers.rva_to_offset(headers.dir(2).unwrap().0).unwrap();+ let header_rva = 0x300u32;+ data.copy_within(root..root + metadata_size as usize, header_rva as usize);+ let dirs = headers.pe_offset + 24 + if headers.pe32_plus { 112 } else { 96 };+ data[dirs + 16..dirs + 20].copy_from_slice(&header_rva.to_le_bytes());+ set_directory_size(&mut data, metadata_size);+ // This later-listed section still takes over the header's identity mapping.+ let data = add_mapping_section(data, false, header_rva + distance, virtual_size, raw_size);+ let mapped = pe::headers(&data).unwrap();+ assert_eq!(mapped.rva_to_offset(header_rva), Some(header_rva as usize));+ assert_eq!(mapped.rva_to_offset(header_rva + last_unit) != Some((header_rva + last_unit) as usize), rejected);+ let resources = pe::parse_resources(&data, 10).unwrap();+ if rejected {+ assert!(resources.entries.is_empty());+ assert!(resources.warnings.iter().any(|warning| warning == "resource name runs past the directory; skipped an entry"));+ } else {+ assert_eq!(resources.entries.len(), 1);+ assert_eq!(resources.entries[0].name, "inside");+ let off = resources.entries[0].file_offset.unwrap() as usize;+ assert_eq!(&data[off..off + 7], b"payload");+ assert!(resources.warnings.is_empty());+ }+ }+}++#[test]+fn resource_metadata_stays_within_the_rva_address_space() {+ let metadata_size = 0x60 + 2 + 6 * 2;+ for remaining in [metadata_size - 1, metadata_size] {+ let mut data = pe_rcdata("inside", b"payload");+ let headers = pe::headers(&data).unwrap();+ let root = headers.rva_to_offset(headers.dir(2).unwrap().0).unwrap();+ let optional_size = u16::from_le_bytes(data[headers.pe_offset + 20..headers.pe_offset + 22].try_into().unwrap());+ let section_at = headers.pe_offset + 24 + usize::from(optional_size);+ let dirs = headers.pe_offset + 24 + if headers.pe32_plus { 112 } else { 96 };+ let rva = u32::MAX - remaining + 1;+ data[section_at + 12..section_at + 16].copy_from_slice(&rva.to_le_bytes());+ data[dirs + 16..dirs + 20].copy_from_slice(&rva.to_le_bytes());+ set_directory_size(&mut data, metadata_size);+ // Keep the payload independently mapped in the header prefix.+ data[0x300..0x307].copy_from_slice(b"payload");+ data[root + 0x48..root + 0x4c].copy_from_slice(&0x300u32.to_le_bytes());+ assert_eq!(pe::headers(&data).unwrap().rva_to_offset(rva), Some(root));+ assert_eq!(rva.checked_add(metadata_size - 1).is_some(), remaining == metadata_size);+ assert_eq!(&data[root + metadata_size as usize - 2..root + metadata_size as usize], b"e\0");+ let resources = pe::parse_resources(&data, 10).unwrap();+ if remaining < metadata_size {+ assert!(resources.entries.is_empty());+ assert!(resources.warnings.iter().any(|warning| warning == "resource name runs past the directory; skipped an entry"));+ } else {+ assert_eq!(resources.entries.len(), 1);+ assert_eq!(resources.entries[0].name, "inside");+ assert_eq!(resources.entries[0].file_offset, Some(0x300));+ assert!(resources.warnings.is_empty());+ }+ }+}++#[test]+fn a_complete_long_resource_name_keeps_the_existing_output_limit() {+ let data = resource_with_long_name();+ let resources = pe::parse_resources(&data, 10).unwrap();+ assert_eq!(resources.entries.len(), 1);+ let entry = &resources.entries[0];+ assert_eq!(entry.name, "x".repeat(4096));+ assert_eq!(entry.size, 7);+ let off = entry.file_offset.unwrap() as usize;+ assert_eq!(&data[off..off + 7], b"payload");+ assert!(resources.warnings.is_empty());+}diff --git a/crates/formats/tests/pixel_rgba_output_overflow.rs b/crates/formats/tests/pixel_rgba_output_overflow.rsnew file mode 100644index 00000000..4fd26691--- /dev/null+++ b/crates/formats/tests/pixel_rgba_output_overflow.rs@@ -0,0 +1,88 @@+use craft_anything_formats::{+ FormatError,+ pixels::{self, Layout},+};++#[test]+fn default_rgba_budget_is_checked_before_reading_source_pixels() {+ // The existing texture export limit is an area limit, not a limit on either axis.+ for (width, height) in [(8192, 8192), (65536, 1024)] {+ assert!(matches!(pixels::decode(Layout::R8, width, height, &[]), Err(FormatError::Truncated(_))));+ }+ assert!(matches!(pixels::decode(Layout::R8, 8192, 8193, &[]), Err(FormatError::TooLarge(_))));+}++#[test]+fn explicit_rgba_budget_rejects_expansion_before_source_validation() {+ for layout in [Layout::R8, Layout::Alpha8, Layout::Dxt1, Layout::Bc4] {+ for data in [&[][..], &[0; 16][..]] {+ for limit in [0, 15] {+ assert!(matches!(pixels::decode_with_limit(layout, 2, 2, data, limit), Err(FormatError::TooLarge(_))), "layout {layout:?}, limit {limit}");+ }+ }+ assert!(matches!(pixels::decode_with_limit(layout, 2, 2, &[], 16), Err(FormatError::Truncated(_))), "layout {layout:?}");+ }+}++#[test]+fn rgba_budget_boundary_preserves_plain_pixels_and_cropped_blocks() {+ for limit in [8, 9] {+ assert_eq!(pixels::decode_with_limit(Layout::R8, 2, 1, &[7, 8], limit).unwrap(), [7, 7, 7, 255, 8, 8, 8, 255]);+ }+ assert!(matches!(pixels::decode_with_limit(Layout::Dxt1, 5, 5, &[0; 32], 99), Err(FormatError::TooLarge(_))));+ assert_eq!(pixels::decode_with_limit(Layout::Dxt1, 5, 5, &[0; 32], 100).unwrap(), [0, 0, 0, 255].repeat(25));+ // A single texel still needs a full 16-byte DXT5 block, but only four RGBA output bytes.+ assert_eq!(pixels::decode_with_limit(Layout::Dxt5, 1, 1, &[0; 16], 4).unwrap(), [0; 4]);+}++#[test]+fn caller_budget_can_exceed_default_but_not_allocation_limits() {+ assert!(matches!(pixels::decode_with_limit(Layout::R8, 8192, 8193, &[], u64::MAX), Err(FormatError::Truncated(_))));+ for layout in [Layout::R8, Layout::Alpha8, Layout::Dxt1, Layout::Bc4] {+ for (width, height) in [(u32::MAX, u32::MAX), (1 << 31, 1 << 30)] {+ assert!(matches!(pixels::decode_with_limit(layout, width, height, &[], u64::MAX), Err(FormatError::TooLarge(_))), "layout {layout:?}");+ }+ }+}++#[test]+fn empty_pictures_remain_malformed_with_a_zero_budget() {+ for (width, height) in [(0, 2), (2, 0)] {+ assert!(matches!(pixels::decode_with_limit(Layout::R8, width, height, &[], 0), Err(FormatError::Malformed(_))));+ }+}++#[test]+fn packed_16_bit_pixels_keep_channel_order_at_the_budget_boundary() {+ for (layout, data, expected) in [+ (Layout::Rgb565, [0x00, 0xf8, 0xe0, 0x07], [255, 0, 0, 255, 0, 255, 0, 255]),+ (Layout::Rgba4444, [0x0f, 0xf0, 0xff, 0x00], [255, 0, 0, 255, 0, 0, 255, 255]),+ (Layout::Argb4444, [0x00, 0xff, 0xf0, 0x80], [255, 0, 0, 255, 0, 255, 0, 136]),+ ] {+ assert_eq!(pixels::decode_with_limit(layout, 2, 1, &data, 8).unwrap(), expected);+ assert_eq!(pixels::decode(layout, 2, 1, &data).unwrap(), expected);+ }+}++#[test]+fn expanded_rgba_dimensions_are_checked_before_reading_or_allocating() {+ for layout in [Layout::R8, Layout::Alpha8, Layout::Dxt1, Layout::Bc4] {+ assert!(matches!(pixels::decode(layout, u32::MAX, u32::MAX, &[]), Err(FormatError::TooLarge(_))), "layout {layout:?}");+ // The product fits u64 but exceeds the largest byte vector on a 64-bit target.+ assert!(matches!(pixels::decode(layout, 1 << 31, 1 << 30, &[]), Err(FormatError::TooLarge(_))), "layout {layout:?}");+ }+}++#[cfg(target_pointer_width = "32")]+#[test]+fn rgba_expansion_cannot_wrap_a_32_bit_output_length() {+ assert!(matches!(pixels::decode(Layout::Dxt1, 65536, 16384, &[]), Err(FormatError::TooLarge(_))));+}++#[test]+fn ordinary_pixel_sizes_and_truncated_inputs_keep_their_results() {+ assert_eq!(pixels::decode(Layout::R8, 2, 1, &[7, 8]).unwrap(), [7, 7, 7, 255, 8, 8, 8, 255]);+ assert_eq!(pixels::decode(Layout::Dxt1, 5, 5, &[0; 32]).unwrap().len(), 100);+ assert!(matches!(pixels::decode(Layout::R8, 2, 1, &[7]), Err(FormatError::Truncated(_))));+ assert!(matches!(pixels::decode(Layout::Dxt1, 0, 1, &[]), Err(FormatError::Malformed(_))));+}diff --git a/crates/formats/tests/pyc_long_limb_validation.rs b/crates/formats/tests/pyc_long_limb_validation.rsnew file mode 100644index 00000000..f982d51e--- /dev/null+++ b/crates/formats/tests/pyc_long_limb_validation.rs@@ -0,0 +1,42 @@+use craft_anything_formats::{FormatError, pyc};++fn long(negative: bool, digits: &[u16]) -> Vec<u8> {+ let mut bytes = vec![b'l'];+ let count = digits.len() as i32 * if negative { -1 } else { 1 };+ bytes.extend_from_slice(&count.to_le_bytes());+ for digit in digits {+ bytes.extend_from_slice(&digit.to_le_bytes());+ }+ bytes+}++#[test]+fn every_long_digit_must_fit_fifteen_bits() {+ for negative in [false, true] {+ for digits in [vec![0x8000], vec![0xffff], vec![0x8000, 1], vec![1, 0xffff], vec![1, 1, 1, 1, 1, 1, 1, 0x8000]] {+ assert!(matches!(pyc::read_value(&long(negative, &digits), None), Err(FormatError::Malformed(_))), "negative {negative}, digits {digits:?}");+ }+ }+}++#[test]+fn nonzero_long_counts_require_a_nonzero_most_significant_digit() {+ for negative in [false, true] {+ for digits in [vec![0], vec![1, 0], vec![0, 0], vec![1, 1, 1, 1, 1, 1, 1, 0]] {+ assert!(matches!(pyc::read_value(&long(negative, &digits), None), Err(FormatError::Malformed(_))), "negative {negative}, digits {digits:?}");+ }+ }+}++#[test]+fn canonical_zero_small_and_large_integers_still_read() {+ assert_eq!(pyc::read_value(&long(false, &[]), None).unwrap().value, pyc::Value::Int(0));+ for negative in [false, true] {+ for (digits, value) in [(vec![0x7fff], 32767), (vec![0, 1], 32768), (vec![1, 1], 32769)] {+ let expected = if negative { -value } else { value };+ assert_eq!(pyc::read_value(&long(negative, &digits), None).unwrap().value, pyc::Value::Int(expected));+ }+ // Legal integers beyond i64 remain readable even though their numeric value isn't kept.+ assert_eq!(pyc::read_value(&long(negative, &[0, 0, 0, 0, 0, 0, 0, 1]), None).unwrap().value, pyc::Value::Other);+ }+}diff --git a/crates/formats/tests/tensor_zero_dimension_product.rs b/crates/formats/tests/tensor_zero_dimension_product.rsnew file mode 100644index 00000000..5dc372e0--- /dev/null+++ b/crates/formats/tests/tensor_zero_dimension_product.rs@@ -0,0 +1,56 @@+use craft_anything_formats::ai_model;+use serde_json::json;++fn safetensors(shape: &[u64], data_bytes: usize) -> Vec<u8> {+ let header = serde_json::to_vec(&json!({"weight": {"dtype": "F32", "shape": shape, "data_offsets": [0, data_bytes]}})).unwrap();+ let mut data = (header.len() as u64).to_le_bytes().to_vec();+ data.extend_from_slice(&header);+ data.resize(data.len() + data_bytes, 0);+ data+}++fn gguf(shape: &[u64]) -> Vec<u8> {+ let mut data = b"GGUF".to_vec();+ data.extend_from_slice(&3u32.to_le_bytes());+ data.extend_from_slice(&1u64.to_le_bytes()); // One tensor.+ data.extend_from_slice(&0u64.to_le_bytes()); // No metadata.+ data.extend_from_slice(&6u64.to_le_bytes());+ data.extend_from_slice(b"weight");+ data.extend_from_slice(&(shape.len() as u32).to_le_bytes());+ for dimension in shape {+ data.extend_from_slice(&dimension.to_le_bytes());+ }+ data.extend_from_slice(&0u32.to_le_bytes()); // F32.+ data.extend_from_slice(&0u64.to_le_bytes()); // Relative data offset.+ data.resize(data.len().next_multiple_of(32), 0);+ data+}++#[test]+fn an_empty_tensor_has_zero_elements_in_every_axis_order() {+ for shape in [[u64::MAX, 2, 0], [2, u64::MAX, 0], [u64::MAX, 0, 2], [0, u64::MAX, 2]] {+ for data in [safetensors(&shape, 0), gguf(&shape)] {+ let report = ai_model::parse(&data, data.len() as u64).unwrap();+ assert_eq!((report.parameters, report.tensors[0].parameters), (0, 0), "shape {shape:?}, format {:?}", report.format);+ assert_eq!(report.tensors[0].data_bytes, Some(0));+ assert_eq!(report.parameters_by_type["F32"], 0);+ assert!(report.complete);+ assert_eq!(report.tensors_past_end, 0);+ assert!(report.warnings.is_empty(), "{:?}", report.warnings);+ }+ }+}++#[test]+fn scalar_nonempty_and_overflowing_shapes_keep_their_counts() {+ for (shape, bytes, parameters) in [(vec![], 4, 1), (vec![2, 3], 24, 6)] {+ let data = safetensors(&shape, bytes);+ let report = ai_model::parse(&data, data.len() as u64).unwrap();+ assert_eq!(report.parameters, parameters);+ assert!(report.warnings.is_empty());+ }+ let data = safetensors(&[u64::MAX, 2], 0);+ let report = ai_model::parse(&data, data.len() as u64).unwrap();+ assert_eq!(report.parameters, u64::MAX);+ assert!(report.warnings.iter().any(|w| w.contains("shape multiplies")));+}diff --git a/crates/formats/tests/unity_bundle_declared_size.rs b/crates/formats/tests/unity_bundle_declared_size.rsnew file mode 100644index 00000000..fecd5df2--- /dev/null+++ b/crates/formats/tests/unity_bundle_declared_size.rs@@ -0,0 +1,110 @@+use craft_anything_formats::{FormatError, unity_bundle};++struct Bundle {+ bytes: Vec<u8>,+ size_at: usize,+ header_end: u64,+ table_at: u64,+ data_at: u64,+}++fn bundle(version: u32, flags: u32) -> Bundle {+ let mut bytes = b"UnityFS\0".to_vec();+ bytes.extend_from_slice(&version.to_be_bytes());+ bytes.extend_from_slice(b"5.x.x\0fixture\0");+ let size_at = bytes.len();+ bytes.extend_from_slice(&0u64.to_be_bytes());+ bytes.extend_from_slice(&24u32.to_be_bytes());+ bytes.extend_from_slice(&24u32.to_be_bytes());+ bytes.extend_from_slice(&flags.to_be_bytes());+ if version >= 7 {+ bytes.resize(bytes.len().next_multiple_of(16), 0);+ }+ let header_end = bytes.len() as u64;+ let table_at;+ if flags & 0x80 == 0 {+ table_at = bytes.len() as u64;+ bytes.extend_from_slice(&[0; 24]); // Hash, zero blocks, zero nodes.+ } else {+ table_at = 0;+ }+ if flags & 0x200 != 0 {+ bytes.resize(bytes.len().next_multiple_of(16), 0);+ }+ let data_at = bytes.len() as u64;+ // A table with no blocks needs no data, but spare bytes are permitted in the data region.+ bytes.extend_from_slice(b"data!");+ let table_at = if flags & 0x80 != 0 {+ let at = bytes.len() as u64;+ bytes.extend_from_slice(&[0; 24]);+ at+ } else {+ table_at+ };+ let size = bytes.len() as u64;+ bytes[size_at..size_at + 8].copy_from_slice(&size.to_be_bytes());+ Bundle { bytes, size_at, header_end, table_at, data_at }+}++fn declare(bundle: &mut Bundle, size: u64) {+ bundle.bytes[bundle.size_at..bundle.size_at + 8].copy_from_slice(&size.to_be_bytes());+}++#[test]+fn trailing_bytes_do_not_move_the_declared_bundle_table() {+ for version in [6, 7, 8] {+ for flags in [0, 0x80, 0x200, 0x280] {+ let mut b = bundle(version, flags);+ let size = b.bytes.len() as u64;+ b.bytes.extend_from_slice(b"an unrelated suffix");+ let h = unity_bundle::header(&b.bytes, b.bytes.len() as u64).unwrap();+ assert_eq!((h.size, h.table_offset, h.data_offset), (size, b.table_at, b.data_at), "version {version}, flags {flags:#x}");+ let table = &b.bytes[h.table_offset as usize..h.table_offset as usize + h.table_size as usize];+ assert_eq!(unity_bundle::table(table, &h).unwrap(), (Vec::new(), Vec::new()));+ }+ }+}++#[test]+fn header_prefixes_describe_a_larger_bundle_without_reading_its_data() {+ let mut data = craft_anything_testkit::games::unity_bundle();+ assert!(data.len() > unity_bundle::HEADER_READ);+ let size = data.len() as u64;+ let expected = unity_bundle::header(&data, size).unwrap();+ assert_eq!(unity_bundle::header(&data[..unity_bundle::HEADER_READ], size).unwrap(), expected);+ data.extend_from_slice(b"suffix");+ assert_eq!(unity_bundle::header(&data[..unity_bundle::HEADER_READ], data.len() as u64).unwrap(), expected);+}++#[test]+fn declared_extent_must_contain_the_header_table_and_data_alignment() {+ for flags in [0, 0x80, 0x200, 0x280] {+ let b = bundle(8, flags);+ for size in [0, b.header_end - 1, b.bytes.len() as u64 + 1] {+ let mut bad = bundle(8, flags);+ declare(&mut bad, size);+ assert!(matches!(unity_bundle::header(&bad.bytes, bad.bytes.len() as u64), Err(FormatError::Malformed(_))), "flags {flags:#x}, size {size}");+ }+ }+ let mut front = bundle(8, 0);+ let size = front.table_at + 23;+ declare(&mut front, size);+ assert!(unity_bundle::header(&front.bytes, front.bytes.len() as u64).is_err(), "the front table crosses the declared end");++ let mut tail = bundle(8, 0x80);+ let size = tail.header_end + 23;+ declare(&mut tail, size);+ assert!(unity_bundle::header(&tail.bytes, tail.bytes.len() as u64).is_err(), "the tail table overlaps the header");++ let mut padded = bundle(8, 0x200);+ let size = padded.table_at + 24;+ assert!(size < padded.data_at);+ declare(&mut padded, size);+ assert!(unity_bundle::header(&padded.bytes, padded.bytes.len() as u64).is_err(), "data alignment crosses the declared end");++ let mut padded_tail = bundle(6, 0x280);+ assert!(padded_tail.header_end < padded_tail.data_at);+ let size = padded_tail.header_end + 24;+ declare(&mut padded_tail, size);+ assert!(unity_bundle::header(&padded_tail.bytes, padded_tail.bytes.len() as u64).is_err(), "the tail table overlaps aligned data");+}diff --git a/crates/formats/tests/unity_bundle_decompressed_length.rs b/crates/formats/tests/unity_bundle_decompressed_length.rsnew file mode 100644index 00000000..37af4c7e--- /dev/null+++ b/crates/formats/tests/unity_bundle_decompressed_length.rs@@ -0,0 +1,99 @@+use craft_anything_formats::{FormatError, unity_bundle};++fn lzma_piece(plain: &[u8], end_marker: bool) -> Vec<u8> {+ let options =+ lzma_rs::compress::Options { unpacked_size: lzma_rs::compress::UnpackedSize::WriteToHeader(if end_marker { None } else { Some(plain.len() as u64) }) };+ let mut alone = Vec::new();+ lzma_rs::lzma_compress_with_options(&mut std::io::Cursor::new(plain), &mut alone, &options).unwrap();+ alone.drain(5..13);+ alone+}++#[test]+fn stored_blocks_must_match_the_declared_output_length() {+ for expected in [0, 2, 4] {+ assert!(matches!(unity_bundle::decompress(0, b"abc", expected), Err(FormatError::Malformed(_))), "declared {expected} bytes");+ }+ assert!(unity_bundle::decompress(0, &[], 1).is_err());+ assert_eq!(unity_bundle::decompress(0, b"abc", 3).unwrap(), b"abc");+ assert!(unity_bundle::decompress(0, &[], 0).unwrap().is_empty());+}++#[test]+fn compressed_blocks_keep_their_exact_length_contract() {+ let plain = b"a small Unity bundle block";+ let lz4 = craft_anything_testkit::games::lz4_literals(plain);+ for kind in [2, 3] {+ assert_eq!(unity_bundle::decompress(kind, &lz4, plain.len() as u32).unwrap(), plain);+ assert!(unity_bundle::decompress(kind, &lz4, plain.len() as u32 + 1).is_err());+ assert!(unity_bundle::decompress(kind, &lz4, plain.len() as u32 - 1).is_err());+ }+ let unity_lzma = lzma_piece(plain, true);+ assert_eq!(unity_bundle::decompress(1, &unity_lzma, plain.len() as u32).unwrap(), plain);+ assert!(unity_bundle::decompress(1, &unity_lzma, plain.len() as u32 + 1).is_err());+}++#[test]+fn lzma_rejects_short_and_long_declarations_after_checking_completion() {+ let plain = b"a small Unity bundle block";+ for end_marker in [false, true] {+ let piece = lzma_piece(plain, end_marker);+ assert_eq!(unity_bundle::decompress(1, &piece, plain.len() as u32).unwrap(), plain);+ for declared in [0, 1, plain.len() as u32 - 1, plain.len() as u32 + 1] {+ assert!(unity_bundle::decompress(1, &piece, declared).is_err(), "end marker {end_marker}, declared {declared}");+ }+ }+}++#[test]+fn lzma_keeps_empty_and_short_zero_streams_without_requiring_end_markers() {+ for end_marker in [false, true] {+ for len in 0..=64 {+ let plain = vec![0; len];+ let piece = lzma_piece(&plain, end_marker);+ assert_eq!(unity_bundle::decompress(1, &piece, len as u32).unwrap(), plain, "end marker {end_marker}, length {len}");+ }+ }+}++#[test]+fn lzma_bounds_dictionary_growth_and_output_across_window_flushes() {+ let plain = vec![0xa5; 8192];+ for end_marker in [false, true] {+ let mut piece = lzma_piece(&plain, end_marker);+ for dictionary in [4096u32, u32::MAX] {+ piece[1..5].copy_from_slice(&dictionary.to_le_bytes());+ assert_eq!(unity_bundle::decompress(1, &piece, plain.len() as u32).unwrap(), plain);+ assert!(unity_bundle::decompress(1, &piece, 5000).is_err(), "end marker {end_marker}, dictionary {dictionary}");+ }+ }+}++#[test]+fn lzma_limits_an_oversized_dictionary_before_probing_past_a_tiny_output() {+ for end_marker in [false, true] {+ let mut piece = lzma_piece(b"ab", end_marker);+ piece[1..5].copy_from_slice(&u32::MAX.to_le_bytes());+ assert_eq!(unity_bundle::decompress(1, &piece, 2).unwrap(), b"ab");+ assert!(unity_bundle::decompress(1, &piece, 1).is_err());+ }+}++#[cfg(target_pointer_width = "32")]+#[test]+fn lzma_rejects_output_lengths_that_exceed_the_target_vector_limit() {+ let piece = lzma_piece(b"", false);+ assert!(unity_bundle::decompress(1, &piece, (isize::MAX as u32) + 1).is_err());+}++#[test]+fn lzma_rejects_truncated_or_unused_compressed_bytes() {+ let plain = b"a small Unity bundle block";+ for end_marker in [false, true] {+ let piece = lzma_piece(plain, end_marker);+ assert!(unity_bundle::decompress(1, &piece[..piece.len() - 1], plain.len() as u32).is_err());+ let mut trailing = piece;+ trailing.extend_from_slice(b"unused");+ assert!(unity_bundle::decompress(1, &trailing, plain.len() as u32).is_err());+ }+}diff --git a/crates/formats/tests/unity_serialized_object_ranges.rs b/crates/formats/tests/unity_serialized_object_ranges.rsnew file mode 100644index 00000000..d97951bd--- /dev/null+++ b/crates/formats/tests/unity_serialized_object_ranges.rs@@ -0,0 +1,78 @@+use craft_anything_formats::{FormatError, unity_serialized};++fn metadata(version: u32, big: bool, start: u64, size: u32) -> (Vec<u8>, unity_serialized::Header) {+ let mut data = vec![0; if version >= 22 { 48 } else { 20 }];+ let metadata_offset = data.len() as u64;+ let u32s = |data: &mut Vec<u8>, value: u32| data.extend_from_slice(&if big { value.to_be_bytes() } else { value.to_le_bytes() });+ let u64s = |data: &mut Vec<u8>, value: u64| data.extend_from_slice(&if big { value.to_be_bytes() } else { value.to_le_bytes() });+ data.extend_from_slice(b"2022.3.1f1\0");+ u32s(&mut data, 0); // Platform.+ data.push(0); // No type trees.+ u32s(&mut data, 1); // One TextAsset type.+ u32s(&mut data, 49);+ data.push(0); // Not stripped.+ data.extend_from_slice(&[0xff; 2]); // No script type index.+ data.extend_from_slice(&[0; 16]); // Type hash.+ u32s(&mut data, 1); // One object.+ data.resize(data.len().next_multiple_of(4), 0);+ u64s(&mut data, 7);+ if version >= 22 {+ u64s(&mut data, start);+ } else {+ u32s(&mut data, start as u32);+ }+ u32s(&mut data, size);+ u32s(&mut data, 0); // Type index.+ u32s(&mut data, 0); // Script references.+ u32s(&mut data, 0); // Externals.+ let h = unity_serialized::Header {+ version,+ big_endian: big,+ metadata_offset,+ metadata_size: data.len() as u64 - metadata_offset,+ data_offset: 256,+ file_size: 512,+ };+ (data, h)+}++#[test]+fn objects_must_fit_the_declared_file() {+ for version in [17, 22] {+ for big in [false, true] {+ for (start, size) in [(256, 1), (257, 0), (255, 2), (0, u32::MAX)] {+ let (data, h) = metadata(version, big, start, size);+ assert!(+ matches!(unity_serialized::metadata(&data, &h), Err(FormatError::Malformed(_))),+ "version {version}, big {big}, start {start}, size {size}"+ );+ }+ for (start, size) in [(0, 32), (255, 1), (256, 0)] {+ let (data, h) = metadata(version, big, start, size);+ let m = unity_serialized::metadata(&data, &h).unwrap();+ assert_eq!((m.objects[0].path_id, m.objects[0].offset, m.objects[0].size), (7, 256 + start, size));+ }+ }+ }+}++#[test]+fn object_offset_and_end_overflow_are_rejected() {+ for (start, size) in [(u64::MAX, 0), (u64::MAX, 1), (u64::MAX - 255, 0)] {+ let (data, h) = metadata(22, false, start, size);+ assert!(unity_serialized::metadata(&data, &h).is_err());+ }+ let (data, mut h) = metadata(22, false, 16, 1);+ h.data_offset = u64::MAX - 16;+ h.file_size = u64::MAX;+ assert!(unity_serialized::metadata(&data, &h).is_err(), "offset fits but offset plus size overflows");+}++#[test]+fn existing_serialized_objects_keep_their_ranges() {+ let data = craft_anything_testkit::games::unity_assets();+ let h = unity_serialized::header(&data, data.len() as u64).unwrap();+ let m = unity_serialized::metadata(&data, &h).unwrap();+ assert_eq!(m.objects.len(), 4);+ assert!(m.objects.iter().all(|o| o.offset >= h.data_offset && o.offset + u64::from(o.size) <= h.file_size));+}diff --git a/crates/formats/tests/unreal_fstring_terminators.rs b/crates/formats/tests/unreal_fstring_terminators.rsnew file mode 100644index 00000000..36219c25--- /dev/null+++ b/crates/formats/tests/unreal_fstring_terminators.rs@@ -0,0 +1,45 @@+use craft_anything_formats::{FormatError, unreal_iostore, unreal_pak};++fn index_mount(count: i32, bytes: &[u8]) -> Result<String, FormatError> {+ let footer = unreal_pak::Footer {+ version: 3,+ index_offset: 0,+ index_size: 0,+ encrypted_index: false,+ encryption_key_guid: None,+ compression_methods: Vec::new(),+ method_slots: 0,+ };+ let mut data = count.to_le_bytes().to_vec();+ data.extend_from_slice(bytes);+ data.extend_from_slice(&0i32.to_le_bytes()); // No entries.+ unreal_pak::index(&data, &footer).map(|index| index.mount_point)+}++#[test]+fn nonempty_fstrings_require_a_final_null_code_unit() {+ for (count, bytes) in [(3, &b"abc"[..]), (1, &b"x"[..]), (-2, &[b'A', 0, b'B', 0][..]), (-1, &[0, 1][..])] {+ assert!(matches!(index_mount(count, bytes), Err(FormatError::Malformed(_))), "count {count}, bytes {bytes:?}");+ }+}++#[test]+fn empty_and_terminated_ansi_and_utf16_strings_still_read() {+ assert_eq!(index_mount(0, &[]).unwrap(), "");+ assert_eq!(index_mount(1, &[0]).unwrap(), "");+ assert_eq!(index_mount(-1, &[0, 0]).unwrap(), "");+ assert_eq!(index_mount(5, b"Game\0").unwrap(), "Game");+ let name = "Game/地形/🧩";+ let units = name.encode_utf16().chain(std::iter::once(0)).collect::<Vec<_>>();+ let bytes = units.iter().flat_map(|u| u.to_le_bytes()).collect::<Vec<_>>();+ assert_eq!(index_mount(-(units.len() as i32), &bytes).unwrap(), name);+}++#[test]+fn iostore_uses_the_same_terminator_validation() {+ let mut toc = unreal_iostore::toc(&craft_anything_testkit::games::unreal_utoc(9, u32::MAX)).unwrap();+ let mount_len = i32::from_le_bytes(toc.directory_index[..4].try_into().unwrap()) as usize;+ assert_eq!(unreal_iostore::files(&toc, 10).unwrap().2, 3);+ toc.directory_index[4 + mount_len - 1] = b'!';+ assert!(matches!(unreal_iostore::files(&toc, 10), Err(FormatError::Malformed(_))));+}diff --git a/crates/formats/tests/unreal_pak_compression_slots.rs b/crates/formats/tests/unreal_pak_compression_slots.rsnew file mode 100644index 00000000..522ee56d--- /dev/null+++ b/crates/formats/tests/unreal_pak_compression_slots.rs@@ -0,0 +1,87 @@+use craft_anything_formats::unreal_pak::{self, Footer, Index};++fn footer(version: i32, names: &[&str]) -> Footer {+ let mut tail = vec![0; 17];+ tail.extend_from_slice(&unreal_pak::MAGIC.to_le_bytes());+ tail.extend_from_slice(&version.to_le_bytes());+ tail.extend_from_slice(&0u64.to_le_bytes());+ tail.extend_from_slice(&100u64.to_le_bytes());+ tail.extend_from_slice(&[0; 20]);+ for name in names {+ let mut slot = name.as_bytes().to_vec();+ slot.resize(32, 0);+ tail.extend_from_slice(&slot);+ }+ unreal_pak::footer(&tail, 4096).unwrap()+}++fn string(data: &mut Vec<u8>, value: &str) {+ data.extend_from_slice(&(value.len() as i32 + 1).to_le_bytes());+ data.extend_from_slice(value.as_bytes());+ data.push(0);+}++fn plain_method(footer: &Footer, method: u8) -> String {+ let mut data = Vec::new();+ string(&mut data, "");+ data.extend_from_slice(&1i32.to_le_bytes());+ string(&mut data, "file.bin");+ for value in [0u64, if method == 0 { 7 } else { 3 }, 7] {+ data.extend_from_slice(&value.to_le_bytes());+ }+ data.push(method); // Version 8 with four method slots stores the index in one byte.+ data.extend_from_slice(&[0; 20]);+ if method != 0 {+ data.extend_from_slice(&1i32.to_le_bytes());+ data.extend_from_slice(&70u64.to_le_bytes());+ data.extend_from_slice(&73u64.to_le_bytes());+ }+ data.push(0);+ data.extend_from_slice(&65536u32.to_le_bytes());+ unreal_pak::index(&data, footer).unwrap().entries[0].compression.clone()+}++fn packed_method(footer: &Footer, method: u8) -> String {+ let bits = (1u32 << 31) | (1 << 30) | (1 << 29) | (u32::from(method) << 23) | (u32::from(method != 0) << 6);+ let mut encoded = bits.to_le_bytes().to_vec();+ encoded.extend_from_slice(&0u32.to_le_bytes());+ encoded.extend_from_slice(&7u32.to_le_bytes());+ if method != 0 {+ encoded.extend_from_slice(&3u32.to_le_bytes());+ }+ let index = Index { mount_point: String::new(), file_count: 1, directory_index: None, entries: Vec::new(), encoded, plain: Vec::new() };+ let mut data = 1i32.to_le_bytes().to_vec();+ string(&mut data, "");+ data.extend_from_slice(&1i32.to_le_bytes());+ string(&mut data, "file.bin");+ data.extend_from_slice(&0i32.to_le_bytes());+ unreal_pak::directory(&data, footer, &index, 1).unwrap()[0].compression.clone()+}++#[test]+fn sparse_method_tables_keep_their_original_indices() {+ let old = footer(8, &["Zlib", "", "Oodle", ""]);+ let new = footer(11, &["Zlib", "", "Oodle", "", ""]);+ for (method, expected) in [(0, "none"), (1, "Zlib"), (2, "method 2"), (3, "Oodle"), (4, "method 4"), (6, "method 6")] {+ assert_eq!(plain_method(&old, method), expected, "plain method {method}");+ assert_eq!(packed_method(&new, method), expected, "packed method {method}");+ }+ assert_eq!(old.compression_methods, ["Zlib", "", "Oodle"]);+ assert_eq!(new.compression_methods, ["Zlib", "", "Oodle"]);+ assert_eq!((old.method_slots, new.method_slots), (4, 5));+}++#[test]+fn an_empty_first_slot_does_not_rename_method_one() {+ let f = footer(11, &["", "Oodle", "", "", ""]);+ assert_eq!(packed_method(&f, 1), "method 1");+ assert_eq!(packed_method(&f, 2), "Oodle");+}++#[test]+fn contiguous_method_tables_keep_their_existing_representation() {+ let f = footer(11, &["Zlib", "Oodle", "", "", ""]);+ assert_eq!(f.compression_methods, ["Zlib", "Oodle"]);+ assert_eq!(packed_method(&f, 1), "Zlib");+ assert_eq!(packed_method(&f, 2), "Oodle");+}diff --git a/crates/formats/tests/zip64_extra_boundaries.rs b/crates/formats/tests/zip64_extra_boundaries.rsindex e6341449..520edfbb 100644--- a/crates/formats/tests/zip64_extra_boundaries.rs+++ b/crates/formats/tests/zip64_extra_boundaries.rs@@ -48,3 +48,14 @@ fn a_legitimate_64_bit_value_equal_to_the_32_bit_sentinel_is_preserved() {let archive = zip::parse(&archive(&extra, 24), 10).unwrap();assert_eq!(archive.entries[0].uncompressed_size, u64::from(u32::MAX));}++#[test]+fn trailing_bytes_too_short_for_a_field_header_are_padding() {+ for stray in 1..=3usize {+ let mut extra = vec![0xaa, 0xbb, 0, 0];+ extra.extend(std::iter::repeat_n(0u8, stray));+ let data = archive(&extra, 36);+ let parsed = zip::parse(&data, 10).unwrap();+ assert_eq!(zip::read_entry(&data, &parsed.entries[0], 1).unwrap(), b"x", "stray {stray}");+ }+}diff --git a/crates/formats/tests/zip_directory_bounds.rs b/crates/formats/tests/zip_directory_bounds.rsnew file mode 100644index 00000000..9b4b110e--- /dev/null+++ b/crates/formats/tests/zip_directory_bounds.rs@@ -0,0 +1,72 @@+use craft_anything_formats::zip::{self, ZipError};+use craft_anything_testkit::electron::zip_stored;++#[test]+fn a_short_declared_entry_is_rejected_before_its_signature_is_checked() {+ for remaining in 0..46 {+ let mut data = zip_stored(&[("a", b"x")]);+ let end = data.len() - 22;+ let size = u32::from_le_bytes(data[end + 12..end + 16].try_into().unwrap());+ data[end + 8..end + 12].copy_from_slice(&[2, 0, 2, 0]);+ data[end + 12..end + 16].copy_from_slice(&(size + remaining).to_le_bytes());+ data.splice(end..end, vec![0; remaining as usize]);+ assert!(matches!(zip::parse(&data, 10), Err(ZipError::Truncated("directory entry"))), "remaining {remaining} bytes");+ }+}++#[test]+fn directory_names_and_comments_cannot_borrow_end_record_bytes() {+ for field in [28, 32] {+ let mut data = zip_stored(&[("a", b"x")]);+ let central = data.windows(4).position(|w| w == b"PK\x01\x02").unwrap();+ let length = if field == 28 { 2u16 } else { 1 };+ data[central + field..central + field + 2].copy_from_slice(&length.to_le_bytes());+ assert!(zip::parse(&data, 10).is_err(), "field {field}");+ }+}++#[test]+fn directory_extra_fields_cannot_borrow_end_record_bytes() {+ let mut data = zip_stored(&[("a", b"x")]);+ let central = data.windows(4).position(|w| w == b"PK\x01\x02").unwrap();+ data[central + 30..central + 32].copy_from_slice(&2u16.to_le_bytes());+ assert_eq!(zip::parse(&data, 10), Err(ZipError::Truncated("directory entry fields")));+}++#[test]+fn a_directory_cannot_extend_into_its_end_record() {+ let mut data = zip_stored(&[("a", b"x")]);+ let end = data.len() - 22;+ let size = u32::from_le_bytes(data[end + 12..end + 16].try_into().unwrap());+ data[end + 12..end + 16].copy_from_slice(&(size + 1).to_le_bytes());+ assert!(zip::parse(&data, 10).is_err());+}++#[test]+fn self_extracting_archives_keep_both_offset_conventions() {+ for adjusted in [false, true] {+ let mut data = zip_stored(&[("a", b"x")]);+ let central = data.windows(4).position(|w| w == b"PK\x01\x02").unwrap();+ let end = data.len() - 22;+ let stub = b"executable stub";+ if adjusted {+ data[central + 42..central + 46].copy_from_slice(&(stub.len() as u32).to_le_bytes());+ data[end + 16..end + 20].copy_from_slice(&((central + stub.len()) as u32).to_le_bytes());+ }+ let mut file = stub.to_vec();+ file.extend(data);+ let archive = zip::parse(&file, 10).unwrap();+ assert_eq!(zip::read_entry(&file, &archive.entries[0], 10).unwrap(), b"x");+ }+}++#[test]+fn a_directory_signature_after_the_entries_is_not_an_extra_file() {+ let mut data = zip_stored(&[("a", b"x")]);+ let end = data.len() - 22;+ let size = u32::from_le_bytes(data[end + 12..end + 16].try_into().unwrap());+ let signature = b"PK\x05\x05\x01\x00x";+ data[end + 12..end + 16].copy_from_slice(&(size + signature.len() as u32).to_le_bytes());+ data.splice(end..end, signature.iter().copied());+ assert_eq!(zip::parse(&data, 10).unwrap().entries.len(), 1);+}diff --git a/crates/formats/tests/zip_split_volumes.rs b/crates/formats/tests/zip_split_volumes.rsnew file mode 100644index 00000000..4d38a169--- /dev/null+++ b/crates/formats/tests/zip_split_volumes.rs@@ -0,0 +1,163 @@+use craft_anything_formats::zip::{self, ZipError};+use craft_anything_testkit::electron::zip_stored;++fn assert_split(data: &[u8]) {+ assert!(matches!(zip::parse(data, 10), Err(ZipError::Unsupported(_))));+}++#[test]+fn classic_end_records_must_describe_one_complete_volume() {+ for field in [4, 6, 8] {+ let mut data = zip_stored(&[("a", b"x")]);+ let end = data.len() - 22;+ let value = if field == 8 { 0u16 } else { 1 };+ data[end + field..end + field + 2].copy_from_slice(&value.to_le_bytes());+ assert_split(&data);+ }+}++#[test]+fn central_entries_cannot_point_to_another_volume() {+ let mut data = zip_stored(&[("a", b"x")]);+ let central = data.windows(4).position(|w| w == b"PK\x01\x02").unwrap();+ data[central + 34..central + 36].copy_from_slice(&1u16.to_le_bytes());+ assert_split(&data);+}++fn zip64_entry_disk(disk: u32, with_sizes_and_offset: bool) -> Vec<u8> {+ let mut data = zip_stored(&[("a", b"x")]);+ let central = data.windows(4).position(|w| w == b"PK\x01\x02").unwrap();+ let end = data.len() - 22;+ data[central + 34..central + 36].copy_from_slice(&u16::MAX.to_le_bytes());+ let mut extra = vec![1, 0, 4, 0];+ if with_sizes_and_offset {+ data[central + 20..central + 28].fill(0xff);+ data[central + 42..central + 46].fill(0xff);+ extra[2..4].copy_from_slice(&28u16.to_le_bytes());+ // Uncompressed size, compressed size, and local header offset precede the disk.+ for value in [1u64, 1, 0] {+ extra.extend(value.to_le_bytes());+ }+ }+ extra.extend(disk.to_le_bytes());+ data[central + 30..central + 32].copy_from_slice(&(extra.len() as u16).to_le_bytes());+ let directory_size = (end - central + extra.len()) as u32;+ data.splice(end..end, extra);+ let end = data.len() - 22;+ data[end + 12..end + 16].copy_from_slice(&directory_size.to_le_bytes());+ data+}++#[test]+fn a_zip64_disk_sentinel_is_resolved_before_rejecting_the_entry() {+ let data = zip64_entry_disk(0, false);+ let archive = zip::parse(&data, 10).unwrap();+ assert_eq!(zip::read_entry(&data, &archive.entries[0], 10).unwrap(), b"x");+ assert_split(&zip64_entry_disk(1, false));+}++#[test]+fn a_zip64_disk_sentinel_follows_sizes_and_the_local_offset() {+ let data = zip64_entry_disk(0, true);+ let archive = zip::parse(&data, 10).unwrap();+ assert_eq!(archive.entries[0].uncompressed_size, 1);+ assert_eq!(archive.entries[0].compressed_size, 1);+ assert_eq!(archive.entries[0].local_header_offset, 0);+ assert_eq!(zip::read_entry(&data, &archive.entries[0], 10).unwrap(), b"x");+ assert_split(&zip64_entry_disk(1, true));+}++fn zip64_archive(record_disk: u32, central_disk: u32, locator_disk: u32, disks: u32, entries_on_disk: u64) -> Vec<u8> {+ let mut data = zip_stored(&[("a", b"x")]);+ let end = data.len() - 22;+ let central = u32::from_le_bytes(data[end + 16..end + 20].try_into().unwrap());+ let size = u32::from_le_bytes(data[end + 12..end + 16].try_into().unwrap());+ let mut record = b"PK\x06\x06".to_vec();+ record.extend(44u64.to_le_bytes());+ record.extend([45, 0, 45, 0]);+ record.extend(record_disk.to_le_bytes());+ record.extend(central_disk.to_le_bytes());+ record.extend(entries_on_disk.to_le_bytes());+ record.extend(1u64.to_le_bytes());+ record.extend(u64::from(size).to_le_bytes());+ record.extend(u64::from(central).to_le_bytes());+ record.extend(b"PK\x06\x07");+ record.extend(locator_disk.to_le_bytes());+ record.extend((end as u64).to_le_bytes());+ record.extend(disks.to_le_bytes());+ data[end + 8..end + 12].fill(0xff);+ data.splice(end..end, record);+ data+}++#[test]+fn zip64_end_records_and_locators_must_also_describe_one_volume() {+ for fields in [(1, 0, 0, 1, 1), (0, 1, 0, 1, 1), (0, 0, 1, 1, 1), (0, 0, 0, 2, 1), (0, 0, 0, 1, 0)] {+ assert_split(&zip64_archive(fields.0, fields.1, fields.2, fields.3, fields.4));+ }+ assert_eq!(zip::parse(&zip64_archive(0, 0, 0, 1, 1), 10).unwrap().entries.len(), 1);+}++#[test]+fn zip64_does_not_erase_explicit_classic_volume_markers() {+ for field in [4, 6] {+ let mut data = zip64_archive(0, 0, 0, 1, 1);+ let end = data.len() - 22;+ data[end + field..end + field + 2].copy_from_slice(&1u16.to_le_bytes());+ assert_split(&data);+ data[end + field..end + field + 2].fill(0xff);+ assert_eq!(zip::parse(&data, 10).unwrap().entries.len(), 1);+ }+}++#[test]+fn zip64_does_not_erase_explicit_classic_entry_counts() {+ for field in [8, 10] {+ for count in [0u16, 2] {+ let mut data = zip64_archive(0, 0, 0, 1, 1);+ let end = data.len() - 22;+ data[end + field..end + field + 2].copy_from_slice(&count.to_le_bytes());+ assert!(matches!(zip::parse(&data, 10), Err(ZipError::Unsupported(_))), "field {field}, count {count}");+ }+ }+}++#[test]+fn mixed_classic_and_zip64_entry_counts_can_describe_one_volume() {+ for field in [8, 10] {+ let mut data = zip64_archive(0, 0, 0, 1, 1);+ let end = data.len() - 22;+ data[end + field..end + field + 2].copy_from_slice(&1u16.to_le_bytes());+ let archive = zip::parse(&data, 10).unwrap();+ assert_eq!(archive.entries.len(), 1, "field {field}");+ assert_eq!(zip::read_entry(&data, &archive.entries[0], 10).unwrap(), b"x");+ }+}++#[test]+fn zip64_cannot_replace_explicit_classic_directory_bounds() {+ for field in [12, 16] {+ let mut data = zip64_archive(0, 0, 0, 1, 1);+ let end = data.len() - 22;+ let value = u32::from_le_bytes(data[end + field..end + field + 4].try_into().unwrap());+ data[end + field..end + field + 4].copy_from_slice(&(value + 1).to_le_bytes());+ assert!(matches!(zip::parse(&data, 10), Err(ZipError::Corrupt(_))), "field {field}");+ }+}++#[test]+fn each_zip64_field_can_resolve_its_own_classic_sentinel() {+ for (field, width) in [(4, 2), (6, 2), (8, 2), (10, 2), (12, 4), (16, 4)] {+ let mut data = zip64_archive(0, 0, 0, 1, 1);+ let end = data.len() - 22;+ data[end + 8..end + 10].copy_from_slice(&1u16.to_le_bytes());+ data[end + 10..end + 12].copy_from_slice(&1u16.to_le_bytes());+ data[end + field..end + field + width].fill(0xff);+ let archive = zip::parse(&data, 10).unwrap();+ assert!(archive.zip64, "field {field}");+ assert_eq!(archive.declared_entries, 1, "field {field}");+ assert_eq!(archive.entries.len(), 1, "field {field}");+ assert_eq!(archive.prefix_bytes, 0, "field {field}");+ assert_eq!(zip::read_entry(&data, &archive.entries[0], 10).unwrap(), b"x", "field {field}");+ }+}diff --git a/docs/ROADMAP.md b/docs/ROADMAP.mdindex 44f4411c..62fecb52 100644--- a/docs/ROADMAP.md+++ b/docs/ROADMAP.md@@ -843,6 +843,74 @@ Owner: open · Status: in progress### R3.12 Format parser correctnessOwner: open · Status: in progress+- [x] Require a complete DNS question's type and class fields before retaining it, and keep+ truncated questions out of packet inventories while reporting the incomplete message+ — claimed: Afloat16, branch bugfix/r3.12-dns-question-class-review-20261104+- [x] Reject impossible IPv4 header and total lengths.+ — claimed: Afloat16, branch bugfix/r3.12-ipv4-header-lengths-20261105+- [x] Validate the version in IPv6 frames.+ — claimed: Afloat16, branch bugfix/r3.12-ipv6-version-20261105+- [x] Stop decoding extension headers inside noninitial IPv6 fragments.+ — claimed: Afloat16, branch bugfix/r3.12-ipv6-fragment-payload-20261105+- [x] Enforce the expanded DNS name wire-length limit.+ — claimed: Afloat16, branch bugfix/r3.12-dns-name-wire-length-20261105+- [x] Report truncated DNS TXT strings as incomplete.+ — claimed: Afloat16, branch bugfix/r3.12-dns-txt-truncation-20261105+ Preserve empty ANY/NONE UPDATE prerequisites with zero TTL; keep TXT validation scoped to parsed answers/prerequisites.+ Preserve empty multicast/unicast DNS-SD TXT records using wire-label service instance names.+- [x] Read HTTP Host fields only from the header section.+ — claimed: Afloat16, branch bugfix/r3.12-http-host-boundary-20261105+- [x] Keep capture flow timestamps in chronological order.+ — claimed: Afloat16, branch bugfix/r3.12-capture-flow-time-range-20261105+- [x] Reject incomplete simple packet block payloads.+ — claimed: Afloat16, branch bugfix/r3.12-pcapng-simple-block-length-20261105+ Count rejected lengths against the packet scan limit and summarize them once at the end of the walk.+- [x] Keep ZIP directory entries within the declared directory.+ — claimed: Afloat16, branch bugfix/r3.12-zip-directory-bounds-20261105+- [x] Refuse split ZIP archives without their other volumes.+ — claimed: Afloat16, branch bugfix/r3.12-zip-multidisk-20261105+- [x] Check Unity bundle blocks against their declared output lengths.+ — claimed: Afloat16, branch bugfix/r3.12-unity-bundle-decompressed-length-20261105+- [x] Locate Unity bundle metadata within the declared bundle size.+ — claimed: Afloat16, branch bugfix/r3.12-unity-bundle-declared-size-20261105+- [ ] Check that Unity bundle compressed blocks end before the trailing block table, or the declared+ bundle end for front-positioned tables, so bytes outside the data region cannot supply block contents.+- [x] Reject Unity serialized objects outside their declared file.+ — claimed: Afloat16, branch bugfix/r3.12-unity-serialized-object-ranges-20261105+- [x] Preserve compression method slots in Unreal pak indexes.+ — claimed: Afloat16, branch bugfix/r3.12-unreal-pak-compression-slots-20261105+- [x] Require complete terminators in Unreal FString values.+ — claimed: Afloat16, branch bugfix/r3.12-unreal-fstring-terminators-20261105+- [x] Count every compression block spanned by an IoStore chunk.+ — claimed: Afloat16, branch bugfix/r3.12-iostore-unaligned-chunk-blocks-20261105+- [x] Reject truncated IoStore fixed headers.+ — claimed: Afloat16, branch bugfix/r3.12-iostore-complete-header-20261105+- [x] Reject invalid marshal long integer digits.+ — claimed: Afloat16, branch bugfix/r3.12-pyc-long-limb-validation-20261105+- [x] Check expanded RGBA image sizes and enforce output budgets before allocation.+ — claimed: Afloat16, branch bugfix/r3.12-pixel-rgba-output-overflow-20261105+- [x] Count empty tensor shapes consistently across axis orders.+ — claimed: Afloat16, branch bugfix/r3.12-tensor-zero-dimension-product-20261105+- [x] Find APK signatures through valid ZIP comments and framed central directories.+ — claimed: Afloat16, branch bugfix/r3.12-apk-sign-eocd-comment-boundary-20261105+- [x] Keep Mach-O load-command facts within their command.+ — claimed: Afloat16, branch bugfix/r3.12-macho-load-command-framing-20261105+- [x] Keep Mach-O function starts within their declared payload.+ — claimed: Afloat16, branch bugfix/r3.12-macho-function-starts-payload-boundary-20261105+- [x] Keep code-signature children and verification reads within their declared superblob.+ — claimed: Afloat16, branch bugfix/r3.12-codesign-superblob-length-boundary-20261105+- [x] Keep PE optional-header reads within the declared header.+ — claimed: Afloat16, branch bugfix/r3.12-pe-optional-header-framing-20261105+- [x] Keep PE resource metadata within the resource directory.+ — claimed: Afloat16, branch bugfix/r3.12-pe-resource-directory-boundary-20261105+- [x] Keep Go function tables and names within their section.+ — claimed: Afloat16, branch bugfix/r3.12-go-pclntab-section-boundary-20261105+- [x] Preserve complete Unicode characters in shortened .NET strings.+ — claimed: Afloat16, branch bugfix/r3.12-dotnet-user-string-surrogate-limit-20261105+- [x] Locate ELF core mapping names after the complete declared table.+ — claimed: Afloat16, branch bugfix/r3.12-elf-core-file-name-count-cap-20261105+- [x] Keep DOS relocations inside the declared executable header.+ — claimed: Afloat16, branch bugfix/r3.12-dos-relocation-header-boundary-20261105- [x] Parsers refuse what they used to half-read: binary plists keep objects inside their objectarea and reject unrepresentable widths, base64 (plists, source maps) refuses damaged tailsand incomplete quanta through one shared decoder, OIDs must be minimally encoded, and string@@ -869,6 +937,11 @@ Owner: open · Status: in progressShared-budget revision `29c48e03` passed [full Linux CI](https://github.com/storytold/craft-anything/actions/runs/41762780268).The merge with main `41d2175e` awaits a new CI run.+- [x] Keep DNS answer names inside their declared RDATA, including compressed names and MX+ exchanges, and report malformed records as incomplete instead of inventing answer values,+ while preserving legal empty DNS UPDATE RRset prerequisites+ — claimed: Afloat16, branch bugfix/r3.12-dns-rdata-names-review-20261104+### R3.13 Web inspection correctnessOwner: open · Status: in progress- [x] The HTML scanner finds script preloads in `rel` token lists, decodes asset URLs once (numericdiff --git a/docs/STATUS.md b/docs/STATUS.mdindex cacb8612..6c65f852 100644--- a/docs/STATUS.md+++ b/docs/STATUS.md@@ -1,13 +1,44 @@# StatusWhat works today and how it was checked. The plan, owners and order of work are in-[ROADMAP.md](ROADMAP.md). Last updated 2026-11-04. The baseline audit on 2026-10-23 from `main` had 923 tests passing;+[ROADMAP.md](ROADMAP.md). Last updated 2026-11-05. The baseline audit on 2026-10-23 from `main` had 923 tests passing;workspace clippy, layers, fmt and the secret scan of all history were clean. Chinese UI checks are listed separately below.## What works, and how it was checked| Area | State | Verified by ||---|---|---|+| DNS question boundaries | A question is retained only when its name, type and class are complete. A missing class byte marks the DNS message incomplete; preceding complete questions remain available, and incomplete questions do not enter the query inventory | Four packet regressions cover both truncation lengths, multiple questions, complete class values and the capture summary. No live capture was used |+| Reject impossible IPv4 header and total lengths | IPv4 decoding rejects impossible header lengths and reports incomplete base headers or options. | Synthetic byte fixtures in `pcap_ipv4_lengths` integration regressions. Cover 10–19 captured header bytes, total lengths below IHL, missing options, complete options, truncated transport headers with readable ports, and a cut UDP payload with both ports and its captured length preserved. |+| Validate the version in IPv6 frames | IPv6 decoding checks the packet version before reporting IPv6 facts, including captures declaring raw IPv6; explicit raw IPv4 likewise uses IPv4 validation. | Synthetic byte fixtures in `pcap_ipv6_version` integration regressions. Cover incorrect versions behind the IPv6 EtherType, mismatched explicit raw IPv4 and IPv6 link types, matching explicit and generic raw packets, and valid IPv6 traffic-class bits. |+| Stop decoding extension headers inside noninitial IPv6 fragments | Noninitial IPv6 fragments no longer supply fabricated extension or transport headers. | Synthetic byte fixtures in `pcap_ipv6_fragments` integration regressions. Cover payloads resembling a second fragment header or destination-options header, plus valid first and atomic fragments. |+| Enforce the expanded DNS name wire-length limit | DNS names obey the 255-byte expanded wire limit. Invalid name-valued RDATA marks parsed answers incomplete; legal empty ANY/NONE UPDATE prerequisites remain supported. | Synthetic byte fixtures in `pcap_dns_name_limit` integration regressions. Cover plain and compressed names at the wire limit, literal-prefix compression overflow in questions and NS/CNAME/PTR/MX records, record boundaries, root names, and legal empty UPDATE prerequisites followed by another record. Coverage is limited to the parsed questions and first 64 answer or UPDATE prerequisite records. |+| Report truncated DNS TXT strings as incomplete | TXT validation covers at most 64 parsed answers, or prerequisites for DNS UPDATE; authority and additional records are not inspected. Empty ANY/NONE UPDATE prerequisites with zero TTL and empty TXT records for wire-identified DNS-SD instance owners in ordinary multicast/unicast DNS are retained. | Synthetic byte fixtures in `pcap_dns_txt_lengths` integration regressions. Cover a cut first string, a cut later string, a missing string body, and valid empty or multiple strings. Review regressions preserve empty UPDATE prerequisites and following records, while checking opcode, class, TTL, and truncated-string boundaries. DNS-SD cases cover known answers, cache-flush records, compressed owners, literal dots and case, plus ordinary/invalid owners and nonempty truncation. |+| Read HTTP Host fields only from the header section | HTTP Host values come only from complete request header lines. | Synthetic byte fixtures in `pcap_http_host_boundary` integration regressions. Cover forged Host lines in bodies, invalid UTF-8 before Host, mixed-case field names, and incomplete header lines. |+| Keep capture flow timestamps in chronological order | Flow time ranges use the earliest and latest available timestamps. | Synthetic byte fixtures in `pcap_flow_time_range` integration regressions. Cover out-of-order timestamps and a flow that starts in an untimestamped simple packet block. |+| Reject incomplete simple packet block payloads | Simple packet blocks validate captured lengths and exclude alignment padding. Rejected lengths count toward the packet scan limit and produce one summary warning when the walk ends. | Synthetic byte fixtures in `pcapng_simple_payload` integration regressions. Cover short payloads, excess payload bytes, unlimited snaplen, legitimate snaplen truncation, alignment padding, bounded warnings, and later valid frames. Unit regressions exercise rejected-only and mixed packet budgets, exact EOF, and repeated iterator exhaustion. |+| Keep ZIP directory entries within the declared directory | ZIP central-directory entries stay within the declared directory. | Synthetic byte fixtures in `zip_directory_bounds` integration regressions. Cover a short declared entry after a valid entry even without a signature, fields borrowing end-record bytes, an oversized directory, both self-extracting offset conventions, and a trailing directory signature. |+| Refuse split ZIP archives without their other volumes | ZIP archives requiring other volumes are reported as unsupported. Explicit classic directory sizes and offsets must agree with ZIP64 unless set to their own sentinel. | Synthetic byte fixtures in `zip_split_volumes` integration regressions. Cover classic disk markers and counts, ZIP64 locator and record fields, conflicting classic/ZIP64 entry counts, entry disk sentinels both alone and after the sizes and local offset, and valid single-volume controls with mixed count sentinels. Additional regressions cover explicit directory-bound conflicts and each independently saturated end field. |+| Check Unity bundle blocks against their declared output lengths | Unity bundle pieces must match their declared decoded lengths; LZMA must finish within the supplied compressed piece. | Synthetic byte fixtures in `unity_bundle_decompressed_length` integration regressions. Cover stored pieces that are short or long, LZ4 and LZ4HC size mismatches, LZMA with or without end markers, empty and short zero streams, bounded dictionary/output growth, oversized dictionary properties, and truncated or trailing compressed bytes. |+| Locate Unity bundle metadata within the declared bundle size | Unity bundle metadata placement respects the declared bundle extent. | Synthetic byte fixtures in `unity_bundle_declared_size` integration regressions. Cover versions 6 through 8, front and trailing tables, padding, appended bytes, invalid extents, and header-only prefixes of larger bundles. |+| Reject Unity serialized objects outside their declared file | Unity serialized object ranges must fit the declared file. | Synthetic byte fixtures in `unity_serialized_object_ranges` integration regressions. Cover offset and end overflow, ranges crossing the file boundary, both byte orders, valid existing objects, and empty objects at EOF. |+| Preserve compression method slots in Unreal pak indexes | PAK compression names retain their original method numbers. | Synthetic byte fixtures in `unreal_pak_compression_slots` integration regressions. Cover interior and leading empty slots in plain and packed indexes, plus unchanged contiguous method tables. |+| Require complete terminators in Unreal FString values | PAK and IoStore strings require complete terminators. | Synthetic byte fixtures in `unreal_fstring_terminators` integration regressions. Cover missing ANSI and UTF-16 terminators, zero-length strings, terminated empty strings, Unicode names, and the shared IoStore path. |+| Count every compression block spanned by an IoStore chunk | IoStore stored-size totals include every block touched by a chunk. | Synthetic byte fixtures in `iostore_unaligned_chunk_blocks` integration regressions. Cover unaligned chunks spanning two or three blocks, aligned chunks, exact-boundary endings, and empty chunks. |+| Reject truncated IoStore fixed headers | IoStore parsing rejects incomplete fixed headers. | Synthetic byte fixtures in `iostore_complete_header` integration regressions. Cover every truncation in the reserved header tail and complete fixtures for the supported header versions. |+| Reject invalid marshal long integer digits | Python marshal long integers reject invalid digit encodings. | Synthetic byte fixtures in `pyc_long_limb_validation` integration regressions. Cover positive and negative invalid digits, leading zero digits, canonical zero, ordinary integers, and valid large integers. |+| Check expanded RGBA image sizes before allocation | Pixel decoding checks expanded RGBA size, applies a caller-selected output budget (256 MiB by default), and reserves output fallibly. Packed 16-bit layouts decode without an intermediate image allocation. | Synthetic byte fixtures in `pixel_rgba_output_overflow` cover budget rejection before source access, exact output limits, caller overrides, overflow, ordinary and packed pixels, partial blocks, empty pictures, and truncated input. Large-dimension checks use empty source data; a 32-bit expansion-overflow regression is included. |+| Count empty tensor shapes consistently across axis orders | Zero-sized tensors have zero elements regardless of dimension order. | Synthetic byte fixtures in `tensor_zero_dimension_product` integration regressions. Cover zero-dimension permutations in safetensors and GGUF, scalar shapes, nonempty tensors, and shapes with genuine multiplication overflow. |+| Find APK signatures through valid ZIP comments | APK signing-block lookup validates EOCD framing and central-directory bounds, prefers recoverable signers over empty or unreadable decoys, and warns when distinct readable signing blocks remain ambiguous. Directory, pair and signer probes share a scan-wide record budget; bounded caches reuse directory prefixes and physical pair and signer records while checking each candidate’s own extent. | Comment-boundary regressions cover nested empty, unknown and unreadable blocks, a fully framed spanning pair, ambiguous readable blocks, empty signed ZIPs and thousands of candidates sharing the genuine directory. Existing damaged-block recovery and directory-framing tests remain; unit tests cover probe recovery, parser limits, directory-cache isolation, optional tails, repeated signer probes with shorter and longer bounds, and work/cache exhaustion. |+| Keep Mach-O load-command facts within their command | Mach-O command facts stay inside their declared command boundaries. | Synthetic byte fixtures in `macho_load_command_framing` integration regressions. Cover undersized build commands, a shortened command region, tool entries spilling into the next command, truncated section arrays in both parsers with later complete commands preserved, and complete commands in both byte orders. |+| Keep Mach-O function starts within their declared payload | Mach-O function-start deltas stay within their payload and cannot wrap addresses. | Synthetic byte fixtures in `macho_function_starts_payload_boundary` integration regressions. Cover a continuation byte at the payload end, retained complete deltas, address overflow, and valid multibyte deltas with a terminator. |+| Keep code-signature children within their declared superblob | Code-signature metadata and engine verification reads stay inside the declared superblob. Stored page and special-slot hashes also stay inside their own CodeDirectory; invalid relative offsets leave them unchecked. Declared special slots whose stored hashes cannot be read remain visible as `not-checked` with `stored: null`. | Synthetic `codesign_superblob_length_boundary` regressions cover an external CMS blob, a cut index, a short header, and a complete signature. Engine signature regressions keep appended entitlements and stored page hashes out of verification, with complete-signature and genuine CMS controls. An engine regression covers all five reported special-slot identities with unreadable stored hashes. Engine regressions also cover stored hashes past a CodeDirectory but inside the superblob, and special-slot offsets before the CodeDirectory. |+| Keep PE optional-header reads within the declared header | PE optional-header reads respect the declared header size. | Synthetic byte fixtures in `pe_optional_header_framing` integration regressions. Cover short fixed headers, partial directory entries, zero or one directory in both PE variants, and unused bytes before the section table. |+| Keep PE resource metadata within the resource directory | PE resource metadata stays within the declared directory and the contiguous range selected by the existing RVA mapping, including raw extents, section priority, header-prefix boundaries, and 32-bit address limits. Resource names must fit their full declared UTF-16 span before the existing 4096-unit output cap is applied. | Synthetic byte fixtures in `pe_resource_directory_boundary` integration regressions. Cover escaping subdirectories and names, partial data-entry records, a valid resource whose payload is addressed separately from its metadata, complete versus directory-truncated names above the output cap, names crossing a section's raw extent with the resource root at its start or inside it, metadata in the header prefix, mapping changes caused by section priority, zero-extent and lower-priority controls, and the end of the RVA address space. |+| Keep Go function tables and names within their section | Go function tables and names respect every containing file-backed section during scan recovery, including unnamed and overlapping sections. Recovery outside known sections keeps the whole-file extent. A named table with no readable functions allows bounded recovery while retaining its partial evidence if no replacement is found. | Synthetic byte fixtures in `go::tests` unit regressions. Cover Go 1.16 and 1.20 table entries, unterminated names, public inspect()/functions() recovery from truncated or empty named sections and interior headers, unreadable named tables with or without a readable interior replacement, unnamed entry/name boundaries, overlapping or expired extents, and recovery outside known sections or without section headers, with complete-table controls. |+| Preserve complete Unicode characters in shortened .NET strings | .NET user-string limits preserve supplementary Unicode characters. | Synthetic byte fixtures in `dotnet_user_string_surrogate_limit` integration regressions. Cover supplementary characters at several limits, a zero-character limit, and unpaired surrogates followed by valid characters. |+| Locate ELF core mapping names after the complete declared table | ELF core filenames follow the full declared mapping table. | Synthetic byte fixtures in `elf_core_file_name_count_cap` integration regressions. Cover 65,537 declared mappings with capped output, an impossible declared table, and a small complete mapping table. |+| Keep DOS relocations inside the declared executable header | DOS relocation records stay inside the declared MZ header. | Synthetic byte fixtures in `dos_relocation_header_boundary` integration regressions. Cover records extending into the load module, a partial final record, and complete records ending exactly at the header boundary. || Java decompilation | `java_vineflower_decompile` decompiles a real JAR to source with the pinned Vineflower 1.12.0, run through the configured Java | Live run on Linux x86-64 (OpenJDK 21.0.12.1) against Apache Commons IO 2.16.1 (497 KB, 374 entries): 253 source files, exit 0; `org.apache.commons.io.FileUtils` returned 1,350 lines with the class and its file-reading methods present. The engine install matched the pinned SHA-256. Not checked: Windows and macOS, a `.class` input, or a second JAR || Conversation width | Agent paragraphs, inline code and fenced code stay within the message column, including glossary terms followed by long file links (#523) | UI regression checks painted text and subsequent answers against the composer bounds in Project and Ask at 1920 × 1032 and 1280 × 820; Unicode/formatted glossary hover check || Settings saved on exit | Pending app settings merge the session's latest AI table when its guard is available. A busy session defers non-AI edits in `config.pending.toml` without waiting for the tool; startup recovers them with the latest committed AI table | Isolated child-process regression exercises idle and busy exit saves, a late AI commit, startup recovery and pending non-AI edits; engine tests cover sidecar migrations and damaged/newer files. No live desktop shutdown was exercised |@@ -332,6 +363,18 @@ so reopening keeps the new request's full allowance. The original failure or canthe result; a reset that cannot be saved is reported separately and never overwrites a brokenor newer record. Scripted turns cover both outcomes, blank notes and unreadable records.+## DNS answer name boundaries++Within the first 64 decoded answer/prerequisite records, NS, CNAME, PTR and MX values must be+fully encoded inside their declared RDATA. DNS UPDATE RRset prerequisites may carry an empty+value only with CLASS ANY/NONE and TTL zero; later prerequisite records are still decoded.+Backward compression pointers still work, including names with a label before the pointer.+A truncated name, missing MX preference or extra bytes after a name marks the DNS message+incomplete and keeps that answer out of the packet and capture inventories. Earlier complete+answers remain available. Eleven synthetic packet regressions cover those boundaries, root+names, literal names, legal and malformed UPDATE prerequisites, and the summary inventory;+no live capture was used.+## Local model identifier task hintsAutomatic local setup recognizes numeric suffixes on known embedding, reranking and speech task