feat(anatomy): prescan caps attributes, namespace declarations and raw markup counts
This commit is contained in:
1 parent
4e01710a34
commit
a7b3d7a4c1
1 file changed
+113
-35
@@ -1,9 +1,12 @@
|
||||
//! Bounds an SVG text before any XML parser sees it (plan R3 C2). roxmltree builds its tree
|
||||
//! recursively enough to overflow the 1 MiB wasm stack between 1,000 and 3,000 nesting
|
||||
//! levels (measured 2026-10-14), so the depth and the element count are taken here by a
|
||||
//! markup scanner: comments, CDATA sections, processing instructions and quoted attribute
|
||||
//! values are skipped as the XML grammar defines them, never by pattern matching. The scan
|
||||
//! is an upper bound of what a parser would build; anything it cannot close is malformed.
|
||||
//! Bounds an SVG text before any XML parser sees it (plan R3 C2). roxmltree 0.21 builds its
|
||||
//! tree recursively, one level per element, enough to overflow the 1 MiB wasm stack between
|
||||
//! 1,000 and 3,000 nesting levels (measured 2026-10-14); it also pre-allocates on the raw
|
||||
//! counts of `<` and `=`, checks duplicate attributes quadratically and copies inherited
|
||||
//! namespaces per declaring element. So the depth, the element, attribute and namespace
|
||||
//! counts are taken here by a markup scanner: comments, CDATA sections, processing
|
||||
//! instructions and quoted attribute values are skipped as the XML grammar defines them,
|
||||
//! never by pattern matching. The scan is an upper bound of what a parser would build;
|
||||
//! anything it cannot close is malformed.
|
||||
|
||||
/// The resource limits of one SVG text.
|
||||
#[derive(Debug, Clone, Copy)]
|
||||
@@ -14,14 +17,27 @@ pub struct SvgCaps {
|
||||
pub max_elements: usize,
|
||||
/// Nesting depth, the root at depth 1.
|
||||
pub max_depth: usize,
|
||||
/// Attributes of one element (roxmltree's duplicate check is quadratic in it).
|
||||
pub max_attributes_per_element: usize,
|
||||
pub max_attributes: usize,
|
||||
/// `xmlns` and `xmlns:*` declarations.
|
||||
pub max_namespace_declarations: usize,
|
||||
/// Raw `<` and `=` bytes, comments and text included.
|
||||
pub max_open_brackets: usize,
|
||||
pub max_equals: usize,
|
||||
}
|
||||
|
||||
/// The engine's caps (`packages/pdf/src/svg/sanitize.ts` SANITIZER_CAPS) plus the byte cap
|
||||
/// R3 adds before parsing.
|
||||
/// The engine's caps (`packages/pdf/src/svg/sanitize.ts` SANITIZER_CAPS) plus the bounds R3
|
||||
/// adds before parsing.
|
||||
pub const SVG_CAPS: SvgCaps = SvgCaps {
|
||||
max_bytes: 2 * 1024 * 1024,
|
||||
max_elements: 20_000,
|
||||
max_depth: 64,
|
||||
max_attributes_per_element: 256,
|
||||
max_attributes: 100_000,
|
||||
max_namespace_declarations: 16,
|
||||
max_open_brackets: 100_000,
|
||||
max_equals: 200_000,
|
||||
};
|
||||
|
||||
/// Why a text is refused before parsing.
|
||||
@@ -32,6 +48,8 @@ pub enum PrescanError {
|
||||
Doctype,
|
||||
TooDeep,
|
||||
TooManyElements,
|
||||
/// Attribute, namespace or raw markup counts over their caps.
|
||||
TooComplex,
|
||||
Malformed,
|
||||
}
|
||||
|
||||
@@ -47,19 +65,20 @@ pub fn prescan(text: &str, caps: &SvgCaps) -> Result<Prescan, PrescanError> {
|
||||
if text.len() > caps.max_bytes {
|
||||
return Err(PrescanError::TooLarge);
|
||||
}
|
||||
if declares_doctype(text.as_bytes()) {
|
||||
// xmldom refuses a byte order mark; roxmltree would skip it.
|
||||
if text.starts_with('\u{feff}') {
|
||||
return Err(PrescanError::Malformed);
|
||||
}
|
||||
let bytes = text.as_bytes();
|
||||
if declares_doctype(bytes) {
|
||||
return Err(PrescanError::Doctype);
|
||||
}
|
||||
let mut scan = Scan {
|
||||
bytes: text.as_bytes(),
|
||||
at: 0,
|
||||
depth: 0,
|
||||
counted: Prescan {
|
||||
elements: 0,
|
||||
depth: 0,
|
||||
},
|
||||
};
|
||||
while let Some(open) = find(scan.bytes, b"<", scan.at) {
|
||||
let count = |b: u8| bytes.iter().filter(|&&x| x == b).count();
|
||||
if count(b'<') > caps.max_open_brackets || count(b'=') > caps.max_equals {
|
||||
return Err(PrescanError::TooComplex);
|
||||
}
|
||||
let mut scan = Scan::new(bytes);
|
||||
while let Some(open) = find(bytes, b"<", scan.at) {
|
||||
scan.at = open;
|
||||
scan.markup(caps)?;
|
||||
}
|
||||
@@ -73,10 +92,33 @@ struct Scan<'a> {
|
||||
bytes: &'a [u8],
|
||||
at: usize,
|
||||
depth: usize,
|
||||
attributes: usize,
|
||||
declarations: usize,
|
||||
counted: Prescan,
|
||||
}
|
||||
|
||||
impl Scan<'_> {
|
||||
/// What one start tag holds.
|
||||
struct Tag {
|
||||
self_closing: bool,
|
||||
attributes: usize,
|
||||
declarations: usize,
|
||||
}
|
||||
|
||||
impl<'a> Scan<'a> {
|
||||
fn new(bytes: &'a [u8]) -> Self {
|
||||
Self {
|
||||
bytes,
|
||||
at: 0,
|
||||
depth: 0,
|
||||
attributes: 0,
|
||||
declarations: 0,
|
||||
counted: Prescan {
|
||||
elements: 0,
|
||||
depth: 0,
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
/// Consumes the markup starting at `self.at` (a `<`).
|
||||
fn markup(&mut self, caps: &SvgCaps) -> Result<(), PrescanError> {
|
||||
let rest = &self.bytes[self.at..];
|
||||
@@ -97,8 +139,21 @@ impl Scan<'_> {
|
||||
self.depth = self.depth.checked_sub(1).ok_or(PrescanError::Malformed)?;
|
||||
return Ok(());
|
||||
}
|
||||
let self_closing = self.skip_tag()?;
|
||||
self.open_element(self_closing, caps)
|
||||
let tag = self.skip_tag()?;
|
||||
self.count_attributes(&tag, caps)?;
|
||||
self.open_element(tag.self_closing, caps)
|
||||
}
|
||||
|
||||
fn count_attributes(&mut self, tag: &Tag, caps: &SvgCaps) -> Result<(), PrescanError> {
|
||||
self.attributes += tag.attributes;
|
||||
self.declarations += tag.declarations;
|
||||
if tag.attributes > caps.max_attributes_per_element
|
||||
|| self.attributes > caps.max_attributes
|
||||
|| self.declarations > caps.max_namespace_declarations
|
||||
{
|
||||
return Err(PrescanError::TooComplex);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn open_element(&mut self, self_closing: bool, caps: &SvgCaps) -> Result<(), PrescanError> {
|
||||
@@ -123,8 +178,14 @@ impl Scan<'_> {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Skips a start tag, quoted values included; answers whether it ends with `/>`.
|
||||
fn skip_tag(&mut self) -> Result<bool, PrescanError> {
|
||||
/// Skips a start tag, quoted values included, counting its attributes (an `=` outside
|
||||
/// quotes) and its namespace declarations (an attribute name starting with `xmlns`).
|
||||
fn skip_tag(&mut self) -> Result<Tag, PrescanError> {
|
||||
let mut tag = Tag {
|
||||
self_closing: false,
|
||||
attributes: 0,
|
||||
declarations: 0,
|
||||
};
|
||||
let mut quote: Option<u8> = None;
|
||||
let mut i = self.at + 1;
|
||||
while let Some(&b) = self.bytes.get(i) {
|
||||
@@ -133,10 +194,13 @@ impl Scan<'_> {
|
||||
(Some(_), _) => {}
|
||||
(None, b'"' | b'\'') => quote = Some(b),
|
||||
(None, b'<') => return Err(PrescanError::Malformed),
|
||||
(None, b'=') => tag.attributes += 1,
|
||||
(None, b'>') => {
|
||||
self.at = i + 1;
|
||||
return Ok(i > 0 && self.bytes[i - 1] == b'/');
|
||||
tag.self_closing = self.bytes[i - 1] == b'/';
|
||||
return Ok(tag);
|
||||
}
|
||||
(None, _) if declaration_at(self.bytes, i) => tag.declarations += 1,
|
||||
(None, _) => {}
|
||||
}
|
||||
i += 1;
|
||||
@@ -145,6 +209,11 @@ impl Scan<'_> {
|
||||
}
|
||||
}
|
||||
|
||||
/// An attribute name starting with `xmlns` begins at `i` (right after whitespace).
|
||||
fn declaration_at(bytes: &[u8], i: usize) -> bool {
|
||||
bytes[i - 1].is_ascii_whitespace() && bytes[i..].starts_with(b"xmlns")
|
||||
}
|
||||
|
||||
fn find(haystack: &[u8], needle: &[u8], from: usize) -> Option<usize> {
|
||||
haystack
|
||||
.get(from..)?
|
||||
@@ -207,8 +276,8 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn stops_a_deep_text_at_the_cap_without_recursion() {
|
||||
// 300,000 levels: the parser would overflow the wasm stack; the scan stops at 65.
|
||||
let text = format!("{SVG}{}", "<g>".repeat(300_000));
|
||||
// 99,000 levels (under the `<` cap): the parser would overflow the wasm stack; the scan stops at 65.
|
||||
let text = format!("{SVG}{}", "<g>".repeat(99_000));
|
||||
assert_eq!(prescan(&text, &SVG_CAPS), Err(PrescanError::TooDeep));
|
||||
}
|
||||
|
||||
@@ -239,14 +308,23 @@ mod tests {
|
||||
depth: 2
|
||||
})
|
||||
);
|
||||
let text = format!("{SVG}<!-- <g><g> --><![CDATA[<g>]]><?pi <g>?><g a='>'/></svg>");
|
||||
assert_eq!(
|
||||
prescan(&text, &SVG_CAPS),
|
||||
Ok(Prescan {
|
||||
elements: 2,
|
||||
depth: 2
|
||||
})
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn refuses_attribute_namespace_and_markup_floods() {
|
||||
let attrs = |n: usize| (0..n).map(|i| format!(" a{i}=\"{i}\"")).collect::<String>();
|
||||
let one = |n: usize| format!("{SVG}<path{}/></svg>", attrs(n));
|
||||
assert!(prescan(&one(256), &SVG_CAPS).is_ok());
|
||||
assert_eq!(prescan(&one(257), &SVG_CAPS), Err(PrescanError::TooComplex));
|
||||
let declarations = (0..16)
|
||||
.map(|i| format!(" xmlns:n{i}=\"u{i}\""))
|
||||
.collect::<String>();
|
||||
let ns = format!("<svg xmlns=\"http://www.w3.org/2000/svg\"{declarations}/>");
|
||||
assert_eq!(prescan(&ns, &SVG_CAPS), Err(PrescanError::TooComplex));
|
||||
let brackets = format!("{SVG}<!--{}--></svg>", "<".repeat(100_001));
|
||||
assert_eq!(prescan(&brackets, &SVG_CAPS), Err(PrescanError::TooComplex));
|
||||
let bom = format!("\u{feff}{SVG}</svg>");
|
||||
assert_eq!(prescan(&bom, &SVG_CAPS), Err(PrescanError::Malformed));
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
Reference in new issue
Block a user