1use proof_core::{ErrorCode, Limits, ProofError};
8
9#[derive(Debug, Clone, PartialEq, Eq)]
11pub enum CborValue {
12 Uint(u64),
13 Nint(i64), Text(String),
15 Bytes(Vec<u8>),
16 Array(Vec<CborValue>),
17 Map(Vec<(CborValue, CborValue)>),
18 Bool(bool),
19 Null,
20}
21
22impl CborValue {
23 fn sort_maps(&mut self) {
24 match self {
25 Self::Array(items) => {
26 for i in items.iter_mut() {
27 i.sort_maps();
28 }
29 }
30 Self::Map(pairs) => {
31 for (k, v) in pairs.iter_mut() {
32 k.sort_maps();
33 v.sort_maps();
34 }
35 pairs.sort_by_key(|a| encode_canonical(&a.0));
36 }
37 _ => {}
38 }
39 }
40}
41
42fn encode_head(major: u8, n: u64, out: &mut Vec<u8>) {
45 debug_assert!(major < 8);
46 let prefix = major << 5;
47 if n < 24 {
48 out.push(prefix | n as u8);
49 } else if n <= u8::MAX as u64 {
50 out.push(prefix | 24);
51 out.push(n as u8);
52 } else if n <= u16::MAX as u64 {
53 out.push(prefix | 25);
54 out.extend_from_slice(&(n as u16).to_be_bytes());
55 } else if n <= u32::MAX as u64 {
56 out.push(prefix | 26);
57 out.extend_from_slice(&(n as u32).to_be_bytes());
58 } else {
59 out.push(prefix | 27);
60 out.extend_from_slice(&n.to_be_bytes());
61 }
62}
63
64fn encode_value(v: &CborValue, out: &mut Vec<u8>) {
66 match v {
67 CborValue::Uint(n) => encode_head(0, *n, out),
68 CborValue::Nint(n) => {
69 debug_assert!(*n < 0, "CborValue::Nint must be negative");
72 let arg = (-1i128 - (*n as i128)) as u64;
74 encode_head(1, arg, out);
75 }
76 CborValue::Bytes(b) => {
77 encode_head(2, b.len() as u64, out);
78 out.extend_from_slice(b);
79 }
80 CborValue::Text(s) => {
81 encode_head(3, s.len() as u64, out);
82 out.extend_from_slice(s.as_bytes());
83 }
84 CborValue::Array(items) => {
85 encode_head(4, items.len() as u64, out);
86 for i in items {
87 encode_value(i, out);
88 }
89 }
90 CborValue::Map(pairs) => {
91 let mut enc_keys: Vec<(Vec<u8>, &CborValue, &CborValue)> = pairs
93 .iter()
94 .map(|(k, val)| {
95 let mut kb = Vec::new();
96 encode_value(k, &mut kb);
97 (kb, k, val)
98 })
99 .collect();
100 enc_keys.sort_by(|a, b| a.0.cmp(&b.0));
101 encode_head(5, pairs.len() as u64, out);
102 for (kb, _, val) in enc_keys {
103 out.extend_from_slice(&kb);
104 encode_value(val, out);
105 }
106 }
107 CborValue::Bool(true) => out.push(0xf5),
108 CborValue::Bool(false) => out.push(0xf4),
109 CborValue::Null => out.push(0xf6),
110 }
111}
112
113pub fn encode_canonical(v: &CborValue) -> Vec<u8> {
115 let mut out = Vec::new();
116 encode_value(v, &mut out);
117 out
118}
119
120struct Decoder<'a> {
123 buf: &'a [u8],
124 pos: usize,
125 depth: usize,
126 limits: Limits,
127}
128
129impl<'a> Decoder<'a> {
130 fn eof(&self) -> bool {
131 self.pos >= self.buf.len()
132 }
133
134 fn read(&mut self, n: usize) -> Result<&'a [u8], ProofError> {
135 if self.pos.checked_add(n).is_none_or(|e| e > self.buf.len()) {
136 return Err(ErrorCode::Malformed.err("truncated CBOR input"));
137 }
138 let s = &self.buf[self.pos..self.pos + n];
139 self.pos += n;
140 Ok(s)
141 }
142
143 fn read_arg(&mut self, ai: u8) -> Result<u64, ProofError> {
144 match ai {
145 n @ 0..=23 => Ok(n as u64),
146 24 => {
147 let b = self.read(1)?[0];
148 if b < 24 {
150 return Err(ErrorCode::NonCanonical.err("non-shortest int encoding (ai=24)"));
151 }
152 Ok(b as u64)
153 }
154 25 => {
155 let b = self.read(2)?;
156 let v = u16::from_be_bytes([b[0], b[1]]) as u64;
157 if v <= u8::MAX as u64 {
158 return Err(ErrorCode::NonCanonical.err("non-shortest int encoding (ai=25)"));
159 }
160 Ok(v)
161 }
162 26 => {
163 let b = self.read(4)?;
164 let v = u32::from_be_bytes([b[0], b[1], b[2], b[3]]) as u64;
165 if v <= u16::MAX as u64 {
166 return Err(ErrorCode::NonCanonical.err("non-shortest int encoding (ai=26)"));
167 }
168 Ok(v)
169 }
170 27 => {
171 let b = self.read(8)?;
172 let v = u64::from_be_bytes([b[0], b[1], b[2], b[3], b[4], b[5], b[6], b[7]]);
173 if v <= u32::MAX as u64 {
174 return Err(ErrorCode::NonCanonical.err("non-shortest int encoding (ai=27)"));
175 }
176 Ok(v)
177 }
178 28..=30 => Err(ErrorCode::ForbiddenCborConstruct.err("reserved additional info")),
179 31 => Err(ErrorCode::ForbiddenCborConstruct.err("indefinite length forbidden")),
180 _ => unreachable!(),
181 }
182 }
183
184 fn decode_value(&mut self) -> Result<CborValue, ProofError> {
186 if self.depth > self.limits.max_depth {
187 return Err(ErrorCode::LimitExceeded.err("max CBOR depth exceeded"));
188 }
189 if self.eof() {
190 return Err(ErrorCode::Malformed.err("empty CBOR input"));
191 }
192 let ib = self.read(1)?[0];
193 let major = ib >> 5;
194 let ai = ib & 0x1f;
195 match major {
196 0 => {
197 let n = self.read_arg(ai)?;
198 Ok(CborValue::Uint(n))
199 }
200 1 => {
201 let n = self.read_arg(ai)?;
202 let v = -1i128 - (n as i128);
206 if v < i64::MIN as i128 {
207 return Err(ErrorCode::ForbiddenCborConstruct
208 .err("nint out of i64 range (bignum not supported in V0.1)"));
209 }
210 Ok(CborValue::Nint(v as i64))
211 }
212 2 => {
213 let len = self.read_arg(ai)? as usize;
214 if len > self.limits.max_field_size {
215 return Err(ErrorCode::LimitExceeded.err("bytes field too large"));
216 }
217 Ok(CborValue::Bytes(self.read(len)?.to_vec()))
218 }
219 3 => {
220 let len = self.read_arg(ai)? as usize;
221 if len > self.limits.max_field_size {
222 return Err(ErrorCode::LimitExceeded.err("text field too large"));
223 }
224 let b = self.read(len)?;
225 let s = std::str::from_utf8(b)
226 .map_err(|_| ErrorCode::Malformed.err("invalid UTF-8 in text string"))?;
227 Ok(CborValue::Text(s.to_owned()))
228 }
229 4 => {
230 let len = self.read_arg(ai)? as usize;
231 if len > self.limits.max_array_items {
232 return Err(ErrorCode::LimitExceeded.err("array too large"));
233 }
234 self.depth += 1;
235 let mut items = Vec::with_capacity(len.min(32));
236 for _ in 0..len {
237 items.push(self.decode_value()?);
238 }
239 self.depth -= 1;
240 Ok(CborValue::Array(items))
241 }
242 5 => {
243 let len = self.read_arg(ai)? as usize;
244 if len > self.limits.max_map_entries {
245 return Err(ErrorCode::LimitExceeded.err("map too large"));
246 }
247 self.depth += 1;
248 let mut pairs = Vec::with_capacity(len.min(32));
249 let mut prev_key_bytes: Option<Vec<u8>> = None;
250 for _ in 0..len {
251 let k = self.decode_value()?;
252 let val = self.decode_value()?;
253 let kb = encode_canonical(&k);
255 if let Some(prev) = &prev_key_bytes {
256 if kb.as_slice() == prev.as_slice() {
257 return Err(ErrorCode::DuplicateMapKey.err("duplicate map key"));
258 }
259 if kb.as_slice() < prev.as_slice() {
260 return Err(
261 ErrorCode::NonCanonical.err("map keys not in lexicographic order")
262 );
263 }
264 }
265 prev_key_bytes = Some(kb);
266 pairs.push((k, val));
267 }
268 self.depth -= 1;
269 Ok(CborValue::Map(pairs))
270 }
271 6 => Err(ErrorCode::ForbiddenCborConstruct.err("tags forbidden in V0.1")),
272 7 => match ai {
273 20 => Ok(CborValue::Bool(false)),
274 21 => Ok(CborValue::Bool(true)),
275 22 => Ok(CborValue::Null),
276 24 => Err(ErrorCode::ForbiddenCborConstruct.err("2-byte simple values forbidden")),
277 25..=27 => Err(ErrorCode::ForbiddenCborConstruct.err("floats forbidden in V0.1")),
278 31 => {
279 Err(ErrorCode::ForbiddenCborConstruct.err("break stop code outside indefinite"))
280 }
281 _ => {
282 Err(ErrorCode::ForbiddenCborConstruct.err("simple/undefined values forbidden"))
283 }
284 },
285 _ => unreachable!(),
286 }
287 }
288}
289
290pub fn decode_strict(bytes: &[u8], limits: &Limits) -> Result<CborValue, ProofError> {
292 if bytes.len() > limits.max_proof_size {
293 return Err(ErrorCode::LimitExceeded.err("proof bytes exceed max_proof_size"));
294 }
295 let mut d = Decoder {
296 buf: bytes,
297 pos: 0,
298 depth: 0,
299 limits: *limits,
300 };
301 let v = d.decode_value()?;
302 if d.pos != bytes.len() {
303 return Err(ErrorCode::Malformed.err("trailing bytes after CBOR item"));
304 }
305 Ok(v)
306}
307
308pub fn is_canonical(bytes: &[u8], limits: &Limits) -> Result<bool, ProofError> {
310 let v = decode_strict(bytes, limits)?;
311 Ok(encode_canonical(&v) == bytes)
312}
313
314pub fn decode_and_check_canonical(bytes: &[u8], limits: &Limits) -> Result<CborValue, ProofError> {
317 let v = decode_strict(bytes, limits)?;
318 if encode_canonical(&v) != bytes {
319 return Err(ErrorCode::NonCanonical.err("bytes are not deterministic encoding"));
320 }
321 Ok(v)
322}
323
324#[allow(dead_code)]
325pub fn sorted_map(mut pairs: Vec<(CborValue, CborValue)>) -> CborValue {
326 let mut v = CborValue::Map(std::mem::take(&mut pairs));
327 v.sort_maps();
328 v
329}
330
331#[cfg(test)]
332mod tests {
337 use super::*;
338 use proof_core::{ErrorCode, Limits};
339
340 fn lim() -> Limits {
341 Limits::default()
342 }
343
344 #[test]
345 fn round_trip_primitives() {
346 let vs = vec![
347 CborValue::Uint(0),
348 CborValue::Uint(23),
349 CborValue::Uint(24),
350 CborValue::Uint(1000),
351 CborValue::Uint(u64::MAX),
352 CborValue::Nint(-1),
353 CborValue::Nint(-1000),
354 CborValue::Text("hello".into()),
355 CborValue::Text("".into()),
356 CborValue::Bytes(vec![0, 1, 2, 255]),
357 CborValue::Bool(true),
358 CborValue::Bool(false),
359 CborValue::Null,
360 CborValue::Array(vec![CborValue::Uint(1), CborValue::Text("a".into())]),
361 ];
362 for v in vs {
363 let b = encode_canonical(&v);
364 let d = decode_strict(&b, &lim()).expect("decode");
365 assert_eq!(d, v);
366 assert_eq!(encode_canonical(&d), b);
367 }
368 }
369
370 #[test]
371 fn map_keys_sorted_lexicographically() {
372 let v = CborValue::Map(vec![
374 (CborValue::Text("z".into()), CborValue::Uint(1)),
375 (CborValue::Text("aa".into()), CborValue::Uint(2)),
376 (CborValue::Uint(10), CborValue::Uint(3)),
377 ]);
378 let b = encode_canonical(&v);
379 let d = decode_strict(&b, &lim()).expect("decode");
380 match d {
382 CborValue::Map(p) => {
383 assert_eq!(p[0].0, CborValue::Uint(10));
384 assert_eq!(p[1].0, CborValue::Text("z".into()));
385 assert_eq!(p[2].0, CborValue::Text("aa".into()));
386 }
387 _ => panic!("expected map"),
388 }
389 }
390
391 #[test]
392 fn duplicate_map_key_rejected() {
393 let raw = hex::decode("a2616101616102").unwrap();
395 let e = decode_strict(&raw, &lim()).unwrap_err();
396 assert_eq!(e.code, ErrorCode::DuplicateMapKey);
397 }
398
399 #[test]
400 fn non_shortest_int_rejected() {
401 let e = decode_strict(&[0x18, 0x00], &lim()).unwrap_err();
403 assert_eq!(e.code, ErrorCode::NonCanonical);
404 let e = decode_strict(&[0x19, 0x00, 0x18], &lim()).unwrap_err();
406 assert_eq!(e.code, ErrorCode::NonCanonical);
407 }
408
409 #[test]
410 fn forbidden_constructs_rejected() {
411 let cases: &[&[u8]] = &[
414 &[
415 0xc0, 0x6a, 0x32, 0x30, 0x32, 0x30, 0x2d, 0x30, 0x31, 0x2d, 0x30, 0x31,
416 ],
417 &[0xf9, 0x3c, 0x00],
418 &[0x9f, 0x01, 0xff],
419 &[0xff],
420 &[0xf7],
421 &[0x1c, 0x00],
422 &[0xfa, 0x47, 0xc3, 0x50, 0x00], ];
424 for c in cases {
425 let e = decode_strict(c, &lim()).unwrap_err();
426 assert_eq!(
427 e.code,
428 ErrorCode::ForbiddenCborConstruct,
429 "input {:02x?}",
430 c
431 );
432 }
433 }
434
435 #[test]
436 fn trailing_bytes_and_empty_rejected() {
437 assert_eq!(
438 decode_strict(&[0x01, 0x02], &lim()).unwrap_err().code,
439 ErrorCode::Malformed
440 );
441 assert_eq!(
442 decode_strict(&[], &lim()).unwrap_err().code,
443 ErrorCode::Malformed
444 );
445 }
446
447 #[test]
448 fn invalid_utf8_rejected() {
449 let e = decode_strict(&[0x61, 0xff], &lim()).unwrap_err();
451 assert_eq!(e.code, ErrorCode::Malformed);
452 }
453
454 #[test]
456 fn text_bytes_as_given_no_normalization() {
457 let v = decode_strict(
459 &encode_canonical(&CborValue::Text("caf\u{e9}".into())),
460 &lim(),
461 )
462 .unwrap();
463 assert_eq!(v, CborValue::Text("caf\u{e9}".into()));
464 let v = decode_strict(
466 &encode_canonical(&CborValue::Text(" MixedCase ".into())),
467 &lim(),
468 )
469 .unwrap();
470 assert_eq!(v, CborValue::Text(" MixedCase ".into()));
471 }
472
473 #[test]
474 fn nfc_nfd_are_distinct_ids() {
475 let nfc_bytes = "caf\u{e9}".as_bytes(); let nfd_bytes = "cafe\u{301}".as_bytes(); assert_ne!(nfc_bytes, nfd_bytes);
480 let nfc = encode_canonical(&CborValue::Text("caf\u{e9}".into()));
481 let nfd = encode_canonical(&CborValue::Text("cafe\u{301}".into()));
482 assert_ne!(nfc, nfd, "engine never folds; distinct bytes stay distinct");
483 let id_nfc = proof_crypto_id_shim(&nfc);
485 let id_nfd = proof_crypto_id_shim(&nfd);
486 assert_ne!(id_nfc, id_nfd);
487 assert!(verify_spelling(&id_nfc, &nfc));
489 assert!(verify_spelling(&id_nfd, &nfd));
490 }
491
492 fn proof_crypto_id_shim(bytes: &[u8]) -> String {
496 use base64::engine::general_purpose::URL_SAFE_NO_PAD;
497 use base64::Engine as _;
498 use sha2::{Digest, Sha256};
499 format!("evt:v1:{}", URL_SAFE_NO_PAD.encode(Sha256::digest(bytes)))
500 }
501
502 fn verify_spelling(id: &str, bytes: &[u8]) -> bool {
503 proof_crypto_id_shim(bytes) == id
504 }
505
506 #[test]
507 fn golden_20_text_byte_identity() {
508 let fixture =
512 std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../../fixtures/golden-20.json");
513 let Ok(text) = std::fs::read_to_string(&fixture) else {
514 return;
517 };
518 let v: serde_json::Value = serde_json::from_str(&text).unwrap();
519 let bytes = hex::decode(v["text_canonical_hex"].as_str().unwrap()).unwrap();
520 let nfd_bytes = hex::decode(v["text_canonical_hex_nfd"].as_str().unwrap()).unwrap();
521 let decoded = decode_strict(&bytes, &lim()).unwrap();
522 match decoded {
523 CborValue::Text(s) => {
524 assert_eq!(proof_crypto_id_shim(&bytes), v["evt_id"].as_str().unwrap());
525 assert_eq!(encode_canonical(&CborValue::Text(s)), bytes);
526 assert_ne!(
528 proof_crypto_id_shim(&nfd_bytes),
529 v["evt_id"].as_str().unwrap()
530 );
531 }
532 other => panic!("golden-20 must be a text item, got {other:?}"),
533 }
534 }
535
536 #[test]
537 fn is_canonical_detects_reordered_map() {
538 let v = CborValue::Map(vec![
539 (CborValue::Uint(1), CborValue::Uint(1)),
540 (CborValue::Uint(2), CborValue::Uint(2)),
541 ]);
542 let good = encode_canonical(&v);
543 assert!(is_canonical(&good, &lim()).unwrap());
544 let bad = vec![0xa2, 0x02, 0x02, 0x01, 0x01];
546 assert_eq!(
547 decode_strict(&bad, &lim()).unwrap_err().code,
548 ErrorCode::NonCanonical
549 );
550 }
551
552 #[test]
555 fn prop_encode_decode_round_trip() {
556 use proptest::prelude::*;
557 use proptest::strategy::ValueTree;
558 fn arb_value() -> impl Strategy<Value = CborValue> {
559 let leaf = prop_oneof![
560 any::<u64>().prop_map(CborValue::Uint),
561 (-1_000_000i64..0i64).prop_map(CborValue::Nint),
563 "[a-z0-9]{0,8}".prop_map(CborValue::Text),
564 proptest::collection::vec(any::<u8>(), 0..16).prop_map(CborValue::Bytes),
565 proptest::bool::ANY.prop_map(CborValue::Bool),
566 Just(CborValue::Null),
567 ];
568 leaf.prop_recursive(3, 16, 4, |inner| {
569 prop_oneof![
570 proptest::collection::vec(inner.clone(), 0..4).prop_map(CborValue::Array),
571 proptest::collection::vec((inner.clone(), inner.clone()), 0..4).prop_map(
572 |pairs| {
573 let mut seen = std::collections::HashSet::new();
575 let mut out = vec![];
576 for (k, v) in pairs {
577 let kb = encode_canonical(&k);
578 if seen.insert(kb) {
579 out.push((k, v));
580 }
581 }
582 CborValue::Map(out)
583 }
584 ),
585 ]
586 })
587 }
588 let mut runner = proptest::test_runner::TestRunner::deterministic();
589 for _ in 0..256 {
590 let v = arb_value().new_tree(&mut runner).expect("tree").current();
591 let b = encode_canonical(&v);
592 let d = decode_strict(&b, &lim()).expect("must decode own encoding");
593 assert_eq!(d, {
594 let mut norm = v.clone();
595 norm.sort_maps();
596 norm
598 });
599 assert_eq!(encode_canonical(&d), b);
600 }
601 }
602
603 #[test]
604 fn prop_raw_bytes_reject_or_round_trip() {
605 use proptest::prelude::*;
606 use proptest::strategy::ValueTree;
607 let mut runner = proptest::test_runner::TestRunner::deterministic();
608 let strat = proptest::collection::vec(any::<u8>(), 0..48);
609 for _ in 0..512 {
610 let bytes: Vec<u8> = strat.new_tree(&mut runner).expect("tree").current();
611 if let Ok(v) = decode_strict(&bytes, &lim()) {
612 assert!(encode_canonical(&v).len() <= 1 << 20);
613 }
614 }
615 }
616}