diff --git a/Cargo.lock b/Cargo.lock
index a9290398b..4da6cf6c9 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3092,14 +3092,18 @@ dependencies = [
"craft-xml",
"data-url",
"flate2",
+ "gif",
+ "image-webp",
"kurbo 0.13.1",
"quick-xml 0.41.0",
"resvg 0.48.1",
"roxmltree 0.21.2",
"thiserror 2.0.21",
+ "toml",
"usvg 0.48.1",
"vectorcraft-geom",
"vectorcraft-pathops",
+ "zune-jpeg",
]
[[package]]
diff --git a/crates/svg/Cargo.toml b/crates/svg/Cargo.toml
index b35c4de41..4b7e928a8 100644
--- a/crates/svg/Cargo.toml
+++ b/crates/svg/Cargo.toml
@@ -31,6 +31,13 @@ usvg = { version = "=0.48.1", default-features = false, optional = true }
resvg = { version = "=0.48.1", default-features = false, features = ["text", "raster-images"], optional = true }
data-url = { version = "0.3.2", optional = true }
+# Renderer-specific validation uses the same resolved backends as resvg0.48.1.
+# zune-jpeg is used under its MIT licence option. The locked edge-alignment
+# regression must pass when changing this renderer/backend dependency group.
+zune-jpeg = { version = "=0.5.15", optional = true }
+gif = { version = "=0.14.2", optional = true }
+image-webp = { version = "=0.2.4", optional = true }
+
[features]
default = ["paths"]
@@ -45,5 +52,9 @@ tree-text = ["tree", "usvg/text"]
# The system's fonts in `usvg::fontdb`.
tree-system-fonts = ["tree-text", "usvg/system-fonts"]
# Bounded rendering of a parsed tree through the matching resvg/tiny-skia versions.
-tree-render = ["tree", "dep:resvg"]
+tree-render = ["tree", "dep:resvg", "dep:zune-jpeg", "dep:gif", "dep:image-webp"]
tree-render-system-fonts = ["tree-render", "resvg/system-fonts"]
+
+[dev-dependencies]
+# Already resolved in the workspace; test-only Cargo.lock edge inspection.
+toml = "=1.1.8"
diff --git a/crates/svg/README.md b/crates/svg/README.md
index 508081367..0810b1217 100644
--- a/crates/svg/README.md
+++ b/crates/svg/README.md
@@ -16,3 +16,58 @@ The shared adapter adds an aggregate 64 MiB stylesheet-text limit and idempotent
### Transform compatibility
`transform_compat::parse_transform` preserves EffectCraft transform-list recovery and exact composition. It retains six numeric arguments per operation; scanning is not time/byte capped and matrix overflow behavior is unchanged. The strict geometry reader is unchanged. Source: Brandon Thomas, EffectCraft94e1c86d89a866771f80ad1610afda9aa12e85d8; bounded safe argument matching by Altynzhan Karybai,4035d181329e847d7a57bf3d059502ea2c91b560.
+
+
+### Opt-in validated embedded images
+
+With `tree-render`, `tree::ValidatedImageResolver` owns one drawing's immutable
+`Limits`, original child-source work, data-URL normalization and renderer-specific
+raster validation. Existing `ImageResolver::new`/`resolver` and legacy parse entry
+points retain their behavior. Opt in explicitly:
+
+```rust
+# #[cfg(feature = "tree-render")]
+# fn example() -> Result<(), craft_svg::tree::Error> {
+use craft_svg::tree::{self, Limits, ValidatedImageResolver, usvg};
+let images = ValidatedImageResolver::new(Limits::default());
+let checked = tree::preflight(
+ " ",
+ &images.limits(),
+)?;
+let drawing = images.parse_preflight(checked, usvg::Options::default())?;
+let usage = images.usage();
+// Importers disclose usage's invalid_* and *_limit_images; strict consumers refuse them.
+# let _ = (drawing, usage);
+# Ok(())
+# }
+```
+
+The caller supplies fonts and a sufficient stack/worker for its depth policy.
+`parse_preflight` accepts only an opaque preflight made with exactly this context's
+limits. It consumes options and installs its own data-only resolver, including for
+all children; unrelated callbacks cannot fetch a linked file or bypass admission.
+The full expanded root height and each child's expanded height share one depth
+allowance. An overlapping root conversion on the same context is refused.
+
+Unchanged XML converts from its original checked DOM. A modified data URL requires
+one checked replacement DOM. Invalid URLs become bounded resolver-visible image
+failures; hidden, unused and foreign elements do not acquire omission counts.
+Original UTF-8 child bytes are charged before XML conversion or shorter repairs,
+with per-document and aggregate bounds. Failed inflation/text work is not refunded;
+separate bounded retry-classification work never admits another child. Encoded
+raster callbacks spend at most `limits.bytes + limits.embedded_bytes` cumulatively,
+without retaining their sources. Pixel work and decoder allocation are admitted
+before decoding; attempted failures keep their charge. An oversized unattempted
+image does not prevent a later smaller image from fitting.
+
+`resolve_text` accepts an already-decoded child SVG through the same admission
+context, rather than an unchecked DOM or a precharged-budget override. `usage()`
+reports omissions and work after conversion. The context is for one drawing, not a
+global rendering cache.
+
+The renderer has no public decoded-pixel or decode-result hook. Validation therefore
+still decodes raster pixels before later renderer painting. The shared validator
+owns the backend dependencies; locked dependency-edge tests in both the shared
+workspace and consumers must keep them aligned with the selected resvg/usvg graph.
+This is a fail-fast maintenance check, not automatic access to private renderer
+code or a decode-once performance claim. Direct zune-jpeg use selects its MIT option.
diff --git a/crates/svg/src/tree.rs b/crates/svg/src/tree.rs
index ab04a3002..80feec75d 100644
--- a/crates/svg/src/tree.rs
+++ b/crates/svg/src/tree.rs
@@ -34,7 +34,13 @@ use crate::{guard, svgz};
pub mod document;
pub mod draw;
+#[cfg(feature = "tree-render")]
+mod image_href;
pub mod primitive;
+#[cfg(feature = "tree-render")]
+mod validated;
+#[cfg(feature = "tree-render")]
+pub use validated::ValidatedImageResolver;
/// What one import may use. The defaults suit a desktop app that parses on a thread with a
/// large stack (see the module text).
@@ -161,6 +167,7 @@ pub fn root_unitless_size(svg: &str, limits: &Limits) -> Result {
+ limits: Limits,
xml: roxmltree::Document<'s>,
depth: usize,
/// [`height`]: the nesting usvg converts, references followed.
@@ -219,6 +226,8 @@ const UNSUPPORTED: &[&str] = &[
/// Checks already-decoded SVG text once, retaining the parsed XML for both depth policy and tree conversion.
pub fn preflight<'s>(svg: &'s str, limits: &Limits) -> Result, Error> {
+ #[cfg(test)]
+ PREFLIGHT_PASSES.with(|count| count.set(count.get().saturating_add(1)));
let preflight_limits = crate::preflight::Limits {
bytes: limits.bytes,
depth: limits.depth,
@@ -239,7 +248,7 @@ pub fn preflight<'s>(svg: &'s str, limits: &Limits) -> Result, Err
let Some(height) = height(&xml, limits.tree_depth)? else {
return Err(Error::TooDeep(limits.tree_depth));
};
- Ok(Preflight { xml, depth, height })
+ Ok(Preflight { limits: *limits, xml, depth, height })
}
/// Dimensions of an SVG viewport in SVG user units.
@@ -432,9 +441,12 @@ struct Used {
/// What resolving one drawing's embedded images used or refused.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct ImageUsage {
- /// Unique decoded raster pixels reserved before decode.
+ /// Decoded raster pixel work reserved before decode. The legacy resolver
+ /// shares a charge across repeated data; the validated context charges each
+ /// attempted decode, including failures.
pub raster_pixels: u64,
- /// Unpacked SVG bytes consumed by embedded SVG data URLs.
+ /// Decoded SVG text work charged to embedded data URLs, including the
+ /// remaining allowance consumed by a failed inflation attempt.
pub embedded_svg_bytes: usize,
/// Embedded SVG images parsed, including nested images.
pub embedded_svg_count: usize,
@@ -730,3 +742,8 @@ fn image_resolver_for(limits: Limits, used: Arc) -> usvg::ImageHrefResolve
#[cfg(test)]
mod tests;
+
+#[cfg(test)]
+thread_local! {
+ static PREFLIGHT_PASSES: std::cell::Cell = const { std::cell::Cell::new(0) };
+}
diff --git a/crates/svg/src/tree/draw.rs b/crates/svg/src/tree/draw.rs
index f83653284..8a8bb1a7a 100644
--- a/crates/svg/src/tree/draw.rs
+++ b/crates/svg/src/tree/draw.rs
@@ -29,6 +29,11 @@ pub use resvg;
#[cfg(feature = "tree-render")]
pub use resvg::tiny_skia;
+#[cfg(feature = "tree-render")]
+mod raster;
+#[cfg(feature = "tree-render")]
+pub use raster::{RasterValidationFailure, validate_raster};
+
/// Filter primitives per filter. A result of every primitive is kept; real filters have 1 to 12
/// (Inkscape's drop shadow has 5), and 64 leaves headroom for generated ones.
const MAX_PRIMITIVES: usize = 64;
@@ -546,3 +551,6 @@ fn deeper(cx: Cx) -> Result<(), Refusal> {
}
Ok(())
}
+
+#[cfg(all(test, feature = "tree-render"))]
+mod decoder_edges;
diff --git a/crates/svg/src/tree/draw/decoder_edges.rs b/crates/svg/src/tree/draw/decoder_edges.rs
new file mode 100644
index 000000000..8258b5792
--- /dev/null
+++ b/crates/svg/src/tree/draw/decoder_edges.rs
@@ -0,0 +1,127 @@
+//! Test-only resolved-edge checks. No Cargo subprocess or global version count.
+#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::indexing_slicing)]
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) struct PackageId {
+ name: String,
+ version: String,
+ source: Option,
+}
+struct Package {
+ id: PackageId,
+ dependencies: Vec,
+}
+pub(crate) struct LockGraph {
+ packages: Vec,
+}
+impl LockGraph {
+ pub(crate) fn parse(text: &str) -> Self {
+ let lock: toml::Value = text.parse().unwrap();
+ let packages = lock
+ .get("package")
+ .unwrap()
+ .as_array()
+ .unwrap()
+ .iter()
+ .map(|package| {
+ let string = |key| package.get(key).unwrap().as_str().unwrap().to_owned();
+ Package {
+ id: PackageId {
+ name: string("name"),
+ version: string("version"),
+ source: package.get("source").map(|v| v.as_str().unwrap().to_owned()),
+ },
+ dependencies: package
+ .get("dependencies")
+ .map(|d| d.as_array().unwrap().iter().map(|v| v.as_str().unwrap().to_owned()).collect())
+ .unwrap_or_default(),
+ }
+ })
+ .collect();
+ Self { packages }
+ }
+ pub(crate) fn workspace_package(&self, name: &str) -> PackageId {
+ let found: Vec<_> = self.packages.iter().filter(|p| p.id.name == name && p.id.source.is_none()).collect();
+ assert_eq!(found.len(), 1, "one exact workspace package required: {name}");
+ found[0].id.clone()
+ }
+ pub(crate) fn dependency(&self, from: &PackageId, name: &str) -> PackageId {
+ let package = self.packages.iter().find(|p| &p.id == from).unwrap();
+ let edges: Vec<_> = package.dependencies.iter().filter(|edge| edge.split_whitespace().next() == Some(name)).collect();
+ assert_eq!(edges.len(), 1, "one {name} dependency edge required from {from:?}");
+ let fields: Vec<_> = edges[0].split_whitespace().collect();
+ let version = fields.get(1).copied();
+ let source = fields.get(2).map(|s| s.trim_start_matches('(').trim_end_matches(')'));
+ let found: Vec<_> = self
+ .packages
+ .iter()
+ .filter(|p| p.id.name == name && version.is_none_or(|v| p.id.version == v) && source.is_none_or(|s| p.id.source.as_deref() == Some(s)))
+ .collect();
+ assert_eq!(found.len(), 1, "ambiguous or absent resolved edge {} from {from:?}", edges[0]);
+ found[0].id.clone()
+ }
+}
+
+pub(crate) fn assert_renderer_edges(graph: &LockGraph, svg: &PackageId) {
+ let renderer = graph.dependency(svg, "resvg");
+ assert_eq!(graph.dependency(svg, "usvg"), graph.dependency(&renderer, "usvg"), "shared and renderer trees must be the same resolved package");
+ for codec in ["gif", "image-webp", "zune-jpeg"] {
+ assert_eq!(graph.dependency(svg, codec), graph.dependency(&renderer, codec), "validator and selected renderer differ for {codec}");
+ }
+}
+
+#[test]
+fn validated_renderer_dependency_edges_are_the_same_resolved_packages() {
+ let file = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../../Cargo.lock");
+ let graph = LockGraph::parse(&std::fs::read_to_string(file).unwrap());
+ assert_renderer_edges(&graph, &graph.workspace_package("craft-svg"));
+}
+
+#[test]
+fn dependency_lookup_follows_the_selected_edge_and_rejects_ambiguity() {
+ let graph = LockGraph::parse(
+ r#"
+[[package]]
+name = "consumer"
+version = "1"
+dependencies = ["codec 1 (registry+one)"]
+[[package]]
+name = "codec"
+version = "1"
+source = "registry+one"
+[[package]]
+name = "codec"
+version = "1"
+source = "registry+two"
+[[package]]
+name = "other"
+version = "1"
+dependencies = ["codec"]
+"#,
+ );
+ let selected = graph.dependency(&graph.workspace_package("consumer"), "codec");
+ assert_eq!(selected.source.as_deref(), Some("registry+one"));
+ assert!(std::panic::catch_unwind(|| graph.dependency(&graph.workspace_package("other"), "codec")).is_err());
+}
+
+#[test]
+fn selected_renderer_graph_rejects_a_split_validator_backend() {
+ use std::fmt::Write;
+ let make = |split: bool| {
+ let mut text = String::from("[[package]]\nname='craft-svg'\nversion='1'\ndependencies=['resvg', 'usvg', 'gif', 'image-webp', '");
+ text.push_str(if split { "zune-jpeg 2" } else { "zune-jpeg 1" });
+ text.push_str(
+ "']\n[[package]]\nname='resvg'\nversion='1'\nsource='registry+one'\ndependencies=['usvg', 'gif', 'image-webp', 'zune-jpeg 1']\n",
+ );
+ for name in ["usvg", "gif", "image-webp", "zune-jpeg"] {
+ write!(&mut text, "[[package]]\nname='{name}'\nversion='1'\nsource='registry+one'\n").unwrap();
+ }
+ // An unrelated second codec version is valid; only the selected edges count.
+ text.push_str("[[package]]\nname='zune-jpeg'\nversion='2'\nsource='registry+one'\n");
+ LockGraph::parse(&text)
+ };
+ let matching = make(false);
+ assert_renderer_edges(&matching, &matching.workspace_package("craft-svg"));
+ let split = make(true);
+ assert!(std::panic::catch_unwind(|| assert_renderer_edges(&split, &split.workspace_package("craft-svg"))).is_err());
+}
diff --git a/crates/svg/src/tree/draw/raster.rs b/crates/svg/src/tree/draw/raster.rs
new file mode 100644
index 000000000..fe250259d
--- /dev/null
+++ b/crates/svg/src/tree/draw/raster.rs
@@ -0,0 +1,140 @@
+//! Validate optional raster images with the same backends used by the SVG renderer.
+//!
+//! Header probing alone cannot detect damaged pixel data. Admit dimensions and
+//! reserve work before decoding: even a failed decode keeps its charge.
+
+use std::io::Cursor;
+use std::num::NonZeroU64;
+
+use crate::tree::{draw::tiny_skia, usvg};
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum RasterValidationFailure {
+ /// The renderer cannot decode the encoded image.
+ Invalid,
+ /// Header dimensions, cumulative work or decoder allocation exceed admission.
+ Limit,
+}
+
+/// Validate the renderer's first frame within per-image and remaining work limits.
+/// Failed attempted decodes keep their pixel charge. No decoded pixels are retained. SVG
+/// children use the same wrapped resolver and need no second recursive walk.
+pub fn validate_raster(kind: &usvg::ImageKind, max_pixels: u64, pixels_left: &mut u64) -> Result<(), RasterValidationFailure> {
+ let data = match kind {
+ usvg::ImageKind::PNG(data) | usvg::ImageKind::JPEG(data) | usvg::ImageKind::GIF(data) | usvg::ImageKind::WEBP(data) => data,
+ usvg::ImageKind::SVG(_) => return Ok(()),
+ };
+ // The allocation probe includes oversized GIF/WebP frames, not merely their
+ // canvas. Reserve before asking any rendering decoder to allocate pixels.
+ let (width, height) = craft_image_codecs::probe_allocation_size(data).map_err(|_| RasterValidationFailure::Invalid)?;
+ let pixels = area(width, height)?;
+ if pixels > max_pixels {
+ return Err(RasterValidationFailure::Limit);
+ }
+ *pixels_left = pixels_left.checked_sub(pixels).ok_or(RasterValidationFailure::Limit)?;
+ match kind {
+ usvg::ImageKind::PNG(data) => {
+ let decoded = tiny_skia::Pixmap::decode_png(data).map_err(|_| RasterValidationFailure::Invalid)?;
+ rgba_bytes(decoded.width(), decoded.height(), pixels)?;
+ Ok(())
+ }
+ usvg::ImageKind::JPEG(data) => jpeg(data, pixels),
+ usvg::ImageKind::GIF(data) => gif(data, pixels),
+ usvg::ImageKind::WEBP(data) => webp(data, pixels),
+ usvg::ImageKind::SVG(_) => Ok(()),
+ }
+}
+
+fn area(width: u32, height: u32) -> Result {
+ if width == 0 || height == 0 {
+ return Err(RasterValidationFailure::Invalid);
+ }
+ u64::from(width).checked_mul(u64::from(height)).ok_or(RasterValidationFailure::Limit)
+}
+
+/// Decoder headers must not request more output than the allocation probe paid for.
+fn rgba_bytes(width: u32, height: u32, admitted: u64) -> Result {
+ let pixels = area(width, height)?;
+ if pixels > admitted {
+ return Err(RasterValidationFailure::Limit);
+ }
+ usize::try_from(pixels.checked_mul(4).ok_or(RasterValidationFailure::Limit)?).map_err(|_| RasterValidationFailure::Limit)
+}
+
+fn buffer(length: usize) -> Result, RasterValidationFailure> {
+ let mut output = Vec::new();
+ output.try_reserve_exact(length).map_err(|_| RasterValidationFailure::Limit)?;
+ output.resize(length, 0);
+ Ok(output)
+}
+
+fn jpeg(data: &[u8], admitted: u64) -> Result<(), RasterValidationFailure> {
+ use zune_jpeg::zune_core::colorspace::ColorSpace;
+ use zune_jpeg::zune_core::options::DecoderOptions;
+
+ // Preserve the rendering decoder's default limits and RGBA conversion; a
+ // general photo decoder may accept formats the SVG renderer cannot draw.
+ let options = DecoderOptions::default().jpeg_set_out_colorspace(ColorSpace::RGBA);
+ let mut decoder = zune_jpeg::JpegDecoder::new_with_options(Cursor::new(data), options);
+ decoder.decode_headers().map_err(|_| RasterValidationFailure::Invalid)?;
+ let info = decoder.info().ok_or(RasterValidationFailure::Invalid)?;
+ let length = rgba_bytes(u32::from(info.width), u32::from(info.height), admitted)?;
+ if decoder.output_colorspace() != Some(ColorSpace::RGBA) || decoder.output_buffer_size() != Some(length) {
+ return Err(RasterValidationFailure::Invalid);
+ }
+ let mut output = buffer(length)?;
+ decoder.decode_into(&mut output).map_err(|_| RasterValidationFailure::Invalid)
+}
+
+fn gif(data: &[u8], admitted: u64) -> Result<(), RasterValidationFailure> {
+ let bytes = admitted.checked_mul(4).ok_or(RasterValidationFailure::Limit)?;
+ // Do not loosen the renderer's default 50 MB GIF frame limit. Smaller
+ // imports also keep their own admitted allocation ceiling during decode.
+ let limit = NonZeroU64::new(bytes.min(50_000_000)).ok_or(RasterValidationFailure::Invalid)?;
+ let mut options = gif::DecodeOptions::new();
+ options.set_color_output(gif::ColorOutput::RGBA);
+ options.set_memory_limit(gif::MemoryLimit::Bytes(limit));
+ let mut decoder = options.read_info(data).map_err(gif_error)?;
+ let frame = decoder.read_next_frame().map_err(gif_error)?.ok_or(RasterValidationFailure::Invalid)?;
+ let expected = rgba_bytes(u32::from(frame.width), u32::from(frame.height), admitted)?;
+ if frame.buffer.len() != expected {
+ return Err(RasterValidationFailure::Invalid);
+ }
+ Ok(())
+}
+
+fn gif_error(error: gif::DecodingError) -> RasterValidationFailure {
+ match error {
+ gif::DecodingError::MemoryLimit | gif::DecodingError::OutOfMemory => RasterValidationFailure::Limit,
+ _ => RasterValidationFailure::Invalid,
+ }
+}
+
+fn webp(data: &[u8], admitted: u64) -> Result<(), RasterValidationFailure> {
+ let mut decoder = image_webp::WebPDecoder::new(Cursor::new(data)).map_err(webp_error)?;
+ let (width, height) = decoder.dimensions();
+ let rgba = rgba_bytes(width, height, admitted)?;
+ let channels = if decoder.has_alpha() { 4 } else { 3 };
+ let expected = usize::try_from(area(width, height)?.checked_mul(channels).ok_or(RasterValidationFailure::Limit)?)
+ .map_err(|_| RasterValidationFailure::Limit)?;
+ if expected > rgba {
+ return Err(RasterValidationFailure::Limit);
+ }
+ if decoder.output_buffer_size() != Some(expected) {
+ return Err(RasterValidationFailure::Invalid);
+ }
+ // A small valid image can have a compressed chunk larger than its pixels.
+ // Bound decoder scratch without rejecting that ordinary encoding overhead.
+ let admitted_bytes =
+ usize::try_from(admitted.checked_mul(4).ok_or(RasterValidationFailure::Limit)?).map_err(|_| RasterValidationFailure::Limit)?;
+ decoder.set_memory_limit(admitted_bytes.max(data.len()));
+ let mut output = buffer(expected)?;
+ decoder.read_image(&mut output).map_err(webp_error)
+}
+
+fn webp_error(error: image_webp::DecodingError) -> RasterValidationFailure {
+ match error {
+ image_webp::DecodingError::MemoryLimitExceeded | image_webp::DecodingError::ImageTooLarge => RasterValidationFailure::Limit,
+ _ => RasterValidationFailure::Invalid,
+ }
+}
diff --git a/crates/svg/src/tree/image_href.rs b/crates/svg/src/tree/image_href.rs
new file mode 100644
index 000000000..d33388846
--- /dev/null
+++ b/crates/svg/src/tree/image_href.rs
@@ -0,0 +1,428 @@
+//! Bounded data-URL normalization over the shared checked XML document.
+//! Only attribute values change; actual usvg callbacks decide image usage.
+use super::Error;
+#[cfg(test)]
+use super::Limits;
+use std::borrow::Cow;
+use std::ops::Range;
+
+#[cfg(test)]
+const SVG_NS: &str = "http://www.w3.org/2000/svg";
+const XLINK_NS: &str = "http://www.w3.org/1999/xlink";
+const INVALID_IMAGE: &str = "data:image/png,%00";
+const IGNORED_DATA: &str = "data:application/octet-stream,%00";
+
+struct Patch {
+ range: Range,
+ replacement: Cow<'static, str>,
+}
+
+fn invalid(message: &str) -> Error {
+ Error::Parse(message.into())
+}
+
+#[cfg(test)]
+fn repair<'a>(text: &'a str, limits: &Limits) -> Result, Error> {
+ normalize(&super::preflight(text, limits)?)
+}
+
+pub(super) fn normalize<'a>(checked: &super::Preflight<'a>) -> Result, Error> {
+ let text = checked.xml.input_text();
+ let limits = &checked.limits;
+ let xml = &checked.xml;
+ if !text.contains("href") {
+ return Ok(Cow::Borrowed(text));
+ }
+ // Expanded values fit source + entity work. Twelve linear passes cover URL
+ // scans/streaming decode, full attribute projection and worst-case XML escaping;
+ // parameter compaction never allocates one record per original parameter.
+ let mut work = text
+ .len()
+ .checked_add(limits.entity_bytes)
+ .and_then(|n| n.checked_mul(12))
+ .ok_or_else(|| invalid("SVG data-URL validation work exceeds its limit"))?;
+ let max_patches = (limits.bytes / std::mem::size_of::()).min(usize::try_from(limits.xml_nodes).unwrap_or(usize::MAX));
+ let mut patches: Vec = Vec::new();
+ for node in xml.descendants().filter(|node| node.is_element()) {
+ if !matches!(node.tag_name().name(), "image" | "feImage") {
+ continue;
+ }
+ // Shared preflight inspects local image names in every namespace and
+ // checks XLink before plain href. Normalize both representations, even
+ // when one is inert or unselected. Only actual resolver callbacks count
+ // omissions, so this does not turn hidden/unused resources into warnings.
+ for href in node.attributes().filter(|a| a.name() == "href" && matches!(a.namespace(), None | Some(XLINK_NS))) {
+ let Some(replacement) = data_url_replacement(href.value(), &mut work)? else { continue };
+ let range = verified_value_range(text, node.range(), href.range(), href.name(), &mut work)?;
+ if patches.len() == patches.capacity() {
+ if patches.len() >= max_patches {
+ return Err(invalid("SVG data-URL repair metadata exceeds its limit"));
+ }
+ let capacity = patches.capacity().max(8).saturating_mul(2).min(max_patches);
+ patches
+ .try_reserve_exact(capacity.saturating_sub(patches.len()))
+ .map_err(|_| invalid("could not allocate bounded SVG data-URL repairs"))?;
+ }
+ patches.push(Patch { range, replacement });
+ }
+ }
+ if patches.is_empty() {
+ return Ok(Cow::Borrowed(text));
+ }
+ patches.sort_unstable_by_key(|patch| (patch.range.start, patch.range.end));
+ patches.dedup_by_key(|patch| (patch.range.start, patch.range.end));
+ let mut end = 0;
+ let mut length = text.len();
+ for patch in &patches {
+ let range = &patch.range;
+ if range.start < end {
+ return Err(invalid("SVG data-URL source ranges overlap"));
+ }
+ end = range.end;
+ length = length
+ .checked_sub(range.len())
+ .and_then(|n| n.checked_add(patch.replacement.len()))
+ .ok_or_else(|| invalid("SVG data-URL repair size overflows"))?;
+ }
+ if length > limits.bytes {
+ return Err(invalid("repaired SVG exceeds the text byte limit"));
+ }
+ let mut result = String::new();
+ result.try_reserve_exact(length).map_err(|_| invalid("could not allocate bounded repaired SVG text"))?;
+ let mut cursor = 0;
+ for patch in patches {
+ result.push_str(text.get(cursor..patch.range.start).ok_or_else(|| invalid("invalid SVG data-URL source range"))?);
+ result.push_str(&patch.replacement);
+ cursor = patch.range.end;
+ }
+ result.push_str(text.get(cursor..).ok_or_else(|| invalid("invalid SVG data-URL source range"))?);
+ Ok(Cow::Owned(result))
+}
+
+// The pinned MIME parser searches all earlier parameters for each new name.
+// Cap even quoted semicolons before invoking it: source-byte work is already
+// charged, so at most this constant times the bounded XML work reaches MIME
+// parsing. Bodies can remain large without acquiring MIME parameter records.
+const MAX_MIME_SEPARATORS: usize = 64;
+
+fn mime_header_admitted(value: &str) -> bool {
+ let trimmed = value.trim_start_matches(|ch| ch <= ' ');
+ let mut bytes = trimmed.bytes();
+ for expected in b"data:" {
+ let Some(actual) = bytes.by_ref().find(|&byte| !matches!(byte, b'\t' | b'\n' | b'\r')) else { return true };
+ if !actual.eq_ignore_ascii_case(expected) {
+ return true; // Not a data URL: preserve external/fragment handling.
+ }
+ }
+ let mut separators = 0;
+ for byte in bytes {
+ if matches!(byte, b',' | b'#') {
+ break;
+ }
+ if byte == b';' {
+ separators += 1;
+ if separators > MAX_MIME_SEPARATORS {
+ return false;
+ }
+ }
+ }
+ true
+}
+
+/// A long parameter list must not reach the quadratic MIME parser, but its
+/// essence, final base64 marker and body still determine the original image.
+/// Compact only that header, then use the same parser/streaming decoder. Escape
+/// the decoded attribute value once when projecting it back into XML.
+fn data_url_replacement(value: &str, work: &mut usize) -> Result>, Error> {
+ if mime_header_admitted(value) {
+ return malformed_data_url_replacement(value, work).map(|replacement| replacement.map(Cow::Borrowed));
+ }
+ *work = work.checked_sub(value.len()).ok_or_else(|| invalid("SVG data-URL validation work exceeds its limit"))?;
+ let normalized = value.trim_matches(|ch| ch <= ' ');
+ let delimiter = normalized.find([',', '#']);
+ let Some(comma) = delimiter.filter(|&at| normalized.as_bytes().get(at) == Some(&b',')) else {
+ return missing_comma_replacement(value, work).map(|replacement| Some(Cow::Borrowed(replacement)));
+ };
+ let header = normalized.get(..comma).ok_or_else(|| invalid("invalid SVG data-URL header framing"))?;
+ let essence = header.split_once(';').map_or(header, |(essence, _)| essence);
+ // Retaining the final parameter lets the pinned parser decide whether its
+ // suffix is a base64 marker, including its case/ASCII-whitespace rules.
+ let suffix = header.rfind(';').and_then(|at| header.get(at..)).unwrap_or("");
+ let body = normalized.get(comma..).ok_or_else(|| invalid("invalid SVG data-URL body framing"))?;
+ let length = essence
+ .len()
+ .checked_add(suffix.len())
+ .and_then(|n| n.checked_add(body.len()))
+ .ok_or_else(|| invalid("SVG data-URL repair size overflows"))?;
+ let mut compact = String::new();
+ compact.try_reserve_exact(length).map_err(|_| invalid("could not allocate bounded SVG data-URL header"))?;
+ compact.push_str(essence);
+ compact.push_str(suffix);
+ compact.push_str(body);
+ if let Some(replacement) = malformed_data_url_replacement(&compact, work)? {
+ return Ok(Some(Cow::Borrowed(replacement)));
+ }
+ let escaped_len = compact
+ .chars()
+ .try_fold(0usize, |n, ch| {
+ n.checked_add(match ch {
+ '&' | '\t' | '\n' | '\r' => 5,
+ '\'' | '"' => 6,
+ '<' | '>' => 4,
+ _ => ch.len_utf8(),
+ })
+ })
+ .ok_or_else(|| invalid("SVG data-URL repair size overflows"))?;
+ *work = work.checked_sub(escaped_len).ok_or_else(|| invalid("SVG data-URL validation work exceeds its limit"))?;
+ let mut escaped = String::new();
+ escaped.try_reserve_exact(escaped_len).map_err(|_| invalid("could not allocate bounded SVG data-URL repair"))?;
+ for ch in compact.chars() {
+ match ch {
+ '&' => escaped.push_str("&"),
+ '\'' => escaped.push_str("'"),
+ '"' => escaped.push_str("""),
+ '<' => escaped.push_str("<"),
+ '>' => escaped.push_str(">"),
+ '\t' => escaped.push_str(" "),
+ '\n' => escaped.push_str("
"),
+ '\r' => escaped.push_str("
"),
+ _ => escaped.push(ch),
+ }
+ }
+ Ok(Some(Cow::Owned(escaped)))
+}
+
+fn malformed_data_url_replacement(value: &str, work: &mut usize) -> Result , Error> {
+ malformed_data_url_replacement_with(value, work, data_url::DataUrl::process)
+}
+
+fn malformed_data_url_replacement_with<'a>(
+ value: &'a str,
+ work: &mut usize,
+ parse: impl FnOnce(&'a str) -> Result, data_url::DataUrlError>,
+) -> Result, Error> {
+ *work = work.checked_sub(value.len()).ok_or_else(|| invalid("SVG data-URL validation work exceeds its limit"))?;
+ if !mime_header_admitted(value) {
+ // Strip parameters before recovering MIME disposition; no original
+ // parameter list reaches either our parser or shared whole-DOM preflight.
+ return missing_comma_replacement(value, work).map(Some);
+ }
+ let url = match parse(value) {
+ Ok(url) => url,
+ Err(data_url::DataUrlError::NoComma) => return missing_comma_replacement(value, work).map(Some),
+ Err(data_url::DataUrlError::NotADataUrl) => return Ok(None),
+ };
+ let mut exhausted = false;
+ let decoded = url.decode(|bytes| {
+ if let Some(left) = work.checked_sub(bytes.len()) {
+ *work = left;
+ Ok(())
+ } else {
+ exhausted = true;
+ Err(())
+ }
+ });
+ if exhausted {
+ return Err(invalid("SVG data-URL validation work exceeds its limit"));
+ }
+ Ok(decoded.is_err().then(|| replacement_for_mime(url.mime_type())))
+}
+
+/// Preflight must see a valid URL, while the resolver must keep its original
+/// disposition. Non-image MIME types are ignored even when their body is bad.
+fn replacement_for_mime(mime: &data_url::mime::Mime) -> &'static str {
+ if mime.type_ == "image" || mime.matches("text", "plain") { INVALID_IMAGE } else { IGNORED_DATA }
+}
+
+fn missing_comma_replacement(value: &str, work: &mut usize) -> Result<&'static str, Error> {
+ // NoComma does not expose its MIME type. Ask the same parser about a header
+ // with an empty body rather than guessing MIME defaults, case or parameters.
+ // Match its URL C0 trimming; fragments and MIME parameters cannot affect
+ // the image/text-plain essence. Do not allocate parameter bookkeeping for a
+ // hostile missing-comma header just to recover that disposition.
+ let normalized = value.trim_matches(|ch| ch <= ' ');
+ let header = normalized.split_once('#').map_or(normalized, |(header, _)| header);
+ let essence = header.split_once(';').map_or(header, |(essence, _)| essence);
+ *work = work.checked_sub(essence.len()).ok_or_else(|| invalid("SVG data-URL validation work exceeds its limit"))?;
+ let length = essence.len().checked_add(1).ok_or_else(|| invalid("SVG data-URL repair size overflows"))?;
+ let mut candidate = String::new();
+ candidate.try_reserve_exact(length).map_err(|_| invalid("could not allocate bounded SVG data-URL header"))?;
+ candidate.push_str(essence);
+ candidate.push(',');
+ // This candidate has no MIME parameters, including for oversized original
+ // lists. Its byte scan/allocation is charged above before the linear parse.
+ if !mime_header_admitted(&candidate) {
+ return Err(invalid("SVG data-URL MIME header exceeds its limit"));
+ }
+ let url = data_url::DataUrl::process(&candidate).map_err(|_| invalid("invalid SVG data-URL header framing"))?;
+ Ok(replacement_for_mime(url.mime_type()))
+}
+
+/// Use the complete source range rather than roxmltree's compact QName/equals
+/// offsets (u16/u8). Scan only this validated attribute, never a DTD declaration
+/// or another node. Charge the extra source scan before examining it.
+fn verified_value_range(text: &str, owner: Range, attribute: Range, local_name: &str, work: &mut usize) -> Result, Error> {
+ let error = || invalid("SVG data-URL attribute source positions cannot be represented safely");
+ if attribute.start < owner.start || attribute.end > owner.end {
+ return Err(error());
+ }
+ *work = work.checked_sub(attribute.len()).ok_or_else(|| invalid("SVG data-URL validation work exceeds its limit"))?;
+ let source = text.get(attribute.clone()).ok_or_else(error)?;
+ let name_end = source.find([' ', '\t', '\r', '\n', '=']).ok_or_else(error)?;
+ let name = source.get(..name_end).ok_or_else(error)?;
+ if name.rsplit(':').next() != Some(local_name) {
+ return Err(error());
+ }
+ let after_name = source.get(name_end..).ok_or_else(error)?.trim_start_matches([' ', '\t', '\r', '\n']);
+ let after_equals = after_name.strip_prefix('=').ok_or_else(error)?.trim_start_matches([' ', '\t', '\r', '\n']);
+ let quote = after_equals.chars().next().ok_or_else(error)?;
+ if !matches!(quote, '\'' | '"') || !after_equals.ends_with(quote) || after_equals.len() < 2 {
+ return Err(error());
+ }
+ let start = attribute.end.checked_sub(after_equals.len()).and_then(|n| n.checked_add(1)).ok_or_else(error)?;
+ let end = attribute.end.checked_sub(1).ok_or_else(error)?;
+ if text.get(start..end).is_none_or(|value| value.contains(quote)) {
+ return Err(error());
+ }
+ Ok(start..end)
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ fn limits() -> Limits {
+ Limits { bytes: 1 << 20, depth: 32, tree_depth: 32, entity_bytes: 65_536, ..Default::default() }
+ }
+
+ #[test]
+ fn malformed_image_urls_are_repaired_in_both_svg_namespaces_and_filter_resources() {
+ for tag in ["image", "feImage"] {
+ for text in [
+ format!("<{tag} href='data:image/png;base64,A'/> "),
+ format!("<{tag} href='data:image/png;base64,A'/> "),
+ format!(" "),
+ ] {
+ let repaired = repair(&text, &limits()).unwrap();
+ assert!(matches!(repaired, Cow::Owned(_)));
+ assert_eq!(repaired.matches(INVALID_IMAGE).count(), 1);
+ }
+ }
+ }
+
+ #[test]
+ fn unselected_href_and_foreign_local_image_names_are_normalized_for_shared_preflight() {
+ for attrs in ["href='data:image/png,%00' x:href='data:image/png;base64,A'", "x:href='data:image/png;base64,A' href='data:image/png,%00'"] {
+ let text = format!(" ");
+ let repaired = repair(&text, &limits()).unwrap();
+ assert!(matches!(repaired, Cow::Owned(_)));
+ assert_eq!(repaired.matches(INVALID_IMAGE).count(), 2);
+ assert!(!repaired.contains("base64,A"));
+ }
+ let text = format!(
+ " "
+ );
+ let repaired = repair(&text, &limits()).unwrap();
+ assert_eq!(repaired.matches(INVALID_IMAGE).count(), 3);
+ assert!(repaired.contains("f:href='data:image/png;base64,A'"), "foreign href attributes remain inert and unchanged");
+ }
+
+ #[test]
+ fn both_href_forms_on_hidden_unused_and_foreign_resources_do_not_preflight_as_omissions() {
+ for tag in ["image", "feImage"] {
+ let text = format!(
+ "<{tag} id='unused' href='data:image/png;base64,A' x:href='data:image/png;base64,A'/> <{tag} display='none' x:href='data:image/png;base64,A' href='data:image/png;base64,A'/> "
+ );
+ let original = text.clone();
+ let repaired = repair(&text, &limits()).unwrap();
+ assert_eq!(text, original, "repair never mutates the original source");
+ assert_eq!(repaired.matches(INVALID_IMAGE).count(), 6);
+ let resolver = crate::tree::ImageResolver::new(limits());
+ resolver.check_document(&repaired).unwrap();
+ let usage = resolver.usage();
+ assert_eq!(
+ (usage.invalid_raster_images, usage.invalid_svg_images),
+ (0, 0),
+ "shared whole-document scanning cannot invent omissions before resolution"
+ );
+ assert!(matches!(repair(&repaired, &limits()).unwrap(), Cow::Borrowed(_)), "normalization is idempotent");
+ }
+ }
+
+ #[test]
+ fn entity_expanded_urls_patch_the_owning_attributes_without_rewriting_the_doctype() {
+ let text = format!(
+ "]> "
+ );
+ let repaired = repair(&text, &limits()).unwrap();
+ assert!(repaired.contains(""));
+ assert_eq!(repaired.matches(INVALID_IMAGE).count(), 2);
+ assert!(!repaired.contains("href='&bad;'"));
+ assert!(matches!(repair(&repaired, &limits()).unwrap(), Cow::Borrowed(_)));
+ }
+
+ #[test]
+ fn valid_data_and_external_urls_are_not_rewritten() {
+ for value in ["data:image/png;base64,AA==", "data:image/svg+xml,%3Csvg%2F%3E", "file.png", "#local"] {
+ let text = format!(" ");
+ assert!(matches!(repair(&text, &limits()).unwrap(), Cow::Borrowed(_)));
+ }
+ let text = " ";
+ assert!(repair(text, &limits()).unwrap().contains(INVALID_IMAGE));
+ }
+
+ #[test]
+ fn malformed_non_image_urls_keep_ignored_replacements_even_without_a_comma() {
+ for value in [
+ "data:application/octet-stream;base64,A",
+ "data:application/octet-stream;base64",
+ "data:APPLICATION/OCTET-STREAM;BASE64,A",
+ "data:text/css;base64,A",
+ "data:audio/ogg;base64,A",
+ "data:application/octet-stream;base64#fragment,not-the-delimiter",
+ ] {
+ let text = format!(" ");
+ let repaired = repair(&text, &limits()).unwrap();
+ assert!(repaired.contains(IGNORED_DATA), "{value}: {repaired}");
+ assert!(!repaired.contains(INVALID_IMAGE));
+ assert!(matches!(repair(&repaired, &limits()).unwrap(), Cow::Borrowed(_)));
+ let resolver = crate::tree::ImageResolver::new(limits());
+ resolver.check_document(&repaired).unwrap();
+ assert_eq!(resolver.usage().invalid_raster_images, 0);
+ }
+ }
+
+ #[test]
+ fn image_and_default_plain_mime_failures_remain_disclosed() {
+ for value in [
+ "data:IMAGE/PNG;base64,A",
+ "data:image/png;base64",
+ "data:text/plain;base64,A",
+ "data:;base64,A",
+ "data:;base64",
+ "data:not-a-mime;base64",
+ ] {
+ let text = format!(" ");
+ assert!(repair(&text, &limits()).unwrap().contains(INVALID_IMAGE), "{value}");
+ }
+ let value = "data:application/octet-stream;base64#fragment";
+ let mut insufficient = value.len();
+ assert!(malformed_data_url_replacement(value, &mut insufficient).is_err(), "the extra MIME-header parse has its own work charge");
+ let mut sufficient = value.len() * 2;
+ assert_eq!(malformed_data_url_replacement(value, &mut sufficient).unwrap(), Some(IGNORED_DATA));
+ }
+
+ #[test]
+ fn long_equals_spacing_is_repaired_and_output_growth_stays_bounded() {
+ let text = format!(" ", " ".repeat(300));
+ let repaired = repair(&text, &limits()).unwrap();
+ assert!(repaired.contains(INVALID_IMAGE));
+ assert!(repaired.contains(&format!("href{}=", " ".repeat(300))));
+ let text = " ";
+ assert!(matches!(repair(text, &Limits { bytes: text.len(), ..limits() }), Err(Error::Parse(message)) if message.contains("byte limit")));
+ }
+}
+
+#[cfg(test)]
+#[path = "mime_header_tests.rs"]
+mod mime_header_tests;
diff --git a/crates/svg/src/tree/mime_header_tests.rs b/crates/svg/src/tree/mime_header_tests.rs
new file mode 100644
index 000000000..393a01729
--- /dev/null
+++ b/crates/svg/src/tree/mime_header_tests.rs
@@ -0,0 +1,158 @@
+use super::*;
+use std::fmt::Write;
+
+fn parameters(count: usize) -> String {
+ let mut text = String::new();
+ for index in 0..count {
+ write!(&mut text, ";p{index}=x").unwrap();
+ }
+ text
+}
+
+#[test]
+fn a_hundred_thousand_unique_mime_parameters_are_refused_before_the_original_parser() {
+ let params = parameters(100_000);
+ for (essence, expected) in [
+ ("image/png", INVALID_IMAGE),
+ ("text/plain", INVALID_IMAGE),
+ ("", INVALID_IMAGE),
+ ("not-a-mime", INVALID_IMAGE),
+ ("application/octet-stream", IGNORED_DATA),
+ ("audio/ogg", IGNORED_DATA),
+ ] {
+ for delimiter in [",AA==", "#fragment,AA==", ""] {
+ let value = format!("data:{essence}{params};base64{delimiter}");
+ let mut work = value.len() * 2;
+ assert!(!mime_header_admitted(&value));
+ let result =
+ malformed_data_url_replacement_with(&value, &mut work, |_| panic!("the original parameter flood must not reach DataUrl::process"))
+ .unwrap();
+ assert_eq!(result, Some(expected), "{essence} {delimiter}");
+ }
+ }
+}
+
+#[test]
+fn mime_parameter_admission_preserves_the_boundary_and_ignores_body_semicolons() {
+ let accepted = format!("data:image/png{};base64,AA==", parameters(MAX_MIME_SEPARATORS - 1));
+ assert!(mime_header_admitted(&accepted));
+ let called = std::cell::Cell::new(false);
+ let mut work = accepted.len() * 2;
+ assert_eq!(
+ malformed_data_url_replacement_with(&accepted, &mut work, |value| {
+ called.set(true);
+ data_url::DataUrl::process(value)
+ })
+ .unwrap(),
+ None
+ );
+ assert!(called.get(), "an admitted original URL still reaches the real parser");
+ let refused = format!("data:image/png{};base64,AA==", parameters(MAX_MIME_SEPARATORS));
+ assert!(!mime_header_admitted(&refused));
+ let mut work = refused.len() * 2;
+ assert_eq!(malformed_data_url_replacement(&refused, &mut work).unwrap(), Some(INVALID_IMAGE));
+
+ for value in [format!("data:text/plain,{}", ";".repeat(100_000)), format!("external.png?{}", parameters(100_000))] {
+ assert!(mime_header_admitted(&value), "payloads/external URLs are not MIME parameters");
+ let mut work = value.len() * 2;
+ assert_eq!(malformed_data_url_replacement(&value, &mut work).unwrap(), None);
+ }
+ let value = format!(" \td\ta\nt\ra:image/png{};base64,A", parameters(MAX_MIME_SEPARATORS));
+ assert!(!mime_header_admitted(&value), "scheme normalization matches the pinned parser");
+ let mut work = value.len() * 2;
+ assert_eq!(malformed_data_url_replacement(&value, &mut work).unwrap(), Some(INVALID_IMAGE));
+}
+
+#[test]
+fn compacted_parameter_lists_preserve_both_hrefs_and_foreign_resources_without_preflight_warnings() {
+ let value = format!("data:image/png{};base64,AA==", parameters(MAX_MIME_SEPARATORS));
+ let text = format!(
+ " "
+ );
+ let limits = Limits { bytes: 1 << 20, ..Default::default() };
+ let repaired = repair(&text, &limits).unwrap();
+ assert_eq!(repaired.matches("data:image/png;base64,AA==").count(), 6);
+ assert!(!repaired.contains(";p0="));
+ let resolver = crate::tree::ImageResolver::new(limits);
+ resolver.check_document(&repaired).unwrap();
+ let usage = resolver.usage();
+ assert_eq!((usage.invalid_raster_images, usage.invalid_svg_images), (0, 0));
+ assert!(matches!(repair(&repaired, &Limits { bytes: 1 << 20, ..Default::default() }).unwrap(), Cow::Borrowed(_)));
+}
+
+#[test]
+fn duplicate_and_quoted_parameters_share_the_same_conservative_boundary() {
+ for (accepted, refused) in [
+ (
+ format!("data:image/png{},%00", ";p=x".repeat(MAX_MIME_SEPARATORS)),
+ format!("data:image/png{},%00", ";p=x".repeat(MAX_MIME_SEPARATORS + 1)),
+ ),
+ (
+ format!("data:image/png;p=\"{}\",%00", ";".repeat(MAX_MIME_SEPARATORS - 1)),
+ format!("data:image/png;p=\"{}\",%00", ";".repeat(MAX_MIME_SEPARATORS)),
+ ),
+ ] {
+ assert!(mime_header_admitted(&accepted));
+ let mut work = accepted.len() * 2;
+ assert_eq!(malformed_data_url_replacement(&accepted, &mut work).unwrap(), None);
+ assert!(!mime_header_admitted(&refused));
+ let mut work = refused.len() * 2;
+ assert_eq!(malformed_data_url_replacement(&refused, &mut work).unwrap(), Some(INVALID_IMAGE));
+ }
+ for value in ["external.png", "#local", "datx:image/png;param=x,body"] {
+ let mut work = value.len() * 2;
+ assert_eq!(malformed_data_url_replacement(value, &mut work).unwrap(), None);
+ }
+ let value = "data:image/png;base64";
+ let mut work = value.len() * 2;
+ assert_eq!(malformed_data_url_replacement(value, &mut work).unwrap(), Some(INVALID_IMAGE));
+}
+
+#[test]
+fn parameter_flood_scans_and_essence_classification_spend_one_shared_work_ledger() {
+ let value = format!("data:application/octet-stream{};base64,AA==", parameters(MAX_MIME_SEPARATORS));
+ let essence_len = "data:application/octet-stream".len();
+ let charge = value.len() + essence_len;
+ let mut work = charge * 2;
+ for remaining in [charge, 0] {
+ assert_eq!(malformed_data_url_replacement_with(&value, &mut work, |_| panic!("not admitted")).unwrap(), Some(IGNORED_DATA));
+ assert_eq!(work, remaining, "the original header scan and parameter-free fallback each retain their charge");
+ }
+ assert!(malformed_data_url_replacement_with(&value, &mut work, |_| panic!("no work remains")).is_err());
+ assert_eq!(work, 0);
+ let mut not_enough_for_essence = value.len();
+ assert!(malformed_data_url_replacement_with(&value, &mut not_enough_for_essence, |_| panic!("not admitted")).is_err());
+ assert_eq!(not_enough_for_essence, 0);
+}
+
+#[test]
+fn many_parameter_urls_preserve_bodies_and_base64_disposition() {
+ let params = parameters(100_000);
+ for (suffix, body, expected) in [
+ (";base64", "AA==", vec![0]),
+ ("; BASE64 ", "AA==", vec![0]),
+ (";p=last", "%00%26%27%22", vec![0, b'&', b'\'', b'"']),
+ (";p=last", "&'"
z", b"&\'\"z".to_vec()),
+ ] {
+ let text = format!(" ");
+ let repaired = repair(&text, &Limits { bytes: 2 << 20, ..Default::default() }).unwrap();
+ let xml = checked_xml(&repaired, &Limits { bytes: 2 << 20, ..Default::default() }).unwrap();
+ let value = xml.descendants().find(|node| node.has_tag_name("image")).unwrap().attribute("href").unwrap();
+ assert!(!value.contains(";p0="));
+ assert_eq!(data_url::DataUrl::process(value).unwrap().decode_to_vec().unwrap().0, expected);
+ assert!(matches!(repair(&repaired, &Limits { bytes: 2 << 20, ..Default::default() }).unwrap(), Cow::Borrowed(_)));
+ }
+ let malformed = format!(" ");
+ assert!(repair(&malformed, &Limits { bytes: 2 << 20, ..Default::default() }).unwrap().contains(INVALID_IMAGE));
+}
+
+#[test]
+fn header_compaction_has_a_shared_nonrefundable_work_charge() {
+ let value = format!("data:image/png{};base64,AA==", parameters(100));
+ let mut work = value.len();
+ assert!(data_url_replacement(&value, &mut work).is_err());
+ assert_eq!(work, 0, "the original parameter scan stays spent on refusal");
+ let mut work = value.len() * 12;
+ assert!(data_url_replacement(&value, &mut work).unwrap().is_some());
+ assert!(work < value.len() * 12 - value.len(), "compact parse, streaming decode and XML projection are charged too");
+}
diff --git a/crates/svg/src/tree/validated.rs b/crates/svg/src/tree/validated.rs
new file mode 100644
index 000000000..cb1b6e8c3
--- /dev/null
+++ b/crates/svg/src/tree/validated.rs
@@ -0,0 +1,393 @@
+//! Opt-in complete image validation and checked-DOM normalization.
+//! Legacy ImageResolver entry points retain their existing behavior.
+use super::{Error, ImageUsage, Limits, Preflight, image_href, preflight, raster_format, usvg};
+use crate::svgz;
+use std::sync::{Arc, Mutex, PoisonError};
+
+struct State {
+ document_bytes: usize,
+ pixel_limit: u64,
+ pixels_left: u64,
+ svg_byte_limit: usize,
+ svg_bytes_left: usize,
+ svg_failure_exhausted: bool,
+ classification_bytes_left: usize,
+ classification_content_left: usize,
+ classification_text_bytes_left: usize,
+ encoded_left: usize,
+ invalid_raster: usize,
+ invalid_svg: usize,
+ raster_limits: usize,
+ svg_limits: usize,
+ svg_resource_limits: usize,
+ root_active: bool,
+ xml_depth: usize,
+ depth: usize,
+ svg_count: usize,
+ svg_depth: usize,
+}
+
+impl State {
+ fn new(limits: Limits) -> Self {
+ Self {
+ document_bytes: limits.bytes,
+ pixel_limit: limits.embedded_raster_pixels,
+ pixels_left: limits.embedded_raster_pixels,
+ svg_byte_limit: limits.embedded_bytes,
+ svg_bytes_left: limits.embedded_bytes,
+ svg_failure_exhausted: false,
+ classification_bytes_left: limits.embedded_bytes,
+ classification_content_left: limits.embedded_bytes,
+ classification_text_bytes_left: limits.embedded_bytes,
+ encoded_left: limits.bytes.saturating_add(limits.embedded_bytes),
+ invalid_raster: 0,
+ invalid_svg: 0,
+ raster_limits: 0,
+ svg_limits: 0,
+ svg_resource_limits: 0,
+ root_active: false,
+ xml_depth: 0,
+ depth: 0,
+ svg_count: 0,
+ svg_depth: 0,
+ }
+ }
+
+ fn usage(&self) -> ImageUsage {
+ ImageUsage {
+ raster_pixels: self.pixel_limit.saturating_sub(self.pixels_left),
+ embedded_svg_bytes: self.svg_byte_limit.saturating_sub(self.svg_bytes_left),
+ embedded_svg_count: self.svg_count,
+ embedded_svg_depth: self.svg_depth,
+ invalid_raster_images: self.invalid_raster,
+ raster_limit_images: self.raster_limits,
+ invalid_svg_images: self.invalid_svg,
+ svg_limit_images: self.svg_limits,
+ svg_resource_limit_images: self.svg_resource_limits,
+ }
+ }
+
+ fn classify_after_svg_failure(&mut self, data: &[u8]) {
+ if self.svg_resource_limits != 0 {
+ self.svg_limits = self.svg_limits.saturating_add(1);
+ self.svg_resource_limits = self.svg_resource_limits.saturating_add(1);
+ return;
+ }
+ let compressed = data.starts_with(&[0x1f, 0x8b]);
+ let content_left = self.classification_content_left;
+ let limit = if compressed { content_left.min(self.classification_bytes_left) } else { content_left }.min(self.document_bytes);
+ if compressed && limit == 0 {
+ self.svg_limits = self.svg_limits.saturating_add(1);
+ self.svg_resource_limits = self.svg_resource_limits.saturating_add(1);
+ return;
+ }
+ let resource_refusal = match crate::svgz::inflate(data, limit) {
+ Ok(bytes) => {
+ if compressed {
+ self.classification_bytes_left = self.classification_bytes_left.saturating_sub(bytes.len());
+ }
+ let Some(text_left) = self.classification_text_bytes_left.checked_sub(bytes.len()) else {
+ self.svg_limits = self.svg_limits.saturating_add(1);
+ self.svg_resource_limits = self.svg_resource_limits.saturating_add(1);
+ return;
+ };
+ self.classification_text_bytes_left = text_left;
+ match crate::svgz::decode(&bytes) {
+ Ok(text) => text.len() > content_left || text.len() > self.document_bytes,
+ Err(_) => {
+ self.invalid_svg = self.invalid_svg.saturating_add(1);
+ return;
+ }
+ }
+ }
+ Err(crate::svgz::Error::TooLarge(_)) => {
+ if compressed {
+ self.classification_bytes_left = self.classification_bytes_left.saturating_sub(limit);
+ }
+ true
+ }
+ Err(error) => {
+ // Nested data was fully inflated before refusal. Other failures
+ // may have consumed the entire attempted inflation allowance.
+ if compressed {
+ let charged = match error {
+ crate::svgz::Error::Nested(bytes) => bytes,
+ _ => limit,
+ };
+ self.classification_bytes_left = self.classification_bytes_left.saturating_sub(charged);
+ }
+ self.invalid_svg = self.invalid_svg.saturating_add(1);
+ return;
+ }
+ };
+ self.svg_limits = self.svg_limits.saturating_add(1);
+ if resource_refusal {
+ self.svg_resource_limits = self.svg_resource_limits.saturating_add(1);
+ }
+ }
+
+ fn raster(&mut self, kind: &usvg::ImageKind) -> bool {
+ let encoded = match kind {
+ usvg::ImageKind::SVG(_) => return true,
+ usvg::ImageKind::PNG(data) | usvg::ImageKind::JPEG(data) | usvg::ImageKind::GIF(data) | usvg::ImageKind::WEBP(data) => data,
+ };
+ // usvg supplies a fresh Arc for every data-URL resolution, including
+ // repeated instances. Charge each actual validation, never retain
+ // encoded buffers in an address-keyed memo that cannot hit this boundary.
+ let Some(left) = self.encoded_left.checked_sub(encoded.len()) else {
+ self.raster_limits = self.raster_limits.saturating_add(1);
+ return false;
+ };
+ self.encoded_left = left;
+ let result = super::draw::validate_raster(kind, self.pixel_limit, &mut self.pixels_left);
+ match result {
+ Ok(()) => true,
+ Err(super::draw::RasterValidationFailure::Invalid) => {
+ self.invalid_raster = self.invalid_raster.saturating_add(1);
+ false
+ }
+ Err(super::draw::RasterValidationFailure::Limit) => {
+ self.raster_limits = self.raster_limits.saturating_add(1);
+ false
+ }
+ }
+ }
+}
+
+/// One opt-in drawing's image work, normalization and exact rendering validation.
+///
+/// Unlike legacy ImageResolver, every attempted raster callback spends encoded
+/// and decoded work, even on failure. Rendering still decodes pixels afterwards:
+/// resvg does not expose a decoded-pixel injection or decode-result hook.
+/// All root and child conversions install this same resolver themselves.
+#[derive(Clone)]
+pub struct ValidatedImageResolver {
+ limits: Limits,
+ state: Arc>,
+}
+
+impl ValidatedImageResolver {
+ /// Create a separate budget for one drawing. Encoded raster work is bounded
+ /// by root text bytes plus aggregate child SVG bytes, without retaining data.
+ pub fn new(limits: Limits) -> Self {
+ Self { limits, state: Arc::new(Mutex::new(State::new(limits))) }
+ }
+
+ /// The immutable admission policy captured by this instance. Remaining work
+ /// never changes these limits; use them for the matching opaque preflight.
+ pub fn limits(&self) -> Limits {
+ self.limits
+ }
+
+ /// Snapshot admitted work and optional-image omissions.
+ pub fn usage(&self) -> ImageUsage {
+ self.state.lock().unwrap_or_else(PoisonError::into_inner).usage()
+ }
+
+ /// Convert exactly the DOM checked under these limits, with this instance's
+ /// resolver. A caller-supplied image callback cannot bypass image admission.
+ /// The caller still supplies the stack/worker and font policy.
+ pub fn parse_preflight(&self, checked: Preflight<'_>, mut options: usvg::Options<'_>) -> Result {
+ if checked.limits != self.limits {
+ return Err(Error::Parse("checked SVG limits differ from the validated image resolver".into()));
+ }
+ // A shallow source can expand through use/paint references. Reserve the
+ // full checked converted height before any child callback, not source depth.
+ let _scope = self.root_scope(checked.height)?;
+ options.image_href_resolver = self.resolver();
+ convert_checked(checked, &options)
+ }
+
+ /// Resolve an already-decoded child SVG, charging original text before XML
+ /// parsing or repair. This is not an unchecked/precharged admission hook.
+ /// As with parse_preflight, unrelated image callbacks are replaced.
+ pub fn resolve_text(&self, text: &str, mut options: usvg::Options<'_>) -> Result, Error> {
+ let _scope = self.root_scope(0)?;
+ options.image_href_resolver = self.resolver();
+ Ok(self.embedded_text(text, &options))
+ }
+
+ fn root_scope(&self, depth: usize) -> Result {
+ let mut state = self.state.lock().unwrap_or_else(PoisonError::into_inner);
+ if state.root_active {
+ return Err(Error::Parse("the validated SVG resolver is already converting a drawing".into()));
+ }
+ let previous = state.xml_depth;
+ state.root_active = true;
+ state.xml_depth = depth;
+ Ok(Scope { state: Arc::clone(&self.state), previous, child: false })
+ }
+
+ fn resolver(&self) -> usvg::ImageHrefResolver<'static> {
+ let this = self.clone();
+ usvg::ImageHrefResolver {
+ resolve_string: Box::new(|_, _| None),
+ resolve_data: Box::new(move |mime, data, options| {
+ let detected = raster_format(&data);
+ let format = match mime {
+ "image/jpg" | "image/jpeg" => (detected == Some(craft_image_codecs::Format::Jpeg)).then_some(craft_image_codecs::Format::Jpeg),
+ "image/png" => (detected == Some(craft_image_codecs::Format::Png)).then_some(craft_image_codecs::Format::Png),
+ "image/gif" => (detected == Some(craft_image_codecs::Format::Gif)).then_some(craft_image_codecs::Format::Gif),
+ "image/webp" => (detected == Some(craft_image_codecs::Format::WebP)).then_some(craft_image_codecs::Format::WebP),
+ "text/plain" => detected,
+ _ => None,
+ };
+ if let Some(format) = format {
+ let kind = match format {
+ craft_image_codecs::Format::Png => usvg::ImageKind::PNG(data),
+ craft_image_codecs::Format::Jpeg => usvg::ImageKind::JPEG(data),
+ craft_image_codecs::Format::Gif => usvg::ImageKind::GIF(data),
+ craft_image_codecs::Format::WebP => usvg::ImageKind::WEBP(data),
+ _ => return None,
+ };
+ return this.state.lock().unwrap_or_else(PoisonError::into_inner).raster(&kind).then_some(kind);
+ }
+ if !matches!(mime, "image/svg+xml" | "text/plain") {
+ if mime.starts_with("image/") {
+ let mut state = this.state.lock().unwrap_or_else(PoisonError::into_inner);
+ state.invalid_raster = state.invalid_raster.saturating_add(1);
+ }
+ return None;
+ }
+ this.embedded_bytes(&data, options)
+ }),
+ }
+ }
+
+ fn can_start_child(&self) -> bool {
+ let mut state = self.state.lock().unwrap_or_else(PoisonError::into_inner);
+ if state.depth >= self.limits.embedded_depth {
+ state.svg_limits = state.svg_limits.saturating_add(1);
+ state.svg_resource_limits = state.svg_resource_limits.saturating_add(1);
+ return false;
+ }
+ true
+ }
+
+ fn embedded_bytes(&self, data: &[u8], options: &usvg::Options<'_>) -> Option {
+ if !self.can_start_child() {
+ return None;
+ }
+ let room = {
+ let mut state = self.state.lock().unwrap_or_else(PoisonError::into_inner);
+ if state.svg_failure_exhausted {
+ state.classify_after_svg_failure(data);
+ return None;
+ }
+ state.svg_bytes_left
+ };
+ let text = match svgz::text(data, room.min(self.limits.bytes)) {
+ Ok(text) if text.len() <= room => text,
+ error => {
+ let mut state = self.state.lock().unwrap_or_else(PoisonError::into_inner);
+ state.svg_bytes_left = 0;
+ if matches!(error, Err(svgz::Error::TooLarge(_))) || error.is_ok() {
+ state.svg_limits = state.svg_limits.saturating_add(1);
+ state.svg_resource_limits = state.svg_resource_limits.saturating_add(1);
+ } else {
+ state.invalid_svg = state.invalid_svg.saturating_add(1);
+ state.svg_failure_exhausted = true;
+ state.classification_content_left = room;
+ }
+ return None;
+ }
+ };
+ self.precharge_and_parse(&text, options)
+ }
+
+ fn embedded_text(&self, text: &str, options: &usvg::Options<'_>) -> Option {
+ if !self.can_start_child() {
+ return None;
+ }
+ self.precharge_and_parse(text, options)
+ }
+
+ fn precharge_and_parse(&self, text: &str, options: &usvg::Options<'_>) -> Option {
+ {
+ let mut state = self.state.lock().unwrap_or_else(PoisonError::into_inner);
+ let Some(left) = state.svg_bytes_left.checked_sub(text.len()) else {
+ state.svg_bytes_left = 0;
+ state.svg_limits = state.svg_limits.saturating_add(1);
+ state.svg_resource_limits = state.svg_resource_limits.saturating_add(1);
+ return None;
+ };
+ // Original UTF-8 bytes/work are never refunded when repair shortens
+ // an attribute or conversion subsequently fails.
+ state.svg_bytes_left = left;
+ }
+ let checked = match preflight(text, &self.limits) {
+ Ok(checked) => checked,
+ Err(error) => {
+ let mut state = self.state.lock().unwrap_or_else(PoisonError::into_inner);
+ match error {
+ Error::TooDeep(_) => state.svg_limits = state.svg_limits.saturating_add(1),
+ Error::Text(svgz::Error::TooLarge(_)) => {
+ state.svg_limits = state.svg_limits.saturating_add(1);
+ state.svg_resource_limits = state.svg_resource_limits.saturating_add(1);
+ }
+ _ => state.invalid_svg = state.invalid_svg.saturating_add(1),
+ }
+ return None;
+ }
+ };
+ let scope = {
+ let mut state = self.state.lock().unwrap_or_else(PoisonError::into_inner);
+ let Some(total) = state.xml_depth.checked_add(checked.height).filter(|depth| *depth <= self.limits.tree_depth) else {
+ state.svg_limits = state.svg_limits.saturating_add(1);
+ return None;
+ };
+ let previous = state.xml_depth;
+ state.xml_depth = total;
+ state.depth = state.depth.saturating_add(1);
+ state.svg_depth = state.svg_depth.max(state.depth);
+ Scope { state: Arc::clone(&self.state), previous, child: true }
+ };
+ let result = convert_checked(checked, options);
+ drop(scope);
+ let mut state = self.state.lock().unwrap_or_else(PoisonError::into_inner);
+ match result {
+ Ok(tree) => {
+ state.svg_count = state.svg_count.saturating_add(1);
+ Some(usvg::ImageKind::SVG(tree))
+ }
+ Err(_) => {
+ state.invalid_svg = state.invalid_svg.saturating_add(1);
+ None
+ }
+ }
+ }
+}
+
+struct Scope {
+ state: Arc>,
+ previous: usize,
+ child: bool,
+}
+impl Drop for Scope {
+ fn drop(&mut self) {
+ let mut state = self.state.lock().unwrap_or_else(PoisonError::into_inner);
+ state.xml_depth = self.previous;
+ if self.child {
+ state.depth = state.depth.saturating_sub(1);
+ } else {
+ state.root_active = false;
+ }
+ }
+}
+
+fn convert_checked(checked: Preflight<'_>, options: &usvg::Options<'_>) -> Result {
+ match image_href::normalize(&checked)? {
+ std::borrow::Cow::Borrowed(_) => checked.parse(options),
+ std::borrow::Cow::Owned(text) => {
+ let limits = checked.limits;
+ drop(checked);
+ preflight(&text, &limits)?.parse(options)
+ }
+ }
+}
+
+#[cfg(test)]
+mod tests;
+
+#[cfg(test)]
+mod xml_tests;
diff --git a/crates/svg/src/tree/validated/tests.rs b/crates/svg/src/tree/validated/tests.rs
new file mode 100644
index 000000000..c090d7ab6
--- /dev/null
+++ b/crates/svg/src/tree/validated/tests.rs
@@ -0,0 +1,340 @@
+#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::indexing_slicing)]
+use super::*;
+use std::io::Write;
+const PIXELS: u64 = 24_000_000;
+const SVG_BYTES: usize = 16 << 20;
+
+fn test_limits(pixels: u64) -> Limits {
+ Limits {
+ bytes: 1 << 30,
+ depth: 513,
+ tree_depth: 513,
+ embedded_bytes: SVG_BYTES,
+ embedded_depth: 32,
+ embedded_raster_pixels: pixels,
+ ..Default::default()
+ }
+}
+fn test_state(pixels: u64) -> State {
+ State::new(test_limits(pixels))
+}
+fn wrapped_options(pixels: u64) -> (usvg::Options<'static>, Arc>, Arc) {
+ let resolver = Arc::new(ValidatedImageResolver::new(test_limits(pixels)));
+ let options = usvg::Options { image_href_resolver: resolver.resolver(), ..Default::default() };
+ (options, Arc::clone(&resolver.state), resolver)
+}
+fn on_test_stack(run: impl FnOnce() -> Result + Send) -> Result {
+ std::thread::scope(|scope| std::thread::Builder::new().stack_size(16 << 20).spawn_scoped(scope, run).unwrap().join().unwrap())
+}
+fn png() -> Vec {
+ let image = craft_image_codecs::Image::from_u8(2, 2, craft_image_codecs::ChannelLayout::Rgb, [17, 83, 149].repeat(4)).unwrap();
+ craft_image_codecs::encode(&image, craft_image_codecs::Format::Png, &Default::default()).unwrap()
+}
+fn data_url(mime: &str, bytes: &[u8]) -> String {
+ use std::fmt::Write;
+ let mut result = format!("data:{mime},");
+ for byte in bytes {
+ write!(&mut result, "%{byte:02X}").unwrap();
+ }
+ result
+}
+
+#[test]
+fn original_nested_xml_bytes_are_not_refunded_when_malformed_hrefs_shrink() {
+ on_test_stack(|| {
+ let (options, state, _resolver) = wrapped_options(PIXELS);
+ let prefix = " ";
+ let original_size = 3 << 20;
+ let source = Arc::new([prefix.as_bytes(), &vec![b'A'; original_size - prefix.len() - suffix.len()], suffix.as_bytes()].concat());
+ assert_eq!(source.len(), original_size);
+ for accepted in 1..=5 {
+ let kind = (options.image_href_resolver.resolve_data)("image/svg+xml", Arc::clone(&source), &options);
+ assert!(matches!(kind, Some(usvg::ImageKind::SVG(_))), "source {accepted} fits the original-text allowance");
+ drop(kind);
+ let state = state.lock().unwrap_or_else(PoisonError::into_inner);
+ assert_eq!(state.svg_bytes_left, SVG_BYTES - accepted * original_size);
+ assert!(!state.svg_failure_exhausted);
+ assert_eq!(state.classification_bytes_left, SVG_BYTES);
+ let usage = state.usage();
+ assert_eq!(usage.embedded_svg_bytes, accepted * original_size, "the short replacement cannot refund original XML work");
+ }
+ assert!((options.image_href_resolver.resolve_data)("image/svg+xml", Arc::clone(&source), &options).is_none());
+ let state = state.lock().unwrap_or_else(PoisonError::into_inner);
+ assert_eq!(state.svg_bytes_left, 0);
+ assert_eq!((state.svg_limits, state.svg_resource_limits), (1, 1));
+ assert!(!state.svg_failure_exhausted, "ordinary byte exhaustion cannot enter compatibility classification");
+ assert_eq!(state.classification_bytes_left, SVG_BYTES);
+ assert_eq!(state.usage().svg_resource_limit_images, 1);
+ Ok(())
+ })
+ .unwrap();
+}
+
+#[test]
+fn invalid_utf8_gzip_consumes_remaining_svg_work_before_the_next_child() {
+ on_test_stack(|| {
+ let (options, state, _resolver) = wrapped_options(PIXELS);
+ let mut encoder = flate2::write::GzEncoder::new(Vec::new(), flate2::Compression::default());
+ encoder.write_all(&[0xff; 4096]).unwrap();
+ let invalid = Arc::new(encoder.finish().unwrap());
+ assert!((options.image_href_resolver.resolve_data)("image/svg+xml", invalid, &options).is_none());
+ {
+ let state = state.lock().unwrap_or_else(PoisonError::into_inner);
+ assert_eq!(state.svg_bytes_left, 0, "a failed decode cannot retry the full work allowance");
+ assert_eq!(state.invalid_svg, 1);
+ assert!(state.svg_failure_exhausted);
+ assert_eq!(state.svg_resource_limits, 0);
+ assert_eq!(state.classification_bytes_left, SVG_BYTES);
+ }
+ let valid = Arc::new(b" ".to_vec());
+ let valid_size = valid.len();
+ assert!((options.image_href_resolver.resolve_data)("image/svg+xml", valid, &options).is_none());
+ let state = state.lock().unwrap_or_else(PoisonError::into_inner);
+ assert_eq!((state.invalid_svg, state.svg_limits, state.svg_resource_limits), (1, 1, 0));
+ assert_eq!(state.classification_bytes_left, SVG_BYTES, "plain input does not spend retry inflation work");
+ let usage = state.usage();
+ assert_eq!(usage.embedded_svg_bytes, SVG_BYTES);
+ assert_eq!(usage.svg_resource_limit_images, 0, "a later small child is omitted, not a resource error");
+ let charged = 2 * SVG_BYTES - state.svg_bytes_left - state.classification_bytes_left;
+ assert_eq!(charged, SVG_BYTES);
+ assert!(valid_size < SVG_BYTES);
+ Ok(())
+ })
+ .unwrap();
+}
+
+#[test]
+fn post_failure_classification_is_cumulative_and_never_admits_later_children() {
+ on_test_stack(|| {
+ let (options, state, _resolver) = wrapped_options(PIXELS);
+ let mut encoder = flate2::write::GzEncoder::new(Vec::new(), flate2::Compression::default());
+ encoder.write_all(&[0xff; 256]).unwrap();
+ assert!((options.image_href_resolver.resolve_data)("image/svg+xml", Arc::new(encoder.finish().unwrap()), &options).is_none());
+ let text = b" ";
+ let mut encoder = flate2::write::GzEncoder::new(Vec::new(), flate2::Compression::default());
+ encoder.write_all(text).unwrap();
+ let valid = Arc::new(encoder.finish().unwrap());
+ // Exercise the cumulative inflated-byte boundary with a small injected
+ // second pool; public tests cover the full 16 MiB allowance.
+ let classification_limit = text.len() * 2 - 1;
+ state.lock().unwrap_or_else(PoisonError::into_inner).classification_bytes_left = classification_limit;
+ assert!((options.image_href_resolver.resolve_data)("image/svg+xml", Arc::clone(&valid), &options).is_none());
+ {
+ let state = state.lock().unwrap_or_else(PoisonError::into_inner);
+ assert_eq!(state.classification_bytes_left, text.len() - 1);
+ assert_eq!((state.svg_limits, state.svg_resource_limits), (1, 0));
+ }
+ assert!((options.image_href_resolver.resolve_data)("image/svg+xml", Arc::clone(&valid), &options).is_none());
+ let state = state.lock().unwrap_or_else(PoisonError::into_inner);
+ assert_eq!(state.classification_bytes_left, 0);
+ assert_eq!((state.svg_limits, state.svg_resource_limits), (2, 1));
+ assert_eq!(state.svg_bytes_left, 0, "classification never refunds original failed work");
+ assert!(state.svg_failure_exhausted);
+ let charged = 2 * SVG_BYTES - state.svg_bytes_left - state.classification_bytes_left;
+ assert_eq!(charged, 2 * SVG_BYTES, "original content plus aggregate retry inflation allowances remain bounded");
+ assert_eq!(state.usage().embedded_svg_count, 0, "classified children must never reach the shared parser");
+ Ok(())
+ })
+ .unwrap();
+}
+
+#[test]
+fn retry_inflation_room_and_saved_decoded_content_room_remain_independent() {
+ on_test_stack(|| {
+ let mut latin1 = b" ");
+ let decoded_len = crate::svgz::decode(&latin1).unwrap().len();
+ assert!(latin1.len() < 256 && decoded_len > 256 && decoded_len < 512);
+ let gzip = |bytes: &[u8]| {
+ let mut encoder = flate2::write::GzEncoder::new(Vec::new(), flate2::Compression::default());
+ encoder.write_all(bytes).unwrap();
+ Arc::new(encoder.finish().unwrap())
+ };
+ for (content_room, expected_resource) in [(512usize, false), (256, true)] {
+ let (options, state, _resolver) = wrapped_options(PIXELS);
+ // Model preceding genuine content consumption before an unreadable
+ // stream burns the rest. Classification must save this exact room.
+ state.lock().unwrap_or_else(PoisonError::into_inner).svg_bytes_left = content_room;
+ assert!((options.image_href_resolver.resolve_data)("image/svg+xml", gzip(&[0xff; 4]), &options).is_none());
+ {
+ let mut state = state.lock().unwrap_or_else(PoisonError::into_inner);
+ assert_eq!(state.classification_content_left, content_room);
+ assert_eq!(state.svg_bytes_left, 0);
+ // Enough compressed retry work for the raw Latin-1 bytes, but
+ // less than their decoded UTF-8 length, just like main's case.
+ state.classification_bytes_left = latin1.len() + 1;
+ }
+ assert!((options.image_href_resolver.resolve_data)("image/svg+xml", gzip(&latin1), &options).is_none());
+ let state = state.lock().unwrap_or_else(PoisonError::into_inner);
+ assert_eq!(state.classification_bytes_left, 1, "retry work charges inflated bytes, not UTF-8 bytes");
+ assert_eq!(state.svg_resource_limits, usize::from(expected_resource));
+ assert_eq!(state.svg_bytes_left, 0, "classification never restores original content allowance");
+ assert_eq!(state.usage().embedded_svg_count, 0, "no classified child is parsed or drawn");
+ }
+ Ok(())
+ })
+ .unwrap();
+}
+
+#[test]
+fn failed_raster_callbacks_release_sources_and_keep_every_decode_charge() {
+ let mut broken = png();
+ let idat = broken.windows(4).position(|bytes| bytes == b"IDAT").unwrap();
+ broken[idat + 4] ^= 1;
+ assert_eq!(craft_image_codecs::probe_allocation_size(&broken).unwrap(), (2, 2));
+ let mut state = test_state(8);
+ let encoded_before = state.encoded_left;
+ for attempt in 1..=2 {
+ // Match usvg's actual callback boundary: each href gets a new Arc.
+ let encoded = Arc::new(broken.clone());
+ let weak = Arc::downgrade(&encoded);
+ let kind = usvg::ImageKind::PNG(Arc::clone(&encoded));
+ assert!(!state.raster(&kind));
+ assert_eq!(state.pixels_left, 8 - attempt * 4);
+ assert_eq!(state.encoded_left, encoded_before - attempt as usize * encoded.len());
+ assert_eq!(state.invalid_raster, attempt as usize);
+ drop(kind);
+ drop(encoded);
+ assert!(weak.upgrade().is_none(), "validation must not retain failed callback buffers until parse completion");
+ }
+ assert!(!state.raster(&usvg::ImageKind::PNG(Arc::new(png()))));
+ assert_eq!((state.invalid_raster, state.raster_limits), (2, 1));
+ assert_eq!(state.usage().raster_pixels, 8);
+}
+
+#[test]
+fn valid_raster_callbacks_spend_exact_pixel_and_encoded_allowances_per_call() {
+ let encoded = Arc::new(png());
+ let kind = usvg::ImageKind::PNG(Arc::clone(&encoded));
+ let mut state = test_state(8);
+ state.encoded_left = encoded.len() * 2;
+ assert!(state.raster(&kind));
+ assert_eq!((state.pixels_left, state.encoded_left), (4, encoded.len()));
+ assert!(state.raster(&kind), "even a directly reused Arc is a new actual validation call");
+ assert_eq!((state.pixels_left, state.encoded_left), (0, 0));
+ assert!(!state.raster(&kind));
+ assert_eq!((state.invalid_raster, state.raster_limits), (0, 1));
+ let usage = state.usage();
+ assert_eq!((usage.raster_pixels, usage.raster_limit_images), (8, 1));
+}
+
+#[test]
+fn raster_callbacks_own_per_call_pixel_charges_and_keep_mime_aliases_separate() {
+ let png = Arc::new(png());
+ let (options, state, resolver) = wrapped_options(4);
+ assert!((options.image_href_resolver.resolve_data)("image/png", Arc::clone(&png), &options).is_some());
+ assert!((options.image_href_resolver.resolve_data)("image/png", Arc::clone(&png), &options).is_none());
+ assert_eq!((resolver.usage().raster_pixels, resolver.usage().invalid_raster_images, resolver.usage().raster_limit_images), (4, 0, 1));
+ assert!((options.image_href_resolver.resolve_data)("image/jpeg", png, &options).is_none());
+ let usage = state.lock().unwrap().usage();
+ assert_eq!((usage.raster_pixels, usage.invalid_raster_images), (4, 1));
+}
+
+#[test]
+fn encoded_raster_refusal_is_per_image_and_does_not_consume_unattempted_work() {
+ let bytes = png();
+ let mut oversized = bytes.clone();
+ oversized.extend([0; 32]);
+ let mut state = test_state(4);
+ state.encoded_left = bytes.len();
+ assert!(!state.raster(&usvg::ImageKind::PNG(Arc::new(oversized))));
+ assert_eq!((state.encoded_left, state.pixels_left), (bytes.len(), 4));
+ assert!(state.raster(&usvg::ImageKind::PNG(Arc::new(bytes))));
+ assert_eq!((state.encoded_left, state.pixels_left), (0, 0));
+ let usage = state.usage();
+ assert_eq!((usage.raster_pixels, usage.raster_limit_images, usage.invalid_raster_images), (4, 1, 0));
+}
+
+#[test]
+fn encoded_raster_exhaustion_keeps_ordinary_drawing_and_reports_only_omitted_images() {
+ let bytes = png();
+ let href = data_url("image/png", &bytes);
+ let text = format!(
+ r##" "##
+ );
+ let resolver = ValidatedImageResolver::new(test_limits(8));
+ resolver.state.lock().unwrap().encoded_left = bytes.len();
+ let tree = resolver.parse_preflight(preflight(&text, &resolver.limits()).unwrap(), usvg::Options::default()).unwrap();
+ let usage = resolver.usage();
+ assert_eq!((usage.raster_pixels, usage.raster_limit_images, usage.invalid_raster_images), (4, 1, 0));
+ let output = super::super::draw::render(&tree, usvg::Transform::identity(), 4, 2, 0, 1 << 20).unwrap();
+ let background = output.pixel(3, 1).unwrap().demultiply();
+ assert_eq!((background.red(), background.green(), background.blue(), background.alpha()), (0, 255, 0, 255));
+ let pixel = output.pixel(0, 0).unwrap().demultiply();
+ assert_eq!((pixel.red(), pixel.green(), pixel.blue(), pixel.alpha()), (17, 83, 149, 255));
+ assert_eq!(resolver.state.lock().unwrap().encoded_left, 0);
+}
+
+// Preserve upstream's text_rechecked boundary using the integrated real resolver.
+// Plain and gzip retries spend source bytes before decoding, independently of
+// inflation work and the drawing's genuine decoded-content capacity.
+#[test]
+fn plain_legacy_encoding_rechecks_have_a_separate_bounded_work_allowance() {
+ on_test_stack(|| {
+ let xml = b" ";
+ for compressed in [false, true] {
+ let (options, state, _resolver) = wrapped_options(PIXELS);
+ let encode = |bytes: &[u8]| {
+ if compressed {
+ let mut encoder = flate2::write::GzEncoder::new(Vec::new(), flate2::Compression::default());
+ encoder.write_all(bytes).unwrap();
+ encoder.finish().unwrap()
+ } else {
+ bytes.to_vec()
+ }
+ };
+ assert!((options.image_href_resolver.resolve_data)("image/svg+xml", Arc::new(encode(&[0xff])), &options).is_none());
+ state.lock().unwrap_or_else(PoisonError::into_inner).classification_text_bytes_left = xml.len();
+ assert!((options.image_href_resolver.resolve_data)("image/svg+xml", Arc::new(encode(xml)), &options).is_none());
+ {
+ let state = state.lock().unwrap_or_else(PoisonError::into_inner);
+ assert_eq!(state.classification_text_bytes_left, 0);
+ assert_eq!(state.svg_resource_limits, 0, "exactly fitting text recheck is permitted");
+ assert_eq!(state.classification_bytes_left, SVG_BYTES - usize::from(compressed) * xml.len());
+ }
+ assert!((options.image_href_resolver.resolve_data)("image/svg+xml", Arc::new(encode(xml)), &options).is_none());
+ let state = state.lock().unwrap_or_else(PoisonError::into_inner);
+ assert_eq!(state.classification_text_bytes_left, 0);
+ assert_eq!(state.svg_resource_limits, 1, "the next source cannot repeat text-conversion work");
+ assert_eq!(state.invalid_svg, 1, "the original encoding error stays invalid");
+ assert_eq!(state.svg_limits, 2);
+ assert_eq!(state.usage().embedded_svg_count, 0, "rechecked children are never admitted");
+ }
+ Ok(())
+ })
+ .unwrap();
+}
+
+#[test]
+fn embedded_gzip_obeys_document_bytes_before_aggregate_inflation_room() {
+ on_test_stack(|| {
+ let mut text = b" ".len(), b' ');
+ text.extend_from_slice(b"-->");
+ assert_eq!(text.len(), 256);
+ let mut encoder = flate2::write::GzEncoder::new(Vec::new(), flate2::Compression::default());
+ encoder.write_all(&text).unwrap();
+ let encoded = Arc::new(encoder.finish().unwrap());
+ for bytes in [text.len() - 1, text.len()] {
+ let limits = Limits { bytes, embedded_bytes: 1024, ..test_limits(4) };
+ assert!(limits.embedded_bytes > text.len());
+ let resolver = ValidatedImageResolver::new(limits);
+ let options = usvg::Options { image_href_resolver: resolver.resolver(), ..Default::default() };
+ let image = (options.image_href_resolver.resolve_data)("image/svg+xml", Arc::clone(&encoded), &options);
+ let usage = resolver.usage();
+ if bytes == text.len() {
+ assert!(matches!(image, Some(usvg::ImageKind::SVG(_))), "exact document boundary remains admissible");
+ assert_eq!((usage.embedded_svg_count, usage.embedded_svg_bytes), (1, text.len()));
+ assert_eq!((usage.svg_resource_limit_images, usage.invalid_svg_images), (0, 0));
+ } else {
+ assert!(image.is_none(), "aggregate room must not lift one document's inflate limit");
+ assert_eq!((usage.embedded_svg_count, usage.svg_resource_limit_images, usage.invalid_svg_images), (0, 1, 0));
+ assert_eq!(usage.embedded_svg_bytes, 1024, "refused work retains its aggregate charge");
+ }
+ }
+ Ok(())
+ })
+ .unwrap();
+}
diff --git a/crates/svg/src/tree/validated/xml_tests.rs b/crates/svg/src/tree/validated/xml_tests.rs
new file mode 100644
index 000000000..b6b594433
--- /dev/null
+++ b/crates/svg/src/tree/validated/xml_tests.rs
@@ -0,0 +1,176 @@
+//! Public validated-context contracts; private byte/raster accounting lives in tests.rs.
+#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::indexing_slicing)]
+use super::super::{Limits, PREFLIGHT_PASSES, preflight, usvg};
+use super::ValidatedImageResolver;
+use std::io::Write;
+use std::sync::{
+ Arc,
+ atomic::{AtomicUsize, Ordering},
+};
+
+const NS: &str = "http://www.w3.org/2000/svg";
+
+fn drawing(contents: &str) -> String {
+ format!("{contents} ")
+}
+
+fn url(bytes: &[u8]) -> String {
+ use std::fmt::Write;
+ let mut value = String::from("data:image/svg+xml,");
+ for byte in bytes {
+ write!(&mut value, "%{byte:02X}").unwrap();
+ }
+ value
+}
+
+fn gzip(bytes: &[u8]) -> Vec {
+ let mut encoder = flate2::write::GzEncoder::new(Vec::new(), flate2::Compression::default());
+ encoder.write_all(bytes).unwrap();
+ encoder.finish().unwrap()
+}
+
+fn image(href: &str) -> String {
+ format!(" ")
+}
+
+fn parse_count(text: &str, limits: Limits) -> (super::super::ImageUsage, usize) {
+ PREFLIGHT_PASSES.with(|count| count.set(0));
+ let context = ValidatedImageResolver::new(limits);
+ let checked = preflight(text, &limits).unwrap();
+ let tree = context.parse_preflight(checked, usvg::Options::default()).unwrap();
+ assert!(!tree.root().children().is_empty(), "the visible drawing survives validation");
+ (context.usage(), PREFLIGHT_PASSES.with(|count| count.get()))
+}
+
+#[test]
+fn validated_root_reuses_checked_xml_and_rechecks_only_changed_attributes() {
+ let ordinary = drawing(" ");
+ let repaired = drawing(" ");
+ let (usage, count) = parse_count(&ordinary, Limits::default());
+ assert_eq!(count, 1);
+ assert_eq!(usage.invalid_raster_images, 0);
+ let (usage, count) = parse_count(&repaired, Limits::default());
+ assert_eq!(count, 2);
+ assert_eq!(usage.invalid_raster_images, 1);
+}
+
+#[test]
+fn validated_plain_and_gzip_children_reuse_their_original_preflight() {
+ for repaired in [false, true] {
+ let mut contents = String::from(" ");
+ if repaired {
+ contents.push_str(" ");
+ }
+ let child = drawing(&contents);
+ for compressed in [false, true] {
+ let encoded = if compressed { gzip(child.as_bytes()) } else { child.as_bytes().to_vec() };
+ let root = drawing(&image(&url(&encoded)));
+ let (usage, count) = parse_count(&root, Limits::default());
+ assert_eq!(count, if repaired { 3 } else { 2 }, "compressed={compressed}, repaired={repaired}");
+ assert_eq!(usage.embedded_svg_count, 1);
+ assert_eq!(usage.embedded_svg_bytes, child.len());
+ assert_eq!(usage.invalid_raster_images, usize::from(repaired));
+ assert_eq!(usage.invalid_svg_images, 0);
+ }
+ }
+}
+
+#[test]
+fn validated_original_xml_guards_precede_normalization_and_conversion() {
+ let normal = drawing(" ");
+ let entity = format!("]>{}", drawing(" "));
+ let markup = format!("'>]>{}", drawing("&a;"));
+ let referenced = drawing(" ");
+ for (text, limits) in [
+ (&normal, Limits { bytes: normal.len() - 1, ..Default::default() }),
+ (&normal, Limits { attributes: 0, ..Default::default() }),
+ (&normal, Limits { xml_nodes: 1, ..Default::default() }),
+ (&entity, Limits { entity_bytes: 1, ..Default::default() }),
+ (&markup, Limits { refuse_entity_markup: true, ..Default::default() }),
+ (&referenced, Limits { tree_depth: 2, ..Default::default() }),
+ ] {
+ assert!(preflight(text, &limits).is_err(), "original source must be refused before normalization: {text}");
+ }
+ let limits = Limits { entity_bytes: 1024, ..Default::default() };
+ let context = ValidatedImageResolver::new(limits);
+ let checked = preflight(&entity, &limits).unwrap();
+ context.parse_preflight(checked, usvg::Options::default()).unwrap();
+ assert_eq!(context.usage().invalid_raster_images, 1, "admitted entity data reaches omission accounting");
+}
+
+#[test]
+fn validated_context_requires_exact_preflight_limits() {
+ let text = drawing(" ");
+ let limits = Limits { bytes: 4096, tree_depth: 16, embedded_bytes: 2048, ..Default::default() };
+ let context = ValidatedImageResolver::new(limits);
+ assert_eq!(context.limits(), limits);
+ for changed in [
+ Limits { bytes: 4095, ..limits },
+ Limits { bytes: 4097, ..limits },
+ Limits { tree_depth: 15, ..limits },
+ Limits { embedded_bytes: 2049, ..limits },
+ ] {
+ let checked = preflight(&text, &changed).unwrap();
+ assert!(context.parse_preflight(checked, usvg::Options::default()).is_err());
+ assert_eq!(context.usage(), Default::default(), "policy mismatch must not start conversion");
+ }
+ context.parse_preflight(preflight(&text, &limits).unwrap(), usvg::Options::default()).unwrap();
+}
+
+fn hostile_options(calls: &Arc) -> usvg::Options<'static> {
+ let string_calls = Arc::clone(calls);
+ let data_calls = Arc::clone(calls);
+ usvg::Options {
+ image_href_resolver: usvg::ImageHrefResolver {
+ resolve_string: Box::new(move |_, _| {
+ string_calls.fetch_add(1, Ordering::SeqCst);
+ panic!("ambient string resolver must not run")
+ }),
+ resolve_data: Box::new(move |_, _, _| {
+ data_calls.fetch_add(1, Ordering::SeqCst);
+ panic!("caller data resolver must not bypass validation")
+ }),
+ },
+ ..Default::default()
+ }
+}
+
+#[test]
+fn validated_root_and_nested_context_override_untrusted_image_callbacks() {
+ let calls = Arc::new(AtomicUsize::new(0));
+ let child = drawing(
+ " ",
+ );
+ let root = drawing(&format!(" {}", image(&url(child.as_bytes()))));
+ let limits = Limits::default();
+ let context = ValidatedImageResolver::new(limits);
+ context.parse_preflight(preflight(&root, &limits).unwrap(), hostile_options(&calls)).unwrap();
+ assert_eq!(calls.load(Ordering::SeqCst), 0);
+ assert_eq!(context.usage().embedded_svg_count, 1);
+ assert_eq!(context.usage().invalid_raster_images, 1);
+ let direct = ValidatedImageResolver::new(limits);
+ assert!(matches!(direct.resolve_text(&child, hostile_options(&calls)).unwrap(), Some(usvg::ImageKind::SVG(_))));
+ assert_eq!(calls.load(Ordering::SeqCst), 0);
+ assert_eq!(direct.usage().invalid_raster_images, 1);
+}
+
+#[test]
+fn expanded_root_references_and_child_share_the_converted_depth_limit() {
+ let child = drawing(" "); // height 3
+ let href = url(child.as_bytes());
+ let root = drawing(&format!("{} ", image(&href))); // height 6
+ assert!(preflight(&root, &Limits { tree_depth: 5, ..Default::default() }).is_err());
+ assert!(preflight(&root, &Limits { tree_depth: 6, ..Default::default() }).is_ok());
+ assert!(preflight(&child, &Limits { tree_depth: 3, ..Default::default() }).is_ok());
+ for (depth, admitted) in [(8, false), (9, true)] {
+ let limits = Limits { tree_depth: depth, ..Default::default() };
+ let checked = preflight(&root, &limits).unwrap();
+ assert!(checked.depth() < 6, "source nesting is shallower than expanded references");
+ let context = ValidatedImageResolver::new(limits);
+ context.parse_preflight(checked, usvg::Options::default()).unwrap();
+ let usage = context.usage();
+ assert_eq!(usage.embedded_svg_count, usize::from(admitted));
+ assert_eq!(usage.svg_limit_images, usize::from(!admitted));
+ assert_eq!(usage.invalid_svg_images, 0);
+ }
+}