use std::io::BufRead;
use crate::import::{ImportError, ImportOrigin};
pub(crate) const MAX_DEPTH: usize = 64;
pub(crate) const MAX_NAME_BYTES: usize = 64;
pub(crate) const MAX_VALUE_BYTES: usize = 256;
pub(crate) const MAX_ELEMENTS: u64 = 1 << 24;
pub(crate) const MAX_ENTITY_BYTES: usize = 16;
const MAX_TEXT_BYTES: usize = 512;
const MAX_TERMINATOR_BYTES: usize = 3;
pub(crate) enum Event {
Start { self_closing: bool },
End,
Eof,
}
#[derive(Debug, Default)]
pub(crate) struct Element {
pub(crate) name: Vec<u8>,
values: Vec<(Vec<u8>, Vec<u8>)>,
}
impl Element {
fn clear(&mut self) {
self.name.clear();
self.values.clear();
}
pub(crate) fn value(&self, name: &[u8]) -> Option<&str> {
self.values
.iter()
.find(|(key, _)| key == name)
.and_then(|(_, value)| std::str::from_utf8(value).ok())
}
}
pub(crate) struct Parser<'a> {
input: &'a mut dyn BufRead,
buffer: Vec<u8>,
position: usize,
line: u64,
element_bytes: usize,
max_element_bytes: usize,
elements: u64,
pub(crate) element: Element,
format: &'static str,
kept: &'static [&'static [u8]],
lossy: &'static [&'static [u8]],
max_value_bytes: usize,
depth: usize,
capture: bool,
text: Vec<u8>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum ValuePolicy {
Skip,
Keep,
KeepIfItFits,
}
impl ValuePolicy {
fn of(kept: bool, lossy: bool) -> Self {
match (kept, lossy) {
(false, _) => Self::Skip,
(true, false) => Self::Keep,
(true, true) => Self::KeepIfItFits,
}
}
}
impl<'a> Parser<'a> {
pub(crate) fn new(
input: &'a mut dyn BufRead,
max_element_bytes: usize,
format: &'static str,
kept: &'static [&'static [u8]],
) -> Self {
Self {
input,
buffer: Vec::new(),
position: 0,
line: 1,
element_bytes: 0,
max_element_bytes,
elements: 0,
element: Element::default(),
format,
kept,
lossy: &[],
max_value_bytes: MAX_VALUE_BYTES,
depth: 0,
capture: false,
text: Vec::new(),
}
}
pub(crate) fn with_lossy(mut self, lossy: &'static [&'static [u8]]) -> Self {
self.lossy = lossy;
self
}
pub(crate) fn with_max_value_bytes(mut self, bytes: usize) -> Self {
self.max_value_bytes = bytes;
self
}
pub(crate) fn begin_text(&mut self) {
self.text.clear();
self.capture = true;
}
pub(crate) fn take_text(&mut self) -> Result<String, ImportError> {
self.capture = false;
let text = std::mem::take(&mut self.text);
let text = std::str::from_utf8(&text).map_err(|_| ImportError::InvalidUtf8 {
origin: self.origin(),
})?;
Ok(text.trim().to_string())
}
pub(crate) fn origin(&self) -> ImportOrigin {
ImportOrigin::line(self.line)
}
pub(crate) fn malformed(&self, message: String) -> ImportError {
ImportError::Malformed {
format: self.format,
origin: self.origin(),
message,
}
}
fn fill(&mut self) -> Result<bool, ImportError> {
if self.position < self.buffer.len() {
return Ok(true);
}
let Self {
input,
buffer,
position,
..
} = self;
buffer.clear();
*position = 0;
let available = input.fill_buf()?;
if available.is_empty() {
return Ok(false);
}
let taken = available.len();
buffer.extend_from_slice(available);
input.consume(taken);
Ok(true)
}
fn peek(&mut self) -> Result<Option<u8>, ImportError> {
if !self.fill()? {
return Ok(None);
}
Ok(Some(self.buffer[self.position]))
}
fn bump(&mut self) -> Result<Option<u8>, ImportError> {
let Some(byte) = self.peek()? else {
return Ok(None);
};
self.position += 1;
if byte == b'\n' {
self.line += 1;
}
self.element_bytes += 1;
if self.element_bytes > self.max_element_bytes {
return Err(ImportError::LineTooLong {
origin: self.origin(),
limit: self.max_element_bytes,
});
}
Ok(Some(byte))
}
pub(crate) fn next_event(&mut self) -> Result<Event, ImportError> {
loop {
loop {
match self.peek()? {
None => return Ok(Event::Eof),
Some(b'<') => break,
Some(b'&') if self.capture => {
self.element_bytes = 0;
let resolved = self.entity()?;
self.keep_text(&resolved)?;
}
Some(byte) => {
self.element_bytes = 0;
self.bump()?;
if self.capture {
self.keep_text(&[byte])?;
}
}
}
}
self.element_bytes = 0;
self.bump()?;
match self.peek()? {
None => return Err(self.malformed("the document ends inside a tag".to_string())),
Some(b'?') => {
self.skip_until(b"?>")?;
continue;
}
Some(b'!') => {
self.declaration()?;
continue;
}
Some(b'/') => {
self.bump()?;
self.element.clear();
self.read_name()?;
self.skip_until(b">")?;
self.depth = self.depth.saturating_sub(1);
return Ok(Event::End);
}
Some(_) => {
self.elements += 1;
if self.elements > MAX_ELEMENTS {
return Err(self.malformed(format!("more than {MAX_ELEMENTS} elements")));
}
self.element.clear();
self.read_name()?;
let self_closing = self.read_attributes()?;
if !self_closing {
self.depth += 1;
if self.depth > MAX_DEPTH {
return Err(self
.malformed(format!("elements nested more than {MAX_DEPTH} deep")));
}
}
return Ok(Event::Start { self_closing });
}
}
}
}
fn declaration(&mut self) -> Result<(), ImportError> {
self.bump()?;
if self.matches(b"--")? {
return self.skip_until(b"-->");
}
if self.matches(b"[CDATA[")? {
return self.capture_until(b"]]>");
}
if self.matches(b"DOCTYPE")? {
return self.doctype();
}
Err(self.malformed(
"a declaration other than a comment, CDATA or DOCTYPE: this parser \
accepts no declarations, which is what makes entity expansion \
impossible rather than merely unimplemented"
.to_string(),
))
}
fn doctype(&mut self) -> Result<(), ImportError> {
loop {
let Some(byte) = self.bump()? else {
return Err(self.malformed("the document ends inside a DOCTYPE".to_string()));
};
match byte {
b'>' => return Ok(()),
b'[' => {
return Err(self.malformed(
"a DOCTYPE with an internal subset, which is where entity \
declarations live. Only a bare '<!DOCTYPE name>' is accepted"
.to_string(),
));
}
b'S' | b'P' => {
let word = if byte == b'S' {
b"YSTEM".as_slice()
} else {
b"UBLIC".as_slice()
};
if self.matches(word)? {
return Err(self.malformed(
"a DOCTYPE naming an external identifier, which asks the \
parser to fetch a document. Only a bare \
'<!DOCTYPE name>' is accepted"
.to_string(),
));
}
}
_ => {}
}
}
}
fn read_name(&mut self) -> Result<(), ImportError> {
loop {
match self.peek()? {
None => return Err(self.malformed("the document ends inside a name".to_string())),
Some(byte) if is_name_byte(byte) => {
self.bump()?;
if self.element.name.len() >= MAX_NAME_BYTES {
return Err(
self.malformed(format!("a name longer than {MAX_NAME_BYTES} bytes"))
);
}
self.element.name.push(byte);
}
Some(_) => return Ok(()),
}
}
}
fn read_attributes(&mut self) -> Result<bool, ImportError> {
loop {
self.skip_whitespace()?;
match self.peek()? {
None => {
return Err(self.malformed("the document ends inside a tag".to_string()));
}
Some(b'>') => {
self.bump()?;
return Ok(false);
}
Some(b'/') => {
self.bump()?;
if self.peek()? != Some(b'>') {
return Err(self.malformed("'/' not followed by '>'".to_string()));
}
self.bump()?;
return Ok(true);
}
Some(_) => self.read_attribute()?,
}
}
}
fn read_attribute(&mut self) -> Result<(), ImportError> {
let mut name = Vec::new();
loop {
match self.peek()? {
None => return Err(self.malformed("the document ends inside a tag".to_string())),
Some(byte) if is_name_byte(byte) => {
self.bump()?;
if name.len() >= MAX_NAME_BYTES {
return Err(self.malformed(format!(
"an attribute name longer than {MAX_NAME_BYTES} bytes"
)));
}
name.push(byte);
}
Some(_) => break,
}
}
self.skip_whitespace()?;
if self.peek()? != Some(b'=') {
return Err(self.malformed(format!(
"attribute '{}' has no value",
String::from_utf8_lossy(&name)
)));
}
self.bump()?;
self.skip_whitespace()?;
let policy = ValuePolicy::of(
self.kept.contains(&name.as_slice()),
self.lossy.contains(&name.as_slice()),
);
if let Some(value) = self.read_value(policy)?
&& policy != ValuePolicy::Skip
{
if std::str::from_utf8(&value).is_err() {
return Err(ImportError::InvalidUtf8 {
origin: self.origin(),
});
}
self.element.values.push((name, value));
}
Ok(())
}
fn read_value(&mut self, policy: ValuePolicy) -> Result<Option<Vec<u8>>, ImportError> {
let keep = policy != ValuePolicy::Skip;
let lossy = policy == ValuePolicy::KeepIfItFits;
let Some(quote) = self.peek()? else {
return Err(self.malformed("the document ends inside a tag".to_string()));
};
if quote != b'"' && quote != b'\'' {
return Err(self.malformed("an attribute value that is not quoted".to_string()));
}
self.bump()?;
let mut value = Vec::new();
let mut dropped = false;
loop {
let Some(byte) = self.peek()? else {
return Err(
self.malformed("the document ends inside an attribute value".to_string())
);
};
if byte == quote {
self.bump()?;
return Ok((!dropped).then_some(value));
}
let bytes = if byte == b'&' {
self.entity()?
} else {
self.bump()?;
vec![byte]
};
if keep && !dropped {
if value.len() + bytes.len() > self.max_value_bytes {
if !lossy {
return Err(self.malformed(format!(
"an attribute value longer than {} bytes",
self.max_value_bytes
)));
}
dropped = true;
value = Vec::new();
} else {
value.extend_from_slice(&bytes);
}
}
}
}
fn entity(&mut self) -> Result<Vec<u8>, ImportError> {
self.bump()?;
let mut name = Vec::new();
loop {
let Some(byte) = self.peek()? else {
return Err(self.malformed("the document ends inside an entity".to_string()));
};
self.bump()?;
if byte == b';' {
break;
}
if name.len() >= MAX_ENTITY_BYTES {
return Err(self.malformed("an entity reference with no ';'".to_string()));
}
name.push(byte);
}
match name.as_slice() {
b"lt" => Ok(vec![b'<']),
b"gt" => Ok(vec![b'>']),
b"amp" => Ok(vec![b'&']),
b"quot" => Ok(vec![b'"']),
b"apos" => Ok(vec![b'\'']),
reference if reference.first() == Some(&b'#') => self.character_reference(reference),
other => Err(self.malformed(format!(
"'&{};' is not a predefined entity, and this parser permits no \
declarations, so nothing can have defined it",
String::from_utf8_lossy(other)
))),
}
}
fn character_reference(&self, reference: &[u8]) -> Result<Vec<u8>, ImportError> {
let digits = String::from_utf8_lossy(&reference[1..]);
let code = match digits.strip_prefix(['x', 'X']) {
Some(hex) => u32::from_str_radix(hex, 16).ok(),
None => digits.parse::<u32>().ok(),
};
let Some(character) = code.and_then(char::from_u32) else {
return Err(self.malformed(format!("'&{digits};' is not a character")));
};
let mut encoded = [0u8; 4];
Ok(character.encode_utf8(&mut encoded).as_bytes().to_vec())
}
fn matches(&mut self, expected: &[u8]) -> Result<bool, ImportError> {
for wanted in expected {
match self.peek()? {
Some(byte) if byte == *wanted => {
self.bump()?;
}
_ => return Ok(false),
}
}
Ok(true)
}
fn skip_whitespace(&mut self) -> Result<(), ImportError> {
while matches!(self.peek()?, Some(b' ' | b'\t' | b'\r' | b'\n')) {
self.bump()?;
}
Ok(())
}
fn skip_until(&mut self, terminator: &[u8]) -> Result<(), ImportError> {
self.scan_until(terminator, false)
}
fn capture_until(&mut self, terminator: &[u8]) -> Result<(), ImportError> {
self.scan_until(terminator, self.capture)
}
fn scan_until(&mut self, terminator: &[u8], keep: bool) -> Result<(), ImportError> {
let width = terminator.len();
debug_assert!(
(1..=MAX_TERMINATOR_BYTES).contains(&width),
"every terminator this parser skips to fits the window"
);
let mut window = [0u8; MAX_TERMINATOR_BYTES];
let mut filled = 0usize;
loop {
let Some(byte) = self.bump()? else {
return Err(self.malformed(format!(
"the document ends before '{}'",
String::from_utf8_lossy(terminator)
)));
};
if filled == width {
let evicted = window[0];
window.copy_within(1..width, 0);
window[width - 1] = byte;
if keep {
self.keep_text(&[evicted])?;
}
} else {
window[filled] = byte;
filled += 1;
}
if filled == width && window[..width] == *terminator {
return Ok(());
}
}
}
}
impl Parser<'_> {
fn keep_text(&mut self, bytes: &[u8]) -> Result<(), ImportError> {
if self.text.len() + bytes.len() > MAX_TEXT_BYTES {
return Err(self.malformed(format!("element text longer than {MAX_TEXT_BYTES} bytes")));
}
self.text.extend_from_slice(bytes);
Ok(())
}
}
fn is_name_byte(byte: u8) -> bool {
!matches!(
byte,
b' ' | b'\t' | b'\r' | b'\n' | b'/' | b'>' | b'=' | b'<'
)
}
#[cfg(test)]
mod tests {
use std::io::Cursor;
use proptest::prelude::*;
use super::*;
const FORMAT: &str = "test";
const KEPT: &[&[u8]] = &[b"id", b"name"];
fn read(document: &str) -> Result<Vec<Event>, ImportError> {
let mut input = Cursor::new(document.as_bytes().to_vec());
let mut parser = Parser::new(&mut input, 64 * 1024, FORMAT, KEPT);
let mut events = Vec::new();
loop {
match parser.next_event()? {
Event::Eof => return Ok(events),
event => events.push(event),
}
}
}
fn refusal(document: &str) -> String {
match read(document) {
Ok(_) => panic!("the parser accepted a document it documents as refused"),
Err(error) => error.to_string(),
}
}
type Kept = Vec<(&'static str, Option<String>)>;
fn attributes(document: &str) -> Result<Kept, ImportError> {
let mut input = Cursor::new(document.as_bytes().to_vec());
let mut parser = Parser::new(&mut input, 64 * 1024, FORMAT, KEPT);
loop {
match parser.next_event()? {
Event::Eof => return Ok(Vec::new()),
Event::Start { .. } => {
return Ok(KEPT
.iter()
.map(|name| {
(
std::str::from_utf8(name).expect("the kept names are ASCII"),
parser.element.value(name).map(str::to_owned),
)
})
.collect());
}
Event::End => {}
}
}
}
#[test]
fn a_terminator_overlapping_its_own_prefix_still_ends_the_section() {
for document in [
r#"<a><![CDATA[b]]]></a>"#,
r#"<a><![CDATA[b]]]]></a>"#,
r#"<a><!--- a comment ---></a>"#,
r#"<a><?target ??></a>"#,
] {
let events =
read(document).unwrap_or_else(|error| panic!("{document} was refused: {error}"));
assert!(!events.is_empty(), "{document}");
}
}
#[test]
fn a_terminator_that_does_not_overlap_still_ends_the_section() {
for document in [
r#"<a><![CDATA[b]]></a>"#,
r#"<a><!-- a comment --></a>"#,
r#"<a><?target value?></a>"#,
] {
assert!(read(document).is_ok(), "{document}");
}
}
#[test]
fn an_attribute_value_that_is_not_text_refuses_the_document() {
let mut document = b"<a id=\"1".to_vec();
document.push(0xFF);
document.extend_from_slice(b"\"/>");
let mut input = Cursor::new(document);
let mut parser = Parser::new(&mut input, 64 * 1024, FORMAT, KEPT);
assert!(
matches!(parser.next_event(), Err(ImportError::InvalidUtf8 { .. })),
"a value that is not text has to be refused, not dropped"
);
}
#[test]
fn an_attribute_nobody_kept_is_not_checked_for_text() {
let mut document = b"<a other=\"".to_vec();
document.push(0xFF);
document.extend_from_slice(b"\" id=\"1\"/>");
let mut input = Cursor::new(document);
let mut parser = Parser::new(&mut input, 64 * 1024, FORMAT, KEPT);
assert!(matches!(parser.next_event(), Ok(Event::Start { .. })));
assert_eq!(parser.element.value(b"id"), Some("1"));
}
#[test]
fn element_text_that_is_not_text_refuses_the_document() {
let mut document = b"<a>cpe:/o:x".to_vec();
document.push(0xFF);
document.extend_from_slice(b"</a>");
let mut input = Cursor::new(document);
let mut parser = Parser::new(&mut input, 64 * 1024, FORMAT, KEPT);
assert!(matches!(parser.next_event(), Ok(Event::Start { .. })));
parser.begin_text();
assert!(matches!(parser.next_event(), Ok(Event::End)));
assert!(matches!(
parser.take_text(),
Err(ImportError::InvalidUtf8 { .. })
));
}
#[test]
fn a_value_and_a_text_run_that_are_text_read_back_whole() {
let kept = attributes(r#"<a id="7" name="gw" other="ignored"/>"#).expect("reads");
assert_eq!(
kept,
vec![
("id", Some("7".to_string())),
("name", Some("gw".to_string())),
]
);
}
#[test]
fn cdata_inside_kept_text_is_read_rather_than_skipped() {
let document = r#"<a><![CDATA[cpe:/a:openbsd:openssh:8.9]]></a>"#;
let mut input = Cursor::new(document.as_bytes().to_vec());
let mut parser = Parser::new(&mut input, 64 * 1024, FORMAT, KEPT);
assert!(matches!(parser.next_event(), Ok(Event::Start { .. })));
parser.begin_text();
assert!(matches!(parser.next_event(), Ok(Event::End)));
assert_eq!(
parser.take_text().expect("reads"),
"cpe:/a:openbsd:openssh:8.9"
);
}
#[test]
fn text_around_a_cdata_section_joins_up_without_its_delimiters() {
let document = r#"<a>before <![CDATA[<inside> & ]]]]> after</a>"#;
let mut input = Cursor::new(document.as_bytes().to_vec());
let mut parser = Parser::new(&mut input, 64 * 1024, FORMAT, KEPT);
assert!(matches!(parser.next_event(), Ok(Event::Start { .. })));
parser.begin_text();
assert!(matches!(parser.next_event(), Ok(Event::End)));
assert_eq!(
parser.take_text().expect("reads"),
"before <inside> & ]] after"
);
}
#[test]
fn a_comment_inside_kept_text_is_still_dropped() {
let document = r#"<a>before <!-- not content --> after</a>"#;
let mut input = Cursor::new(document.as_bytes().to_vec());
let mut parser = Parser::new(&mut input, 64 * 1024, FORMAT, KEPT);
assert!(matches!(parser.next_event(), Ok(Event::Start { .. })));
parser.begin_text();
assert!(matches!(parser.next_event(), Ok(Event::End)));
assert_eq!(parser.take_text().expect("reads"), "before after");
}
#[test]
fn a_cdata_section_is_held_to_the_text_ceiling() {
let document = format!("<a><![CDATA[{}]]></a>", "x".repeat(MAX_TEXT_BYTES + 1));
let mut input = Cursor::new(document.into_bytes());
let mut parser = Parser::new(&mut input, 1024 * 1024, FORMAT, KEPT);
assert!(matches!(parser.next_event(), Ok(Event::Start { .. })));
parser.begin_text();
assert!(
parser.next_event().is_err(),
"a section wider than the ceiling was kept whole"
);
}
#[test]
fn an_entity_declaration_is_refused_outright() {
let message = refusal(r#"<!DOCTYPE lolz [<!ENTITY lol "lol">]><lolz>&lol;</lolz>"#);
assert!(
message.contains("internal subset") || message.contains("declaration"),
"the refusal should name what it refused, said: {message}"
);
}
#[test]
fn the_billion_laughs_document_is_refused_before_anything_expands() {
let message = refusal(
r#"<?xml version="1.0"?>
<!DOCTYPE lolz [
<!ENTITY lol "lol">
<!ENTITY lol2 "&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;">
<!ENTITY lol3 "&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;">
]>
<lolz>&lol3;</lolz>"#,
);
assert!(!message.is_empty());
}
#[test]
fn a_bare_doctype_is_accepted_because_nmap_writes_one() {
let events = read(r#"<?xml version="1.0"?><!DOCTYPE nmaprun><nmaprun/>"#)
.expect("the inert form nmap writes is readable");
assert!(!events.is_empty());
}
#[test]
fn a_doctype_naming_a_system_identifier_is_refused() {
let message = refusal(r#"<!DOCTYPE a SYSTEM "file:///etc/passwd"><a/>"#);
assert!(message.contains("external identifier"), "said: {message}");
}
#[test]
fn a_doctype_naming_a_public_identifier_is_refused() {
let message =
refusal(r#"<!DOCTYPE a PUBLIC "-//X//EN" "http://example.invalid/x.dtd"><a/>"#);
assert!(message.contains("external identifier"), "said: {message}");
}
#[test]
fn a_doctype_with_an_internal_subset_is_refused() {
let message = refusal(r#"<!DOCTYPE a [<!ELEMENT a EMPTY>]><a/>"#);
assert!(message.contains("internal subset"), "said: {message}");
}
#[test]
fn an_external_entity_reference_has_nothing_to_resolve_against() {
let message =
refusal(r#"<!DOCTYPE a [<!ENTITY xxe SYSTEM "file:///etc/passwd">]><a>&xxe;</a>"#);
assert!(!message.is_empty());
}
#[test]
fn an_undeclared_entity_reference_is_refused_and_named() {
let message = refusal(r#"<a id="&whoami;"/>"#);
assert!(
message.contains("whoami"),
"the refusal must name the reference, said: {message}"
);
}
#[test]
fn the_five_predefined_entities_resolve() {
let mut input = Cursor::new(r#"<a id="<>&"'"/>"#.as_bytes().to_vec());
let mut parser = Parser::new(&mut input, 64 * 1024, FORMAT, KEPT);
parser.next_event().expect("the document reads");
assert_eq!(parser.element.value(b"id"), Some("<>&\"'"));
}
#[test]
fn a_numeric_character_reference_resolves() {
let mut input = Cursor::new(r#"<a id="AB"/>"#.as_bytes().to_vec());
let mut parser = Parser::new(&mut input, 64 * 1024, FORMAT, KEPT);
parser.next_event().expect("the document reads");
assert_eq!(parser.element.value(b"id"), Some("AB"));
}
#[test]
fn a_processing_instruction_is_skipped_rather_than_read() {
let events = read(
r#"<?xml version="1.0"?><?xml-stylesheet href="file:///usr/share/nmap/nmap.xsl" type="text/xsl"?><a/>"#,
)
.expect("a stylesheet instruction is skipped, not followed");
assert!(
matches!(events.as_slice(), [Event::Start { self_closing: true }]),
"the two instructions produce no events, leaving only the element"
);
}
#[test]
fn nesting_is_bounded() {
let deep = |levels: usize| {
let mut doc = String::new();
for _ in 0..levels {
doc.push_str("<a>");
}
for _ in 0..levels {
doc.push_str("</a>");
}
doc
};
read(&deep(MAX_DEPTH)).expect("nesting at the bound is accepted");
let message = refusal(&deep(MAX_DEPTH + 2));
assert!(
message.contains("nest") || message.contains("deep"),
"said: {message}"
);
}
#[test]
fn an_element_name_is_bounded() {
let long = "n".repeat(MAX_NAME_BYTES + 1);
let message = refusal(&format!("<{long}/>"));
assert!(message.contains("name"), "said: {message}");
}
#[test]
fn an_attribute_name_is_bounded() {
let long = "n".repeat(MAX_NAME_BYTES + 1);
let message = refusal(&format!(r#"<a {long}="x"/>"#));
assert!(message.contains("name"), "said: {message}");
}
#[test]
fn an_unwanted_attribute_is_not_accumulated_and_so_is_not_bounded() {
let enormous = "v".repeat(MAX_VALUE_BYTES * 8);
let events = read(&format!(r#"<a id="kept" args="{enormous}"/>"#))
.expect("an unwanted value is never measured against the bound");
assert!(
events
.iter()
.any(|event| matches!(event, Event::Start { .. })),
"the element should have been read"
);
assert!(!refusal(&format!(r#"<a id="{enormous}"/>"#)).is_empty());
}
#[test]
fn a_kept_attribute_value_is_bounded() {
let at_bound = "v".repeat(MAX_VALUE_BYTES);
read(&format!(r#"<a id="{at_bound}"/>"#)).expect("a value at the bound is accepted");
let past = "v".repeat(MAX_VALUE_BYTES + 1);
assert!(!refusal(&format!(r#"<a id="{past}"/>"#)).is_empty());
}
#[test]
fn one_elements_markup_is_bounded() {
let mut input = Cursor::new(format!(r#"<a id="{}"/>"#, "v".repeat(4096)).into_bytes());
let mut parser = Parser::new(&mut input, 128, FORMAT, KEPT);
assert!(
parser.next_event().is_err(),
"an element past max_element_bytes is refused"
);
}
#[test]
fn an_entity_reference_that_never_closes_is_bounded() {
let message = refusal(&format!(
r#"<a id="&{}"/>"#,
"x".repeat(MAX_ENTITY_BYTES * 4)
));
assert!(!message.is_empty());
}
#[test]
fn a_document_that_ends_mid_element_is_an_error_not_a_hang() {
for truncated in [
"<a",
"<a id=",
r#"<a id=""#,
"<a><b",
"<!DOCTYPE",
"<!--",
"<?xml",
] {
let _ = read(truncated);
}
}
proptest! {
#[test]
fn the_parser_never_panics_on_arbitrary_input(document in "(?s).{0,2000}") {
let _ = read(&document);
}
#[test]
fn the_parser_never_panics_on_arbitrary_bytes(bytes in proptest::collection::vec(any::<u8>(), 0..2000)) {
let mut input = Cursor::new(bytes);
let mut parser = Parser::new(&mut input, 64 * 1024, FORMAT, KEPT);
for _ in 0..10_000 {
match parser.next_event() {
Ok(Event::Eof) | Err(_) => break,
Ok(_) => {}
}
}
}
}
}