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