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); + } +}