From e4963a8f625a6ce4c5798a60edcb511670673e7f Mon Sep 17 00:00:00 2001 From: Ray Walker Date: Wed, 2 Sep 2026 18:05:39 +1000 Subject: [PATCH 1/3] fix(serializer): own the msgpack decode depth bound (100, not rmp-serde's 1024) (LAB-2503) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Both untrusted decode paths (serializer::deserialize, interop::deserialize) build their Deserializer through bounded_deserializer with an explicit MAX_DECODE_DEPTH. rmp-serde's 1024 default is not a safe bound: a debug build overflows a 2 MiB thread stack (uncatchable abort) between 512 and 768 nested arrays — a ~700-byte forged entry. 100 matches cachekit-ts and sits inside the protocol's 32..=1024 window. Regression-guarded by the vendored protocol decode-bounds vectors. --- README.md | 2 +- crates/cachekit/src/interop.rs | 4 +- crates/cachekit/src/serializer/mod.rs | 42 +++- crates/cachekit/tests/decode_bounds_tests.rs | 148 ++++++++++++ .../cachekit/tests/vectors/decode-bounds.json | 210 ++++++++++++++++++ 5 files changed, 402 insertions(+), 4 deletions(-) create mode 100644 crates/cachekit/tests/decode_bounds_tests.rs create mode 100644 crates/cachekit/tests/vectors/decode-bounds.json diff --git a/README.md b/README.md index a771728..90abb5d 100644 --- a/README.md +++ b/README.md @@ -199,7 +199,7 @@ cache.set_with_ttl(&key, &user, ttl).await?; // plain MessagePack — a let user: Option = cache.interop_get(&key).await?; // strict read: exactly one document ``` -Argument hashing is byte-identical across SDKs (canonical MessagePack + Blake2b-256), verified against the shared [protocol test vectors](https://github.com/cachekit-io/protocol/blob/main/test-vectors/interop-mode.json) in this repo's test suite. `interop_get` (also on `SecureCache`) rejects trailing bytes and Python-internal CK frames instead of silently misreading them. Encryption works unchanged — interop keys are identical across SDKs, so the AAD verifies cross-SDK. +Argument hashing is byte-identical across SDKs (canonical MessagePack + Blake2b-256), verified against the shared [protocol test vectors](https://github.com/cachekit-io/protocol/blob/main/test-vectors/interop-mode.json) in this repo's test suite. `interop_get` (also on `SecureCache`) rejects trailing bytes and Python-internal CK frames instead of silently misreading them. Every decode of backend-supplied bytes (`get` and `interop_get` alike) runs under an explicit nesting-depth bound (`serializer::MAX_DECODE_DEPTH` = 100, matching the TypeScript SDK — a cachekit-owned invariant, not `rmp-serde`'s 1024 default, which a debug build cannot even reach on a 2 MiB stack without overflowing) and is checked against the protocol's shared [`decode-bounds.json`](https://github.com/cachekit-io/protocol/blob/main/test-vectors/decode-bounds.json) vectors; `rmp-serde` never pre-allocates from a header, so a forged nested-header entry is a bounded `Serialization` error, not a memory blow-up. Encryption works unchanged — interop keys are identical across SDKs, so the AAD verifies cross-SDK. > [!IMPORTANT] > Use interop keys on a client **without** `.namespace()` — a client prefix would rewrite the storage key to `{prefix}:{interop_key}`, which no other SDK computes. `interop_get` fails closed with a config error rather than silently missing; interop keys already carry their own namespace segment. diff --git a/crates/cachekit/src/interop.rs b/crates/cachekit/src/interop.rs index 69fae90..373dc87 100644 --- a/crates/cachekit/src/interop.rs +++ b/crates/cachekit/src/interop.rs @@ -344,6 +344,8 @@ pub fn serialize_value(value: &InteropValue) -> Result, CachekitError> { /// Deserialize an interop-mode MessagePack document, consuming **exactly one** /// document and rejecting trailing bytes (spec MUST). /// +/// Nesting depth is bounded by [`crate::serializer::MAX_DECODE_DEPTH`] (LAB-2503). +/// /// `rmp_serde::from_slice` silently ignores trailing bytes. That leniency is /// dangerous here: a Python-SDK-internal CK frame begins `0x43` (`'C'`), which /// is a *complete* one-byte MessagePack document (positive fixint 67) — a @@ -368,7 +370,7 @@ pub fn deserialize(bytes: &[u8]) -> Result(rd: R) -> rmp_serde::Deserializer> { + let mut de = rmp_serde::Deserializer::new(rd); + // rmp-serde decrements its counter on entry and errors when it reaches 0, so + // `set_max_depth(n)` admits n - 1 nested collections. +1 makes the constant mean + // what it says: exactly MAX_DECODE_DEPTH levels decode, MAX_DECODE_DEPTH + 1 is + // rejected (pinned by tests/decode_bounds_tests.rs). + de.set_max_depth(MAX_DECODE_DEPTH + 1); + de +} + /// Serialize `value` to MessagePack bytes using named fields (map format). pub fn serialize(value: &T) -> Result, CachekitError> { rmp_serde::to_vec_named(value).map_err(|e| CachekitError::Serialization(e.to_string())) } -/// Deserialize `bytes` from MessagePack into `T`. +/// Deserialize `bytes` from MessagePack into `T`, nesting bounded by +/// [`MAX_DECODE_DEPTH`]. Trailing bytes are ignored (auto mode is SDK-internal; +/// interop mode's strict single-document read is [`crate::interop::deserialize`]). pub fn deserialize(bytes: &[u8]) -> Result { - rmp_serde::from_slice(bytes).map_err(|e| CachekitError::Serialization(e.to_string())) + T::deserialize(&mut bounded_deserializer(bytes)) + .map_err(|e| CachekitError::Serialization(e.to_string())) } diff --git a/crates/cachekit/tests/decode_bounds_tests.rs b/crates/cachekit/tests/decode_bounds_tests.rs new file mode 100644 index 0000000..db4f8bb --- /dev/null +++ b/crates/cachekit/tests/decode_bounds_tests.rs @@ -0,0 +1,148 @@ +//! Untrusted-decode bounds (LAB-2503): the shared protocol `decode-bounds.json` +//! vectors run against BOTH decode entry points, plus the depth-bound boundary. +//! +//! Vectors: `tests/vectors/decode-bounds.json`, vendored verbatim from +//! `cachekit-io/protocol` `test-vectors/decode-bounds.json` +//! (sha256 `864b7126986e9a2bd0dd50358018eda34fe2f70bca06ae9763e8ce6321f34b0a`). +//! Do not edit the JSON here; regenerate upstream and re-vendor. +//! +//! Why this exists: `rmp-serde` never pre-allocates from a header, so the only +//! amplification axis is recursion depth — and its 1024 default is NOT a safe +//! bound: a debug build overflows a 2 MiB thread stack (uncatchable abort) +//! somewhere between 512 and 768 nested arrays, i.e. a ~700-byte forged entry. +//! `serializer::MAX_DECODE_DEPTH` (100) makes the bound ours, and this file +//! fails if a dependency bump (or a new decode path bypassing +//! `bounded_deserializer`) re-opens it. + +use cachekit::interop; +use cachekit::serializer::{self, MAX_DECODE_DEPTH}; +use cachekit::CachekitError; +use serde_json::Value as Json; + +const VECTORS_JSON: &str = include_str!("vectors/decode-bounds.json"); + +fn vectors() -> Json { + serde_json::from_str(VECTORS_JSON).expect("vendored vector file must be valid JSON") +} + +fn unhex(s: &str) -> Vec { + (0..s.len()) + .step_by(2) + .map(|i| u8::from_str_radix(&s[i..i + 2], 16).expect("vector input_hex must be hex")) + .collect() +} + +/// Both untrusted decode entry points: auto-mode `get` and interop `interop_get`. +fn decode_both(bytes: &[u8]) -> [(&'static str, Result); 2] { + [ + ( + "serializer::deserialize", + serializer::deserialize::(bytes), + ), + ("interop::deserialize", interop::deserialize::(bytes)), + ] +} + +/// Rejecting a document nested N deep unwinds N recursion frames. Run each case on +/// a thread with the DEFAULT Rust thread stack (2 MiB) so the test also proves the +/// bound is reachable without overflowing an ordinary tokio worker stack. +fn on_default_stack(f: F) { + std::thread::Builder::new() + .stack_size(2 << 20) + .spawn(f) + .expect("spawn") + .join() + .expect("decode must not panic or overflow the stack"); +} + +fn nested_fixarray(depth: usize) -> Vec { + let mut v = vec![0x91u8; depth]; + v.push(0xc0); + v +} + +#[test] +fn vector_file_shape_is_the_vendored_one() { + let v = vectors(); + assert_eq!(v["reject_vectors"].as_array().map(Vec::len), Some(10)); + assert_eq!(v["accept_vectors"].as_array().map(Vec::len), Some(2)); + assert_eq!(v["spec"], "spec/interop-mode.md#decode-bounds"); +} + +#[test] +fn every_reject_vector_is_rejected_by_both_decoders() { + on_default_stack(|| { + for vector in vectors()["reject_vectors"].as_array().unwrap() { + let name = vector["name"].as_str().unwrap(); + let bytes = unhex(vector["input_hex"].as_str().unwrap()); + assert_eq!( + bytes.len() as u64, + vector["input_len"].as_u64().unwrap(), + "{name}: input_len" + ); + for (path, result) in decode_both(&bytes) { + let err = result + .err() + .unwrap_or_else(|| panic!("{name}: {path} decoded a reject vector")); + assert!( + matches!(err, CachekitError::Serialization(_)), + "{name}: {path} must fail as a catchable Serialization error, got {err:?}" + ); + } + } + }); +} + +#[test] +fn every_accept_vector_decodes_on_both_paths() { + on_default_stack(|| { + for vector in vectors()["accept_vectors"].as_array().unwrap() { + let name = vector["name"].as_str().unwrap(); + let bytes = unhex(vector["input_hex"].as_str().unwrap()); + for (path, result) in decode_both(&bytes) { + let value = result + .unwrap_or_else(|e| panic!("{name}: {path} rejected an accept vector: {e}")); + let depth = vector["nesting_depth"].as_u64().unwrap(); + assert_eq!( + nesting_depth(&value) as u64, + depth, + "{name}: {path} decoded to the wrong shape" + ); + } + } + }); +} + +fn nesting_depth(v: &Json) -> usize { + match v { + Json::Array(items) => 1 + items.iter().map(nesting_depth).max().unwrap_or(0), + Json::Object(map) => 1 + map.values().map(nesting_depth).max().unwrap_or(0), + _ => 0, + } +} + +#[test] +fn depth_bound_is_owned_and_matches_the_typescript_sdk() { + // The protocol requires 32 <= bound <= 1024; 100 matches cachekit-ts and stays + // far below the stack-overflow region measured for debug builds (512..768). + assert_eq!(MAX_DECODE_DEPTH, 100); + on_default_stack(|| { + for (path, result) in decode_both(&nested_fixarray(MAX_DECODE_DEPTH)) { + assert_eq!( + nesting_depth(&result.unwrap()), + MAX_DECODE_DEPTH, + "{path}: depth == bound must decode" + ); + } + for (path, result) in decode_both(&nested_fixarray(MAX_DECODE_DEPTH + 1)) { + let msg = result + .err() + .unwrap_or_else(|| panic!("{path}: depth bound+1 decoded")) + .to_string(); + assert!( + msg.contains("depth limit exceeded"), + "{path}: expected the depth-limit error, got {msg}" + ); + } + }); +} diff --git a/crates/cachekit/tests/vectors/decode-bounds.json b/crates/cachekit/tests/vectors/decode-bounds.json new file mode 100644 index 0000000..91ab717 --- /dev/null +++ b/crates/cachekit/tests/vectors/decode-bounds.json @@ -0,0 +1,210 @@ +{ + "version": "1.0.0", + "spec": "spec/interop-mode.md#decode-bounds", + "generator": "tools/decode-bounds-reference.py generate (CPython stdlib)", + "scope": "Any untrusted MessagePack decode in any SDK: interop/v1 values, auto-mode payloads after the ByteStorage envelope is unwrapped, invalidation events. The bytes are plain MessagePack with no envelope.", + "rules": { + "depth": "Readers MUST bound nesting depth. The bound MUST be >= 32 and MUST be <= 1024; every reject vector tagged 'depth' nests deeper than 1024.", + "overclaim": "Readers MUST NOT pre-allocate for a collection/str/bin header more than the remaining input can back (each element or byte needs >= 1 input byte), and MUST reject a structurally incomplete document. Every reject vector tagged 'overclaim' has declared_slots > input_len - 1 (the root header is the only byte that is not an element).", + "failure_mode": "Rejection MUST surface as a catchable decode error that the SDK read path turns into a cache miss (fail-closed), never an uncaught crash or an OOM abort." + }, + "field_notes": { + "construction": "input = bytes.fromhex(repeat_hex) * count + bytes.fromhex(suffix_hex)", + "nesting_depth": "collection headers along the deepest spine (str/bin count as 0)", + "declared_slots": "sum of every header's declared element/byte count (a nested header counts as one element of its parent)", + "reject_reasons": "which rule(s) the vector violates; a maintainer note, not a normative message" + }, + "reject_vectors": [ + { + "name": "nested_array16_depth_2048", + "description": "2048 nested array16 headers each claiming 10 000 elements, 0 backing bytes. The LAB-2487 amplifier shape: an eager decoder pre-allocates 10 000 slots per level before hitting EOF.", + "construction": { + "repeat_hex": "dc2710", + "count": 2048, + "suffix_hex": "" + }, + "input_hex": "dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710", + "input_len": 6144, + "nesting_depth": 2048, + "declared_slots": 20480000, + "reject_reasons": [ + "depth", + "overclaim" + ] + }, + { + "name": "nested_array32_input_len_depth_1100", + "description": "1100 nested array32 headers each claiming exactly len(input)=5500 elements. Defeats a per-collection cap of len(input): peak pre-allocation is depth x len(input) x slot size.", + "construction": { + "repeat_hex": "dd0000157c", + "count": 1100, + "suffix_hex": "" + }, + "input_hex": "dd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157cdd0000157c", + "input_len": 5500, + "nesting_depth": 1100, + "declared_slots": 6050000, + "reject_reasons": [ + "depth", + "overclaim" + ] + }, + { + "name": "nested_map16_depth_2048", + "description": "Map twin of nested_array16_depth_2048 (map pre-allocation is typically larger per slot).", + "construction": { + "repeat_hex": "de2710", + "count": 2048, + "suffix_hex": "" + }, + "input_hex": "de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710", + "input_len": 6144, + "nesting_depth": 2048, + "declared_slots": 20480000, + "reject_reasons": [ + "depth", + "overclaim" + ] + }, + { + "name": "nested_fixarray_depth_2048_complete", + "description": "Structurally COMPLETE document ([[...[null]...]]) nested 2048 deep: every header is backed, so only the depth bound rejects it. Isolates the depth rule from the allocation rule.", + "construction": { + "repeat_hex": "91", + "count": 2048, + "suffix_hex": "c0" + }, + "input_hex": "9191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191919191c0", + "input_len": 2049, + "nesting_depth": 2048, + "declared_slots": 2048, + "reject_reasons": [ + "depth" + ] + }, + { + "name": "array16_overclaim_shallow", + "description": "One array16 header claiming 10 000 elements with 3 backing bytes.", + "construction": { + "repeat_hex": "dc2710", + "count": 1, + "suffix_hex": "010203" + }, + "input_hex": "dc2710010203", + "input_len": 6, + "nesting_depth": 1, + "declared_slots": 10000, + "reject_reasons": [ + "overclaim" + ] + }, + { + "name": "array32_max_claim_alone", + "description": "A lone 5-byte array32 header claiming 2^32-1 elements.", + "construction": { + "repeat_hex": "ddffffffff", + "count": 1, + "suffix_hex": "" + }, + "input_hex": "ddffffffff", + "input_len": 5, + "nesting_depth": 1, + "declared_slots": 4294967295, + "reject_reasons": [ + "overclaim" + ] + }, + { + "name": "map32_max_claim_alone", + "description": "A lone 5-byte map32 header claiming 2^32-1 pairs.", + "construction": { + "repeat_hex": "dfffffffff", + "count": 1, + "suffix_hex": "" + }, + "input_hex": "dfffffffff", + "input_len": 5, + "nesting_depth": 1, + "declared_slots": 4294967295, + "reject_reasons": [ + "overclaim" + ] + }, + { + "name": "bin32_overclaim", + "description": "bin32 header claiming 2^32-1 bytes with 1 backing byte (a 6-byte document declaring a 4 GiB buffer).", + "construction": { + "repeat_hex": "c6ffffffff", + "count": 1, + "suffix_hex": "41" + }, + "input_hex": "c6ffffffff41", + "input_len": 6, + "nesting_depth": 0, + "declared_slots": 4294967295, + "reject_reasons": [ + "overclaim" + ] + }, + { + "name": "str32_overclaim", + "description": "str32 twin of bin32_overclaim.", + "construction": { + "repeat_hex": "dbffffffff", + "count": 1, + "suffix_hex": "41" + }, + "input_hex": "dbffffffff41", + "input_len": 6, + "nesting_depth": 0, + "declared_slots": 4294967295, + "reject_reasons": [ + "overclaim" + ] + }, + { + "name": "fixarray_short_by_one", + "description": "fixarray claiming 5 elements with 4 present: the minimal truncated document.", + "construction": { + "repeat_hex": "95", + "count": 1, + "suffix_hex": "c0c0c0c0" + }, + "input_hex": "95c0c0c0c0", + "input_len": 5, + "nesting_depth": 1, + "declared_slots": 5, + "reject_reasons": [ + "overclaim" + ] + } + ], + "accept_vectors": [ + { + "name": "nested_fixarray_depth_32", + "description": "[[...[null]...]] nested 32 deep, complete. A conforming reader MUST accept it: the depth bound may not be tighter than 32.", + "construction": { + "repeat_hex": "91", + "count": 32, + "suffix_hex": "c0" + }, + "input_hex": "9191919191919191919191919191919191919191919191919191919191919191c0", + "input_len": 33, + "nesting_depth": 32, + "declared_slots": 32 + }, + { + "name": "array16_256_backed_nils", + "description": "array16 header claiming 256 elements with all 256 present. A *16 header that is fully backed by input is legitimate; the allocation rule is about backing, not header width.", + "construction": { + "repeat_hex": "dc0100", + "count": 1, + "suffix_hex": "c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0" + }, + "input_hex": "dc0100c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0", + "input_len": 259, + "nesting_depth": 1, + "declared_slots": 256 + } + ] +} From 7a86f104bd666bce7583a0c7305b3b390b82b409 Mon Sep 17 00:00:00 2001 From: Ray Walker Date: Wed, 2 Sep 2026 18:53:55 +1000 Subject: [PATCH 2/3] fix(serializer): add header-only structural walk before decode (LAB-2503 panel) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Panel finding: rmp-serde is not allocation-free — serde's Vec visitor pre-allocates min(declared, 1 MiB) per collection from size_hint, so 50 nested array32(0xFFFFFFFF) headers (250 bytes) cost 50 MiB into a Vec-bearing target before EOF (an OOM kill on a Workers isolate). check_structure() walks headers only (Σ declared ≤ remaining input, fail closed on 0xc1/truncation/overflow) and runs inside bounded_deserializer, so both decode paths get it; interop reads trailing bytes via into_inner. Test: recursive Vec enum target rejected before allocation; docs corrected. --- README.md | 2 +- crates/cachekit/src/interop.rs | 11 +- crates/cachekit/src/serializer/mod.rs | 122 ++++++++++++++---- crates/cachekit/tests/decode_bounds_tests.rs | 76 +++++++++-- .../cachekit/tests/vectors/decode-bounds.json | 14 +- 5 files changed, 175 insertions(+), 50 deletions(-) diff --git a/README.md b/README.md index 90abb5d..b335c1b 100644 --- a/README.md +++ b/README.md @@ -199,7 +199,7 @@ cache.set_with_ttl(&key, &user, ttl).await?; // plain MessagePack — a let user: Option = cache.interop_get(&key).await?; // strict read: exactly one document ``` -Argument hashing is byte-identical across SDKs (canonical MessagePack + Blake2b-256), verified against the shared [protocol test vectors](https://github.com/cachekit-io/protocol/blob/main/test-vectors/interop-mode.json) in this repo's test suite. `interop_get` (also on `SecureCache`) rejects trailing bytes and Python-internal CK frames instead of silently misreading them. Every decode of backend-supplied bytes (`get` and `interop_get` alike) runs under an explicit nesting-depth bound (`serializer::MAX_DECODE_DEPTH` = 100, matching the TypeScript SDK — a cachekit-owned invariant, not `rmp-serde`'s 1024 default, which a debug build cannot even reach on a 2 MiB stack without overflowing) and is checked against the protocol's shared [`decode-bounds.json`](https://github.com/cachekit-io/protocol/blob/main/test-vectors/decode-bounds.json) vectors; `rmp-serde` never pre-allocates from a header, so a forged nested-header entry is a bounded `Serialization` error, not a memory blow-up. Encryption works unchanged — interop keys are identical across SDKs, so the AAD verifies cross-SDK. +Argument hashing is byte-identical across SDKs (canonical MessagePack + Blake2b-256), verified against the shared [protocol test vectors](https://github.com/cachekit-io/protocol/blob/main/test-vectors/interop-mode.json) in this repo's test suite. `interop_get` (also on `SecureCache`) rejects trailing bytes and Python-internal CK frames instead of silently misreading them. Every decode of backend-supplied bytes (`get` and `interop_get` alike) runs under an explicit nesting-depth bound (`serializer::MAX_DECODE_DEPTH` = 100, matching the TypeScript SDK) and a header-only structural walk that rejects headers declaring more than the input can back, verified against the protocol's shared [`decode-bounds.json`](https://github.com/cachekit-io/protocol/blob/main/test-vectors/decode-bounds.json) vectors — a forged nested-header entry is a bounded `Serialization` error, not a memory blow-up or a stack overflow. Encryption works unchanged — interop keys are identical across SDKs, so the AAD verifies cross-SDK. > [!IMPORTANT] > Use interop keys on a client **without** `.namespace()` — a client prefix would rewrite the storage key to `{prefix}:{interop_key}`, which no other SDK computes. `interop_get` fails closed with a config error rather than silently missing; interop keys already carry their own namespace segment. diff --git a/crates/cachekit/src/interop.rs b/crates/cachekit/src/interop.rs index 373dc87..67abef6 100644 --- a/crates/cachekit/src/interop.rs +++ b/crates/cachekit/src/interop.rs @@ -344,7 +344,8 @@ pub fn serialize_value(value: &InteropValue) -> Result, CachekitError> { /// Deserialize an interop-mode MessagePack document, consuming **exactly one** /// document and rejecting trailing bytes (spec MUST). /// -/// Nesting depth is bounded by [`crate::serializer::MAX_DECODE_DEPTH`] (LAB-2503). +/// Decode bounds: [`crate::serializer::MAX_DECODE_DEPTH`] and the header walk in +/// `crate::serializer::check_structure` (LAB-2503). /// /// `rmp_serde::from_slice` silently ignores trailing bytes. That leniency is /// dangerous here: a Python-SDK-internal CK frame begins `0x43` (`'C'`), which @@ -367,13 +368,13 @@ pub fn deserialize(bytes: &[u8]) -> Result` visitor pre-allocates `min(declared_len, 1 MiB)` per collection +/// from `size_hint`, so without this walk a 500-byte payload of nested +/// `array32(0xFFFFFFFF)` headers costs `MAX_DECODE_DEPTH` MiB before the first +/// EOF error — an OOM kill on a Cloudflare Workers isolate. Trailing bytes are +/// left to the caller (auto mode ignores them; interop rejects them). +pub(crate) fn check_structure(bytes: &[u8]) -> Result<(), CachekitError> { + fn reject(what: &str) -> CachekitError { + CachekitError::Serialization(format!("decode bound: {what}")) + } + fn be(bytes: &[u8], pos: usize, width: usize) -> Result { + let end = pos.checked_add(width).filter(|e| *e <= bytes.len()); + let field = &bytes[pos..end.ok_or_else(|| reject("input ends inside a length prefix"))?]; + Ok(field.iter().fold(0u64, |acc, b| (acc << 8) | u64::from(*b))) + } + + let mut pos = 0usize; + let mut pending: u64 = 1; // elements still owed by open headers (the root counts as one) + while pending > 0 { + let marker = *bytes + .get(pos) + .ok_or_else(|| reject("input ends before the document is complete"))?; + pos += 1; + pending -= 1; + // (prefix bytes, payload bytes after the prefix, child elements) + let (prefix, payload, children): (usize, u64, u64) = match marker { + 0x00..=0x7f | 0xc0 | 0xc2 | 0xc3 | 0xe0..=0xff => (0, 0, 0), + 0x80..=0x8f => (0, 0, 2 * u64::from(marker & 0x0f)), + 0x90..=0x9f => (0, 0, u64::from(marker & 0x0f)), + 0xa0..=0xbf => (0, u64::from(marker & 0x1f), 0), + 0xc1 => return Err(reject("reserved marker 0xc1")), + 0xc4 | 0xd9 => (1, be(bytes, pos, 1)?, 0), + 0xc5 | 0xda => (2, be(bytes, pos, 2)?, 0), + 0xc6 | 0xdb => (4, be(bytes, pos, 4)?, 0), + 0xc7 => (1, be(bytes, pos, 1)? + 1, 0), // ext: length prefix, then type byte + data + 0xc8 => (2, be(bytes, pos, 2)? + 1, 0), + 0xc9 => (4, be(bytes, pos, 4)? + 1, 0), + 0xca..=0xd3 => (0, 1u64 << (marker & 0x03), 0), // f32/f64/u8..u64/i8..i64: 4,8,1,2,4,8,1,2,4,8 + 0xd4..=0xd8 => (0, 1 + (1u64 << (marker - 0xd4)), 0), // fixext: type byte + 1/2/4/8/16 + 0xdc => (2, 0, be(bytes, pos, 2)?), + 0xdd => (4, 0, be(bytes, pos, 4)?), + 0xde => (2, 0, 2 * be(bytes, pos, 2)?), + 0xdf => (4, 0, 2 * be(bytes, pos, 4)?), + }; + pos += prefix; + let remaining = (bytes.len() - pos) as u64; + if payload > remaining { + return Err(reject("header declares more bytes than the input holds")); + } + pos += usize::try_from(payload) + .map_err(|_| reject("header declares more bytes than the input holds"))?; + pending += children; + if pending > remaining - payload { + return Err(reject( + "header declares more elements than the input can back", + )); + } + } + Ok(()) +} + +/// Build a depth- and allocation-bounded `rmp_serde::Deserializer` over `bytes`. /// /// Every decode of backend-supplied bytes (auto-mode [`deserialize`] and -/// [`crate::interop::deserialize`]) MUST go through here so the bound cannot -/// drift between paths. -pub(crate) fn bounded_deserializer(rd: R) -> rmp_serde::Deserializer> { - let mut de = rmp_serde::Deserializer::new(rd); +/// [`crate::interop::deserialize`]) MUST go through here so the bounds cannot +/// drift between paths. Runs [`check_structure`] first, then applies +/// [`MAX_DECODE_DEPTH`]. +pub(crate) fn bounded_deserializer( + bytes: &[u8], +) -> Result>, CachekitError> { + check_structure(bytes)?; + let mut de = rmp_serde::Deserializer::new(bytes); // rmp-serde decrements its counter on entry and errors when it reaches 0, so // `set_max_depth(n)` admits n - 1 nested collections. +1 makes the constant mean // what it says: exactly MAX_DECODE_DEPTH levels decode, MAX_DECODE_DEPTH + 1 is // rejected (pinned by tests/decode_bounds_tests.rs). de.set_max_depth(MAX_DECODE_DEPTH + 1); - de + Ok(de) } /// Serialize `value` to MessagePack bytes using named fields (map format). @@ -42,10 +115,11 @@ pub fn serialize(value: &T) -> Result, CachekitError> { rmp_serde::to_vec_named(value).map_err(|e| CachekitError::Serialization(e.to_string())) } -/// Deserialize `bytes` from MessagePack into `T`, nesting bounded by -/// [`MAX_DECODE_DEPTH`]. Trailing bytes are ignored (auto mode is SDK-internal; -/// interop mode's strict single-document read is [`crate::interop::deserialize`]). +/// Deserialize `bytes` from MessagePack into `T` under the decode bounds +/// ([`MAX_DECODE_DEPTH`], [`check_structure`]). Trailing bytes are ignored +/// (auto mode is SDK-internal; interop mode's strict single-document read is +/// [`crate::interop::deserialize`]). pub fn deserialize(bytes: &[u8]) -> Result { - T::deserialize(&mut bounded_deserializer(bytes)) + T::deserialize(&mut bounded_deserializer(bytes)?) .map_err(|e| CachekitError::Serialization(e.to_string())) } diff --git a/crates/cachekit/tests/decode_bounds_tests.rs b/crates/cachekit/tests/decode_bounds_tests.rs index db4f8bb..d0ba808 100644 --- a/crates/cachekit/tests/decode_bounds_tests.rs +++ b/crates/cachekit/tests/decode_bounds_tests.rs @@ -3,20 +3,18 @@ //! //! Vectors: `tests/vectors/decode-bounds.json`, vendored verbatim from //! `cachekit-io/protocol` `test-vectors/decode-bounds.json` -//! (sha256 `864b7126986e9a2bd0dd50358018eda34fe2f70bca06ae9763e8ce6321f34b0a`). +//! (sha256 `fa8bc750a4911fe3663b9ab68f13438a3e924b6bc742e9f6763ca35ad2407476`). //! Do not edit the JSON here; regenerate upstream and re-vendor. //! -//! Why this exists: `rmp-serde` never pre-allocates from a header, so the only -//! amplification axis is recursion depth — and its 1024 default is NOT a safe -//! bound: a debug build overflows a 2 MiB thread stack (uncatchable abort) -//! somewhere between 512 and 768 nested arrays, i.e. a ~700-byte forged entry. -//! `serializer::MAX_DECODE_DEPTH` (100) makes the bound ours, and this file -//! fails if a dependency bump (or a new decode path bypassing -//! `bounded_deserializer`) re-opens it. +//! Why 100 and not rmp-serde's 1024, and why a header walk is needed at all: +//! see the rustdoc on `serializer::MAX_DECODE_DEPTH` and `check_structure`. +//! This file fails if a dependency bump (or a new decode path bypassing +//! `bounded_deserializer`) re-opens either bound. use cachekit::interop; use cachekit::serializer::{self, MAX_DECODE_DEPTH}; use cachekit::CachekitError; +use serde::Deserialize; use serde_json::Value as Json; const VECTORS_JSON: &str = include_str!("vectors/decode-bounds.json"); @@ -75,11 +73,6 @@ fn every_reject_vector_is_rejected_by_both_decoders() { for vector in vectors()["reject_vectors"].as_array().unwrap() { let name = vector["name"].as_str().unwrap(); let bytes = unhex(vector["input_hex"].as_str().unwrap()); - assert_eq!( - bytes.len() as u64, - vector["input_len"].as_u64().unwrap(), - "{name}: input_len" - ); for (path, result) in decode_both(&bytes) { let err = result .err() @@ -146,3 +139,60 @@ fn depth_bound_is_owned_and_matches_the_typescript_sdk() { } }); } + +/// A recursive `Vec`-bearing target: serde's `Vec` visitor pre-allocates +/// `min(declared, 1 MiB)` per level from the header, so WITHOUT the structural walk +/// 50 nested `array32(0xFFFFFFFF)` headers (250 bytes) cost 50 MiB before EOF. +/// `serde_json::Value` happens to allocate nothing here, which is why the vector +/// tests alone cannot catch a walk regression — this one can. +#[derive(Debug, Deserialize)] +#[serde(untagged)] +enum Tree { + Leaf(u8), + Node(Vec), +} + +#[test] +fn vec_target_amplifier_is_rejected_before_any_allocation() { + let mut bomb = Vec::new(); + for _ in 0..50 { + bomb.extend_from_slice(&[0xdd, 0xff, 0xff, 0xff, 0xff]); + } + for (path, result) in [ + ("serializer", serializer::deserialize::(&bomb)), + ("interop", interop::deserialize::(&bomb)), + ] { + let msg = result + .err() + .unwrap_or_else(|| panic!("{path}: decoded the amplifier")) + .to_string(); + assert!( + msg.contains("more elements than the input can back"), + "{path}: {msg}" + ); + } + // …and a legitimately backed Vec-tree still decodes on both paths. + let legit = [0x92, 0x92, 0x01, 0x02, 0x91, 0x03]; // [[1, 2], [3]] + for tree in [ + serializer::deserialize::(&legit).unwrap(), + interop::deserialize::(&legit).unwrap(), + ] { + let Tree::Node(children) = tree else { + panic!("root must be a node") + }; + let leaves: Vec> = children + .iter() + .map(|c| match c { + Tree::Node(n) => n + .iter() + .map(|l| match l { + Tree::Leaf(v) => *v, + Tree::Node(_) => u8::MAX, + }) + .collect(), + Tree::Leaf(v) => vec![*v], + }) + .collect(); + assert_eq!(leaves, vec![vec![1, 2], vec![3]]); + } +} diff --git a/crates/cachekit/tests/vectors/decode-bounds.json b/crates/cachekit/tests/vectors/decode-bounds.json index 91ab717..6a58520 100644 --- a/crates/cachekit/tests/vectors/decode-bounds.json +++ b/crates/cachekit/tests/vectors/decode-bounds.json @@ -17,16 +17,16 @@ "reject_vectors": [ { "name": "nested_array16_depth_2048", - "description": "2048 nested array16 headers each claiming 10 000 elements, 0 backing bytes. The LAB-2487 amplifier shape: an eager decoder pre-allocates 10 000 slots per level before hitting EOF.", + "description": "2048 nested array16 headers each claiming 2000 elements, 0 backing bytes. The LAB-2487 amplifier shape: an eager decoder pre-allocates 2000 slots per level before hitting EOF. 2000 < input_len, so a per-collection cap of len(input) does NOT reject it.", "construction": { - "repeat_hex": "dc2710", + "repeat_hex": "dc07d0", "count": 2048, "suffix_hex": "" }, - "input_hex": "dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710dc2710", + "input_hex": "dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0dc07d0", "input_len": 6144, "nesting_depth": 2048, - "declared_slots": 20480000, + "declared_slots": 4096000, "reject_reasons": [ "depth", "overclaim" @@ -53,14 +53,14 @@ "name": "nested_map16_depth_2048", "description": "Map twin of nested_array16_depth_2048 (map pre-allocation is typically larger per slot).", "construction": { - "repeat_hex": "de2710", + "repeat_hex": "de07d0", "count": 2048, "suffix_hex": "" }, - "input_hex": "de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710de2710", + "input_hex": "de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0de07d0", "input_len": 6144, "nesting_depth": 2048, - "declared_slots": 20480000, + "declared_slots": 8192000, "reject_reasons": [ "depth", "overclaim" From 47a9da79f44e95676877124ef4eefac10720906a Mon Sep 17 00:00:00 2001 From: Ray Walker Date: Thu, 3 Sep 2026 09:38:18 +1000 Subject: [PATCH 3/3] =?UTF-8?q?fix:=20address=20coderabbit=20review=20?= =?UTF-8?q?=E2=80=94=20decode-bound=20docs,=20rustdoc=20links,=20beta=20cl?= =?UTF-8?q?ippy=20(LAB-2503)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit CodeRabbit round on PR #73 plus the red beta lane: - serializer/mod.rs, decode_bounds_tests.rs: restate the serde pre-allocation figure with units — min(declared_len x size_of::(), 1 MiB) bytes per collection — and note that #[serde(untagged)] targets decode through serde's Content buffer, which uses the same cautious size_hint cap as Vec. The 1 MiB / 50 MiB figures were verified against serde 1.0.228 src/core/private/size_hint.rs and reproduced with a counting allocator (250 B of nested array32 headers -> 50.0 MiB requested); CodeRabbit's "stale figure" premise was wrong, only the units were sloppy. - serializer/mod.rs: check_structure is pub(crate); linking it from public rustdoc trips private_intra_doc_links. Plain code spans now. Also resolved the four pre-existing unresolved module-doc links in interop.rs and memcached.rs (//! docs resolve in the parent scope) so cargo doc is warning-free. - README: decode-bounds.json and interop-mode.json both link the vendored copies the test suite actually runs (upstream decode-bounds.json 404s until protocol#59 merges), with one link to the protocol repo root. - Cargo.lock: async-trait 0.1.89 -> 0.1.92. Rust 1.99 beta clippy's double_must_use fires on the #[must_use] async-trait 0.1.89 injects onto every generated method (Pin> is already must_use); 0.1.92 removes it (dtolnay/async-trait#303). Adds syn 3.0.4 as a compile-time proc-macro dep alongside syn 2 (MSRV 1.71 <= 1.85; OSV clean; cargo deny passes; crates.io artifacts byte-identical to the 0.1.92 / 3.0.4 tags). Beta clippy, stable clippy, and the 1.85 lane verified locally. CodeRabbit-Resolved: crates/cachekit/src/serializer/mod.rs:38:stale serde pre-allocation CodeRabbit-Resolved: crates/cachekit/src/serializer/mod.rs:119:rustdoc intra-doc link to CodeRabbit-Resolved: README.md:202:dead link to decode-bounds --- Cargo.lock | 65 ++++++++++++-------- README.md | 2 +- crates/cachekit/src/backend/memcached.rs | 4 +- crates/cachekit/src/interop.rs | 4 +- crates/cachekit/src/serializer/mod.rs | 18 +++--- crates/cachekit/tests/decode_bounds_tests.rs | 7 ++- 6 files changed, 57 insertions(+), 43 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 48b324a..976ffcd 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -106,13 +106,13 @@ dependencies = [ [[package]] name = "async-trait" -version = "0.1.89" +version = "0.1.92" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9035ad2d096bed7955a320ee7e2230574d28fd3c3a0f186cbea1ff3c7eed5dbb" +checksum = "82f6aeea286b8eb4dd3431a1be1b59d290ace00f5bfd8e2a159bc2a05e2c1667" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 3.0.4", ] [[package]] @@ -217,7 +217,7 @@ version = "0.7.0" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 2.0.117", ] [[package]] @@ -273,7 +273,7 @@ dependencies = [ "quote", "serde", "serde_json", - "syn", + "syn 2.0.117", "tempfile", "toml", ] @@ -467,7 +467,7 @@ checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 2.0.117", ] [[package]] @@ -485,7 +485,7 @@ dependencies = [ "once_cell", "proc-macro2", "quote", - "syn", + "syn 2.0.117", ] [[package]] @@ -575,7 +575,7 @@ checksum = "1458c6e22d36d61507034d5afecc64f105c1d39712b7ac6ec3b352c423f715cc" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 2.0.117", ] [[package]] @@ -634,7 +634,7 @@ checksum = "e835b70203e41293343137df5c0664546da5745f82ec9b84d40be8336958447b" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 2.0.117", ] [[package]] @@ -1257,7 +1257,7 @@ checksum = "d9b20ed30f105399776b9c883e68e536ef602a16ae6f596d2c473591d6ad64c6" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 2.0.117", ] [[package]] @@ -1315,7 +1315,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b" dependencies = [ "proc-macro2", - "syn", + "syn 2.0.117", ] [[package]] @@ -1729,7 +1729,7 @@ checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 2.0.117", ] [[package]] @@ -1789,7 +1789,7 @@ checksum = "0a7d91949b85b0d2fb687445e448b40d322b6b3e4af6b44a29b21d9a5f33e6d9" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 2.0.117", ] [[package]] @@ -1870,6 +1870,17 @@ dependencies = [ "unicode-ident", ] +[[package]] +name = "syn" +version = "3.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e6275cddf4610d1775e6d1fe9469b2e77d0f39fd98fb7450901b821e0c53649f" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + [[package]] name = "sync_wrapper" version = "1.0.2" @@ -1887,7 +1898,7 @@ checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 2.0.117", ] [[package]] @@ -1935,7 +1946,7 @@ checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 2.0.117", ] [[package]] @@ -1946,7 +1957,7 @@ checksum = "ebc4ee7f67670e9b64d05fa4253e753e016c6c95ff35b89b7941d6b856dec1d5" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 2.0.117", ] [[package]] @@ -1997,7 +2008,7 @@ checksum = "5c55a2eff8b69ce66c84f85e1da1c233edc36ceb85a2058d11b0d6a3c7e7569c" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 2.0.117", ] [[package]] @@ -2315,7 +2326,7 @@ dependencies = [ "bumpalo", "proc-macro2", "quote", - "syn", + "syn 2.0.117", "wasm-bindgen-shared", ] @@ -2358,7 +2369,7 @@ checksum = "3c81b9fef827e575e0e54431736d1baa0d700315d8c62cfef1f61fa3aad0cbeb" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 2.0.117", ] [[package]] @@ -2650,7 +2661,7 @@ dependencies = [ "heck", "indexmap", "prettyplease", - "syn", + "syn 2.0.117", "wasm-metadata", "wit-bindgen-core", "wit-component", @@ -2666,7 +2677,7 @@ dependencies = [ "prettyplease", "proc-macro2", "quote", - "syn", + "syn 2.0.117", "wit-bindgen-core", "wit-bindgen-rust", ] @@ -2763,7 +2774,7 @@ dependencies = [ "async-trait", "proc-macro2", "quote", - "syn", + "syn 2.0.117", "wasm-bindgen", "wasm-bindgen-futures", "wasm-bindgen-macro-support", @@ -2813,7 +2824,7 @@ checksum = "b659052874eb698efe5b9e8cf382204678a0086ebf46982b79d6ca3182927e5d" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 2.0.117", "synstructure", ] @@ -2834,7 +2845,7 @@ checksum = "7e6cc098ea4d3bd6246687de65af3f920c430e236bee1e3bf2e441463f08a02f" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 2.0.117", ] [[package]] @@ -2854,7 +2865,7 @@ checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 2.0.117", "synstructure", ] @@ -2875,7 +2886,7 @@ checksum = "85a5b4158499876c763cb03bc4e49185d3cccbabb15b33c627f7884f43db852e" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 2.0.117", ] [[package]] @@ -2908,7 +2919,7 @@ checksum = "eadce39539ca5cb3985590102671f2567e659fca9666581ad3411d59207951f3" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 2.0.117", ] [[package]] diff --git a/README.md b/README.md index b335c1b..14140ae 100644 --- a/README.md +++ b/README.md @@ -199,7 +199,7 @@ cache.set_with_ttl(&key, &user, ttl).await?; // plain MessagePack — a let user: Option = cache.interop_get(&key).await?; // strict read: exactly one document ``` -Argument hashing is byte-identical across SDKs (canonical MessagePack + Blake2b-256), verified against the shared [protocol test vectors](https://github.com/cachekit-io/protocol/blob/main/test-vectors/interop-mode.json) in this repo's test suite. `interop_get` (also on `SecureCache`) rejects trailing bytes and Python-internal CK frames instead of silently misreading them. Every decode of backend-supplied bytes (`get` and `interop_get` alike) runs under an explicit nesting-depth bound (`serializer::MAX_DECODE_DEPTH` = 100, matching the TypeScript SDK) and a header-only structural walk that rejects headers declaring more than the input can back, verified against the protocol's shared [`decode-bounds.json`](https://github.com/cachekit-io/protocol/blob/main/test-vectors/decode-bounds.json) vectors — a forged nested-header entry is a bounded `Serialization` error, not a memory blow-up or a stack overflow. Encryption works unchanged — interop keys are identical across SDKs, so the AAD verifies cross-SDK. +Argument hashing is byte-identical across SDKs (canonical MessagePack + Blake2b-256), verified against the shared [protocol](https://github.com/cachekit-io/protocol) test vectors ([`interop-mode.json`](crates/cachekit/tests/vectors/interop-mode.json), vendored) in this repo's test suite. `interop_get` (also on `SecureCache`) rejects trailing bytes and Python-internal CK frames instead of silently misreading them. Every decode of backend-supplied bytes (`get` and `interop_get` alike) runs under an explicit nesting-depth bound (`serializer::MAX_DECODE_DEPTH` = 100, matching the TypeScript SDK) and a header-only structural walk that rejects headers declaring more than the input can back, verified against the protocol's shared [`decode-bounds.json`](crates/cachekit/tests/vectors/decode-bounds.json) vectors (vendored) — a forged nested-header entry is a bounded `Serialization` error, not a memory blow-up or a stack overflow. Encryption works unchanged — interop keys are identical across SDKs, so the AAD verifies cross-SDK. > [!IMPORTANT] > Use interop keys on a client **without** `.namespace()` — a client prefix would rewrite the storage key to `{prefix}:{interop_key}`, which no other SDK computes. `interop_get` fails closed with a config error rather than silently missing; interop keys already carry their own namespace segment. diff --git a/crates/cachekit/src/backend/memcached.rs b/crates/cachekit/src/backend/memcached.rs index 7e1fa5d..a096358 100644 --- a/crates/cachekit/src/backend/memcached.rs +++ b/crates/cachekit/src/backend/memcached.rs @@ -11,7 +11,7 @@ //! different key. The ASCII `get` validates the echoed key, and a desynced //! connection fails its next pool-checkout ping and is discarded. Every //! operation additionally runs under a hard async time budget (see -//! [`MemcachedBackendBuilder::timeout`]) so a wedged server surfaces as a +//! [`crate::backend::memcached::MemcachedBackendBuilder::timeout`]) so a wedged server surfaces as a //! `Timeout` error instead of hanging callers. //! //! ## TTL capability — the honest parity picture @@ -24,7 +24,7 @@ //! //! This backend mirrors that exactly: no [`TtlInspectable`] impl (the trait //! requires the unreadable `ttl()`), and a bare inherent -//! [`refresh_ttl`](MemcachedBackend::refresh_ttl) wrapping `touch`. Rust +//! [`refresh_ttl`](crate::backend::memcached::MemcachedBackend::refresh_ttl) wrapping `touch`. Rust //! *could* read TTLs via the meta protocol (`mg t`, memcached >= 1.6), //! but shipping a capability py cannot match would make TTL-driven behaviour //! diverge between SDKs on the same cluster. Revisit only when cachekit-py diff --git a/crates/cachekit/src/interop.rs b/crates/cachekit/src/interop.rs index 67abef6..fc08ae2 100644 --- a/crates/cachekit/src/interop.rs +++ b/crates/cachekit/src/interop.rs @@ -24,7 +24,7 @@ //! sorted by encoded bytes, and integral-float collapse. `rmp-serde` happens to //! emit shortest forms but provides no sorting, no set semantics, and no number //! canonicalization — hashing whatever serde produces would make key equality an -//! implementation accident. The closed [`InteropValue`] model plus an explicit +//! implementation accident. The closed [`crate::interop::InteropValue`] model plus an explicit //! encoder is the only way to guarantee byte-identical hashes across SDKs. //! //! # Values @@ -34,7 +34,7 @@ //! (via [`crate::serializer`]), so regular [`crate::CacheKit::set`] output is //! interop-readable as-is. Reads are the sharp edge: interop readers MUST //! consume exactly one MessagePack document and reject trailing bytes — see -//! [`deserialize`]. +//! [`crate::interop::deserialize`]. //! //! # Example //! diff --git a/crates/cachekit/src/serializer/mod.rs b/crates/cachekit/src/serializer/mod.rs index 813fa57..9509c60 100644 --- a/crates/cachekit/src/serializer/mod.rs +++ b/crates/cachekit/src/serializer/mod.rs @@ -16,7 +16,7 @@ use crate::error::CachekitError; /// every profile and target (wasm32 included), and sits inside the protocol's /// required `32..=1024` window (`spec/interop-mode.md` → Decode bounds). /// -/// Depth is only half the bound: see [`check_structure`] for the allocation +/// Depth is only half the bound: see `check_structure` for the allocation /// half. `tests/decode_bounds_tests.rs` runs the shared `decode-bounds.json` /// vectors against both decode entry points so a dependency bump cannot move /// either silently. @@ -31,11 +31,13 @@ pub const MAX_DECODE_DEPTH: usize = 100; /// reserved marker, truncation, and length overflow. /// /// Why it is needed even though `rmp-serde` reads str/bin lazily: serde's -/// `Vec` visitor pre-allocates `min(declared_len, 1 MiB)` per collection -/// from `size_hint`, so without this walk a 500-byte payload of nested -/// `array32(0xFFFFFFFF)` headers costs `MAX_DECODE_DEPTH` MiB before the first -/// EOF error — an OOM kill on a Cloudflare Workers isolate. Trailing bytes are -/// left to the caller (auto mode ignores them; interop rejects them). +/// sequence visitors (`Vec`, and the `Content` buffer that +/// `#[serde(untagged)]` targets decode through) reserve +/// `min(declared_len × size_of::(), 1 MiB)` bytes per collection from +/// `size_hint`, so without this walk a 500-byte payload of nested +/// `array32(0xFFFFFFFF)` headers requests `MAX_DECODE_DEPTH` MiB before the +/// first EOF error — an OOM kill on a Cloudflare Workers isolate. Trailing +/// bytes are left to the caller (auto mode ignores them; interop rejects them). pub(crate) fn check_structure(bytes: &[u8]) -> Result<(), CachekitError> { fn reject(what: &str) -> CachekitError { CachekitError::Serialization(format!("decode bound: {what}")) @@ -95,7 +97,7 @@ pub(crate) fn check_structure(bytes: &[u8]) -> Result<(), CachekitError> { /// /// Every decode of backend-supplied bytes (auto-mode [`deserialize`] and /// [`crate::interop::deserialize`]) MUST go through here so the bounds cannot -/// drift between paths. Runs [`check_structure`] first, then applies +/// drift between paths. Runs `check_structure` first, then applies /// [`MAX_DECODE_DEPTH`]. pub(crate) fn bounded_deserializer( bytes: &[u8], @@ -116,7 +118,7 @@ pub fn serialize(value: &T) -> Result, CachekitError> { } /// Deserialize `bytes` from MessagePack into `T` under the decode bounds -/// ([`MAX_DECODE_DEPTH`], [`check_structure`]). Trailing bytes are ignored +/// ([`MAX_DECODE_DEPTH`], `check_structure`). Trailing bytes are ignored /// (auto mode is SDK-internal; interop mode's strict single-document read is /// [`crate::interop::deserialize`]). pub fn deserialize(bytes: &[u8]) -> Result { diff --git a/crates/cachekit/tests/decode_bounds_tests.rs b/crates/cachekit/tests/decode_bounds_tests.rs index d0ba808..959a38b 100644 --- a/crates/cachekit/tests/decode_bounds_tests.rs +++ b/crates/cachekit/tests/decode_bounds_tests.rs @@ -140,9 +140,10 @@ fn depth_bound_is_owned_and_matches_the_typescript_sdk() { }); } -/// A recursive `Vec`-bearing target: serde's `Vec` visitor pre-allocates -/// `min(declared, 1 MiB)` per level from the header, so WITHOUT the structural walk -/// 50 nested `array32(0xFFFFFFFF)` headers (250 bytes) cost 50 MiB before EOF. +/// A recursive `Vec`-bearing target. `#[serde(untagged)]` decodes through serde's +/// `Content` buffer, which pre-allocates from `size_hint` like `Vec` (1 MiB per +/// level; see `check_structure`), so WITHOUT the structural walk 50 nested +/// `array32(0xFFFFFFFF)` headers (250 bytes) request 50 MiB before EOF. /// `serde_json::Value` happens to allocate nothing here, which is why the vector /// tests alone cannot catch a walk regression — this one can. #[derive(Debug, Deserialize)]