From 4e9b3e9fdd5483d1a91e14a2d405aea922a12aa7 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 04:11:43 -0500 Subject: [PATCH 1/3] fix(svg): account for invalid embedded image data --- Cargo.lock | 1 + crates/svg/Cargo.toml | 4 ++- crates/svg/src/tree.rs | 39 ++++++++++++++++++++++++++ crates/svg/src/tree/tests.rs | 54 ++++++++++++++++++++++++++++++++++++ 4 files changed, 97 insertions(+), 1 deletion(-) diff --git a/Cargo.lock b/Cargo.lock index 27fc4016c..bb4fbbf9b 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2580,6 +2580,7 @@ version = "0.1.0" dependencies = [ "craft-image-codecs", "craft-xml", + "data-url", "flate2", "kurbo 0.13.1", "resvg 0.48.1", diff --git a/crates/svg/Cargo.toml b/crates/svg/Cargo.toml index c3912696d..3615a719c 100644 --- a/crates/svg/Cargo.toml +++ b/crates/svg/Cargo.toml @@ -27,9 +27,11 @@ usvg = { version = "=0.48.1", default-features = false, optional = true } # so callers that only need bounded SVG text/tree parsing do not pull in raster backends. resvg = { version = "=0.48.1", default-features = false, features = ["text", "raster-images"], optional = true } +data-url = { version = "0.3.2", optional = true } + [features] # `craft_svg::tree`: usvg behind the bounded entry point. -tree = ["dep:usvg"] +tree = ["dep:usvg", "dep:data-url"] # Text converted to paths (needs a font database in the options). tree-text = ["tree", "usvg/text"] # The system's fonts in `usvg::fontdb`. diff --git a/crates/svg/src/tree.rs b/crates/svg/src/tree.rs index 2f67edbda..9d56125d1 100644 --- a/crates/svg/src/tree.rs +++ b/crates/svg/src/tree.rs @@ -371,6 +371,16 @@ impl ImageResolver { self.used.xml_depth.store(depth, Ordering::Relaxed); } + /// Account for malformed image data URLs before usvg discards them without calling + /// its image resolver. Call once for the outer document, before `parse_text`. + /// Nested SVGs are checked automatically. The scan shares the normal XML limits and + /// streaming-validates URL encoding without allocating another decoded image buffer. + pub fn check_document(&self, svg: &str) -> Result<(), Error> { + let xml = checked(svg, &self.limits)?; + account_invalid_data_urls(&xml, &self.used); + Ok(()) + } + /// Snapshot accounting after parsing has finished. pub fn usage(&self) -> ImageUsage { ImageUsage { @@ -387,6 +397,19 @@ impl ImageResolver { } } +// usvg's data-URL decoder returns before resolve_data for invalid base64. Count +// these omissions separately, including feImage, without reading linked resources. +fn account_invalid_data_urls(xml: &roxmltree::Document<'_>, used: &Used) { + for node in xml.descendants().filter(|n| n.is_element() && matches!(n.tag_name().name(), "image" | "feImage")) { + let href = node.attribute(("http://www.w3.org/1999/xlink", "href")).or_else(|| node.attribute("href")); + let Some(href) = href else { continue }; + let Ok(url) = data_url::DataUrl::process(href) else { continue }; + if url.decode(|_| Ok::<(), std::convert::Infallible>(())).is_err() { + used.invalid_raster.fetch_add(1, Ordering::Relaxed); + } + } +} + fn raster_format(data: &[u8]) -> Option { match craft_image_codecs::detect(data)? { format @ (craft_image_codecs::Format::Png @@ -432,6 +455,21 @@ fn raster_image(used: &Used, limits: &Limits, data: Arc>, format: craft_ } } drop(seen); + // A valid header is not proof of valid pixels. resvg can silently omit a damaged + // image later; decode now under explicit limits so omission accounting is honest. + let decode_limits = craft_image_codecs::Limits::new(width, height, pixels, limits.embedded_raster_pixels.saturating_mul(8)); + let options = craft_image_codecs::DecodeOptions { limits: decode_limits, keep_orientation: true }; + if let Err(error) = craft_image_codecs::decode_as_with(format, &data, &options) { + match error { + craft_image_codecs::CodecError::LimitExceeded(_) => { + used.raster_limit.fetch_add(1, Ordering::Relaxed); + } + _ => { + used.invalid_raster.fetch_add(1, Ordering::Relaxed); + } + } + return None; + } Some(match format { craft_image_codecs::Format::Png => usvg::ImageKind::PNG(data), craft_image_codecs::Format::Jpeg => usvg::ImageKind::JPEG(data), @@ -501,6 +539,7 @@ fn embedded(used: &Used, limits: &Limits, data: &[u8], options: &usvg::Options<' let previous_depth = used.xml_depth.swap(total_depth, Ordering::Relaxed); let depth = used.depth.fetch_add(1, Ordering::Relaxed).saturating_add(1); used.svg_depth.fetch_max(depth, Ordering::Relaxed); + account_invalid_data_urls(&xml, used); let tree = usvg::Tree::from_xmltree(&xml, options); used.xml_depth.store(previous_depth, Ordering::Relaxed); used.depth.fetch_sub(1, Ordering::Relaxed); diff --git a/crates/svg/src/tree/tests.rs b/crates/svg/src/tree/tests.rs index 80681cad4..7b0ab4824 100644 --- a/crates/svg/src/tree/tests.rs +++ b/crates/svg/src/tree/tests.rs @@ -492,3 +492,57 @@ mod draw_checks { assert!(!refusal.memory && refusal.message.contains("clip-paths"), "{refusal:?}"); } } + +mod invalid_image_accounting { + use super::*; + + fn usage(body: &str, limits: Limits) -> (Vec, ImageUsage) { + let text = svg(body); + let resolver = ImageResolver::new(limits); + resolver.check_document(&text).unwrap(); + let options = usvg::Options { image_href_resolver: resolver.resolver(), ..Default::default() }; + let tree = parse_text(&text, &limits, &options).unwrap(); + let mut found = Vec::new(); + images(tree.root(), &mut found); + (found, resolver.usage()) + } + + fn png() -> Vec { + use craft_image_codecs::{ChannelLayout, EncodeOptions, Format, Image, SampleType, encode}; + let image = Image::new(1, 1, ChannelLayout::Rgba, SampleType::U8).unwrap(); + encode(&image, Format::Png, &EncodeOptions::default()).unwrap() + } + + fn image(data: &[u8]) -> String { + let encoded: String = data.iter().map(|b| format!("%{b:02X}")).collect(); + format!(r#""#) + } + + #[test] + fn malformed_base64_is_counted_before_usvg_discards_it() { + let bad = r#""#; + let (found, report) = usage(bad, shallow()); + assert!(found.is_empty()); + assert_eq!(report.invalid_raster_images, 1); + let (found, report) = usage(&embed(&svg(bad)), shallow()); + assert_eq!(found, [true]); + assert_eq!(report.invalid_raster_images, 1); + } + + #[test] + fn corrupt_pixels_do_not_pass_a_valid_header_probe() { + let valid = png(); + let (found, report) = usage(&image(&valid), shallow()); + assert_eq!(found, [false]); + assert_eq!(report.invalid_raster_images, 0); + let idat = valid.windows(4).position(|b| b == b"IDAT").unwrap(); + let corrupt = &valid[..idat + 4]; + assert_eq!(craft_image_codecs::probe_allocation_size(corrupt).unwrap(), (1, 1)); + let (found, report) = usage(&image(corrupt), shallow()); + assert!(found.is_empty()); + assert_eq!(report.invalid_raster_images, 1); + let (found, report) = usage(&image(&valid), Limits { embedded_raster_pixels: 0, ..shallow() }); + assert!(found.is_empty()); + assert_eq!(report.raster_limit_images, 1); + } +} From 586041bb6805932659ca4940d76e1b6152b9324d Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 04:30:16 -0500 Subject: [PATCH 2/3] fix(svg): preserve omission accounting on malformed data --- crates/svg/src/tree.rs | 13 ++++++++++++- crates/svg/src/tree/tests.rs | 36 ++++++++++++++++++++++++++++++++++++ 2 files changed, 48 insertions(+), 1 deletion(-) diff --git a/crates/svg/src/tree.rs b/crates/svg/src/tree.rs index 9d56125d1..5cf9df089 100644 --- a/crates/svg/src/tree.rs +++ b/crates/svg/src/tree.rs @@ -403,7 +403,15 @@ fn account_invalid_data_urls(xml: &roxmltree::Document<'_>, used: &Used) { for node in xml.descendants().filter(|n| n.is_element() && matches!(n.tag_name().name(), "image" | "feImage")) { let href = node.attribute(("http://www.w3.org/1999/xlink", "href")).or_else(|| node.attribute("href")); let Some(href) = href else { continue }; - let Ok(url) = data_url::DataUrl::process(href) else { continue }; + let url = match data_url::DataUrl::process(href) { + Ok(url) => url, + Err(_) => { + if href.split_once(':').is_some_and(|(scheme, _)| scheme.eq_ignore_ascii_case("data")) { + used.invalid_raster.fetch_add(1, Ordering::Relaxed); + } + continue; + } + }; if url.decode(|_| Ok::<(), std::convert::Infallible>(())).is_err() { used.invalid_raster.fetch_add(1, Ordering::Relaxed); } @@ -460,6 +468,9 @@ fn raster_image(used: &Used, limits: &Limits, data: Arc>, format: craft_ let decode_limits = craft_image_codecs::Limits::new(width, height, pixels, limits.embedded_raster_pixels.saturating_mul(8)); let options = craft_image_codecs::DecodeOptions { limits: decode_limits, keep_orientation: true }; if let Err(error) = craft_image_codecs::decode_as_with(format, &data, &options) { + // No tree retains this allocation on failure. Forget its address before it + // can be reused, but keep the pixel charge for the decode work already spent. + used.raster_data.lock().unwrap_or_else(PoisonError::into_inner).remove(&pointer); match error { craft_image_codecs::CodecError::LimitExceeded(_) => { used.raster_limit.fetch_add(1, Ordering::Relaxed); diff --git a/crates/svg/src/tree/tests.rs b/crates/svg/src/tree/tests.rs index 7b0ab4824..aa4d5a553 100644 --- a/crates/svg/src/tree/tests.rs +++ b/crates/svg/src/tree/tests.rs @@ -529,6 +529,42 @@ mod invalid_image_accounting { assert_eq!(report.invalid_raster_images, 1); } + #[test] + fn malformed_data_url_without_comma_is_counted() { + let bad = r#""#; + let (found, report) = usage(bad, shallow()); + assert!(found.is_empty()); + assert_eq!(report.invalid_raster_images, 1); + let (found, report) = usage(&embed(&svg(bad)), shallow()); + assert_eq!(found, [true]); + assert_eq!(report.invalid_raster_images, 1); + } + + #[test] + fn failed_decode_forgets_address_but_preserves_spent_budget() { + let valid = png(); + let idat = valid.windows(4).position(|b| b == b"IDAT").unwrap(); + let invalid = Arc::new(valid[..idat + 4].to_vec()); + let pointer = Arc::as_ptr(&invalid) as usize; + let limits = Limits { embedded_raster_pixels: 3, ..shallow() }; + let resolver = ImageResolver::new(limits); + let used = &resolver.used; + let format = craft_image_codecs::Format::Png; + assert!(raster_image(used, &limits, invalid, format).is_none()); + assert!(!used.raster_data.lock().unwrap().contains(&pointer)); + assert_eq!(resolver.usage().raster_pixels, 1); + let first_data = Arc::new(valid.clone()); + let first = raster_image(used, &limits, first_data.clone(), format).unwrap(); + assert_eq!(resolver.usage().raster_pixels, 2); + let repeated = raster_image(used, &limits, first_data, format).unwrap(); + assert_eq!(resolver.usage().raster_pixels, 2); + let second = raster_image(used, &limits, Arc::new(valid.clone()), format).unwrap(); + assert_eq!(resolver.usage().raster_pixels, 3); + assert!(raster_image(used, &limits, Arc::new(valid), format).is_none()); + assert_eq!(resolver.usage().raster_limit_images, 1); + drop((first, repeated, second)); + } + #[test] fn corrupt_pixels_do_not_pass_a_valid_header_probe() { let valid = png(); From d594b6763b48814b94c5d3f4e15012e995060e01 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 04:32:18 -0500 Subject: [PATCH 3/3] fix(svg): use normalized data URL error accounting --- crates/svg/src/tree.rs | 8 ++++---- crates/svg/src/tree/tests.rs | 16 +++++++++------- 2 files changed, 13 insertions(+), 11 deletions(-) diff --git a/crates/svg/src/tree.rs b/crates/svg/src/tree.rs index 5cf9df089..cb33137b8 100644 --- a/crates/svg/src/tree.rs +++ b/crates/svg/src/tree.rs @@ -405,12 +405,12 @@ fn account_invalid_data_urls(xml: &roxmltree::Document<'_>, used: &Used) { let Some(href) = href else { continue }; let url = match data_url::DataUrl::process(href) { Ok(url) => url, - Err(_) => { - if href.split_once(':').is_some_and(|(scheme, _)| scheme.eq_ignore_ascii_case("data")) { - used.invalid_raster.fetch_add(1, Ordering::Relaxed); - } + // Use the parser's normalized scheme recognition, including whitespace. + Err(data_url::DataUrlError::NoComma) => { + used.invalid_raster.fetch_add(1, Ordering::Relaxed); continue; } + Err(data_url::DataUrlError::NotADataUrl) => continue, }; if url.decode(|_| Ok::<(), std::convert::Infallible>(())).is_err() { used.invalid_raster.fetch_add(1, Ordering::Relaxed); diff --git a/crates/svg/src/tree/tests.rs b/crates/svg/src/tree/tests.rs index aa4d5a553..103c0fe7c 100644 --- a/crates/svg/src/tree/tests.rs +++ b/crates/svg/src/tree/tests.rs @@ -531,13 +531,15 @@ mod invalid_image_accounting { #[test] fn malformed_data_url_without_comma_is_counted() { - let bad = r#""#; - let (found, report) = usage(bad, shallow()); - assert!(found.is_empty()); - assert_eq!(report.invalid_raster_images, 1); - let (found, report) = usage(&embed(&svg(bad)), shallow()); - assert_eq!(found, [true]); - assert_eq!(report.invalid_raster_images, 1); + for href in ["data:image/png;base64", " data:image/png;base64", "da ta:image/png;base64", "da ta:image/png;base64"] { + let bad = format!(r#""#); + let (found, report) = usage(&bad, shallow()); + assert!(found.is_empty(), "{href}"); + assert_eq!(report.invalid_raster_images, 1, "{href}"); + let (found, report) = usage(&embed(&svg(&bad)), shallow()); + assert_eq!(found, [true], "{href}"); + assert_eq!(report.invalid_raster_images, 1, "{href}"); + } } #[test]