lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README

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 }