From 9a9b89e9e8f057705e56398069c6f288a254b077 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 17:43:57 +0000 Subject: [PATCH 1/4] Reject duplicate attributes in strict XML reads --- crates/xml/README.md | 6 +++--- crates/xml/src/read.rs | 25 +++++++++++++++++++++++- crates/xml/tests/hostile.rs | 38 +++++++++++++++++++++++++++++++++++++ 3 files changed, 65 insertions(+), 4 deletions(-) diff --git a/crates/xml/README.md b/crates/xml/README.md index adb178159..a61a46832 100644 --- a/crates/xml/README.md +++ b/crates/xml/README.md @@ -46,7 +46,7 @@ assert_eq!((rows, sheet.map(|s| s.children.len())), (3, Ok(0))); | `max_input` | 256 MiB | `TooLarge` | | `max_depth` | 256 levels (the root is 1) | `TooDeep` | | `max_nodes` | 2,000,000 nodes kept in the tree: elements, text stretches, kept CDATA, instructions and comments | `TooManyNodes` | -| `max_attrs` | 1024 on one start tag, namespace declarations and malformed ones included; with canonical names, also the declarations in scope at once | `TooManyAttrs` | +| `max_attrs` | 1024 on one start tag, namespace declarations and malformed ones included; with canonical names or strict reads, also the declarations in scope at once | `TooManyAttrs` | | `max_attrs_total` | 4,000,000 attributes kept in the tree, over all its elements | `TooManyAttrsTotal` | A limit exceeded is an error, never a panic and never a truncated tree. `parse_streaming_partial` @@ -73,9 +73,9 @@ A lenient read keeps what a damaged document had: - reading stops when the root element ends: nothing after it is looked at; - a malformed attribute is skipped; bytes that are not UTF-8 become U+FFFD. -A strict read makes each of those an error, and also a second root element and text outside the +A strict read rejects duplicate raw or expanded attribute names (while allowing undeclared prefixes in fragments). It makes each of those an error, and also a second root element and text outside the root, in the pull reader as in the tree. Markup the tokenizer cannot read (` Events<'o, 'i> { _ => None, }; let scope = self.scope.len(); - if canonical.is_some() { + if canonical.is_some() || self.opts.strict { self.declare(e)?; } let raw = e.name(); @@ -707,6 +708,8 @@ impl<'o, 'i> Events<'o, 'i> { let mut out = Vec::new(); let mut attrs = e.attributes(); attrs.with_checks(false); + let mut raw_names = BTreeSet::new(); + let mut expanded_names = BTreeSet::new(); for (seen, a) in attrs.enumerate() { if seen >= limits.max_attrs { return Err(Error::TooManyAttrs(limits.max_attrs)); @@ -718,6 +721,26 @@ impl<'o, 'i> Events<'o, 'i> { }; let key = a.key.as_ref(); let decl = is_ns_decl(key); + if self.opts.strict { + let raw_key = self.decode(key)?; + if !raw_names.insert(raw_key.to_string()) { + return self.syntax(format!("duplicate attribute `{raw_key}`")); + } + if !decl { + // Default namespaces do not apply to attributes. Keep undeclared prefixes + // distinct so standalone fragments retain the reader's existing behaviour. + let expanded = match raw_key.split_once(':') { + Some(("xml", local)) => (XML_NS, local), + Some((prefix, local)) => { + self.scope.iter().rev().find(|(p, _)| p == prefix).map_or(("", raw_key.as_ref()), |(_, uri)| (uri.as_str(), local)) + } + None => ("", raw_key.as_ref()), + }; + if !expanded_names.insert((expanded.0.to_string(), expanded.1.to_string())) { + return self.syntax(format!("duplicate expanded attribute `{raw_key}`")); + } + } + } if decl && !self.opts.ns_decls { continue; } diff --git a/crates/xml/tests/hostile.rs b/crates/xml/tests/hostile.rs index 2d387519b..6a846d3a7 100644 --- a/crates/xml/tests/hostile.rs +++ b/crates/xml/tests/hostile.rs @@ -524,3 +524,41 @@ fn a_strict_pull_reader_refuses_what_is_outside_the_root() { // white space, comments and instructions may stand outside the root assert!(read(strict, b"\r\n \tx\n ").is_ok()); } + +#[test] +fn strict_attributes_are_unique_before_name_rewriting() { + use craft_xml::{Names, Options}; + for names in [Names::AsWritten, Names::Local] { + let strict = Options { names, ..Options::default() }.strict(); + for xml in [ + "", + "", + "", + "", + ] { + assert!(strict.parse(xml.as_bytes()).is_err(), "{xml}"); + let mut events = strict.events(xml.as_bytes()); + assert!( + loop { + match events.next() { + Ok(Some(_)) => {} + Ok(None) => break false, + Err(_) => break true, + } + }, + "{xml}" + ); + } + for xml in [ + "", + "", + "", + ] { + assert!(strict.parse(xml.as_bytes()).is_ok(), "{xml}"); + } + assert!(Options { names, ..Options::default() }.parse(b"").is_ok()); + } + let strict = Options { limits: craft_xml::Limits { max_attrs: 2, ..craft_xml::Limits::DEFAULT }, ..Options::default() }.strict(); + assert!(strict.parse(b"").is_err()); + assert!(strict.parse(b"").is_err()); +} From 99007f1915d8b3495effffdfb8550a94a4d0bf87 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 17:45:11 +0000 Subject: [PATCH 2/4] Allow strict duplicate error in attribute flood test --- crates/xml/tests/hostile.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/xml/tests/hostile.rs b/crates/xml/tests/hostile.rs index 6a846d3a7..37684f059 100644 --- a/crates/xml/tests/hostile.rs +++ b/crates/xml/tests/hostile.rs @@ -117,7 +117,7 @@ fn an_attribute_flood_is_refused_at_the_limit() { let opts = opts.with_limits(limits); for (k, kind) in kinds.iter().enumerate() { let _ = opts.parse(tag(16, kind).as_bytes()); - assert_eq!(opts.parse(tag(17, kind).as_bytes()).err().map(|e| e.is_limit() || (opts.strict && k == 3)), Some(true), "kind {k}"); + assert_eq!(opts.parse(tag(17, kind).as_bytes()).err().map(|e| e.is_limit() || (opts.strict && (k == 1 || k == 3))), Some(true), "kind {k}"); assert!(opts.first_start(tag(17, kind).as_bytes(), "a").is_none()); } assert_eq!(opts.parse(tag(17, kinds[0]).as_bytes()), Err(Error::TooManyAttrs(16))); From 24c496e95af81484812d62c72a6dcf8f119679ed Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 18:00:22 +0000 Subject: [PATCH 3/4] Format strict XML attribute flood regression --- crates/xml/tests/hostile.rs | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/crates/xml/tests/hostile.rs b/crates/xml/tests/hostile.rs index 37684f059..4ef151914 100644 --- a/crates/xml/tests/hostile.rs +++ b/crates/xml/tests/hostile.rs @@ -117,7 +117,11 @@ fn an_attribute_flood_is_refused_at_the_limit() { let opts = opts.with_limits(limits); for (k, kind) in kinds.iter().enumerate() { let _ = opts.parse(tag(16, kind).as_bytes()); - assert_eq!(opts.parse(tag(17, kind).as_bytes()).err().map(|e| e.is_limit() || (opts.strict && (k == 1 || k == 3))), Some(true), "kind {k}"); + assert_eq!( + opts.parse(tag(17, kind).as_bytes()).err().map(|e| e.is_limit() || (opts.strict && (k == 1 || k == 3))), + Some(true), + "kind {k}" + ); assert!(opts.first_start(tag(17, kind).as_bytes(), "a").is_none()); } assert_eq!(opts.parse(tag(17, kinds[0]).as_bytes()), Err(Error::TooManyAttrs(16))); From 17f402798e5aad206d0d29b88a09346f100f7176 Mon Sep 17 00:00:00 2001 From: FredApps <153173854+FredApps@users.noreply.github.com> Date: Mon, 16 Nov 2026 00:00:18 +0100 Subject: [PATCH 4/4] xml: compare strict expanded attribute names by namespace id, not a URI copy A declaration's URI was copied once per attribute that used it, so one long URI and many attributes multiplied memory. Give each binding an id (shared by equal URIs, found once at declaration) and key expanded names by that id. --- crates/xml/src/read.rs | 42 +++++++++++++++++++++++++++++++++++------- 1 file changed, 35 insertions(+), 7 deletions(-) diff --git a/crates/xml/src/read.rs b/crates/xml/src/read.rs index a5d9b58ee..aaea862fc 100644 --- a/crates/xml/src/read.rs +++ b/crates/xml/src/read.rs @@ -13,6 +13,10 @@ use crate::write::is_xml_char; /// The namespace the `xml` prefix is always bound to. pub const XML_NS: &str = "http://www.w3.org/XML/1998/namespace"; +/// [`Events::scope_ids`] id of the XML namespace, bound to `xml:` without a declaration. +const XML_NS_ID: usize = usize::MAX; +/// Expanded-name id of an attribute in no namespace (or with an undeclared prefix). +const NO_NS_ID: usize = usize::MAX - 1; /// What the reader refuses to exceed. #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -470,6 +474,10 @@ pub struct Events<'o, 'i> { end_names: bool, open: Vec, scope: Vec<(String, String)>, + /// For each binding in `scope`, an id shared by every binding of an equal URI (the index of + /// the first such binding, or [`XML_NS_ID`]), with the URI's hash. Strict reads compare + /// expanded attribute names by this id instead of copying the URI for each attribute. + scope_ids: Vec<(u64, usize)>, /// The end of an empty element, due after its start. pending: bool, /// Whether a root element has started. @@ -501,7 +509,7 @@ impl<'o, 'i> Events<'o, 'i> { cfg.trim_text_start = false; cfg.trim_text_end = false; cfg.expand_empty_elements = false; - Events { reader, opts, end_names, open: Vec::new(), scope: Vec::new(), pending: false, rooted: false, span: 0..0 } + Events { reader, opts, end_names, open: Vec::new(), scope: Vec::new(), scope_ids: Vec::new(), pending: false, rooted: false, span: 0..0 } } /// The bytes of the input the last event was read from. Both events of an empty element @@ -615,6 +623,7 @@ impl<'o, 'i> Events<'o, 'i> { fn end(&mut self) -> Event { let (scope, name) = self.open.pop().map_or((0, String::new()), |o| (o.scope, o.name)); self.scope.truncate(scope); + self.scope_ids.truncate(scope); Event::End { name } } @@ -670,6 +679,7 @@ impl<'o, 'i> Events<'o, 'i> { if is_ns_decl(key) { let prefix = self.decode(key.get(6..).unwrap_or_default())?.into_owned(); let uri = self.attr_value(&a.value)?; + self.scope_ids.push(self.uri_id(&uri)); self.scope.push((prefix, uri)); } } @@ -681,6 +691,20 @@ impl<'o, 'i> Events<'o, 'i> { Ok(()) } + /// The id an expanded name uses for `uri`: one hash and at most one full comparison per + /// declaration, so a long URI costs its length once however many attributes use it. + fn uri_id(&self, uri: &str) -> (u64, usize) { + use std::hash::{Hash, Hasher}; + let mut h = std::collections::hash_map::DefaultHasher::new(); + uri.hash(&mut h); + let hash = h.finish(); + if uri == XML_NS { + return (hash, XML_NS_ID); + } + let first = self.scope_ids.iter().zip(&self.scope).position(|((h, _), (_, u))| *h == hash && u == uri); + (hash, first.map_or(self.scope.len(), |i| self.scope_ids.get(i).map_or(i, |(_, id)| *id))) + } + /// In a strict read: is the reader before or after the root element? fn outside_root(&self) -> bool { self.opts.strict && self.open.is_empty() @@ -730,13 +754,17 @@ impl<'o, 'i> Events<'o, 'i> { // Default namespaces do not apply to attributes. Keep undeclared prefixes // distinct so standalone fragments retain the reader's existing behaviour. let expanded = match raw_key.split_once(':') { - Some(("xml", local)) => (XML_NS, local), - Some((prefix, local)) => { - self.scope.iter().rev().find(|(p, _)| p == prefix).map_or(("", raw_key.as_ref()), |(_, uri)| (uri.as_str(), local)) - } - None => ("", raw_key.as_ref()), + Some(("xml", local)) => (XML_NS_ID, local), + Some((prefix, local)) => self + .scope + .iter() + .zip(&self.scope_ids) + .rev() + .find(|((p, _), _)| p == prefix) + .map_or((NO_NS_ID, raw_key.as_ref()), |(_, (_, id))| (*id, local)), + None => (NO_NS_ID, raw_key.as_ref()), }; - if !expanded_names.insert((expanded.0.to_string(), expanded.1.to_string())) { + if !expanded_names.insert((expanded.0, expanded.1.to_string())) { return self.syntax(format!("duplicate expanded attribute `{raw_key}`")); } }