Merge pull request #2032 from r31lin/fix/preview-reader-non-zip

document-bundle: turn a non-zip file away after four bytes in read_preview_from
This commit is contained in:
Dylan M. Taylor authored and GitHub committed 2026-11-18 00:00:13 -05:00
commit b6020ec2fc
3 files changed
+116 -3

No files matched your search

+3 -2
View File
@@ -127,9 +127,10 @@ pub fn starts_designcraft(prefix: &[u8]) -> bool {
craft_document_bundle::starts_with_mimetype(prefix, BUNDLE)
}
/// Read the first-page PNG preview from a ZIP package, with a fixed 4 MiB cap.
/// Read the first-page PNG preview from an unprefixed native ZIP package, with a fixed 4 MiB cap.
/// Nonmatching signatures are rejected after at most four bytes read.
pub fn read_preview<R: Read + Seek>(reader: R) -> Option<Vec<u8>> {
craft_document_bundle::read_preview_from(reader, PREVIEW)
craft_document_bundle::read_unprefixed_preview_from(reader, PREVIEW)
}
fn is_linked(document: &Value, id: &str) -> bool {
+34
View File
@@ -167,3 +167,37 @@ fn bytes_supplied_for_a_linked_asset_are_not_written() -> Result<(), Box<dyn std
assert_eq!(load::<Value>(&bytes)?.assets, [("8".to_owned(), b"kept".to_vec())]);
Ok(())
}
#[test]
fn preview_uses_the_strict_signature_path_without_losing_cursor_independence() -> Result<(), Box<dyn std::error::Error>> {
struct Counted {
cursor: std::io::Cursor<Vec<u8>>,
bytes_read: usize,
}
impl std::io::Read for Counted {
fn read(&mut self, out: &mut [u8]) -> std::io::Result<usize> {
let n = self.cursor.read(out)?;
self.bytes_read += n;
Ok(n)
}
}
impl std::io::Seek for Counted {
fn seek(&mut self, position: std::io::SeekFrom) -> std::io::Result<u64> {
self.cursor.seek(position)
}
}
let mut non_zip = Counted { cursor: std::io::Cursor::new(vec![0x42; 1 << 20]), bytes_read: 0 };
non_zip.cursor.set_position(100);
assert_eq!(read_preview(&mut non_zip), None);
assert!(non_zip.bytes_read <= 4);
let bytes = save(&json!({}), "DesignCraft test", Some(b"png"), &[], &[])?;
let mut cursor = std::io::Cursor::new(&bytes);
cursor.set_position(bytes.len() as u64);
assert_eq!(read_preview(cursor), Some(b"png".to_vec()));
let mut prefixed = b"MZsynthetic-prefix".to_vec();
prefixed.extend(bytes);
assert_eq!(craft_document_bundle::read_preview_from(std::io::Cursor::new(&prefixed), PREVIEW), Some(b"png".to_vec()));
assert_eq!(read_preview(std::io::Cursor::new(prefixed)), None);
Ok(())
}
+79 -1
View File
@@ -315,7 +315,8 @@ pub fn read_preview(bytes: &[u8], preview_entry: &str) -> Option<Vec<u8>> {
archive.read(preview_entry, PREVIEW_LIMIT).ok().flatten()
}
/// Read a bounded preview from a seekable file without loading the full bundle into memory.
/// Read a preview from a seekable ZIP, including archives with a leading prefix.
/// The decompressed preview is limited to 4 MiB; archive discovery may perform substantial I/O.
pub fn read_preview_from<R: Read + Seek>(reader: R, preview_entry: &str) -> Option<Vec<u8>> {
const PREVIEW_LIMIT: u64 = 4 << 20;
let mut zip = zip::ZipArchive::new(reader).ok()?;
@@ -328,6 +329,22 @@ pub fn read_preview_from<R: Read + Seek>(reader: R, preview_entry: &str) -> Opti
(u64::try_from(preview.len()).ok()? <= PREVIEW_LIMIT).then_some(preview)
}
/// Read a preview only from a ZIP with a local-file header at byte zero.
///
/// Use for native formats whose contract excludes prefixed/self-extracting archives.
/// Nonmatching inputs require at most four bytes read, regardless of the initial cursor position.
/// Matching ZIPs still require directory I/O; this is not an overall read/time budget.
pub fn read_unprefixed_preview_from<R: Read + Seek>(mut reader: R, preview_entry: &str) -> Option<Vec<u8>> {
reader.seek(std::io::SeekFrom::Start(0)).ok()?;
let mut magic = [0u8; 4];
reader.read_exact(&mut magic).ok()?;
if &magic != b"PK\x03\x04" {
return None;
}
reader.seek(std::io::SeekFrom::Start(0)).ok()?;
read_preview_from(reader, preview_entry)
}
fn read_legacy(bytes: &[u8], spec: Spec<'_>) -> Result<Package, Error> {
let mut document: Value = serde_json::from_slice(bytes).map_err(|e| Error::NotBundle(e.to_string()))?;
let mut assets = Vec::new();
@@ -409,6 +426,67 @@ mod tests {
assert_eq!(read_preview(&bytes, SPEC.preview_entry).as_deref(), Some(&b"png"[..]));
}
/// Counts the bytes read through it.
struct Counting<R> {
inner: R,
read: usize,
}
impl<R: Read> Read for Counting<R> {
fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
let n = self.inner.read(buf)?;
self.read += n;
Ok(n)
}
}
impl<R: Seek> Seek for Counting<R> {
fn seek(&mut self, pos: std::io::SeekFrom) -> std::io::Result<u64> {
self.inner.seek(pos)
}
}
#[test]
fn preview_from_a_reader_reads_a_bundle() {
let bytes = write(br#"{}"#, 4, "Test 0.1", Some(b"png"), &[], &[], SPEC).unwrap();
assert_eq!(read_preview_from(Cursor::new(&bytes), SPEC.preview_entry).as_deref(), Some(&b"png"[..]));
}
#[test]
fn prefixed_bundle_admission_is_explicit() {
let bundle = write(br#"{}"#, 4, "Test 0.1", Some(b"png"), &[], &[], SPEC).unwrap();
let mut bytes = b"MZsynthetic-prefix".to_vec();
bytes.extend(bundle);
let mut original = zip::ZipArchive::new(Cursor::new(&bytes)).unwrap();
let mut preview = Vec::new();
original.by_name(SPEC.preview_entry).unwrap().read_to_end(&mut preview).unwrap();
assert_eq!(preview, b"png");
assert!(has_document(&bytes, SPEC));
assert!(!starts_with_mimetype(&bytes, SPEC));
assert_eq!(read_preview_from(Cursor::new(&bytes), SPEC.preview_entry), Some(preview));
assert_eq!(read_unprefixed_preview_from(Cursor::new(&bytes), SPEC.preview_entry), None);
}
#[test]
fn preview_from_an_advanced_reader_still_reads_the_bundle() {
let bytes = write(br#"{}"#, 4, "Test 0.1", Some(b"png"), &[], &[], SPEC).unwrap();
for offset in [1, 4, bytes.len() / 2, bytes.len()] {
let mut reader = Cursor::new(&bytes);
reader.set_position(offset as u64);
assert_eq!(read_preview_from(reader.clone(), SPEC.preview_entry).as_deref(), Some(&b"png"[..]), "offset {offset}");
assert_eq!(read_unprefixed_preview_from(reader, SPEC.preview_entry).as_deref(), Some(&b"png"[..]), "offset {offset}");
}
}
#[test]
fn preview_from_a_non_zip_reads_only_its_signature() {
let mut file = Counting { inner: Cursor::new(vec![0x42u8; 1 << 20]), read: 0 };
assert_eq!(read_unprefixed_preview_from(&mut file, SPEC.preview_entry), None);
assert!(file.read <= 4, "read {} bytes of a file that is not a zip", file.read);
let mut empty = Counting { inner: Cursor::new(Vec::new()), read: 0 };
assert_eq!(read_unprefixed_preview_from(&mut empty, SPEC.preview_entry), None);
}
#[test]
fn extracts_legacy_inline_assets() {
let loaded = read(br#"{"assetData":{"7":"AQID"},"name":"x"}"#, 4, SPEC).unwrap();