lib

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

json.rs (5939B)


      1 use core::{fmt, marker::PhantomData};
      2 use serde::{
      3     Deserialize, Deserializer,
      4     de::{self, SeqAccess, Visitor},
      5 };
      6 use serde_json::value::RawValue;
      7 
      8 // Allocation-free structural preflight, followed by the actual closed serde
      9 // codec. Fixed identifier arrays contain 32 bytes; descriptor lists use the
     10 // stricter sixteen-element visitor below.
     11 pub(in crate::workspace) fn bounded(raw: &[u8], array_limit: usize) -> bool {
     12     let mut stack = [(0u8, false, 0usize); 16];
     13     let mut depth = 0usize;
     14     let mut quoted = false;
     15     let mut escaped = false;
     16     for byte in raw.iter().copied() {
     17         if quoted {
     18             if escaped {
     19                 escaped = false;
     20             } else if byte == b'\\' {
     21                 escaped = true;
     22             } else if byte == b'"' {
     23                 quoted = false;
     24             }
     25             continue;
     26         }
     27         if byte.is_ascii_whitespace() || byte == b':' {
     28             continue;
     29         }
     30         if byte == b',' {
     31             if depth > 0 && stack[depth - 1].0 == b'[' {
     32                 stack[depth - 1].1 = true;
     33             }
     34             continue;
     35         }
     36         if matches!(byte, b'}' | b']') {
     37             if depth == 0 {
     38                 return false;
     39             }
     40             depth -= 1;
     41             if stack[depth].0 != if byte == b'}' { b'{' } else { b'[' } {
     42                 return false;
     43             }
     44             continue;
     45         }
     46         if depth > 0 && stack[depth - 1].0 == b'[' && stack[depth - 1].1 {
     47             stack[depth - 1].2 += 1;
     48             stack[depth - 1].1 = false;
     49             if stack[depth - 1].2 > array_limit {
     50                 return false;
     51             }
     52         }
     53         if matches!(byte, b'{' | b'[') {
     54             if depth == stack.len() {
     55                 return false;
     56             }
     57             stack[depth] = (byte, byte == b'[', 0);
     58             depth += 1;
     59         } else if byte == b'"' {
     60             quoted = true;
     61         }
     62     }
     63     !quoted && !escaped && depth == 0
     64 }
     65 
     66 pub(in crate::workspace) fn small_vec<'de, D, T>(deserializer: D) -> Result<Vec<T>, D::Error>
     67 where
     68     D: Deserializer<'de>,
     69     T: Deserialize<'de>,
     70 {
     71     struct Items<T>(PhantomData<T>);
     72     impl<'de, T: Deserialize<'de>> Visitor<'de> for Items<T> {
     73         type Value = Vec<T>;
     74         fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
     75             f.write_str("at most sixteen bounded entries")
     76         }
     77         fn visit_seq<A: SeqAccess<'de>>(self, mut sequence: A) -> Result<Self::Value, A::Error> {
     78             let mut result = Vec::with_capacity(sequence.size_hint().unwrap_or(0).min(16));
     79             while let Some(raw) = sequence.next_element::<&'de RawValue>()? {
     80                 if result.len() == 16 || raw.get().len() > 16384 {
     81                     return Err(de::Error::custom("private delivery entry limit"));
     82                 }
     83                 result.push(serde_json::from_str(raw.get()).map_err(de::Error::custom)?);
     84             }
     85             Ok(result)
     86         }
     87     }
     88     deserializer.deserialize_seq(Items(PhantomData))
     89 }
     90 
     91 pub(in crate::workspace) fn targets<'de, D: Deserializer<'de>>(
     92     deserializer: D,
     93 ) -> Result<radroots_transport::TargetSet, D::Error> {
     94     #[derive(Deserialize)]
     95     #[serde(deny_unknown_fields)]
     96     struct Wire {
     97         #[serde(deserialize_with = "small_vec")]
     98         targets: Vec<radroots_transport::Target>,
     99     }
    100     let wire = Wire::deserialize(deserializer)?;
    101     radroots_transport::TargetSet::new(wire.targets).map_err(de::Error::custom)
    102 }
    103 
    104 pub(in crate::workspace) fn policy<'de, D: Deserializer<'de>>(
    105     deserializer: D,
    106 ) -> Result<radroots_transport::policy::SatisfactionPolicy, D::Error> {
    107     let raw = <&RawValue>::deserialize(deserializer)?;
    108     if raw.get().len() > 16384 || !bounded(raw.get().as_bytes(), 16) {
    109         return Err(de::Error::custom("private delivery policy limit"));
    110     }
    111     serde_json::from_str(raw.get()).map_err(de::Error::custom)
    112 }
    113 
    114 #[cfg(test)]
    115 mod tests {
    116     use super::*;
    117     #[test]
    118     fn structural_preflight_and_typed_lists_bound_untrusted_private_records() {
    119         for raw in [
    120             br#"{"a":["escaped\\\"[]",null,{}]}"#.as_slice(),
    121             b"[]",
    122             b"{}",
    123             br#"{"a":1,"b":2}"#,
    124             b"[ [1], [2] ]",
    125         ] {
    126             assert!(bounded(raw, 3));
    127         }
    128         for raw in [
    129             b"]".as_slice(),
    130             b"[}",
    131             b"\"unfinished",
    132             b"\"escape\\",
    133             b"[1,2,3]",
    134             b"[[1]",
    135         ] {
    136             assert!(!bounded(raw, 2));
    137         }
    138         assert!(!bounded(
    139             format!("{}0{}", "[".repeat(17), "]".repeat(17)).as_bytes(),
    140             32
    141         ));
    142         #[derive(Deserialize)]
    143         struct List {
    144             #[serde(deserialize_with = "small_vec")]
    145             items: Vec<String>,
    146         }
    147         let accepted: List = serde_json::from_str(r#"{"items":["one","two"]}"#).unwrap();
    148         assert_eq!(accepted.items, ["one", "two"]);
    149         for value in [
    150             serde_json::json!({"items":vec!["item";17]}),
    151             serde_json::json!({"items":["x".repeat(16385)]}),
    152             serde_json::json!({"items":false}),
    153         ] {
    154             assert!(serde_json::from_str::<List>(&value.to_string()).is_err());
    155         }
    156         #[derive(Deserialize)]
    157         struct Policy {
    158             #[serde(deserialize_with = "policy")]
    159             value: radroots_transport::policy::SatisfactionPolicy,
    160         }
    161         let raw = serde_json::json!({"value":{"class":"accepted","targets":"all"}}).to_string();
    162         let decoded = serde_json::from_str::<Policy>(&raw).unwrap();
    163         assert!(decoded.value.targets().is_all());
    164         for raw in [
    165             format!("{{\"value\":\"{}\"}}", "x".repeat(16385)),
    166             format!("{{\"value\":[{}]}}", vec!["0"; 17].join(",")),
    167             String::from("{\"value\":false}"),
    168         ] {
    169             assert!(serde_json::from_str::<Policy>(&raw).is_err());
    170         }
    171     }
    172 }