writer.rs (6687B)
1 use super::{TERMS_MAX_BYTES, TermsWireError}; 2 use alloc::{string::String, vec::Vec}; 3 use core::{fmt, fmt::Write as _}; 4 use serde::Serialize; 5 use serde_json::Value; 6 use zeroize::{Zeroize as _, Zeroizing}; 7 8 pub(crate) struct Writer { 9 length: usize, 10 output: Option<Zeroizing<String>>, 11 } 12 impl Writer { 13 pub(crate) const fn counting() -> Self { 14 Self { 15 length: 0, 16 output: None, 17 } 18 } 19 pub(crate) fn emitting(length: usize) -> Self { 20 Self { 21 length: 0, 22 output: Some(Zeroizing::new(String::with_capacity(length))), 23 } 24 } 25 pub(crate) const fn len(&self) -> usize { 26 self.length 27 } 28 pub(crate) fn finish(self) -> Result<Zeroizing<String>, TermsWireError> { 29 self.output.ok_or(TermsWireError::InvalidInput) 30 } 31 pub(crate) fn raw(&mut self, value: &str) -> Result<(), TermsWireError> { 32 let length = self 33 .length 34 .checked_add(value.len()) 35 .filter(|length| *length <= TERMS_MAX_BYTES) 36 .ok_or(TermsWireError::LimitExceeded)?; 37 if let Some(output) = &mut self.output { 38 output.push_str(value); 39 } 40 self.length = length; 41 Ok(()) 42 } 43 pub(crate) fn string(&mut self, value: &str) -> Result<(), TermsWireError> { 44 self.raw("\"")?; 45 const HEX: &[u8; 16] = b"0123456789abcdef"; 46 for ch in value.chars() { 47 match ch { 48 '"' => self.raw("\\\"")?, 49 '\\' => self.raw("\\\\")?, 50 '\n' => self.raw("\\n")?, 51 '\r' => self.raw("\\r")?, 52 '\t' => self.raw("\\t")?, 53 '\u{08}' => self.raw("\\b")?, 54 '\u{0c}' => self.raw("\\f")?, 55 '\0'..='\u{1f}' => { 56 let byte = ch as u8; 57 let mut escaped = [ 58 b'\\', 59 b'u', 60 b'0', 61 b'0', 62 HEX[(byte >> 4) as usize], 63 HEX[(byte & 15) as usize], 64 ]; 65 let text = 66 core::str::from_utf8(&escaped).map_err(|_| TermsWireError::InvalidInput)?; 67 let result = self.raw(text); 68 escaped.zeroize(); 69 result?; 70 } 71 _ => { 72 let mut encoded = [0; 4]; 73 let result = self.raw(ch.encode_utf8(&mut encoded)); 74 encoded.zeroize(); 75 result?; 76 } 77 } 78 } 79 self.raw("\"") 80 } 81 pub(crate) fn exact_string(&mut self, value: impl fmt::Display) -> Result<(), TermsWireError> { 82 self.raw("\"")?; 83 write!(self, "{value}").map_err(|_| TermsWireError::LimitExceeded)?; 84 self.raw("\"") 85 } 86 pub(crate) fn integer(&mut self, value: u16) -> Result<(), TermsWireError> { 87 write!(self, "{value}").map_err(|_| TermsWireError::LimitExceeded) 88 } 89 pub(crate) fn optional_string(&mut self, value: Option<&str>) -> Result<(), TermsWireError> { 90 match value { 91 Some(value) => self.string(value), 92 None => self.raw("null"), 93 } 94 } 95 // Only explicitly public listing snapshots enter this temporary JSON tree. 96 // Private fulfillment, lot labels, agreed prices and risk disclosures use 97 // the bounded zeroizing writer directly. 98 pub(crate) fn public_snapshot<T: Serialize>( 99 &mut self, 100 value: &T, 101 ) -> Result<(), TermsWireError> { 102 self.value(&serde_json::to_value(value).map_err(|_| TermsWireError::InvalidInput)?) 103 } 104 fn value(&mut self, value: &Value) -> Result<(), TermsWireError> { 105 match value { 106 Value::Object(fields) => { 107 let mut keys: Vec<_> = fields.keys().collect(); 108 if keys.iter().any(|key| !key.is_ascii()) { 109 return Err(TermsWireError::InvalidInput); 110 } 111 keys.sort_unstable(); 112 self.raw("{")?; 113 for (index, key) in keys.into_iter().enumerate() { 114 if index != 0 { 115 self.raw(",")?; 116 } 117 self.string(key)?; 118 self.raw(":")?; 119 self.value(&fields[key])?; 120 } 121 self.raw("}") 122 } 123 Value::Array(values) => { 124 self.raw("[")?; 125 for (index, value) in values.iter().enumerate() { 126 if index != 0 { 127 self.raw(",")?; 128 } 129 self.value(value)?; 130 } 131 self.raw("]") 132 } 133 Value::String(value) => self.string(value), 134 Value::Number(value) => { 135 let number = value 136 .as_u64() 137 .filter(|value| *value <= 9_007_199_254_740_991) 138 .ok_or(TermsWireError::InvalidInput)?; 139 write!(self, "{number}").map_err(|_| TermsWireError::LimitExceeded) 140 } 141 Value::Bool(true) => self.raw("true"), 142 Value::Bool(false) => self.raw("false"), 143 Value::Null => self.raw("null"), 144 } 145 } 146 } 147 impl fmt::Write for Writer { 148 fn write_str(&mut self, text: &str) -> fmt::Result { 149 self.raw(text).map_err(|_| fmt::Error) 150 } 151 } 152 153 #[cfg(test)] 154 mod tests { 155 use super::*; 156 use serde_json::json; 157 158 #[test] 159 fn canonical_subset_preserves_literals_safe_integers_strings_and_sorted_keys() { 160 let input = json!({"z":"é🧺\0\n\"\\","a":[true,false,null,9_007_199_254_740_991u64]}); 161 let mut count = Writer::counting(); 162 count.public_snapshot(&input).unwrap(); 163 let mut output = Writer::emitting(count.len()); 164 output.public_snapshot(&input).unwrap(); 165 let wire = output.finish().unwrap(); 166 assert_eq!( 167 wire.as_str(), 168 r#"{"a":[true,false,null,9007199254740991],"z":"é🧺\u0000\n\"\\"}"# 169 ); 170 assert_eq!(wire.len(), count.len()); 171 assert_eq!(serde_json::from_str::<Value>(&wire).unwrap(), input); 172 } 173 174 #[test] 175 fn canonical_subset_refuses_unknown_field_alphabet_and_unsafe_numeric_types() { 176 for input in [ 177 json!({"é":1}), 178 json!(-1), 179 json!(0.5), 180 json!(9_007_199_254_740_992u64), 181 ] { 182 assert_eq!( 183 Writer::counting().public_snapshot(&input), 184 Err(TermsWireError::InvalidInput) 185 ); 186 } 187 } 188 }