Merge pull request #1505 from storytold/fix/svg-embedded-image-accounting

craft-svg: account for malformed embedded image data
This commit is contained in:
Dylan M. Taylor
2026-11-15 06:37:46 -05:00
committed by GitHub
4 changed files with 146 additions and 1 deletions
Generated
+1
View File
@@ -2667,6 +2667,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`.
+50
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,27 @@ 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 url = match data_url::DataUrl::process(href) {
Ok(url) => url,
// 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);
}
}
}
fn raster_format(data: &[u8]) -> Option<craft_image_codecs::Format> {
match craft_image_codecs::detect(data)? {
format @ (craft_image_codecs::Format::Png
@@ -432,6 +463,24 @@ 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) {
// 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);
}
_ => {
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 +550,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);
+92
View File
@@ -492,3 +492,95 @@ 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 malformed_data_url_without_comma_is_counted() {
for href in ["data:image/png;base64", " data:image/png;base64", "da&#x9;ta:image/png;base64", "da&#xA;ta:image/png;base64"] {
let bad = format!(r#"<image width="1" height="1" xlink:href="{href}"/>"#);
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]
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();
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);
}
}