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 }