diff --git a/crates/io/src/svg.rs b/crates/io/src/svg.rs index 6ffac539a9..5d040c69d3 100644 --- a/crates/io/src/svg.rs +++ b/crates/io/src/svg.rs @@ -112,6 +112,10 @@ const MAX_FILTER_COST: u64 = 2_000_000_000; /// Reads per pixel any primitive may take for free (a 16 × 16 morphology window or kernel, 16 /// turbulence octaves), so ordinary filters open on any canvas. const ORDINARY_FILTER_READS: u64 = 256; +/// Most elements [`filter_cost`] visits, counting a shared mask, clip path or pattern once per +/// use, as resvg renders it: patterns that fill and stroke with the next one double the work at +/// each level, so a few dozen levels would keep the check (and the render) busy for hours. +const MAX_FILTER_VISITS: usize = 10_000_000; /// One `feTurbulence` octave per pixel, in pixel reads (it measures about 15 times a read). const TURBULENCE_OCTAVE_COST: u64 = 16; /// Deepest element nesting accepted. The XML parser recurses once per level, so a file nested @@ -487,8 +491,9 @@ fn count_nodes(root: &usvg::Group) -> usize { /// the drawing through `base` (drawing units to canvas px), in pixel reads: its morphology reads /// the whole radius window per pixel, convolution the whole kernel, and turbulence runs every /// octave (usvg doesn't clamp `numOctaves`). Masks, clip paths, patterns and embedded drawings -/// count too, at the scale of the element that uses them, as resvg renders them. -fn filter_cost(root: &usvg::Group, base: tiny_skia::Transform, rec: usize) -> u64 { +/// count too, at the scale of the element that uses them, as resvg renders them. Past `visits` +/// elements the drawing counts as too costly. +fn filter_cost(root: &usvg::Group, base: tiny_skia::Transform, rec: usize, visits: &mut usize) -> u64 { use usvg::filter::Kind; let mut cost = 0u64; let mut stack: Vec<&usvg::Group> = vec![root]; @@ -511,6 +516,10 @@ fn filter_cost(root: &usvg::Group, base: tiny_skia::Transform, rec: usize) -> u6 } } for node in g.children() { + *visits = visits.saturating_sub(1); + if *visits == 0 { + return u64::MAX; + } if let usvg::Node::Group(child) = node { stack.push(child); } @@ -518,7 +527,7 @@ fn filter_cost(root: &usvg::Group, base: tiny_skia::Transform, rec: usize) -> u6 continue; } let world = base.pre_concat(node.abs_transform()); - let mut sub = |root: &usvg::Group, ts: tiny_skia::Transform| cost = cost.saturating_add(filter_cost(root, ts, rec + 1)); + let mut sub = |root: &usvg::Group, ts: tiny_skia::Transform| cost = cost.saturating_add(filter_cost(root, ts, rec + 1, visits)); match node { // resvg draws a pattern's tile at the path's scale times the pattern's own. usvg::Node::Path(p) => { @@ -537,9 +546,9 @@ fn filter_cost(root: &usvg::Group, base: tiny_skia::Transform, rec: usize) -> u6 /// An error when the drawing's filters are too costly to render at `scale` (see [`filter_cost`]). fn check_filter_cost(tree: &usvg::Tree, scale: f32) -> Result<(), IoError> { - if filter_cost(tree.root(), tiny_skia::Transform::from_scale(scale, scale), 0) > MAX_FILTER_COST { + if filter_cost(tree.root(), tiny_skia::Transform::from_scale(scale, scale), 0, &mut { MAX_FILTER_VISITS }) > MAX_FILTER_COST { return Err(IoError::Svg( - "the drawing's filters are too costly to render (a huge morphology radius, convolution kernel or turbulence octave count)".into(), + "the drawing's filters are too costly to render (a huge morphology radius, convolution kernel or turbulence octave count, or patterns nested too deep)".into(), )); } Ok(()) @@ -1004,7 +1013,7 @@ mod tests { vec!["1"; 25].join(" ") ); let tree = parse(svg.as_bytes()).unwrap().tree; - assert_eq!(filter_cost(tree.root(), tiny_skia::Transform::identity(), 0), 0); + assert_eq!(filter_cost(tree.root(), tiny_skia::Transform::identity(), 0, &mut { MAX_FILTER_VISITS }), 0); assert!(check_filter_cost(&tree, 1.0).is_ok()); } diff --git a/crates/io/tests/it/svg.rs b/crates/io/tests/it/svg.rs index 55b835d306..60f9d6c15f 100644 --- a/crates/io/tests/it/svg.rs +++ b/crates/io/tests/it/svg.rs @@ -455,6 +455,27 @@ fn filters_too_costly_to_render_are_refused_not_run() { assert!(svg::rasterize(small.as_bytes(), 40.0).is_err()); } +/// Patterns that fill and stroke with the next one double resvg's work at every level: past the +/// check's element budget the drawing is refused, not walked (or rendered) for hours. +#[test] +fn patterns_nested_too_deep_are_refused_not_walked() { + let chain = |depth: usize| { + let defs: String = (0..depth) + .map(|i| { + let paint = if i + 1 < depth { format!("url(#p{})", i + 1) } else { "red".into() }; + format!("") + }) + .collect(); + format!("{defs}") + }; + let deep = chain(24); + let e = import("x.svg", deep.as_bytes()).err().unwrap_or_else(|| panic!("opened a 2^24-use pattern chain")); + assert!(matches!(&e, IoError::Svg(m) if m.contains("too costly")), "{e}"); + assert!(svg::rasterize(deep.as_bytes(), 1.0).is_err()); + // A few levels still open. + assert!(!open(&chain(4)).document.layers.is_empty()); +} + #[test] fn an_svg_round_trips_through_pcraft_as_shapes() { let r = open(&format!(