fix(svg): account for invalid embedded image data

This commit is contained in:
Dylan M. Taylor committed 2026-11-15 04:11:43 -05:00
1 parent 26a4f6c855
commit 4e9b3e9fdd
4 files changed
+97 -1

No files matched your search

Generated
+1
View File
@@ -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",
+3 -1
View File
@@ -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`.
+39
View File
@@ -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<craft_image_codecs::Format> {
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<Vec<u8>>, 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);
+54
View File
@@ -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<bool>, 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<u8> {
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#"<image width="1" height="1" xlink:href="data:image/png,{encoded}"/>"#)
}
#[test]
fn malformed_base64_is_counted_before_usvg_discards_it() {
let bad = r#"<image width="1" height="1" xlink:href="data:image/png;base64,A"/>"#;
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);
}
}