Skip to main content

proof_format/
cbor.rs

1// Copyright 2026 Proof Engine Contributors
2// SPDX-License-Identifier: MIT OR Apache-2.0
3//! Minimal deterministic CBOR codec for the V0.1 subset.
4//! Encoder always emits preferred serialization + lexicographic map order.
5//! Decoder rejects everything outside the subset (fail closed).
6
7use proof_core::{ErrorCode, Limits, ProofError};
8
9/// Closed CBOR value set for V0.1.
10#[derive(Debug, Clone, PartialEq, Eq)]
11pub enum CborValue {
12    Uint(u64),
13    Nint(i64), // -2^64..=-1
14    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
42// ---------- encoder ----------
43
44fn 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
64// PE-FMT-001 (lexicographic maps) · PE-FMT-002 (shortest ints).
65fn 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            // Invariant: CBOR nint is always <= -1. Callers must uphold it
70            // (schema layer never constructs non-negative Nint).
71            debug_assert!(*n < 0, "CborValue::Nint must be negative");
72            // value = -1 - n  =>  n_arg = (-1 - value) as u64
73            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            // Deterministic: sort by encoded key bytes.
92            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
113/// Encode deterministically (preferred serialization + lexicographic maps).
114pub fn encode_canonical(v: &CborValue) -> Vec<u8> {
115    let mut out = Vec::new();
116    encode_value(v, &mut out);
117    out
118}
119
120// ---------- decoder ----------
121
122struct 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                // Shortest-form: values < 24 MUST use single-byte form.
149                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    // PE-FMT-003 (dup keys) · PE-FMT-004 (forbidden) · PE-FMT-005 (trailing/UTF-8) · PE-FMT-006 (limits).
185    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                // nint range check: arg <= u64::MAX always fits i64 -1-n? -1-2^64 < i64::MIN.
203                // CBOR nint covers -2^64..-1; we restrict to i64 (-2^63..-1) for V0.1? No:
204                // allow full range but store as i64 only if fits, else reject (no bignum path).
205                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                    // Keys must be valid deterministic encodings; re-encode key for ordering check.
254                    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
290/// Strict decode: full input consumed, limits enforced, canonical order checked.
291pub 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
308/// True iff `bytes` is exactly the deterministic encoding of its decoded value.
309pub 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
314/// Decode + re-encode check. Returns value or NON_CANONICAL.
315// PE-FMT-007 (decode->re-encode identity).
316pub 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)]
332// PE-FMT-008 · PE-FMT-009 · PE-CRYPTO-009: ids bind the exact UTF-8 bytes as
333/// given — no Unicode normalization/folding anywhere (FORMAT.md §3.1). Tests:
334/// `text_bytes_as_given_no_normalization`, `nfc_nfd_are_distinct_ids`,
335/// `golden_20_text_byte_identity`.
336mod 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        // Insert out of order; encoder must sort by encoded bytes.
373        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        // Expected lexicographic byte order: 0x0a (10) < 0x617a ("z") < 0x626161 ("aa").
381        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        // {"a":1,"a":2} hand-encoded: a2 61 61 01 61 61 02.
394        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        // 0 encoded as 0x1800 (two bytes) instead of 0x00.
402        let e = decode_strict(&[0x18, 0x00], &lim()).unwrap_err();
403        assert_eq!(e.code, ErrorCode::NonCanonical);
404        // 24 encoded as 0x190018 instead of 0x1818.
405        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        // tag 0 (0xc0 + "2020-01-01"), float16 (0xf9), indefinite array (0x9f), break (0xff),
412        // undefined (0xf7), reserved ai 28 (0x1c).
413        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], // float32
423        ];
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        // text(1) with 0xff.
450        let e = decode_strict(&[0x61, 0xff], &lim()).unwrap_err();
451        assert_eq!(e.code, ErrorCode::Malformed);
452    }
453
454    // PE-FMT-009 (FORMAT.md §3.1): ids bind exact bytes; no normalization.
455    #[test]
456    fn text_bytes_as_given_no_normalization() {
457        // NFC spelling must round-trip byte-exactly: no folding, no trimming.
458        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        // Whitespace and case are preserved verbatim too.
465        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        // The two byte spellings of the same logical string are different
476        // canonical texts -> different ids (FORMAT.md §3.1; golden-20).
477        let nfc_bytes = "caf\u{e9}".as_bytes(); // 63 61 66 C3 A9
478        let nfd_bytes = "cafe\u{301}".as_bytes(); // 63 61 66 65 CC 81
479        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        // Distinct canonical bytes must yield distinct ids (byte-binding).
484        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        // But each id verifies against exactly its own bytes.
488        assert!(verify_spelling(&id_nfc, &nfc));
489        assert!(verify_spelling(&id_nfd, &nfd));
490    }
491
492    /// Local stand-ins so the format crate does not depend on proof-crypto:
493    /// replicate the id construction `<prefix>:v1:<b64u(sha256(bytes))>` and
494    /// its byte-binding check to assert the id-level consequence.
495    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        // Interop vector: exact canonical bytes and derived id for NFC input.
509        // Golden-20 (fixtures/golden-20.json) pins these bytes; re-derive the
510        // id from the parsed text to prove byte fidelity end to end.
511        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            // Fixture not present in this checkout: in-repo assertion above
515            // (nfc_nfd_are_distinct_ids) still covers the property.
516            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                // The NFD spelling of the same word must never share the id.
527                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        // Manually swap pairs: still valid CBOR but non-canonical order.
545        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    // Property: any decoded value re-encodes identically (idempotent canonical form),
553    // and any encoded value decodes back to itself.
554    #[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                // CBOR nint is always <= -1; positive values are unrepresentable.
562                (-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                            // Deduplicate by encoded key to keep maps valid.
574                            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                // Encoder sorts maps; decoded form equals sorted original.
597                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}