lib

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

json.rs (3726B)


      1 //! Bounded host-private metadata parsing, followed by checked shared models.
      2 use core::{fmt, marker::PhantomData};
      3 use serde::{
      4     Deserialize, Deserializer,
      5     de::{self, SeqAccess, Visitor},
      6 };
      7 use serde_json::value::RawValue;
      8 
      9 pub(super) fn bounded(raw: &[u8], array_limit: usize) -> bool {
     10     let mut stack = [(0u8, false, 0usize); 16];
     11     let (mut depth, mut quoted, mut escaped) = (0, false, false);
     12     for byte in raw.iter().copied() {
     13         if quoted {
     14             if escaped {
     15                 escaped = false;
     16             } else if byte == b'\\' {
     17                 escaped = true;
     18             } else if byte == b'"' {
     19                 quoted = false;
     20             }
     21             continue;
     22         }
     23         if byte.is_ascii_whitespace() || byte == b':' {
     24             continue;
     25         }
     26         if byte == b',' {
     27             if depth > 0 && stack[depth - 1].0 == b'[' {
     28                 stack[depth - 1].1 = true;
     29             }
     30             continue;
     31         }
     32         if matches!(byte, b'}' | b']') {
     33             if depth == 0 {
     34                 return false;
     35             }
     36             depth -= 1;
     37             if stack[depth].0 != if byte == b'}' { b'{' } else { b'[' } {
     38                 return false;
     39             }
     40             continue;
     41         }
     42         if depth > 0 && stack[depth - 1].0 == b'[' && stack[depth - 1].1 {
     43             stack[depth - 1].2 += 1;
     44             stack[depth - 1].1 = false;
     45             if stack[depth - 1].2 > array_limit {
     46                 return false;
     47             }
     48         }
     49         if matches!(byte, b'{' | b'[') {
     50             if depth == stack.len() {
     51                 return false;
     52             }
     53             stack[depth] = (byte, byte == b'[', 0);
     54             depth += 1;
     55         } else if byte == b'"' {
     56             quoted = true;
     57         }
     58     }
     59     !quoted && !escaped && depth == 0
     60 }
     61 pub(super) fn small_vec<'de, D, T>(deserializer: D) -> Result<Vec<T>, D::Error>
     62 where
     63     D: Deserializer<'de>,
     64     T: Deserialize<'de>,
     65 {
     66     struct Items<T>(PhantomData<T>);
     67     impl<'de, T: Deserialize<'de>> Visitor<'de> for Items<T> {
     68         type Value = Vec<T>;
     69         fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
     70             f.write_str("at most sixteen bounded entries")
     71         }
     72         fn visit_seq<A: SeqAccess<'de>>(self, mut sequence: A) -> Result<Self::Value, A::Error> {
     73             let mut result = Vec::with_capacity(sequence.size_hint().unwrap_or(0).min(16));
     74             while let Some(raw) = sequence.next_element::<&'de RawValue>()? {
     75                 if result.len() == 16 || raw.get().len() > 16384 {
     76                     return Err(de::Error::custom("private delivery entry limit"));
     77                 }
     78                 result.push(serde_json::from_str(raw.get()).map_err(de::Error::custom)?);
     79             }
     80             Ok(result)
     81         }
     82     }
     83     deserializer.deserialize_seq(Items(PhantomData))
     84 }
     85 pub(super) fn targets<'de, D: Deserializer<'de>>(
     86     deserializer: D,
     87 ) -> Result<radroots_transport::TargetSet, D::Error> {
     88     #[derive(Deserialize)]
     89     #[serde(deny_unknown_fields)]
     90     struct Wire {
     91         #[serde(deserialize_with = "small_vec")]
     92         targets: Vec<radroots_transport::Target>,
     93     }
     94     let wire = Wire::deserialize(deserializer)?;
     95     radroots_transport::TargetSet::new(wire.targets).map_err(de::Error::custom)
     96 }
     97 pub(super) fn policy<'de, D: Deserializer<'de>>(
     98     deserializer: D,
     99 ) -> Result<radroots_transport::policy::SatisfactionPolicy, D::Error> {
    100     let raw = <&RawValue>::deserialize(deserializer)?;
    101     if raw.get().len() > 16384 || !bounded(raw.get().as_bytes(), 16) {
    102         return Err(de::Error::custom("private delivery policy limit"));
    103     }
    104     serde_json::from_str(raw.get()).map_err(de::Error::custom)
    105 }