1use super::{Zeroize, ZeroizeOnDrop, Zeroizing};
3use alloc::{boxed::Box, collections::BTreeMap};
4use core::{borrow::Borrow, fmt};
5
6#[doc(hidden)]
9pub struct MapKey<K: Zeroize>(Box<Zeroizing<K>>);
10impl<K: Zeroize> core::ops::Deref for MapKey<K> {
11 type Target = K;
12 fn deref(&self) -> &K {
13 &self.0
14 }
15}
16impl<K: Zeroize + PartialEq> PartialEq for MapKey<K> {
17 fn eq(&self, other: &Self) -> bool {
18 **self == **other
19 }
20}
21impl<K: Zeroize + Eq> Eq for MapKey<K> {}
22impl<K: Zeroize + PartialOrd> PartialOrd for MapKey<K> {
23 fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
24 (**self).partial_cmp(&**other)
25 }
26}
27impl<K: Zeroize + Ord> Ord for MapKey<K> {
28 fn cmp(&self, other: &Self) -> core::cmp::Ordering {
29 (**self).cmp(&**other)
30 }
31}
32impl<K: Zeroize> Borrow<K> for MapKey<K> {
33 fn borrow(&self) -> &K {
34 self
35 }
36}
37impl<K: Zeroize + Borrow<str>> Borrow<str> for MapKey<K> {
38 fn borrow(&self) -> &str {
39 K::borrow(self)
40 }
41}
42impl<K: Zeroize + Borrow<[u8]>> Borrow<[u8]> for MapKey<K> {
43 fn borrow(&self) -> &[u8] {
44 K::borrow(self)
45 }
46}
47
48pub struct Map<K: Zeroize, V: Zeroize>(BTreeMap<MapKey<K>, Box<Zeroizing<V>>>);
58impl<K: Zeroize, V: Zeroize> Default for Map<K, V> {
59 fn default() -> Self {
60 Self(BTreeMap::new())
61 }
62}
63impl<K: Zeroize, V: Zeroize> Map<K, V> {
64 pub fn len(&self) -> usize {
66 self.0.len()
67 }
68 pub fn is_empty(&self) -> bool {
70 self.0.is_empty()
71 }
72 pub fn iter(&self) -> Iter<'_, K, V> {
74 Iter {
75 inner: self.0.iter(),
76 }
77 }
78 pub fn keys(&self) -> impl DoubleEndedIterator<Item = &K> + ExactSizeIterator {
80 self.0.keys().map(|key| &**key)
81 }
82 pub fn values(&self) -> impl DoubleEndedIterator<Item = &V> + ExactSizeIterator {
84 self.0.values().map(|value| &***value)
85 }
86 pub fn values_mut(&mut self) -> impl DoubleEndedIterator<Item = &mut V> + ExactSizeIterator {
88 self.0.values_mut().map(|value| &mut ***value)
89 }
90 pub fn clear(&mut self) {
92 self.0.clear();
93 }
94}
95impl<K: Zeroize + Ord, V: Zeroize> Map<K, V> {
96 pub fn insert(&mut self, key: K, value: V) {
98 self.0.insert(
99 MapKey(Box::new(Zeroizing::new(key))),
100 Box::new(Zeroizing::new(value)),
101 );
102 }
103 pub fn get<Q: Ord + ?Sized>(&self, key: &Q) -> Option<&V>
105 where
106 MapKey<K>: Borrow<Q>,
107 {
108 self.0.get(key).map(|value| &***value)
109 }
110 pub fn get_mut<Q: Ord + ?Sized>(&mut self, key: &Q) -> Option<&mut V>
112 where
113 MapKey<K>: Borrow<Q>,
114 {
115 self.0.get_mut(key).map(|value| &mut ***value)
116 }
117}
118impl<K: Zeroize, V: Zeroize> Zeroize for Map<K, V> {
119 fn zeroize(&mut self) {
120 self.clear();
121 }
122}
123impl<K: Zeroize, V: Zeroize> Drop for Map<K, V> {
124 fn drop(&mut self) {
125 self.zeroize();
126 }
127}
128impl<K: Zeroize, V: Zeroize> ZeroizeOnDrop for Map<K, V> {}
129impl<K: Zeroize + Ord + Clone, V: Zeroize + Clone> Clone for Map<K, V> {
130 fn clone(&self) -> Self {
131 self.iter().map(|(k, v)| (k.clone(), v.clone())).collect()
132 }
133}
134impl<K: Zeroize + Ord, V: Zeroize + PartialEq> PartialEq for Map<K, V> {
135 fn eq(&self, other: &Self) -> bool {
136 self.len() == other.len()
137 && self
138 .iter()
139 .all(|(key, value)| other.get(key) == Some(value))
140 }
141}
142impl<K: Zeroize + Ord, V: Zeroize + Eq> Eq for Map<K, V> {}
143impl<K: Zeroize, V: Zeroize> fmt::Debug for Map<K, V> {
144 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
145 f.write_str("Map([REDACTED])")
146 }
147}
148impl<K: Zeroize + Ord, V: Zeroize> FromIterator<(K, V)> for Map<K, V> {
149 fn from_iter<I: IntoIterator<Item = (K, V)>>(iter: I) -> Self {
150 let mut map = Self::default();
151 for (k, v) in iter {
152 map.insert(k, v);
153 }
154 map
155 }
156}
157impl<K: Zeroize + Ord, V: Zeroize> crate::map_codec::MapStorage for Map<K, V> {
158 type Key = K;
159 type Value = V;
160 fn storage_len(&self) -> usize {
161 self.len()
162 }
163 fn storage_insert(&mut self, key: K, value: V) {
164 self.insert(key, value);
165 }
166 fn storage_clear(&mut self) {
167 self.clear();
168 }
169 fn storage_erase_key(key: &mut K) {
170 key.zeroize();
171 }
172 fn storage_erase_value(value: &mut V) {
173 value.zeroize();
174 }
175 fn storage_iter<'a>(&'a self) -> impl Iterator<Item = (&'a K, &'a V)>
176 where
177 K: 'a,
178 V: 'a,
179 {
180 self.iter()
181 }
182}
183pub struct Iter<'a, K: Zeroize, V: Zeroize> {
185 inner: alloc::collections::btree_map::Iter<'a, MapKey<K>, Box<Zeroizing<V>>>,
186}
187impl<'a, K: Zeroize, V: Zeroize> Iterator for Iter<'a, K, V> {
188 type Item = (&'a K, &'a V);
189 fn next(&mut self) -> Option<Self::Item> {
190 self.inner.next().map(|(key, value)| (&**key, &***value))
191 }
192 fn size_hint(&self) -> (usize, Option<usize>) {
193 self.inner.size_hint()
194 }
195}
196impl<K: Zeroize, V: Zeroize> DoubleEndedIterator for Iter<'_, K, V> {
197 fn next_back(&mut self) -> Option<Self::Item> {
198 self.inner
199 .next_back()
200 .map(|(key, value)| (&**key, &***value))
201 }
202}
203impl<K: Zeroize, V: Zeroize> ExactSizeIterator for Iter<'_, K, V> {}
204impl<K: Zeroize, V: Zeroize> core::iter::FusedIterator for Iter<'_, K, V> {}
205impl<'a, K: Zeroize, V: Zeroize> IntoIterator for &'a Map<K, V> {
206 type Item = (&'a K, &'a V);
207 type IntoIter = Iter<'a, K, V>;
208 fn into_iter(self) -> Self::IntoIter {
209 self.iter()
210 }
211}
212#[cfg(feature = "json")]
213impl<K: Zeroize + serde::Serialize, V: Zeroize + serde::Serialize> serde::Serialize for Map<K, V> {
214 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
215 use serde::ser::SerializeMap;
216 let mut map = serializer.serialize_map(Some(self.len()))?;
217 for (k, v) in self.iter() {
218 map.serialize_entry(k, v)?;
219 }
220 map.end()
221 }
222}
223#[cfg(feature = "json")]
224impl<'de, K: Zeroize + Ord + serde::Deserialize<'de>, V: Zeroize + serde::Deserialize<'de>>
225 serde::Deserialize<'de> for Map<K, V>
226{
227 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
228 struct Visitor<K, V>(core::marker::PhantomData<(K, V)>);
229 impl<
230 'de,
231 K: Zeroize + Ord + serde::Deserialize<'de>,
232 V: Zeroize + serde::Deserialize<'de>,
233 > serde::de::Visitor<'de> for Visitor<K, V>
234 {
235 type Value = Map<K, V>;
236 fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
237 f.write_str("an object")
238 }
239 fn visit_map<A: serde::de::MapAccess<'de>>(
240 self,
241 mut access: A,
242 ) -> Result<Self::Value, A::Error> {
243 let mut map = Map::default();
244 while let Some(key) = access.next_key::<K>()? {
245 let key = Zeroizing::new(key);
246 let value = access.next_value()?;
247 map.0
248 .insert(MapKey(Box::new(key)), Box::new(Zeroizing::new(value)));
249 }
250 Ok(map)
251 }
252 crate::reject_other_json_kinds!(
253 bool, i64, u64, i128, u128, f64, str, string, bytes, byte_buf, unit, seq
254 );
255 }
256 if deserializer.is_human_readable() {
259 deserializer.deserialize_any(Visitor(core::marker::PhantomData))
260 } else {
261 deserializer.deserialize_map(Visitor(core::marker::PhantomData))
262 }
263 }
264}
265
266#[cfg(test)]
267mod tests {
268 use super::*;
269 use alloc::string::String;
270 use core::sync::atomic::{AtomicUsize, Ordering};
271 static ERASED: AtomicUsize = AtomicUsize::new(0);
272 #[derive(Clone)]
273 struct Counted(u64);
274 impl Zeroize for Counted {
275 fn zeroize(&mut self) {
276 self.0.zeroize();
277 ERASED.fetch_add(1, Ordering::SeqCst);
278 }
279 }
280 #[test]
281 fn stable_values_are_wiped_on_replacement_clear_and_drop() {
282 ERASED.store(0, Ordering::SeqCst);
283 let mut map = Map::<String, Counted>::default();
284 map.insert("key".into(), Counted(42));
285 let address = map.get("key").unwrap() as *const Counted;
286 for n in 0..100 {
287 map.insert(alloc::format!("other-{n}"), Counted(n));
288 }
289 assert_eq!(address, map.get("key").unwrap() as *const Counted);
290 map.insert("key".into(), Counted(43));
291 assert_eq!(ERASED.load(Ordering::SeqCst), 1);
292 map.get_mut("key").unwrap().0 = 44;
293 map.clear();
294 assert!(map.is_empty());
295 assert_eq!(ERASED.load(Ordering::SeqCst), 102);
296 map.insert("key".into(), Counted(45));
297 drop(map);
298 assert_eq!(ERASED.load(Ordering::SeqCst), 103);
299 }
300 #[cfg(feature = "json")]
301 #[test]
302 fn native_serde_handles_duplicates_and_invalid_values() {
303 let map: Map<String, u64> = serde_json::from_str(r#"{"key":1,"key":2}"#).unwrap();
304 assert_eq!(map.get("key"), Some(&2));
305 assert_eq!(serde_json::to_string(&map).unwrap(), r#"{"key":2}"#);
306 assert!(serde_json::from_str::<Map<String, u64>>(r#"{"key":1,"bad":[]}"#).is_err());
307 }
308}