mirror of
https://github.com/storytold/craft-libs.git
synced 2026-11-16 23:42:27 +00:00
Merge pull request #1505 from storytold/fix/svg-embedded-image-accounting
craft-svg: account for malformed embedded image data
This commit is contained in:
4 files changed
+146
-1
No files matched your search
Generated
+1
@@ -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",
|
||||
|
||||
@@ -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`.
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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	ta:image/png;base64", "da
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);
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user