//! Bounded pre-guest response sanitization (`SMH-SPEC-SPEC0001`, Authentication). //! //! Request-owned borrowed credentials never enter guest state or diagnostics. //! Matching recognizes raw bytes and single-level JSON scalar spellings without //! enumerating combinations. Only a bounded classification window survives a call. //! //! For a large dictionary, a JSON token at each byte offset has one successor //! (or none), including offsets inside another escape. A reverse automaton over //! that DAG finds the longest complete credential at every start in one pass. //! Persistent transition maps bound a lookup by alphabet depth, not prefix length. //! Starts with a full worst-case spelling of lookahead cannot be partial matches. //! Retaining lookahead plus one credential-sized processing block amortizes the //! overlapping passes: lookahead <= 6 * block, so steady work is <= 7 passes/byte. //! No spelling expansion, response-sized state, or input-dependent work rejection. //! An incremental earliest-start frontier reuses matched prefixes across chunks. //! Failed lookahead switches to blocks instead of restarting at overlapping offsets. //! Complete long echoes and public packets can progress before EOF. mod automaton; mod frontier; use automaton::Automaton; use frontier::PrefixProgress; const CREDENTIAL_COUNT_MAX: usize = 32; const CREDENTIAL_BYTES_MAX: usize = 4096; const CREDENTIAL_TOTAL_BYTES_MAX: usize = 32 * 1024; const CARRY_BYTES_MAX: usize = CREDENTIAL_BYTES_MAX * 6; const REPLACEMENT_BYTES_MAX: usize = 32; const JSON_SCALAR_BYTES_MAX: usize = 12; #[cfg(test)] const REPLACEMENT: &[u8] = b""; pub struct ResponseSanitizer<'a> { credentials: &'a [String], replacement: &'static [u8], carry: Vec, dictionary: Option>, } // Small credentials retain eager classification with a fixed comparison bound. // Large credentials use reverse dynamic programming over bounded blocks. const EAGER_BYTES_MAX: usize = 64; struct Dictionary { raw: Automaton, json: Option, lookahead: usize, block_bytes: usize, next_scan: usize, progress: Vec, matched_length: u16, inspected_bytes: u16, stage: MatchingStage, } #[derive(Clone, Copy)] enum MatchingStage { Eager, Frontier, Block, } #[cfg(all(not(test), target_arch = "x86_64"))] const _: () = assert!( std::mem::size_of::() == 168, "production request dictionary must remain 168 bytes" ); #[cfg(test)] impl Dictionary { fn comparisons(&self) -> u64 { self.raw.comparisons() + self.json.as_ref().map_or(0, Automaton::comparisons) } } #[derive(Clone, Copy)] enum Spelling { Different, Prefix, Complete(usize), } impl<'a> ResponseSanitizer<'a> { pub(super) fn validate(credentials: &[String]) -> Result<(), &'static str> { if credentials.len() > CREDENTIAL_COUNT_MAX || credentials .iter() .any(|credential| credential.is_empty() || credential.len() > CREDENTIAL_BYTES_MAX) || credentials.iter().map(String::len).sum::() > CREDENTIAL_TOTAL_BYTES_MAX { return Err("response sanitizer credential bounds exceeded"); } Ok(()) } pub(super) fn new( credentials: &'a [String], replacement: &'static [u8], ) -> Result { Self::validate(credentials)?; if replacement.is_empty() || replacement.len() > REPLACEMENT_BYTES_MAX { return Err("response sanitizer replacement bound exceeded"); } let dictionary = credentials .iter() .any(|value| value.len() > EAGER_BYTES_MAX) .then(|| { let lookahead = credentials .iter() .map(|value| { value .chars() .map(|scalar| scalar.len_utf16() * 6) .sum::() }) .max() .unwrap_or_default(); Box::new(Dictionary { raw: Automaton::new( credentials .iter() .map(|value| value.bytes().rev().map(u32::from).collect()) .collect(), ), // ASCII byte and scalar patterns are identical; borrow // the raw table for both traversals instead of duplicating it. json: (!credentials.iter().all(|value| value.is_ascii())).then(|| { Automaton::new( credentials .iter() .map(|value| value.chars().rev().map(u32::from).collect()) .collect(), ) }), lookahead, block_bytes: credentials .iter() .map(String::len) .max() .unwrap_or_default(), next_scan: lookahead, progress: Vec::new(), matched_length: 0, inspected_bytes: 0, stage: MatchingStage::Eager, }) }); let carry = dictionary.as_ref().map_or_else(Vec::new, |dictionary| { Vec::with_capacity(dictionary.lookahead + dictionary.block_bytes) }); Ok(Self { credentials, replacement, carry, dictionary, }) } pub(super) fn push(&mut self, mut bytes: &[u8]) -> Result, &'static str> { if self.credentials.is_empty() { return Ok(bytes.to_vec()); } let mut output = Vec::new(); while !bytes.is_empty() { let bound = self .dictionary .as_ref() .map_or(CARRY_BYTES_MAX, |dictionary| { dictionary.lookahead + dictionary.block_bytes }); // Probe bounded prefixes even when transport delivers a large // packet; unrelated public bytes must not wait for block lookahead. let limit = if self.dictionary.is_some() && self.carry.len() < EAGER_BYTES_MAX { EAGER_BYTES_MAX } else { bound }; let count = bytes.len().min(limit - self.carry.len()); if count == 0 { self.carry.clear(); return Err("response sanitizer carry bound exceeded"); } self.carry.extend_from_slice(&bytes[..count]); bytes = &bytes[count..]; if self.dictionary.is_some() { self.classify_dictionary(&mut output); } else { self.classify(&mut output, false, CARRY_BYTES_MAX); } } Ok(output) } // Invoke only on normal completion. Dropping on every other exit discards // carry, including a potentially sensitive prefix at disconnect. pub(super) fn finish(&mut self) -> Vec { let mut output = Vec::new(); if self.dictionary.is_some() { self.classify_block(&mut output, true); } else { self.classify(&mut output, true, CARRY_BYTES_MAX); } output } fn classify_dictionary(&mut self, output: &mut Vec) { loop { let Some(dictionary) = &self.dictionary else { return; }; match dictionary.stage { MatchingStage::Eager => { let before = self.carry.len(); self.classify(output, false, EAGER_BYTES_MAX); if self.carry.is_empty() { return; } if self.carry.len() != before { continue; } if self.carry.len() < EAGER_BYTES_MAX { return; } let Some(dictionary) = &mut self.dictionary else { return; }; dictionary.progress.clear(); dictionary .progress .resize(self.credentials.len(), PrefixProgress::default()); dictionary.matched_length = 0; dictionary.inspected_bytes = 0; dictionary.stage = MatchingStage::Frontier; } MatchingStage::Frontier => { let Some(dictionary) = &mut self.dictionary else { return; }; if dictionary.advance_start(&self.carry, self.credentials) { return; } let matched = usize::from(dictionary.matched_length); let inspected = usize::from(dictionary.inspected_bytes); if matched != 0 { output.extend_from_slice(self.replacement); self.carry.drain(..matched); } dictionary.progress.clear(); // A failed scalar may inspect at most twelve bytes beyond // a completion. Larger unpaid lookahead must use blocks, // otherwise short overlapping matches restart long scans. dictionary.stage = if matched != 0 && (self.carry.len() <= EAGER_BYTES_MAX || matched + JSON_SCALAR_BYTES_MAX >= inspected) { MatchingStage::Eager } else { MatchingStage::Block }; } MatchingStage::Block => { if self.carry.len() < dictionary.next_scan { return; } self.classify_block(output, false); } } } } fn classify_block(&mut self, output: &mut Vec, finished: bool) { let Some(dictionary) = &mut self.dictionary else { return; }; let length = self.carry.len(); if length == 0 { dictionary.progress.clear(); dictionary.stage = MatchingStage::Eager; return; } let json = dictionary.json.as_ref().unwrap_or(&dictionary.raw); let mut ends = vec![0_u32; length]; let mut states = vec![0_u32; length + 1]; let mut raw_lengths = vec![0_u16; length]; let mut raw_state = 0; for offset in (0..length).rev() { raw_state = dictionary .raw .advance(raw_state, u32::from(self.carry[offset])); raw_lengths[offset] = self::length(dictionary.raw.longest(raw_state)); if let Some((scalar, count)) = json_token(&self.carry[offset..]) { let end = offset + count; ends[offset] = automaton::index(end); states[offset] = json.advance(states[end], u32::from(scalar)); } } let safe = if finished { length } else { length + 1 - dictionary.lookahead }; let mut offset = 0; while offset < safe { let mut end = offset; for _ in 0..json.longest(states[offset]) { end = ends[end] as usize; } let matched = usize::from(raw_lengths[offset]).max(end - offset); if matched == 0 { output.push(self.carry[offset]); offset += 1; } else { output.extend_from_slice(self.replacement); offset += matched; } } self.carry.drain(..offset); dictionary.next_scan = dictionary .lookahead .max(self.carry.len() + dictionary.block_bytes); dictionary.progress.clear(); dictionary.stage = if finished || self.carry.len() <= EAGER_BYTES_MAX { MatchingStage::Eager } else { MatchingStage::Block }; } fn classify(&mut self, output: &mut Vec, finished: bool, byte_limit: usize) { let mut offset = 0; let length = self.carry.len().min(byte_limit); while offset < length { let bytes = &self.carry[offset..length]; let mut matched = 0; let mut pending = false; for credential in self.credentials { for spelling in [ raw_spelling(bytes, credential.as_bytes()), json_spelling(bytes, credential), ] { match spelling { Spelling::Complete(length) => matched = matched.max(length), Spelling::Prefix => pending = true, Spelling::Different => {} } } } if pending && !finished { break; } if matched == 0 { output.push(bytes[0]); offset += 1; } else { output.extend_from_slice(self.replacement); offset += matched; } } self.carry.drain(..offset); } } #[expect( clippy::cast_possible_truncation, reason = "credential validation bounds every accepted pattern length to 4096" )] fn length(value: usize) -> u16 { assert!( value <= CREDENTIAL_BYTES_MAX, "accepted dictionary length must fit its credential bound" ); value as u16 } #[expect( clippy::cast_possible_truncation, reason = "classification windows are bounded to 28672 bytes" )] fn spelling_offset(value: usize) -> u16 { assert!( value <= CARRY_BYTES_MAX + CREDENTIAL_BYTES_MAX, "spelling offset must fit the bounded classification window" ); value as u16 } fn json_token(bytes: &[u8]) -> Option<(char, usize)> { let first = *bytes.first()?; if first != b'\\' { if first == b'"' || first < 0x20 { return None; } let length = match first { 0..=0x7f => 1, 0xc2..=0xdf => 2, 0xe0..=0xef => 3, 0xf0..=0xf4 => 4, _ => return None, }; return Some(( std::str::from_utf8(bytes.get(..length)?) .ok()? .chars() .next()?, length, )); } let short = match *bytes.get(1)? { b'"' => '"', b'\\' => '\\', b'/' => '/', b'b' => '\u{8}', b'f' => '\u{c}', b'n' => '\n', b'r' => '\r', b't' => '\t', b'u' => { let unit = unicode_unit(bytes)?; if (0xd800..=0xdbff).contains(&unit) { let low = unicode_unit(bytes.get(6..)?)?; if !(0xdc00..=0xdfff).contains(&low) { return None; } let scalar = 0x10000 + ((unit - 0xd800) << 10) + low - 0xdc00; return Some((char::from_u32(scalar)?, 12)); } return Some((char::from_u32(unit)?, 6)); } _ => return None, }; Some((short, 2)) } fn unicode_unit(bytes: &[u8]) -> Option { if bytes.get(..2)? != b"\\u" { return None; } bytes.get(2..6)?.iter().try_fold(0, |unit, digit| { Some((unit << 4) | char::from(*digit).to_digit(16)?) }) } #[cfg(test)] thread_local! { static COMPARISONS: std::cell::Cell = const { std::cell::Cell::new(0) }; } fn raw_spelling(bytes: &[u8], spelling: &[u8]) -> Spelling { #[cfg(test)] let starts_with = |bytes: &[u8], prefix: &[u8]| { bytes.len() >= prefix.len() && bytes.iter().zip(prefix).all(|(actual, expected)| { COMPARISONS.with(|count| count.set(count.get() + 1)); actual == expected }) }; #[cfg(not(test))] let starts_with = <[u8]>::starts_with; if starts_with(bytes, spelling) { Spelling::Complete(spelling.len()) } else if starts_with(spelling, bytes) { Spelling::Prefix } else { Spelling::Different } } fn json_spelling(bytes: &[u8], credential: &str) -> Spelling { let mut offset = 0; for scalar in credential.chars() { match scalar_spelling(&bytes[offset..], scalar) { Spelling::Complete(length) => offset += length, other => return other, } } Spelling::Complete(offset) } fn scalar_spelling(bytes: &[u8], scalar: char) -> Spelling { if bytes.first() == Some(&b'\\') { escaped_scalar(bytes, scalar) } else if scalar == '"' || scalar == '\\' || scalar <= '\u{1f}' { if bytes.is_empty() { Spelling::Prefix } else { Spelling::Different } } else { raw_spelling(bytes, scalar.encode_utf8(&mut [0; 4]).as_bytes()) } } fn escaped_scalar(bytes: &[u8], scalar: char) -> Spelling { let short = match scalar { '"' => Some(b'"'), '\\' => Some(b'\\'), '/' => Some(b'/'), '\u{8}' => Some(b'b'), '\u{c}' => Some(b'f'), '\n' => Some(b'n'), '\r' => Some(b'r'), '\t' => Some(b't'), _ => None, }; if let Some(short) = short { match raw_spelling(bytes, &[b'\\', short]) { Spelling::Different => {} other => return other, } } let mut spelling = [0; JSON_SCALAR_BYTES_MAX]; let mut length = 0; for unit in scalar.encode_utf16(&mut [0; 2]) { spelling[length..length + 2].copy_from_slice(b"\\u"); for (index, shift) in [12, 8, 4, 0].into_iter().enumerate() { spelling[length + 2 + index] = b"0123456789abcdef"[usize::from((*unit >> shift) & 15)]; } length += 6; } // Only hex digits are case-insensitive; JSON's escape introducer is not. for (index, expected) in spelling[..length].iter().enumerate() { let Some(actual) = bytes.get(index) else { return Spelling::Prefix; }; #[cfg(test)] COMPARISONS.with(|count| count.set(count.get() + 1)); if (index % 6 < 2 && actual != expected) || (index % 6 >= 2 && actual.to_ascii_lowercase() != *expected) { return Spelling::Different; } } Spelling::Complete(length) } #[cfg(test)] mod tests { //! SMH-SPEC-SPEC0001: chunking, preservation, carry, and request memory bounds. use super::*; fn sanitize(credentials: &[String], chunks: &[&[u8]], complete: bool) -> Vec { let mut sanitizer = ResponseSanitizer::new(credentials, REPLACEMENT).unwrap(); let mut output = Vec::new(); for chunk in chunks { output.extend_from_slice(&sanitizer.push(chunk).unwrap()); let bound = sanitizer .dictionary .as_ref() .map_or(CARRY_BYTES_MAX, |dictionary| { dictionary.lookahead + dictionary.block_bytes }); assert!(sanitizer.carry.len() <= bound); } if complete { output.extend_from_slice(&sanitizer.finish()); } output } #[test] fn bytewise_near_match_work_is_linear() { for (count, length) in [(32, 1024), (8, 4096)] { let credentials: Vec = (0..count) .map(|index| format!("{}{:02}", "a".repeat(length - 2), index)) .collect(); ResponseSanitizer::validate(&credentials).unwrap(); for (encoded, repetitions) in [(false, 1), (true, 1), (false, 8), (true, 8)] { let wire = if encoded { b"\\u0061".repeat(length * repetitions) } else { vec![b'a'; length * repetitions] }; COMPARISONS.with(|count| count.set(0)); let mut sanitizer = ResponseSanitizer::new(&credentials, REPLACEMENT).unwrap(); let mut output = Vec::new(); for byte in &wire { output.extend(sanitizer.push(std::slice::from_ref(byte)).unwrap()); } output.extend(sanitizer.finish()); assert_eq!(output, wire); let dictionary = sanitizer.dictionary.as_ref().unwrap(); let comparisons = COMPARISONS.with(std::cell::Cell::get) + dictionary.comparisons(); eprintln!( "fixed {count}x{length}, encoded={encoded}, repetitions={repetitions}: {comparisons} comparisons/transition steps, {} input bytes", wire.len() ); assert!( comparisons <= wire.len() as u64 * 256 + 65536, "long-prefix work restarted: {comparisons}" ); } } } #[test] fn ascii_dictionary_shares_raw_and_json_block_traversals() { let credentials = ["a".repeat(CREDENTIAL_BYTES_MAX), "x".repeat(65)]; let sanitizer = ResponseSanitizer::new(&credentials, REPLACEMENT).unwrap(); assert!(sanitizer.dictionary.as_ref().unwrap().json.is_none()); for spelling in [ credentials[0].as_bytes().to_vec(), b"\\u0061".repeat(CREDENTIAL_BYTES_MAX), ] { let mut wire = vec![b'x'; 64]; wire.push(b'!'); let mut expected = wire.clone(); wire.extend_from_slice(&spelling); wire.extend_from_slice(b":after"); expected.extend_from_slice(REPLACEMENT); expected.extend_from_slice(b":after"); for chunk_bytes in [1, 64, 4096, wire.len()] { assert_eq!( sanitize( &credentials, &wire.chunks(chunk_bytes).collect::>(), true ), expected ); } } } #[test] fn complete_large_raw_and_json_echoes_progress_before_finish() { let credential = "a".repeat(CREDENTIAL_BYTES_MAX); let credentials = [credential.clone()]; for wire in [ credential.into_bytes(), b"\\u0061".repeat(CREDENTIAL_BYTES_MAX), ] { let mut sanitizer = ResponseSanitizer::new(&credentials, REPLACEMENT).unwrap(); let mut output = Vec::new(); for byte in &wire { output.extend(sanitizer.push(std::slice::from_ref(byte)).unwrap()); } assert_eq!(output, REPLACEMENT); assert!(sanitizer.finish().is_empty()); } } #[test] fn short_matches_cannot_restart_failed_long_overlaps() { let credentials = [ "a".into(), format!("{}00", "a".repeat(CREDENTIAL_BYTES_MAX - 2)), ]; let wire = vec![b'a'; CREDENTIAL_BYTES_MAX * 2]; COMPARISONS.with(|count| count.set(0)); let mut sanitizer = ResponseSanitizer::new(&credentials, REPLACEMENT).unwrap(); let mut output = sanitizer.push(&wire).unwrap(); output.extend(sanitizer.finish()); let dictionary = sanitizer.dictionary.as_ref().unwrap(); let comparisons = COMPARISONS.with(std::cell::Cell::get) + dictionary.comparisons(); assert_eq!(output, REPLACEMENT.repeat(wire.len())); assert!( comparisons <= wire.len() as u64 * 256 + 65536, "overlapping short completions restarted long scans: {comparisons}" ); } #[test] fn large_dictionary_matches_raw_mixed_unicode_and_surrogate_spellings_at_every_split() { let prefix = "a".repeat(65); let tail = "a\"\\Ă©đŸ˜€/\u{7f}\u{85}\0z"; let credentials = [format!("{prefix}{tail}"), prefix.clone()]; for spelling in [ format!("{prefix}{tail}"), format!( "{prefix}{}{}{}", r#"a\"\\\u00E9\ud83D\uDE00\/"#, "\u{7f}\u{85}", r#"\u0000z"# ), format!( "{}{}", "\\u0061".repeat(65), r#"\u0061\u0022\u005cĂ©đŸ˜€/\u007F\u0085\u0000\u007a"# ), ] { for force_block in [false, true] { let mut safe = b"safe:".to_vec(); if force_block { // A failed first frontier forces the later rich match through block DP. safe.extend_from_slice(&[b'a'; 64]); safe.push(b'!'); } let mut wire = safe.clone(); wire.extend_from_slice(spelling.as_bytes()); let after = b":after".repeat(100); wire.extend_from_slice(&after); wire.push(0xff); let mut expected = safe; expected.extend_from_slice(REPLACEMENT); expected.extend_from_slice(&after); expected.push(0xff); for split in 0..=wire.len() { assert_eq!( sanitize(&credentials, &[&wire[..split], &wire[split..]], true), expected ); } assert_eq!( sanitize(&credentials, &wire.chunks(1).collect::>(), true), expected ); } } } #[test] fn large_dictionary_does_not_delay_unrelated_public_packets() { let credentials = ["a".repeat(CREDENTIAL_BYTES_MAX)]; let wire = b"public.".repeat(128); let mut sanitizer = ResponseSanitizer::new(&credentials, REPLACEMENT).unwrap(); assert_eq!(sanitizer.push(&wire).unwrap(), wire); assert!(sanitizer.finish().is_empty()); } #[test] fn large_dictionary_abort_discards_prefix_and_completion_preserves_truncated_escape() { let credentials = ["a".repeat(CREDENTIAL_BYTES_MAX)]; let mut prefix = b"\\u0061".repeat(CREDENTIAL_BYTES_MAX - 1); prefix.extend_from_slice(b"\\u00"); for chunk_bytes in [1, 7, 64, 4096, prefix.len()] { let mut sanitizer = ResponseSanitizer::new(&credentials, REPLACEMENT).unwrap(); assert_eq!(sanitizer.push(b"safe:").unwrap(), b"safe:"); for chunk in prefix.chunks(chunk_bytes) { assert!(sanitizer.push(chunk).unwrap().is_empty()); } assert_eq!(sanitizer.finish(), prefix); assert!(sanitizer.finish().is_empty()); assert_eq!( sanitize(&credentials, &[b"safe:", &prefix], false), b"safe:" ); } } #[test] fn large_dictionary_preserves_escape_interior_matches_and_greedy_partition_law() { let credentials = vec![ "x".repeat(65), "u0061b".into(), "31".into(), "1x".into(), "a\"\\Ă©đŸ˜€/z".into(), "abc".into(), "abcdef".into(), ]; let mut wire = vec![b'x'; 64]; wire.push(b'!'); wire.extend_from_slice( &b"\\u0061\\u0062|3\\u0031x|abcdef|a\\\"\\\\\\u00E9\\ud83D\\uDE00\\/z|\xff\\uD800?" .repeat(12), ); let mut reference = ResponseSanitizer::new(&credentials, REPLACEMENT).unwrap(); reference.dictionary = None; let mut expected = reference.push(&wire).unwrap(); expected.extend(reference.finish()); for chunk_bytes in 1..=wire.len() { assert_eq!( sanitize( &credentials, &wire.chunks(chunk_bytes).collect::>(), true ), expected ); } } #[test] fn every_partition_preserves_binary_unrelated_bytes_and_supported_spellings() { let credentials = ["a\"\\Ă©đŸ˜€/z".to_string()]; for spelling in [ "a\"\\Ă©đŸ˜€/z", r#"a\"\\\u00E9\ud83D\uDE00\/z"#, r#"\u0061\u0022\u005cĂ©đŸ˜€/\u007a"#, ] { let mut wire = b"\xff\0before:".to_vec(); wire.extend_from_slice(spelling.as_bytes()); wire.extend_from_slice(b":after\0\xfe"); let expected = b"\xff\0before::after\0\xfe"; // Exhaustive two-boundary partitions include empty, bytewise UTF-8, // short-escape, Unicode-escape and surrogate-pair fragments. for first in 0..=wire.len() { for second in first..=wire.len() { assert_eq!( sanitize( &credentials, &[&wire[..first], &wire[first..second], &wire[second..]], true ), expected ); } } let chunks: Vec<_> = wire.chunks(1).collect(); assert_eq!(sanitize(&credentials, &chunks, true), expected); } } #[test] fn json_literal_del_and_c1_controls_remain_valid_in_mixed_spellings() { let credentials = ["a\u{7f}\u{85}z".into()]; let wire = "\\u0061\u{7f}\u{85}\\u007a".as_bytes(); for split in 0..=wire.len() { assert_eq!( sanitize(&credentials, &[&wire[..split], &wire[split..]], true), REPLACEMENT ); } } #[test] fn arbitrary_binary_bytes_without_matches_are_preserved_under_chunking() { let credentials = ["not-present".to_string()]; let bytes: Vec = (0..=255).collect(); for size in 1..=bytes.len() { assert_eq!( sanitize(&credentials, &bytes.chunks(size).collect::>(), true), bytes ); } } #[test] fn failed_streams_discard_unresolved_suffix_but_completion_classifies_it() { let credentials = ["credential".to_string()]; for prefix in [ b"cred".as_slice(), br"\u0063\u0072\u0065\u0064", br"\u0063\u00", ] { let chunks = [b"safe:".as_slice(), prefix]; assert_eq!(sanitize(&credentials, &chunks, false), b"safe:"); let mut expected = b"safe:".to_vec(); expected.extend_from_slice(prefix); assert_eq!(sanitize(&credentials, &chunks, true), expected); } } #[test] fn longest_match_and_overlapping_prefixes_are_chunk_independent() { let credentials = ["abc".into(), "abcdef".into(), "bc".into(), "\\".into()]; for split in 0..=12 { let wire = br"abcdef abc\\"; assert_eq!( sanitize(&credentials, &[&wire[..split], &wire[split..]], true), b" " ); } } #[test] fn bounds_are_finite_and_diagnostics_do_not_contain_inputs() { for credentials in [ vec!["private".into(); CREDENTIAL_COUNT_MAX + 1], vec!["x".repeat(CREDENTIAL_BYTES_MAX + 1)], vec!["x".repeat(CREDENTIAL_BYTES_MAX); 9], vec![String::new()], ] { let error = ResponseSanitizer::new(&credentials, REPLACEMENT) .err() .unwrap(); assert_eq!(error, "response sanitizer credential bounds exceeded"); } let credentials = ["a".repeat(CREDENTIAL_BYTES_MAX)]; let encoded = "\\u0061".repeat(CREDENTIAL_BYTES_MAX); let mut sanitizer = ResponseSanitizer::new(&credentials, REPLACEMENT).unwrap(); assert!( sanitizer .push(&encoded.as_bytes()[..encoded.len() - 1]) .unwrap() .is_empty() ); assert_eq!(sanitizer.carry.len(), CARRY_BYTES_MAX - 1); assert_eq!(sanitizer.push(b"1").unwrap(), REPLACEMENT); assert!(sanitizer.finish().is_empty()); } fn empty_dictionary_allocates_only_returned_bytes() { let (output, cost) = smith_alloc::measure(smith_alloc::Scope::KernelCall, || { let mut sanitizer = ResponseSanitizer::new(&[], REPLACEMENT).unwrap(); let output = sanitizer.push(b"public!").unwrap(); assert!(sanitizer.finish().is_empty()); output }); assert_eq!(output, b"public!"); assert_eq!(cost.allocations, 1); assert_eq!(cost.bytes, 7); } #[cfg(target_arch = "x86_64")] fn large_dictionary_layout_and_allocation_cost_are_exact() { assert_eq!(std::mem::size_of::(), 184); assert_eq!(std::mem::size_of::(), 1); let credentials: Vec = (0..8) .map(|index| format!("{}{:02}", "a".repeat(4094), index)) .collect(); let (mut sanitizer, construction) = smith_alloc::measure(smith_alloc::Scope::KernelCall, || { ResponseSanitizer::new(&credentials, REPLACEMENT).unwrap() }); let wire = vec![b'a'; 4096]; let (output, streaming) = smith_alloc::measure(smith_alloc::Scope::KernelCall, || { let mut output = sanitizer.push(&wire).unwrap(); output.extend(sanitizer.finish()); output }); assert_eq!(output, wire); assert_eq!(construction.allocations, 33); assert_eq!(construction.bytes, 3_092_912); assert_eq!(construction.peak, 2_654_428); assert_eq!(streaming.allocations, 15); assert_eq!(streaming.bytes, 53_308); assert_eq!(streaming.peak, 45_124); } #[test] fn request_layout_and_allocation_cost_are_exact() { empty_dictionary_allocates_only_returned_bytes(); #[cfg(target_arch = "x86_64")] large_dictionary_layout_and_allocation_cost_are_exact(); #[cfg(target_arch = "x86_64")] assert_eq!(std::mem::size_of::>(), 64); let credentials = ["credential".into()]; let (output, cost) = smith_alloc::measure(smith_alloc::Scope::KernelCall, || { let mut sanitizer = ResponseSanitizer::new(&credentials, REPLACEMENT).unwrap(); let output = sanitizer.push(b"public!").unwrap(); assert!(sanitizer.finish().is_empty()); output }); assert_eq!(output, b"public!"); assert_eq!(cost.allocations, 2); assert_eq!(cost.bytes, 16); } }