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 21c7fa8a15..7fc7285dbb 100644 --- a/crates/engine/tests/import_fuzz.rs +++ b/crates/engine/tests/import_fuzz.rs @@ -4524,7 +4524,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![];