From e28c25639b6559cbd2d4eb2db4c00c36ec69998f Mon Sep 17 00:00:00 2001 From: Martin Ball <98639962+benandez@users.noreply.github.com> Date: Tue, 17 Nov 2026 20:47:27 +0100 Subject: [PATCH] #778: the ZIP entry-count guard delegates to craft-zip (#6948) * #778: zip_guard delegates to craft-zip's entry-count guard wordcraft_doc::zip_guard::check and zip64_entry_count_sample now call craft-zip, which also treats a central-directory size of u32::MAX as a ZIP64 marker. Co-Authored-By: Claude Opus 5.5 * #778: Cargo.lock: wordcraft-doc depends on craft-zip Co-Authored-By: Claude Opus 5.5 * #778: zip_guard: craft-zip test-support as a dev-dependency Co-Authored-By: Claude Opus 5.5 --------- Co-authored-by: Claude Opus 5.5 --- Cargo.lock | 1 + crates/doc/Cargo.toml | 4 +- crates/doc/src/zip_guard.rs | 264 ++++++++++++++++++++---------------- 3 files changed, 149 insertions(+), 120 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 527d0426dd..3505fb3a9f 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -7385,6 +7385,7 @@ name = "wordcraft-doc" version = "0.18.1" dependencies = [ "base64 0.23.1", + "craft-zip", "log", "proptest", "serde", diff --git a/crates/doc/Cargo.toml b/crates/doc/Cargo.toml index e6c7f41c0c..7d640d5a5e 100644 --- a/crates/doc/Cargo.toml +++ b/crates/doc/Cargo.toml @@ -13,10 +13,11 @@ workspace = true # `zip_guard::zip64_entry_count_sample`) and the step count of # `work::count`; turned on only as a dev-dependency, so never built into # the app. -test-support = [] +test-support = ["craft-zip/test-support"] [dependencies] wordcraft-geom = { workspace = true } +craft-zip = { workspace = true } base64 = { workspace = true } log = { workspace = true } serde = { workspace = true } @@ -25,4 +26,5 @@ thiserror = { workspace = true } unicode-segmentation = { workspace = true } [dev-dependencies] +craft-zip = { workspace = true, features = ["test-support"] } proptest = { workspace = true } diff --git a/crates/doc/src/zip_guard.rs b/crates/doc/src/zip_guard.rs index 0610cac1e3..b6364c5bac 100644 --- a/crates/doc/src/zip_guard.rs +++ b/crates/doc/src/zip_guard.rs @@ -1,131 +1,21 @@ -//! A bytes-only check of a ZIP package's declared entry count before the `zip` crate opens it -//! (#3660). Every reader of `.docx`, `.odt` and spreadsheet packages calls [`check`] first. -//! -//! `zip::ZipArchive::new` reserves room for, and parses, as many central directory headers as the -//! end record declares before its caller can look at `len()`. A ZIP64 end record can declare -//! millions of entries for a file of a few hundred megabytes (only 46 bytes each have to fit), and -//! each parsed entry costs several times that in memory. Here the end records are found the way -//! `zip` finds them (APPNOTE.TXT §4.3.14 to §4.3.16), and a package declaring more than the -//! reader's limit is refused before `zip` parses anything. Anything else that is wrong is left for -//! `zip` to report. - -const EOCD: &[u8; 4] = b"PK\x05\x06"; -const EOCD64_LOCATOR: &[u8; 4] = b"PK\x06\x07"; -const EOCD64: &[u8; 4] = b"PK\x06\x06"; -const CENTRAL_HEADER: &[u8; 4] = b"PK\x01\x02"; - -/// End records looked at, at most. A package has one; a few more can turn up inside stored data. -const MAX_END_RECORDS: usize = 16; +//! A bytes-only check of a ZIP package's declared entry count, run before anything opens the ZIP +//! (#3660). The logic lives in `craft-zip`; this wraps its error as a `String`. /// Refuse `bytes` when the end record `zip` would use declares more than `max_entries` entries. -/// -/// `zip` searches the file backwards for an end of central directory record. A ZIP64 one points -/// through its locator at the ZIP64 end record, which `zip` looks for from the locator's offset -/// on: every such record there is checked, and as `zip` may fall back to an earlier end record -/// when one doesn't parse, the search goes on. A plain one is used when it declares no entries, or -/// a central directory header lies between its directory offset and itself: it is the last one -/// looked at. pub fn check(bytes: &[u8], max_entries: u64) -> Result<(), String> { - let u16_at = |at: usize| bytes.get(at..at.checked_add(2)?).map(|b| u16::from_le_bytes([b[0], b[1]])); - let u32_at = |at: usize| bytes.get(at..at.checked_add(4)?).map(|b| u32::from_le_bytes([b[0], b[1], b[2], b[3]])); - let u64_at = |at: usize| bytes.get(at..at.checked_add(8)?).and_then(|b| <[u8; 8]>::try_from(b).ok()).map(u64::from_le_bytes); - let refuse = |n: u64| -> Result<(), String> { - if n > max_entries { Err(format!("the package declares {n} entries, more than {max_entries}")) } else { Ok(()) } - }; - let mut end = bytes.len(); - let mut seen = 0; - while let Some(at) = bytes.get(..end).and_then(|b| b.windows(4).rposition(|w| w == EOCD)) { - end = at; - seen += 1; - if seen > MAX_END_RECORDS { - return Err(format!("more than {MAX_END_RECORDS} end of central directory records")); - } - // `zip` skips a record whose comment runs past the end of the file. - let Some(comment) = u16_at(at + 20) else { continue }; - if at + 22 + usize::from(comment) > bytes.len() { - continue; - } - let (Some(on_disk), Some(total), Some(cd_offset)) = (u16_at(at + 8), u16_at(at + 10), u32_at(at + 16)) else { continue }; - let zip64 = total == u16::MAX || cd_offset == u32::MAX; - if zip64 - && let Some(locator) = at.checked_sub(20) - && bytes.get(locator..locator + 4) == Some(EOCD64_LOCATOR.as_slice()) - { - let (Some(eocd64), Some(disks)) = (u64_at(locator + 8), u32_at(locator + 16)) else { continue }; - let Some(from) = usize::try_from(eocd64).ok().filter(|&f| f < locator) else { continue }; - if disks > 1 { - continue; - } - let records = bytes.get(from..locator).unwrap_or_default().windows(4).enumerate().filter(|(_, w)| *w == EOCD64); - for (i, _) in records { - let p = from + i; - refuse(u64_at(p + 24).unwrap_or(0).max(u64_at(p + 32).unwrap_or(0)))?; - } - continue; - } - if total == 0 { - return Ok(()); - } - let cd = cd_offset as usize; - if cd < at && bytes.get(cd..at).is_some_and(|b| b.windows(4).any(|w| w == CENTRAL_HEADER)) { - return refuse(u64::from(on_disk.max(total))); - } - } - Ok(()) + craft_zip::check_entry_count(bytes, max_entries).map_err(|e| e.to_string()) } -/// A package of one empty stored file, `a`, whose central directory lists it `entries` times (at -/// most as many as fit in 64 MiB) under a ZIP64 end record that declares them all: `zip` 3.0.0 -/// parses and keeps every one of them before its caller can count them. Regression input for the -/// readers' tests: built only for tests, this crate's and (through the `test-support` feature, -/// which they turn on as a dev-dependency) the readers', never into the app. +/// A ZIP64 package declaring `entries` entries: regression input for the readers' tests. #[cfg(any(test, feature = "test-support"))] -pub fn zip64_entry_count_sample(entries: u64) -> Vec { - // Local file header (APPNOTE.TXT §4.3.7): version 10, stored, no data, name "a". - let mut f = b"PK\x03\x04".to_vec(); - f.extend_from_slice(&[10, 0, 0, 0, 0, 0, 0, 0, 0x21, 0]); // version, flags, method, time, date - f.extend_from_slice(&[0; 12]); // crc, sizes - f.extend_from_slice(&[1, 0, 0, 0]); // name and extra lengths - f.push(b'a'); - let cd_at = f.len() as u64; - // Its central header (§4.3.12), 47 bytes. - let mut header = CENTRAL_HEADER.to_vec(); - header.extend_from_slice(&[10, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0x21, 0]); // versions, flags, method, time, date - header.extend_from_slice(&[0; 12]); // crc, sizes - header.extend_from_slice(&[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]); // name, extra, comment, disk, attributes - header.extend_from_slice(&[0; 4]); // local header offset - header.push(b'a'); - let count = entries.min((64 << 20) / header.len() as u64); - for _ in 0..count { - f.extend_from_slice(&header); - } - let cd_len = f.len() as u64 - cd_at; - let eocd64_at = f.len() as u64; - // ZIP64 end of central directory record (§4.3.14), 56 bytes. - f.extend_from_slice(EOCD64); - f.extend_from_slice(&44u64.to_le_bytes()); // size of the rest of the record - f.extend_from_slice(&[45, 0, 45, 0]); // versions - f.extend_from_slice(&[0; 8]); // this disk, disk with the central directory - f.extend_from_slice(&entries.to_le_bytes()); // entries on this disk - f.extend_from_slice(&entries.to_le_bytes()); // entries - f.extend_from_slice(&cd_len.to_le_bytes()); - f.extend_from_slice(&cd_at.to_le_bytes()); - // Its locator (§4.3.15), 20 bytes. - f.extend_from_slice(EOCD64_LOCATOR); - f.extend_from_slice(&0u32.to_le_bytes()); - f.extend_from_slice(&eocd64_at.to_le_bytes()); - f.extend_from_slice(&1u32.to_le_bytes()); - // End of central directory record (§4.3.16), 22 bytes, each count and offset "see ZIP64". - f.extend_from_slice(EOCD); - f.extend_from_slice(&[0; 4]); - f.extend_from_slice(&[0xFF; 12]); - f.extend_from_slice(&[0; 2]); - f -} +pub use craft_zip::zip64_entry_count_sample; #[cfg(test)] mod tests { - use super::{CENTRAL_HEADER, EOCD, check, zip64_entry_count_sample}; + use super::{check, zip64_entry_count_sample}; + + const EOCD: &[u8; 4] = b"PK\x05\x06"; + const CENTRAL_HEADER: &[u8; 4] = b"PK\x01\x02"; /// A plain package's tail: one central header at 0, then an end record declaring `entries`. fn plain(entries: u16, comment: &[u8]) -> Vec { @@ -188,4 +78,140 @@ mod tests { let f: Vec = (0..20).flat_map(|_| EOCD.iter().copied().chain(record)).collect(); assert!(check(&f, 20_000).is_err_and(|e| e.contains("end of central directory records"))); } + + /// The pre-cutover implementation, kept as a differential oracle. + mod old { + const EOCD: &[u8; 4] = b"PK\x05\x06"; + const EOCD64_LOCATOR: &[u8; 4] = b"PK\x06\x07"; + const EOCD64: &[u8; 4] = b"PK\x06\x06"; + const CENTRAL_HEADER: &[u8; 4] = b"PK\x01\x02"; + /// End records looked at, at most. A package has one; a few more can turn up inside stored data. + const MAX_END_RECORDS: usize = 16; + + /// Refuse `bytes` when the end record `zip` would use declares more than `max_entries` entries. + /// + /// `zip` searches the file backwards for an end of central directory record. A ZIP64 one points + /// through its locator at the ZIP64 end record, which `zip` looks for from the locator's offset + /// on: every such record there is checked, and as `zip` may fall back to an earlier end record + /// when one doesn't parse, the search goes on. A plain one is used when it declares no entries, or + /// a central directory header lies between its directory offset and itself: it is the last one + /// looked at. + pub fn check(bytes: &[u8], max_entries: u64) -> Result<(), String> { + let u16_at = |at: usize| bytes.get(at..at.checked_add(2)?).map(|b| u16::from_le_bytes([b[0], b[1]])); + let u32_at = |at: usize| bytes.get(at..at.checked_add(4)?).map(|b| u32::from_le_bytes([b[0], b[1], b[2], b[3]])); + let u64_at = |at: usize| bytes.get(at..at.checked_add(8)?).and_then(|b| <[u8; 8]>::try_from(b).ok()).map(u64::from_le_bytes); + let refuse = |n: u64| -> Result<(), String> { + if n > max_entries { Err(format!("the package declares {n} entries, more than {max_entries}")) } else { Ok(()) } + }; + let mut end = bytes.len(); + let mut seen = 0; + while let Some(at) = bytes.get(..end).and_then(|b| b.windows(4).rposition(|w| w == EOCD)) { + end = at; + seen += 1; + if seen > MAX_END_RECORDS { + return Err(format!("more than {MAX_END_RECORDS} end of central directory records")); + } + // `zip` skips a record whose comment runs past the end of the file. + let Some(comment) = u16_at(at + 20) else { continue }; + if at + 22 + usize::from(comment) > bytes.len() { + continue; + } + let (Some(on_disk), Some(total), Some(cd_offset)) = (u16_at(at + 8), u16_at(at + 10), u32_at(at + 16)) else { continue }; + let zip64 = total == u16::MAX || cd_offset == u32::MAX; + if zip64 + && let Some(locator) = at.checked_sub(20) + && bytes.get(locator..locator + 4) == Some(EOCD64_LOCATOR.as_slice()) + { + let (Some(eocd64), Some(disks)) = (u64_at(locator + 8), u32_at(locator + 16)) else { continue }; + let Some(from) = usize::try_from(eocd64).ok().filter(|&f| f < locator) else { continue }; + if disks > 1 { + continue; + } + let records = bytes.get(from..locator).unwrap_or_default().windows(4).enumerate().filter(|(_, w)| *w == EOCD64); + for (i, _) in records { + let p = from + i; + refuse(u64_at(p + 24).unwrap_or(0).max(u64_at(p + 32).unwrap_or(0)))?; + } + continue; + } + if total == 0 { + return Ok(()); + } + let cd = cd_offset as usize; + if cd < at && bytes.get(cd..at).is_some_and(|b| b.windows(4).any(|w| w == CENTRAL_HEADER)) { + return refuse(u64::from(on_disk.max(total))); + } + } + Ok(()) + } + } + + fn sentinel_sample() -> Vec { + // ZIP64 sample whose plain end record claims one entry and a real directory offset but + // sets the directory size to u32::MAX, the ZIP64 marker `zip` honours. + let mut f = zip64_entry_count_sample(30_000); + let n = f.len(); + f[n - 14..n - 12].copy_from_slice(&1u16.to_le_bytes()); + f[n - 12..n - 10].copy_from_slice(&1u16.to_le_bytes()); + f[n - 10..n - 6].copy_from_slice(&u32::MAX.to_le_bytes()); + f[n - 6..n - 2].copy_from_slice(&31u32.to_le_bytes()); + f + } + + fn corpus() -> Vec> { + let mut seed = 0x2545_F491_4F6C_DD1Du64; + let mut rnd = |n: usize| -> Vec { + (0..n) + .map(|_| { + seed ^= seed << 13; + seed ^= seed >> 7; + seed ^= seed << 17; + (seed >> 24) as u8 + }) + .collect() + }; + let mut truncated = zip64_entry_count_sample(10); + truncated.truncate(truncated.len() - 5); + vec![ + vec![], + plain(3, b""), + plain(30_000, b"c"), + zip64_entry_count_sample(1), + zip64_entry_count_sample(10), + zip64_entry_count_sample(30_000), + zip64_entry_count_sample(5_000_000), + truncated, + rnd(1), + rnd(100), + rnd(5000), + ] + } + + #[test] + fn agrees_with_the_old_implementation_except_for_the_sentinel() { + for (i, input) in corpus().iter().enumerate() { + for max in [0u64, 9, 10, 20_000] { + assert_eq!(check(input, max).is_ok(), old::check(input, max).is_ok(), "input {i}, max {max}"); + } + } + } + + #[test] + fn a_directory_size_sentinel_alone_cannot_bypass_the_count_limit() { + let f = sentinel_sample(); + assert!(old::check(&f, 20_000).is_ok(), "the old check missed it"); + assert!(check(&f, 20_000).is_err_and(|e| e.contains("30000 entries"))); + } + + #[test] + fn no_truncation_of_a_zip64_package_panics() { + for f in [zip64_entry_count_sample(10), sentinel_sample()] { + for end in 0..=f.len().min(4096) { + let _ = check(&f[..end], 5); + } + for start in f.len().saturating_sub(300)..f.len() { + let _ = check(&f[start..], 5); + } + } + } }