mirror of
https://github.com/storytold/craft-libs.git
synced 2026-11-18 16:24:38 +00:00
Merge pull request #2054 from Bra1nZ/docx-package-element-budget
craft-docx: a package-wide XML element budget bounds hostile files' tree memory
This commit is contained in:
7 files changed
+414
-36
No files matched your search
@@ -3,8 +3,8 @@
|
||||
//! [`read`] turns a `.docx` package into a [`craft_wordmodel::Document`]; [`write`] does the
|
||||
//! reverse. Both are written from the public specification. The reader is lenient (unknown
|
||||
//! markup is skipped, bad numbers fall back to defaults) and bounded (zip entry sizes, total
|
||||
//! decompressed size, XML depth and element counts are capped), so hostile input yields an
|
||||
//! error or a best-effort document, never a panic.
|
||||
//! decompressed size, XML depth, element counts per part and a package-wide element budget are
|
||||
//! capped), so hostile input yields an error or a best-effort document, never a panic.
|
||||
#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
|
||||
// The code came from an app whose lints allow this.
|
||||
#![allow(clippy::type_complexity)]
|
||||
|
||||
+131
-4
@@ -1,5 +1,6 @@
|
||||
//! OPC package access: bounded zip reading, relationships, part names.
|
||||
|
||||
use std::cell::Cell;
|
||||
use std::collections::{BTreeMap, HashMap};
|
||||
use std::sync::Arc;
|
||||
|
||||
@@ -216,6 +217,14 @@ fn opc_error(e: craft_opc::Error) -> DocxError {
|
||||
/// document keeps as it is (a picture, an embedded object) is handed over rather than copied.
|
||||
pub struct Package {
|
||||
opc: craft_opc::Package,
|
||||
/// Elements this package's XML parts may still be parsed into. Every XML part read through
|
||||
/// [`Package::xml`] charges it, so a file of many parts each inside the per-part cap builds
|
||||
/// bounded tree memory in total — a chart part with no series builds a maximal tree for
|
||||
/// almost no graphic work, and the trees the reader keeps accumulate.
|
||||
budget: Cell<usize>,
|
||||
/// What [`Package::reset_budget`] restores: the cap the package was opened with (the default,
|
||||
/// or a smaller one from [`Package::open_limited_within`]).
|
||||
budget_cap: usize,
|
||||
}
|
||||
|
||||
impl Package {
|
||||
@@ -227,8 +236,16 @@ impl Package {
|
||||
/// `max_total` (counting entries that fail their checksum), is an error. A damaged entry is
|
||||
/// left out with a logged warning.
|
||||
pub fn open_limited(bytes: &[u8], max_part: u64, max_total: u64) -> Result<Package, DocxError> {
|
||||
Package::open_limited_within(bytes, max_part, max_total, xml::MAX_ELEMENTS_TOTAL)
|
||||
}
|
||||
|
||||
/// [`open_limited`] with an XML element budget of its own (nested documents share their
|
||||
/// container's, tests use a small one).
|
||||
pub fn open_limited_within(bytes: &[u8], max_part: u64, max_total: u64, max_elements: usize) -> Result<Package, DocxError> {
|
||||
let limits = craft_opc::Limits::new(MAX_ENTRIES, max_part, max_total);
|
||||
craft_opc::Package::open(bytes, &limits).map(|opc| Package { opc }).map_err(opc_error)
|
||||
craft_opc::Package::open(bytes, &limits)
|
||||
.map(|opc| Package { opc, budget: Cell::new(max_elements), budget_cap: max_elements })
|
||||
.map_err(opc_error)
|
||||
}
|
||||
|
||||
/// The bytes of all its parts.
|
||||
@@ -244,7 +261,27 @@ impl Package {
|
||||
/// A package from parts already in memory (a Flat OPC file, a converted document), by part
|
||||
/// name without the leading `/`.
|
||||
pub fn from_parts(files: BTreeMap<String, Vec<u8>>) -> Package {
|
||||
Package { opc: craft_opc::Package::from_parts(files) }
|
||||
Package { opc: craft_opc::Package::from_parts(files), budget: Cell::new(xml::MAX_ELEMENTS_TOTAL), budget_cap: xml::MAX_ELEMENTS_TOTAL }
|
||||
}
|
||||
|
||||
/// Start a read's element budget over: the budget is per read, not per package's lifetime.
|
||||
pub(crate) fn reset_budget(&self) {
|
||||
self.budget.set(self.budget_cap);
|
||||
}
|
||||
|
||||
/// The XML elements left of the package's budget: nested documents open within it.
|
||||
pub(crate) fn elements_left(&self) -> usize {
|
||||
self.budget.get()
|
||||
}
|
||||
|
||||
/// Charge `count` elements a parsed part built against the budget.
|
||||
pub(crate) fn charge(&self, count: usize) -> Result<(), DocxError> {
|
||||
let left = self.budget.get();
|
||||
if count > left {
|
||||
return Err(DocxError::Limit(format!("{count} XML elements, {left} left of the package's {} budget", self.budget_cap)));
|
||||
}
|
||||
self.budget.set(left - count);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Part bytes by name (leading `/` ignored; case-insensitive).
|
||||
@@ -261,14 +298,28 @@ impl Package {
|
||||
/// [`Package::xml`] for the main document part: malformed XML is an error, not a truncated read.
|
||||
pub fn xml_strict(&self, name: &str) -> Result<Option<El>, DocxError> {
|
||||
match self.get(name) {
|
||||
Some(b) => xml::parse_strict(b).map(Some),
|
||||
Some(b) => {
|
||||
// The parser stops at the remaining budget or the per-part cap, whichever is less:
|
||||
// a part over what is left of the package's budget is refused before the whole
|
||||
// per-part tree is built.
|
||||
let (el, count) = xml::parse_strict_counted(b, self.budget.get().min(xml::MAX_ELEMENTS))?;
|
||||
self.charge(count)?;
|
||||
Ok(Some(el))
|
||||
}
|
||||
None => Ok(None),
|
||||
}
|
||||
}
|
||||
|
||||
/// A package part as a parsed XML tree, charged against the element budget: the parser
|
||||
/// stops at what is left of the budget or the per-part cap, whichever is less, and the
|
||||
/// count it built is charged after. A lenient read: malformed XML is a truncated one.
|
||||
pub fn xml(&self, name: &str) -> Result<Option<El>, DocxError> {
|
||||
match self.get(name) {
|
||||
Some(b) => xml::parse(b).map(Some),
|
||||
Some(b) => {
|
||||
let (el, count) = xml::parse_counted(b, self.budget.get().min(xml::MAX_ELEMENTS))?;
|
||||
self.charge(count)?;
|
||||
Ok(Some(el))
|
||||
}
|
||||
None => Ok(None),
|
||||
}
|
||||
}
|
||||
@@ -448,6 +499,82 @@ mod tests {
|
||||
let junk = EmbeddedManifest::parse(b"R\tnope\trId1\tk\tt\tI\nP\tonly-two\n\t\t\n\xff\xfe");
|
||||
assert!(junk.parts.is_empty());
|
||||
}
|
||||
|
||||
/// A file of many parts each inside the per-part cap is bounded in total: every XML part
|
||||
/// read through the package charges a package-wide budget, and a part over it is skipped
|
||||
/// (warned), never built. A chart part with no series builds a maximal tree for almost no
|
||||
/// graphic work, so the trees a reader keeps would otherwise accumulate one per part.
|
||||
#[test]
|
||||
fn the_xml_element_budget_is_package_wide() {
|
||||
let ns = r#"xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main""#;
|
||||
let rels = r#"<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles" Target="styles.xml"/><Relationship Id="rId2" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/numbering" Target="numbering.xml"/></Relationships>"#;
|
||||
let document = format!(r#"<w:document {ns}><w:body/></w:document>"#);
|
||||
let dense = |root: &str| format!(r#"<{root} {ns}>{}</{root}>"#, "<a/>".repeat(900));
|
||||
let z = zip_of(&[
|
||||
("word/document.xml", document.into_bytes()),
|
||||
("word/_rels/document.xml.rels", rels.as_bytes().to_vec()),
|
||||
("word/styles.xml", dense("w:styles").into_bytes()),
|
||||
("word/numbering.xml", dense("w:numbering").into_bytes()),
|
||||
]);
|
||||
let pkg = Package::open_limited_within(&z, MAX_PART, MAX_TOTAL, 1_000).unwrap();
|
||||
// styles (900 elements) reads; numbering (900 more) is over what is left and is skipped
|
||||
// with a warning, not built.
|
||||
let read = || crate::read::read_opened(&pkg, None);
|
||||
let (first, warned) = crate::test_log::warnings(read);
|
||||
assert!(first.is_ok(), "{:?}", first.err());
|
||||
let refused: Vec<_> = warned.iter().filter(|w| w.contains("numbering") && w.contains("XML element")).collect();
|
||||
assert_eq!(refused.len(), 1, "{warned:?}");
|
||||
// The budget is per read: a second read starts it over and behaves the same.
|
||||
let (second, warned) = crate::test_log::warnings(read);
|
||||
assert!(second.is_ok(), "{:?}", second.err());
|
||||
assert_eq!(warned.iter().filter(|w| w.contains("numbering") && w.contains("XML element")).count(), 1, "{warned:?}");
|
||||
}
|
||||
|
||||
/// The main document part itself is strict: over the budget it is an error, not a
|
||||
/// best-effort read of a tree the file then paid for.
|
||||
#[test]
|
||||
fn a_main_part_over_the_element_budget_is_refused() {
|
||||
let ns = r#"xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main""#;
|
||||
let document = format!(r#"<w:document {ns}>{}</w:document>"#, "<a/>".repeat(20));
|
||||
let z = zip_of(&[("word/document.xml", document.into_bytes())]);
|
||||
let pkg = Package::open_limited_within(&z, MAX_PART, MAX_TOTAL, 10).unwrap();
|
||||
assert!(matches!(crate::read::read_opened(&pkg, None), Err(DocxError::Limit(_))));
|
||||
}
|
||||
|
||||
/// A part over what is left of the package's budget is refused while parsing, not after the
|
||||
/// whole per-part tree is built: the parser stops at the remaining budget or the per-part
|
||||
/// cap, whichever is less, so the file pays for at most what is left of the budget.
|
||||
#[test]
|
||||
fn a_part_over_the_remaining_budget_is_refused_while_parsing() {
|
||||
let ns = r#"xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main""#;
|
||||
let document = format!(r#"<w:document {ns}>{}</w:document>"#, "<a/>".repeat(200));
|
||||
let z = zip_of(&[("word/document.xml", document.into_bytes())]);
|
||||
// 200 elements: inside the per-part cap, over the package's 100 budget. The parse
|
||||
// refuses at the budget, so the error is the parse's, not the charge's, and names
|
||||
// the effective limit for this parse (the remaining budget), not the whole budget.
|
||||
let pkg = Package::open_limited_within(&z, MAX_PART, MAX_TOTAL, 100).unwrap();
|
||||
let e = crate::read::read_opened(&pkg, None).expect_err("refused");
|
||||
assert_eq!(e, DocxError::Limit("over the XML element budget for this parse: at most 100 elements".into()));
|
||||
}
|
||||
|
||||
/// A part parsed earlier shrinks what is left of the budget: the next part is refused while
|
||||
/// parsing at the remaining, not at the whole budget, and the error names the effective limit
|
||||
/// for this parse (the remaining), not the package's budget.
|
||||
#[test]
|
||||
fn an_earlier_part_reduces_the_remaining_budget_the_next_part_names_it() {
|
||||
let ns = r#"xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main""#;
|
||||
let styles = format!(r#"<w:styles {ns}>{}</w:styles>"#, "<a/>".repeat(60));
|
||||
let settings = format!(r#"<w:settings {ns}>{}</w:settings>"#, "<a/>".repeat(60));
|
||||
let z = zip_of(&[("word/styles.xml", styles.into_bytes()), ("word/settings.xml", settings.into_bytes())]);
|
||||
// 100 elements of budget. The styles part parses (the main-part path: `xml_strict`) and
|
||||
// charges its 61 elements, leaving 39.
|
||||
let pkg = Package::open_limited_within(&z, MAX_PART, MAX_TOTAL, 100).unwrap();
|
||||
pkg.xml_strict("word/styles.xml").unwrap();
|
||||
// The settings part needs 61 elements, over the 39 left and under the per-part cap: the
|
||||
// parse refuses at the remaining, so the error names 39, not the package's 100 budget.
|
||||
let e = pkg.xml("word/settings.xml").expect_err("refused");
|
||||
assert_eq!(e, DocxError::Limit("over the XML element budget for this parse: at most 39 elements".into()));
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
|
||||
@@ -154,9 +154,11 @@ pub(crate) fn read_opened(pkg: &Package, chunks: Option<ChunkImporter>) -> Resul
|
||||
read_opened_in(pkg, ChunkState::new(chunks)).map(|(doc, ..)| doc)
|
||||
}
|
||||
|
||||
/// [`read_opened`] with what chunks may still bring in; also gives the chunks, chunk bytes and
|
||||
/// graphic work left of that.
|
||||
fn read_opened_in(pkg: &Package, chunks: ChunkState) -> Result<(Document, usize, u64, usize), DocxError> {
|
||||
/// [`read_opened`] with what chunks may still bring in; also gives the chunks, chunk bytes,
|
||||
/// graphic work and XML elements left of that.
|
||||
fn read_opened_in(pkg: &Package, chunks: ChunkState) -> Result<(Document, usize, u64, usize, usize), DocxError> {
|
||||
// The budget is per read, so a package read twice (tests, a Flat OPC conversion) starts over.
|
||||
pkg.reset_budget();
|
||||
let root_rels = pkg.rels("");
|
||||
let main = root_rels.by_type(rt::OFFICE_DOC).filter(|r| !r.external).map(|r| r.target.clone()).unwrap_or_else(|| "word/document.xml".to_string());
|
||||
let Some(root) = pkg.xml_strict(&main)? else {
|
||||
@@ -371,11 +373,11 @@ fn read_opened_in(pkg: &Package, chunks: ChunkState) -> Result<(Document, usize,
|
||||
if r.shape_ids {
|
||||
keep_glued_ids(&mut r.doc, &r.glued);
|
||||
}
|
||||
let (left, bytes, graphic) = (r.chunks.left, r.chunks.bytes, r.chunks.graphic);
|
||||
let (left, bytes, graphic, elements) = (r.chunks.left, r.chunks.bytes, r.chunks.graphic, pkg.elements_left());
|
||||
let mut doc = r.doc;
|
||||
doc.skipped_parts.extend(pkg.skipped().iter().cloned());
|
||||
doc.ensure_nonempty();
|
||||
Ok((doc, left, bytes, graphic))
|
||||
Ok((doc, left, bytes, graphic, elements))
|
||||
}
|
||||
|
||||
/// Most move ranges open at once, and most move names tracked, per file.
|
||||
|
||||
@@ -110,11 +110,27 @@ impl Reader<'_> {
|
||||
log::warn!("docx: alternative format chunks nest deeper than {MAX_CHUNK_NESTING}; the inner ones are left out");
|
||||
return None;
|
||||
}
|
||||
let pkg =
|
||||
Package::open_limited(bytes, MAX_PART, self.chunks.bytes).map_err(|e| log::warn!("docx: unreadable nested document chunk: {e}")).ok()?;
|
||||
// The nested document shares the file's element budget: open_limited_within, not a
|
||||
// fresh cap — nesting goes deep, so 5 packages each getting 16M is the OOM class the
|
||||
// budget exists for. The container's own parse spent part of the chain, so the cap is
|
||||
// the lesser of the chain and what the container has left.
|
||||
let cap = self.chunks.elements.min(self.pkg.elements_left());
|
||||
let pkg = Package::open_limited_within(bytes, MAX_PART, self.chunks.bytes, cap)
|
||||
.map_err(|e| log::warn!("docx: unreadable nested document chunk: {e}"))
|
||||
.ok()?;
|
||||
self.chunks.bytes = self.chunks.bytes.saturating_sub(pkg.size());
|
||||
let state = ChunkState { nesting: self.chunks.nesting + 1, depth: depth + 1, ..self.chunks };
|
||||
let (doc, left, bytes, graphic) = match super::read_opened_in(&pkg, state) {
|
||||
let read = super::read_opened_in(&pkg, state);
|
||||
// A parsed main part can still fail semantic validation (for example, a non-Word
|
||||
// root). Charge its elements before returning that error, so later siblings cannot
|
||||
// reuse the reservation. On success this is the same single charge as before.
|
||||
let elements = pkg.elements_left();
|
||||
self.chunks.elements = elements;
|
||||
let spent = cap.saturating_sub(elements);
|
||||
if let Err(e) = self.pkg.charge(spent) {
|
||||
log::warn!("docx: nested document chunk outspent the container's element budget: {e}");
|
||||
}
|
||||
let (doc, left, bytes, graphic, _) = match read {
|
||||
Ok(read) => read,
|
||||
Err(e) => {
|
||||
log::warn!("docx: unreadable nested document chunk: {e}");
|
||||
@@ -139,6 +155,9 @@ pub(crate) struct ChunkState<'a> {
|
||||
/// Graphic work left in the file's budget ([`super::MAX_GRAPHIC_WORK`]): nested documents'
|
||||
/// charts and diagrams count against it too.
|
||||
pub graphic: usize,
|
||||
/// XML elements left in the file's budget: nested packages share their container's
|
||||
/// ([`crate::xml::MAX_ELEMENTS_TOTAL`]), not one of their own.
|
||||
pub elements: usize,
|
||||
/// How deep in nested WordprocessingML chunks this reader is.
|
||||
pub nesting: u8,
|
||||
/// The XML depth its stories start at (a nested document's: that of the chunk naming it).
|
||||
@@ -148,7 +167,15 @@ pub(crate) struct ChunkState<'a> {
|
||||
|
||||
impl<'a> ChunkState<'a> {
|
||||
pub fn new(import: Option<ChunkImporter<'a>>) -> Self {
|
||||
ChunkState { left: MAX_CHUNKS, bytes: MAX_TOTAL, graphic: super::MAX_GRAPHIC_WORK, nesting: 0, depth: 0, import }
|
||||
ChunkState {
|
||||
left: MAX_CHUNKS,
|
||||
bytes: MAX_TOTAL,
|
||||
graphic: super::MAX_GRAPHIC_WORK,
|
||||
elements: crate::xml::MAX_ELEMENTS_TOTAL,
|
||||
nesting: 0,
|
||||
depth: 0,
|
||||
import,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -159,7 +186,7 @@ mod tests {
|
||||
use craft_wordmodel::{Block, Document, InlineObject};
|
||||
|
||||
use super::ChunkState;
|
||||
use crate::package::Package;
|
||||
use crate::package::{MAX_PART, MAX_TOTAL, Package};
|
||||
|
||||
/// A package whose body is `body`, with the document relationship `rel` (id, type, target) to
|
||||
/// the part `(name, bytes)`.
|
||||
@@ -198,8 +225,8 @@ mod tests {
|
||||
let outer = package(r#"<w:altChunk r:id="rIdC"/>"#, ("rIdC", "aFChunk", "afchunk.docx"), ("word/afchunk.docx", &inner));
|
||||
let pkg = Package::open(&outer).unwrap();
|
||||
let read = |graphic| {
|
||||
let (d, .., left) = super::super::read_opened_in(&pkg, ChunkState { graphic, ..ChunkState::new(None) }).unwrap();
|
||||
(drawn(&d), left)
|
||||
let (d, .., work, _) = super::super::read_opened_in(&pkg, ChunkState { graphic, ..ChunkState::new(None) }).unwrap();
|
||||
(drawn(&d), work)
|
||||
};
|
||||
let (shown, left) = read(super::super::MAX_GRAPHIC_WORK);
|
||||
assert!(shown);
|
||||
@@ -207,4 +234,152 @@ mod tests {
|
||||
// With the file's budget spent, the nested document doesn't get one of its own.
|
||||
assert_eq!(read(0), (false, 0));
|
||||
}
|
||||
|
||||
/// A package whose body is `body`, with the document relationships `rels` (id, type, target)
|
||||
/// and the parts `(name, bytes)` they name.
|
||||
fn package_parts(body: &str, rels: &[(&str, &str, &str)], parts: &[(&str, &[u8])]) -> Vec<u8> {
|
||||
let ns = r#"xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" xmlns:wp="http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing" xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main""#;
|
||||
let rels_xml =
|
||||
|inner: &str| format!(r#"<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">{inner}</Relationships>"#);
|
||||
let rel = |(id, ty, target): &(&str, &str, &str)| {
|
||||
format!(r#"<Relationship Id="{id}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/{ty}" Target="{target}"/>"#)
|
||||
};
|
||||
let names: String = rels.iter().map(rel).collect::<Vec<_>>().join("");
|
||||
let mut files: Vec<(&str, Vec<u8>)> = vec![
|
||||
("_rels/.rels", rels_xml(&rel(&("rId1", "officeDocument", "word/document.xml"))).into_bytes()),
|
||||
("word/document.xml", format!(r#"<w:document {ns}><w:body>{body}</w:body></w:document>"#).into_bytes()),
|
||||
("word/_rels/document.xml.rels", rels_xml(&names).into_bytes()),
|
||||
];
|
||||
files.extend(parts.iter().map(|(name, bytes)| (*name, bytes.to_vec())));
|
||||
let mut zw = zip::ZipWriter::new(std::io::Cursor::new(Vec::new()));
|
||||
for (name, bytes) in files {
|
||||
zw.start_file(name, zip::write::SimpleFileOptions::default()).unwrap();
|
||||
zw.write_all(&bytes).unwrap();
|
||||
}
|
||||
zw.finish().unwrap().into_inner()
|
||||
}
|
||||
|
||||
/// Whether the body holds a paragraph with `s`.
|
||||
fn has(d: &Document, s: &str) -> bool {
|
||||
d.body.iter().any(|b| b.as_para().map(|p| p.text.contains(s)).unwrap_or(false))
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_nested_documents_elements_come_out_of_the_files_budget() {
|
||||
// Three levels: the outer's altChunk names the inner, whose altChunk names the
|
||||
// innermost. The chain spends down: the inner's own parse charges the file's budget,
|
||||
// so the innermost opens with what the inner has left, not a fresh cap.
|
||||
let innermost = package(r#"<w:p><w:r><w:t>innermost</w:t></w:r></w:p>"#, ("rIdZ", "chart", "charts/z.xml"), ("word/charts/z.xml", b"<a/>"));
|
||||
let inner = package(
|
||||
r#"<w:p><w:r><w:t>inner</w:t></w:r></w:p><w:altChunk r:id="rIdD"/>"#,
|
||||
("rIdD", "aFChunk", "afchunk.docx"),
|
||||
("word/afchunk.docx", &innermost),
|
||||
);
|
||||
let outer = package(r#"<w:altChunk r:id="rIdC"/>"#, ("rIdC", "aFChunk", "afchunk.docx"), ("word/afchunk.docx", &inner));
|
||||
let pkg = Package::open(&outer).unwrap();
|
||||
let read = |elements| {
|
||||
let (d, ..) = super::super::read_opened_in(&pkg, ChunkState { elements, ..ChunkState::new(None) }).unwrap();
|
||||
(has(&d, "inner"), has(&d, "innermost"))
|
||||
};
|
||||
// With room, both levels flow in.
|
||||
assert_eq!(read(crate::xml::MAX_ELEMENTS_TOTAL), (true, true));
|
||||
// The inner's own parse (its rels, then its main part) charged the file's budget: the
|
||||
// innermost is left out instead of getting one of its own (before this, each nested
|
||||
// package started with the full 16M).
|
||||
assert_eq!(read(10), (true, false));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_nested_documents_elements_charge_the_container() {
|
||||
// The nested document's XML usage comes out of the container's budget too: the cap
|
||||
// the nested package was given, minus its returned remainder, is charged, so the
|
||||
// container's remaining parts parse against what is left of the shared cap — not a
|
||||
// budget that ignores the chunk.
|
||||
let nested = package(r#"<w:p><w:r><w:t>inner</w:t></w:r></w:p>"#, ("rIdZ", "chart", "charts/z.xml"), ("word/charts/z.xml", b"<a/>"));
|
||||
let body = r#"<w:p><w:r><w:t>after</w:t></w:r></w:p>"#;
|
||||
let with = package(&format!(r#"<w:altChunk r:id="rIdC"/>{body}"#), ("rIdC", "aFChunk", "afchunk.docx"), ("word/afchunk.docx", &nested));
|
||||
let without = package(body, ("rIdZ", "chart", "charts/z.xml"), ("word/charts/z.xml", b"<a/>"));
|
||||
let read = |outer: &[u8]| {
|
||||
let pkg = Package::open(outer).unwrap();
|
||||
let (d, ..) = super::super::read_opened_in(&pkg, ChunkState { elements: 10, ..ChunkState::new(None) }).unwrap();
|
||||
(has(&d, "inner"), pkg.elements_left())
|
||||
};
|
||||
let (inner_in, charged) = read(&with);
|
||||
assert!(inner_in);
|
||||
let (_, base) = read(&without);
|
||||
assert!(charged < base, "the nested document's usage is the container's: {charged} of {base}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_grandchilds_reservation_charges_every_level() {
|
||||
// Three levels: the innermost's reservation comes out of the inner's budget, and the
|
||||
// inner's out of the outer's — the chain charges every container, so the outer's
|
||||
// remainder is smaller with the deeper chain than with a shallow one.
|
||||
let innermost = package(r#"<w:p><w:r><w:t>leaf</w:t></w:r></w:p>"#, ("rIdZ", "chart", "charts/z.xml"), ("word/charts/z.xml", b"<a/>"));
|
||||
let inner = package(
|
||||
r#"<w:p><w:r><w:t>mid</w:t></w:r></w:p><w:altChunk r:id="rIdD"/>"#,
|
||||
("rIdD", "aFChunk", "afchunk.docx"),
|
||||
("word/afchunk.docx", &innermost),
|
||||
);
|
||||
let outer = package(r#"<w:altChunk r:id="rIdC"/>"#, ("rIdC", "aFChunk", "afchunk.docx"), ("word/afchunk.docx", &inner));
|
||||
let pkg = Package::open(&outer).unwrap();
|
||||
let (d, .., elements) = super::super::read_opened_in(&pkg, ChunkState::new(None)).unwrap();
|
||||
assert!(has(&d, "mid"), "the inner document didn't flow in");
|
||||
assert!(has(&d, "leaf"), "the innermost document didn't flow in");
|
||||
// The same container with a shallow chain: one reservation instead of two.
|
||||
let shallow = package(r#"<w:altChunk r:id="rIdC"/>"#, ("rIdC", "aFChunk", "afchunk.docx"), ("word/afchunk.docx", &innermost));
|
||||
let pkg = Package::open(&shallow).unwrap();
|
||||
let (.., shallow_elements) = super::super::read_opened_in(&pkg, ChunkState::new(None)).unwrap();
|
||||
assert!(elements < shallow_elements, "every level's reservation is charged: {elements} of {shallow_elements}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_charged_budget_bounds_the_containers_part_and_the_sibling_after_it() {
|
||||
// The container's budget pays for the parts it parses (the section's header, read
|
||||
// during the chunk's own walk) and for the chunks after the first one: with a budget
|
||||
// that fits the grandchild chunk and the header but not the sibling document's XML,
|
||||
// the sibling is left out; skip the header's charge and it would flow in.
|
||||
let hdr = r#"<w:hdr xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"><w:p><w:r><w:t>head</w:t></w:r></w:p><w:p><w:r><w:t>head</w:t></w:r></w:p><w:p><w:r><w:t>head</w:t></w:r></w:p></w:hdr>"#;
|
||||
let gc = package(r#"<w:p><w:r><w:t>gc</w:t></w:r></w:p>"#, ("rIdZ", "chart", "charts/z.xml"), ("word/charts/z.xml", b"<a/>"));
|
||||
let sibling =
|
||||
package(&r#"<w:p><w:r><w:t>sibling</w:t></w:r></w:p>"#.repeat(8), ("rIdZ", "chart", "charts/z.xml"), ("word/charts/z.xml", b"<a/>"));
|
||||
let inner = package_parts(
|
||||
r#"<w:p><w:r><w:t>mid</w:t></w:r></w:p><w:altChunk r:id="rIdD"/><w:p><w:pPr><w:sectPr><w:headerReference r:id="rIdH"/></w:sectPr></w:pPr></w:p><w:altChunk r:id="rIdS"/>"#,
|
||||
&[("rIdD", "aFChunk", "afchunk.docx"), ("rIdH", "header", "header1.xml"), ("rIdS", "aFChunk", "afchunk2.docx")],
|
||||
&[("word/afchunk.docx", &gc), ("word/header1.xml", hdr.as_bytes()), ("word/afchunk2.docx", &sibling)],
|
||||
);
|
||||
let outer = package(r#"<w:altChunk r:id="rIdC"/>"#, ("rIdC", "aFChunk", "afchunk.docx"), ("word/afchunk.docx", &inner));
|
||||
let pkg = Package::open(&outer).unwrap();
|
||||
let read = |elements| {
|
||||
let (d, ..) = super::super::read_opened_in(&pkg, ChunkState { elements, ..ChunkState::new(None) }).unwrap();
|
||||
(has(&d, "mid"), has(&d, "gc"), has(&d, "sibling"))
|
||||
};
|
||||
// With room, everything flows in.
|
||||
assert_eq!(read(crate::xml::MAX_ELEMENTS_TOTAL), (true, true, true));
|
||||
// The grandchild chunk and the header fit the file's budget; the sibling document's
|
||||
// XML (8 paragraphs) doesn't, so it's left out instead of getting a fresh cap.
|
||||
assert_eq!(read(40), (true, true, false));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_rejected_nested_root_still_charges_the_siblings_budget() {
|
||||
// Four outer elements, sixty rejected elements, five sibling elements: 69 in total.
|
||||
let bad_xml = format!("<notword>{}</notword>", "<a/>".repeat(59));
|
||||
let mut zip = zip::ZipWriter::new(std::io::Cursor::new(Vec::new()));
|
||||
zip.start_file("word/document.xml", zip::write::SimpleFileOptions::default()).unwrap();
|
||||
zip.write_all(bad_xml.as_bytes()).unwrap();
|
||||
let bad = zip.finish().unwrap().into_inner();
|
||||
let sibling = package_parts(r#"<w:p><w:r><w:t>sibling</w:t></w:r></w:p>"#, &[], &[]);
|
||||
let outer = package_parts(
|
||||
r#"<w:altChunk r:id="bad"/><w:altChunk r:id="good"/>"#,
|
||||
&[("bad", "aFChunk", "bad.docx"), ("good", "aFChunk", "good.docx")],
|
||||
&[("word/bad.docx", &bad), ("word/good.docx", &sibling)],
|
||||
);
|
||||
for (cap, included, remaining) in [(69, true, 0), (68, false, 4)] {
|
||||
let pkg = Package::open_limited_within(&outer, MAX_PART, MAX_TOTAL, cap).unwrap();
|
||||
let doc = super::super::read_opened(&pkg, None).unwrap();
|
||||
assert_eq!(has(&doc, "sibling"), included, "budget {cap}");
|
||||
assert_eq!(pkg.elements_left(), remaining, "budget {cap}");
|
||||
}
|
||||
}
|
||||
}
|
||||
+47
-18
@@ -10,6 +10,10 @@ use crate::DocxError;
|
||||
pub const MAX_DEPTH: usize = 256;
|
||||
/// Maximum number of elements in one part.
|
||||
pub const MAX_ELEMENTS: usize = 8_000_000;
|
||||
/// Maximum number of elements summed over every part a read parses: a file of many parts each
|
||||
/// inside [`MAX_ELEMENTS`] would otherwise cost a tree per part, and the trees a reader keeps
|
||||
/// (the main part's, charts' and diagrams') accumulate.
|
||||
pub const MAX_ELEMENTS_TOTAL: usize = MAX_ELEMENTS * 2;
|
||||
/// Maximum number of attributes on one element (#3702).
|
||||
pub const MAX_ATTRS: usize = 1024;
|
||||
|
||||
@@ -329,19 +333,31 @@ pub fn parse(bytes: &[u8]) -> Result<El, DocxError> {
|
||||
parse_ns(bytes, &[])
|
||||
}
|
||||
|
||||
/// [`parse`], with the number of elements it built, stopping early at `max` elements: the caller
|
||||
/// charges the count against a package-wide budget (see [`MAX_ELEMENTS_TOTAL`]), and a part over
|
||||
/// what is left of it is refused before the whole per-part tree is built.
|
||||
pub fn parse_counted(bytes: &[u8], max: usize) -> Result<(El, usize), DocxError> {
|
||||
parse_with(bytes, &[], false, max)
|
||||
}
|
||||
|
||||
/// [`parse_counted`], strict, for a part whose loss would be silent data loss (the main
|
||||
/// document): a mismatched end tag or an element left open at the end of the data is an error,
|
||||
/// not a cue to stop reading.
|
||||
pub fn parse_strict_counted(bytes: &[u8], max: usize) -> Result<(El, usize), DocxError> {
|
||||
parse_with(bytes, &[], true, max)
|
||||
}
|
||||
|
||||
/// [`parse`] with `extra` namespaces (prefix, URI) mapped to canonical prefixes first, so a
|
||||
/// related vocabulary (WordprocessingML 2003) reads with the prefixes the reader knows.
|
||||
pub fn parse_ns(bytes: &[u8], extra: &[(&'static str, &str)]) -> Result<El, DocxError> {
|
||||
parse_with(bytes, extra, false)
|
||||
parse_with(bytes, extra, false, MAX_ELEMENTS).map(|(e, _)| e)
|
||||
}
|
||||
|
||||
/// [`parse`] for a part whose loss would be silent data loss (the main document): a mismatched end
|
||||
/// tag or an element left open at the end of the data is an error, not a cue to stop reading.
|
||||
pub fn parse_strict(bytes: &[u8]) -> Result<El, DocxError> {
|
||||
parse_with(bytes, &[], true)
|
||||
}
|
||||
|
||||
fn parse_with(bytes: &[u8], extra: &[(&'static str, &str)], strict: bool) -> Result<El, DocxError> {
|
||||
/// The XML parser everything else goes through: transcodes UTF-16, walks the events and builds
|
||||
/// the tree depth-first, stopping at `max` elements and counting the ones it built. A mismatched
|
||||
/// end tag or an element left open at the end of the data is an error when `strict`, a cue to
|
||||
/// stop reading when not.
|
||||
fn parse_with(bytes: &[u8], extra: &[(&'static str, &str)], strict: bool, max: usize) -> Result<(El, usize), DocxError> {
|
||||
let namespaces: Vec<(&str, &str)> =
|
||||
extra.iter().copied().chain(NAMESPACES.iter().copied()).chain(OTHER_NAMESPACES.iter().copied()).chain(STRICT.iter().copied()).collect();
|
||||
// The prefix of an element: its namespace's, with two exceptions for Strict documents
|
||||
@@ -375,7 +391,9 @@ fn parse_with(bytes: &[u8], extra: &[(&'static str, &str)], strict: bool) -> Res
|
||||
max_depth: MAX_DEPTH + 1,
|
||||
// Text stretches count as nodes too: two for each element.
|
||||
max_nodes: 2 * MAX_ELEMENTS,
|
||||
max_elements: MAX_ELEMENTS,
|
||||
// The parse stops here before the whole tree is built: a part over what is left of the
|
||||
// package's element budget pays for at most that, not for the per-part cap.
|
||||
max_elements: max,
|
||||
max_attrs: MAX_ATTRS,
|
||||
max_attrs_total: 2 * MAX_ELEMENTS,
|
||||
};
|
||||
@@ -383,17 +401,27 @@ fn parse_with(bytes: &[u8], extra: &[(&'static str, &str)], strict: bool) -> Res
|
||||
if strict {
|
||||
options = options.strict();
|
||||
}
|
||||
let root = options.parse(bytes).map_err(|e| if e.is_limit() { DocxError::Limit(e.to_string()) } else { DocxError::Xml(e.to_string()) })?;
|
||||
Ok(from_tree(root))
|
||||
let root = options.parse(bytes).map_err(|e| match &e {
|
||||
craft_xml::Error::TooManyElements(_) => DocxError::Limit(format!("over the XML element budget for this parse: at most {max} elements")),
|
||||
e if e.is_limit() => DocxError::Limit(e.to_string()),
|
||||
e => DocxError::Xml(e.to_string()),
|
||||
})?;
|
||||
Ok(from_tree_counted(root))
|
||||
}
|
||||
|
||||
/// The `craft-xml` tree as this module's (whose shape the reader was written against).
|
||||
/// The `craft-xml` tree as this module's (whose shape the reader was written against), with the
|
||||
/// number of elements the subtree holds (the caller charges it against a package-wide budget).
|
||||
// shortcut: one copy of each parsed part; read craft_xml::El directly when the reader is ported to it.
|
||||
fn from_tree(e: craft_xml::El) -> El {
|
||||
fn from_tree_counted(e: craft_xml::El) -> (El, usize) {
|
||||
let mut kids = Vec::with_capacity(e.children.len());
|
||||
let mut count = 1usize;
|
||||
for n in e.children {
|
||||
match n {
|
||||
craft_xml::Node::El(c) => kids.push(Node::El(from_tree(c))),
|
||||
craft_xml::Node::El(c) => {
|
||||
let (kid, built) = from_tree_counted(c);
|
||||
count += built;
|
||||
kids.push(Node::El(kid));
|
||||
}
|
||||
craft_xml::Node::Text(t) | craft_xml::Node::CData(t) => match kids.last_mut() {
|
||||
Some(Node::Text(prev)) => prev.push_str(&t),
|
||||
_ => kids.push(Node::Text(t)),
|
||||
@@ -401,7 +429,7 @@ fn from_tree(e: craft_xml::El) -> El {
|
||||
craft_xml::Node::Pi { .. } | craft_xml::Node::Comment(_) => {}
|
||||
}
|
||||
}
|
||||
El { name: e.name, attrs: e.attrs, kids }
|
||||
(El { name: e.name, attrs: e.attrs, kids }, count)
|
||||
}
|
||||
|
||||
/// This module's tree as `craft-xml`'s, for the shared readers (`craft-drawingml`, `craft-math`)
|
||||
@@ -515,12 +543,13 @@ mod tests {
|
||||
fn strict_parsing_rejects_a_dropped_entity_and_trailing_markup() {
|
||||
let bad = [&b"<w:t>before &unknown; after</w:t>"[..], b"<a></a><b></b>", b"<a></a><b>"];
|
||||
for xml in bad {
|
||||
assert!(parse_strict(xml).is_err(), "{}", String::from_utf8_lossy(xml));
|
||||
assert!(parse_strict_counted(xml, MAX_ELEMENTS).is_err(), "{}", String::from_utf8_lossy(xml));
|
||||
}
|
||||
assert!(
|
||||
parse_strict(
|
||||
parse_strict_counted(
|
||||
b"<a>x & y</a>
|
||||
"
|
||||
",
|
||||
MAX_ELEMENTS
|
||||
)
|
||||
.is_ok()
|
||||
);
|
||||
|
||||
@@ -0,0 +1,44 @@
|
||||
//! The package-wide XML element budget: a file of many parts each inside the per-part
|
||||
//! cap reads bounded, where every part used to build its own tree and the trees the
|
||||
//! reader keeps accumulated.
|
||||
|
||||
use crate::fixtures;
|
||||
use craft_docx::read;
|
||||
|
||||
const W_NS: &str = r#"xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships""#;
|
||||
|
||||
#[test]
|
||||
fn a_file_of_element_budget_parts_still_reads() {
|
||||
// Nine chart parts of 2M elements each: 18M over the package's 16M budget. The later
|
||||
// parts are skipped with a warning instead of built, and the file still reads. Before
|
||||
// the budget, every part's whole tree was parsed and the chart trees stayed cached for
|
||||
// the whole read (~230 MB per 2M-element part, measured), so a file like this cost one
|
||||
// tree per part and scales linearly with the part count.
|
||||
let parts = 9usize;
|
||||
let chunk = "<a/>".repeat(2_000_000);
|
||||
let chart_xml = format!(r#"<c:chart {W_NS}>{chunk}</c:chart>"#);
|
||||
let mut document = format!(
|
||||
r#"<w:document {W_NS} xmlns:wp="http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing" xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main" xmlns:c="http://schemas.openxmlformats.org/drawingml/2006/chart"><w:body>"#
|
||||
);
|
||||
for i in 0..parts {
|
||||
document.push_str(&format!(
|
||||
r#"<w:p><w:r><w:drawing><wp:inline><wp:extent cx="635000" cy="635000"/><a:graphic><a:graphicData uri="http://schemas.openxmlformats.org/drawingml/2006/chart"><c:chart r:id="rId{i}"/></a:graphicData></a:graphic></wp:inline></w:drawing></w:r></w:p>"#
|
||||
));
|
||||
}
|
||||
document.push_str("</w:body></w:document>");
|
||||
let mut rels = String::from(r#"<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">"#);
|
||||
for i in 0..parts {
|
||||
rels.push_str(&format!(
|
||||
r#"<Relationship Id="rId{i}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/chart" Target="charts/chart{i}.xml"/>"#
|
||||
));
|
||||
}
|
||||
rels.push_str("</Relationships>");
|
||||
let mut entries: Vec<(&str, Vec<u8>)> = vec![("word/document.xml", document.into_bytes()), ("word/_rels/document.xml.rels", rels.into_bytes())];
|
||||
for i in 0..parts {
|
||||
entries.push((Box::leak(format!("word/charts/chart{i}.xml").into_boxed_str()), chart_xml.clone().into_bytes()));
|
||||
}
|
||||
let refs: Vec<(&str, &[u8])> = entries.iter().map(|(n, b)| (*n, b.as_slice())).collect();
|
||||
let z = fixtures::zip(&refs);
|
||||
let doc = read(&z).expect("a file over the element budget still reads, the extra parts skipped");
|
||||
assert_eq!(doc.body.len(), parts, "the document's own paragraphs read");
|
||||
}
|
||||
@@ -16,6 +16,7 @@ mod default_size;
|
||||
mod drawing_payload;
|
||||
mod east_asian_lang;
|
||||
mod east_asian_layout;
|
||||
mod element_budget;
|
||||
mod emphasis_marks;
|
||||
mod fixtures;
|
||||
mod font_table;
|
||||
|
||||
Reference in new issue
Block a user