From 139f881f811cb9d56a0c800b3367e8a77638afc8 Mon Sep 17 00:00:00 2001 From: dotCooCoo Date: Mon, 16 Nov 2026 07:56:57 -0800 Subject: [PATCH] .ai import: a refused PDF part's error says why the editing data couldn't be read When the import refuses a file's PDF part and its editing data can't be read either, the error named only the PDF part. It now adds "its editing data couldn't be read either ()", as layers already do (crates/eps/src/import.rs). The reasons come from the editing data reader (a size limit, damaged compression) and from the private data streams (larger than 256 MB, another filter or decode parameters, damaged zlib data). A file without editing data, and an open with pages picked, layers off or the editing data off, keep the PDF part's error. Part of #4366. --- crates/engine/src/cmd/fileio/load.rs | 26 +++++--- .../engine/src/cmd/fileio/tests_aiimport.rs | 19 +++++- crates/engine/tests/import_fuzz.rs | 3 +- crates/pdf/src/lib.rs | 2 +- crates/pdf/src/pages.rs | 59 +++++++++++++------ crates/pdf/src/tests/import_layers.rs | 9 +++ crates/testkit/src/ai.rs | 15 ++++- 7 files changed, 100 insertions(+), 33 deletions(-) diff --git a/crates/engine/src/cmd/fileio/load.rs b/crates/engine/src/cmd/fileio/load.rs index e26d9a765a..ff0e14c40d 100644 --- a/crates/engine/src/cmd/fileio/load.rs +++ b/crates/engine/src/cmd/fileio/load.rs @@ -286,16 +286,24 @@ fn editing_copy(opened: &vectorcraft_pdf::Opened, opts: &LoadOptions) -> Option< /// A `.ai`, or a PDF saved with the editing data, whose PDF part can't be read (`e`, the import's /// error) from the editor's own copy of its art alone, as a file saved without PDF compatibility -/// is read, its first note saying why: `None` when pages are picked, layers or the editing data -/// are off, or the file has no editing data that reads. Its type is outlines when `opts` asks. -fn without_pdf_part(bytes: &[u8], opts: &LoadOptions, e: &EngineError) -> Option<(Document, Vec)> { +/// is read, its first note saying why. Else `e`: as it is when pages are picked, layers or the +/// editing data are off, or the file has no editing data, and followed by why when the file has +/// editing data that can't be read. Its type is outlines when `opts` asks. +fn without_pdf_part(bytes: &[u8], opts: &LoadOptions, e: EngineError) -> Result<(Document, Vec)> { if opts.pages.is_some() || !opts.layers || !opts.editing_data { - return None; + return Err(e); + } + let read = vectorcraft_pdf::read_illustrator_data_without_pdf_part(bytes, opts.password.as_deref()) + .and_then(|private| private.map(|p| vectorcraft_eps::ai_alone_on_page(&p.data, p.trim, p.user_unit, opts.legacy_names)).transpose()); + match read { + Ok(Some((doc, warnings))) => { + let notes = + std::iter::once(format!("the PDF part couldn't be read ({e}): the file opened from its editing data")).chain(warnings).collect(); + Ok(outlined_if_asked(doc, notes, opts)) + } + Ok(None) => Err(e), + Err(why) => Err(err(format!("{e}; its editing data couldn't be read either ({why})"))), } - let private = vectorcraft_pdf::illustrator_data_without_pdf_part(bytes, opts.password.as_deref())?; - let (doc, warnings) = vectorcraft_eps::ai_alone_on_page(&private.data, private.trim, private.user_unit, opts.legacy_names).ok()?; - let notes = std::iter::once(format!("the PDF part couldn't be read ({e}): the file opened from its editing data")).chain(warnings).collect(); - Some(outlined_if_asked(doc, notes, opts)) } /// Is `w` a note on the PDF part as a page, which says nothing was skipped: that the art off the @@ -497,7 +505,7 @@ pub fn load_with(name: &str, bytes: &[u8], opts: &LoadOptions) -> Result .inspect(|_| editing_data = true), // A PDF part that can't be read (a stream the import refuses): the editing copy // alone where it reads, else the error. - Err(e) => without_pdf_part(bytes, opts, &e).inspect(|_| editing_data = true).ok_or(e), + Err(e) => without_pdf_part(bytes, opts, e).inspect(|_| editing_data = true), } })?; // The File Info of a file read from its pages or its editing copy. diff --git a/crates/engine/src/cmd/fileio/tests_aiimport.rs b/crates/engine/src/cmd/fileio/tests_aiimport.rs index d89dab774f..9d263c8c97 100644 --- a/crates/engine/src/cmd/fileio/tests_aiimport.rs +++ b/crates/engine/src/cmd/fileio/tests_aiimport.rs @@ -799,7 +799,7 @@ fn unread_pdf_part(e: &str) -> String { /// #4366: a `.ai`, or a PDF saved with the editing data, whose PDF part can't be read opens from /// its editing data, with a first note saying why. Pages picked, layers off or the editing data -/// off keep the error, and so does editing data that can't be read. +/// off keep the error. Editing data that can't be read keeps it too, followed by why. #[test] fn a_file_whose_pdf_part_cant_be_read_opens_from_its_editing_data() { let mut s = Session::new(); @@ -817,10 +817,25 @@ fn a_file_whose_pdf_part_cant_be_read_opens_from_its_editing_data() { } for (name, file) in refused_files(b"%AI12_CompressedData not zlib", ai::page_pdf()) { let plain = open(&mut s, name, &file, json!({"editingData": false})).unwrap_err().to_string(); - assert_eq!(open(&mut s, name, &file, json!({})).unwrap_err().to_string(), plain, "{name}"); + let both = format!("{plain}; its editing data couldn't be read either (its zlib compression is damaged)"); + assert_eq!(open(&mut s, name, &file, json!({})).unwrap_err().to_string(), both, "{name}"); + for p in [json!({"pages": "1"}), json!({"layers": false})] { + assert_eq!(open(&mut s, name, &file, p.clone()).unwrap_err().to_string(), plain, "{name}: {p}"); + } } } +/// #4366: editing data stored in a form the reader doesn't take, beside a PDF part that can't be +/// read, is named in the error. +#[test] +fn the_error_says_why_the_editing_data_couldnt_be_read() { + let mut s = Session::new(); + let file = ai::ai_with_private_streams(&compressed(&ai::sample_data()), ai::page_pdf(), REFUSED_CONTENT, "/Filter /Bogus "); + let plain = open(&mut s, "art.ai", &file, json!({"editingData": false})).unwrap_err().to_string(); + let e = open(&mut s, "art.ai", &file, json!({})).unwrap_err().to_string(); + assert_eq!(e, format!("{plain}; its editing data couldn't be read either (it is stored in a form that isn't read)")); +} + /// A file saved in units of 10 points (`/UserUnit 10`, as in /// `an_ai_file_with_a_user_unit_opens_at_its_size_in_points`) whose PDF part can't be read opens /// from its editing data at its size in points. diff --git a/crates/engine/tests/import_fuzz.rs b/crates/engine/tests/import_fuzz.rs index 6630f91a47..e8baa20a55 100644 --- a/crates/engine/tests/import_fuzz.rs +++ b/crates/engine/tests/import_fuzz.rs @@ -4498,7 +4498,8 @@ proptest! { })?; match opened { Some(Ok(editing)) => prop_assert!(editing), - Some(Err(e)) => prop_assert_eq!(Some(e), page_error), + // The page's error, followed by why the editing data couldn't be read when it says. + Some(Err(e)) => prop_assert!(page_error.as_deref().is_some_and(|p| e == p || e.starts_with(&format!("{p}; its editing data couldn't be read either ("))), "{e}"), None => {} } } diff --git a/crates/pdf/src/lib.rs b/crates/pdf/src/lib.rs index 9cef615783..a5f93a2a76 100644 --- a/crates/pdf/src/lib.rs +++ b/crates/pdf/src/lib.rs @@ -87,7 +87,7 @@ pub use import::{ pub use pages::reads_of; pub use pages::{ IllustratorData, Opened, PageInfo, PdfInfo, TrimPages, has_illustrator_data, illustrator_data, illustrator_data_without_pdf_part, info, - is_postscript, open_pdf, + is_postscript, open_pdf, read_illustrator_data_without_pdf_part, }; pub use piece_info::{PRIVATE_CHUNK, PrivateData}; pub use post::{THUMBNAIL_SIZE, Thumbnail}; diff --git a/crates/pdf/src/pages.rs b/crates/pdf/src/pages.rs index 683a14d1c3..64e6217148 100644 --- a/crates/pdf/src/pages.rs +++ b/crates/pdf/src/pages.rs @@ -502,25 +502,42 @@ pub struct IllustratorData { /// objects, and only the private data streams are read, with the same limits. `None` when the /// file itself can't be opened, or as for [`illustrator_data`]. pub fn illustrator_data_without_pdf_part(bytes: &[u8], password: Option<&str>) -> Option { - let pdf = open_structural_with_options(bytes, password, &open_options()).ok()?; - let data = private_data(&pdf)?; - let page = pdf.pages().first()?; + read_illustrator_data_without_pdf_part(bytes, password).ok().flatten() +} + +/// [`illustrator_data_without_pdf_part`], with why the private data can't be read: `Ok(None)` +/// when the file can't be opened or has no private data, `Err` (for a note, such as "it is larger +/// than 256 MB") when it has private data that can't be read. +pub fn read_illustrator_data_without_pdf_part(bytes: &[u8], password: Option<&str>) -> Result, String> { + let Ok(pdf) = open_structural_with_options(bytes, password, &open_options()) else { return Ok(None) }; + let Some(data) = read_private_data(&pdf)? else { return Ok(None) }; + let Some(page) = pdf.pages().first() else { return Ok(None) }; // (The page transform is in points: it applies the `UserUnit`.) let trim = frame(page, CropTo::Trim).1; - Some(IllustratorData { data, user_unit: f64::from(page.user_unit()), trim: (trim.width(), trim.height()) }) + Ok(Some(IllustratorData { data, user_unit: f64::from(page.user_unit()), trim: (trim.width(), trim.height()) })) } /// The private data of `pdf`'s first page, as [`illustrator_data`] reads it. fn private_data(pdf: &Pdf) -> Option> { - let page = pdf.pages().first()?; - let private = page.raw().get::>(b"PieceInfo")?.get::>(PRIVATE_DATA_OWNER)?.get::>(b"Private")?; + read_private_data(pdf).ok().flatten() +} + +/// [`private_data`], with why a private data stream can't be read ([`inflated`]). +fn read_private_data(pdf: &Pdf) -> Result>, String> { + let Some(private) = pdf + .pages() + .first() + .and_then(|page| page.raw().get::>(b"PieceInfo")?.get::>(PRIVATE_DATA_OWNER)?.get::>(b"Private")) + else { + return Ok(None); + }; let key = if private.contains_key(b"AIPrivateData1") { "AIPrivateData" } else { "AIPDFPrivateData" }; let mut data = vec![]; for n in 1..=100_000u32 { let Some(stream) = private.get::>(format!("{key}{n}").as_bytes()) else { break }; - data.extend_from_slice(&inflated(&stream, MAX_PRIVATE - data.len())?); + data.extend_from_slice(&inflated(&stream, MAX_PRIVATE - data.len()).map_err(|why| why.to_string())?); } - (!data.is_empty()).then_some(data) + Ok((!data.is_empty()).then_some(data)) } /// Does the PDF's first page carry an editor's copy of the art: a PDF-compatible `.ai` @@ -538,10 +555,12 @@ fn has_private_data_keys(pdf: &Pdf) -> bool { /// `stream` decoded, up to `most` bytes: the decoder is run here rather than by the PDF reader's /// `decoded()`, which has no limit, so a stream of zeros can't grow to the size of the memory. Only a /// stream that is plain or only deflated is read (the private data is no other), without decode -/// parameters; else, or when it is larger once decoded, `None`. A filter the reader doesn't know -/// counts as another filter. -fn inflated(stream: &Stream<'_>, most: usize) -> Option> { +/// parameters; else, or when it is larger once decoded, `Err` with why. A filter the reader +/// doesn't know counts as another filter. +fn inflated(stream: &Stream<'_>, most: usize) -> Result, String> { use std::io::Read; + let unread = || "it is stored in a form that isn't read".to_string(); + let too_large = || format!("it is larger than {} MB", MAX_PRIVATE >> 20); let dict = stream.dict(); let named = |key: &[u8]| match dict.get::>(key) { None | Some(Object::Null(_)) => Some(0), @@ -555,24 +574,28 @@ fn inflated(stream: &Stream<'_>, most: usize) -> Option> { Some(_) => true, }; if params(b"DecodeParms") || params(b"DP") { - return None; + return Err(unread()); } let filters = stream.filters(); // (The reader leaves out the filters it doesn't know.) - if named(b"Filter")?.max(named(b"F")?) != filters.len() { - return None; + if named(b"Filter").zip(named(b"F")).is_none_or(|(a, b)| a.max(b) != filters.len()) { + return Err(unread()); } let raw = stream.raw_data(); let mut out = vec![]; - let limit = u64::try_from(most).ok()?.checked_add(1)?; + let limit = u64::try_from(most).ok().and_then(|m| m.checked_add(1)).ok_or_else(too_large)?; match filters.as_slice() { [] if raw.len() <= most => out.extend_from_slice(&raw), + [] => return Err(too_large()), [craft_pdf::syntax::Filter::FlateDecode] => { - flate2::read::ZlibDecoder::new(&*raw).take(limit).read_to_end(&mut out).ok()?; + flate2::read::ZlibDecoder::new(&*raw).take(limit).read_to_end(&mut out).map_err(|_| "its zlib compression is damaged".to_string())?; } - _ => return None, + _ => return Err(unread()), } - (out.len() <= most).then_some(out) + if out.len() > most { + return Err(too_large()); + } + Ok(out) } /// Does `page` carry an editor's private data (`PieceInfo` keys starting with `AIPrivateData`)? diff --git a/crates/pdf/src/tests/import_layers.rs b/crates/pdf/src/tests/import_layers.rs index 86e1a88fb1..c0f9dfc970 100644 --- a/crates/pdf/src/tests/import_layers.rs +++ b/crates/pdf/src/tests/import_layers.rs @@ -446,7 +446,16 @@ fn private_data_reads_without_a_pdf_part_that_cant_be_read() { let pdf = pdf_with_catalog(std::slice::from_ref(&page), &[&first, &two], "", None); assert!(illustrator_data(&pdf, None).is_none(), "{odd}"); assert!(illustrator_data_without_pdf_part(&pdf, None).is_none(), "{odd}"); + let why = read_illustrator_data_without_pdf_part(&pdf, None); + assert_eq!(why, Err("it is stored in a form that isn't read".to_string()), "{odd}"); } + // Damaged zlib data, and a file without private data or that isn't a PDF. + let damaged = stream("/Filter /FlateDecode", "not zlib"); + let pdf = pdf_with_catalog(std::slice::from_ref(&page), &[&damaged, &two], "", None); + assert_eq!(read_illustrator_data_without_pdf_part(&pdf, None), Err("its zlib compression is damaged".to_string())); + let bare = pdf_with_catalog(&[PdfPage::new(100.0, 100.0, "")], &[], "", None); + assert_eq!(read_illustrator_data_without_pdf_part(&bare, None), Ok(None)); + assert_eq!(read_illustrator_data_without_pdf_part(b"not a pdf", None), Ok(None)); } /// Art in ordinary tags nested inside a layer's sequence goes to that layer; the group is kept diff --git a/crates/testkit/src/ai.rs b/crates/testkit/src/ai.rs index b560255e32..50af82d04c 100644 --- a/crates/testkit/src/ai.rs +++ b/crates/testkit/src/ai.rs @@ -338,6 +338,12 @@ pub fn ai_with_entries_and_content(private: &[u8], page: &str, entries: &str, co with_private(private, page, "AIPrivateData", entries, content) } +/// [`ai_with_content`] with `streams` more in the dictionary of each private data stream +/// (`/Filter /Bogus `). +pub fn ai_with_private_streams(private: &[u8], page: &str, content: &str, streams: &str) -> Vec { + with_private_streams(private, page, "AIPrivateData", "", content, streams) +} + /// A PDF saved with Illustrator's editing data: [`ai`]'s file with the two streams under /// `AIPDFPrivateData1` and `AIPDFPrivateData2`. These key names were seen in the PDF attached to /// #868, and nothing else of that file is used; ExifTool's PDF tag table lists them too @@ -354,6 +360,11 @@ pub fn pdf_with_content(private: &[u8], page: &str, content: &str) -> Vec { /// The file of [`ai`] and [`pdf`], with `private` in the streams `{key}1` and `{key}2`, `entries` /// more in the page dictionary and `content` more in its content stream's dictionary. fn with_private(private: &[u8], page: &str, key: &str, entries: &str, content: &str) -> Vec { + with_private_streams(private, page, key, entries, content, "") +} + +/// [`with_private`] with `streams` more in each private data stream's dictionary. +fn with_private_streams(private: &[u8], page: &str, key: &str, entries: &str, content: &str, streams: &str) -> Vec { let (first, second) = private.split_at(private.len() / 2); let stream = |part: &[u8], more: &str| { let mut s = format!("<< /Length {} {more}>>\nstream\n", part.len()).into_bytes(); @@ -371,8 +382,8 @@ fn with_private(private: &[u8], page: &str, key: &str, entries: &str, content: & ) .into_bytes(), stream(page.as_bytes(), content), - stream(first, ""), - stream(second, ""), + stream(first, streams), + stream(second, streams), ]; let mut out = b"%PDF-1.5\n".to_vec(); let mut offsets = vec![];