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 }