jcs-admit

Admission control for JSON that is about to be signed or verified. It checks the raw bytes before any parser sees them, refuses documents that two parsers could read differently, and then writes the RFC 8785 canonical form.

It's for Rust code that signs, verifies or hashes canonical JSON, such as in-toto statements, DSSE payloads or signed receipts.

Quick start

Add it as a pinned dependency of a new project:

cargo new jcs-admit-demo && cd jcs-admit-demo
cargo add jcs-admit@=0.1.3

Then put this in src/main.rs to admit a document before you sign it:

use jcs_admit::{admit, Error};

fn main() -> Result<(), Error> {
    let canonical = admit(br#"{ "b": 1, "a": [1.0, 1e30] }"#)?;
    assert_eq!(canonical, br#"{"a":[1,1e+30],"b":1}"#);

    // One document, two readings: refused before any parser picks one.
    let refused = admit(br#"{"a":1,"a":2}"#);
    assert!(matches!(refused, Err(Error::DuplicateMember { .. })));

    println!("{}", String::from_utf8_lossy(&canonical));
    Ok(())
}

cargo run prints {"a":[1,1e+30],"b":1}.

What it refuses

It refuses a repeated object member, compared on the decoded name; nesting past a depth cap, 128 by default, the value the in-toto attestation specification sets; a string whose bytes aren't Unicode scalar values, such as an unpaired surrogate or an overlong form; a number with no finite double, and under the opt-in I-JSON profile an integer at or above 2^53; and an input past a size cap. Each refusal is a named error variant with structured fault details, such as a byte offset or offending token. Number formatting is delegated to serde_json_canonicalizer.

Status

Version 0.1.3 on crates.io, minimum Rust 1.74. The tests load vectors produced by the Go implementation in agent-evidence-vectors, never by this crate, and every refusal is mutation-tested.

Version 0.1.2 adds optional error serialization and the shared byte-cap check. The npm package has its own version and release, and is not yet on the npm registry. The Python wheel is built and tested from python/ and is not yet on PyPI.

Documentation

page	read it for
JavaScript and WebAssembly	raw-byte Node and browser API, packed consumer checks and release verification
Python	the `probityai` wheel's bytes-in, bytes-out API, its refusal contract and the corpora it is tested on
Design and evidence	why a serializer can't make these checks, what the delegate does with a hostile document, and the test evidence
APS canonical-byte comparison	pinned 8-case and 10-case byte results and how to reproduce them
Python byte-profile comparison	independent byte cases, native raw-input refusals and a source-pinned Python consumer
Go raw-admission adapter	pinned Go bytes, original input admission and explicit root/profile boundaries
Version 0.1.3 API reference	every function, option and error variant in the installed release
Agent guide	raw-input admission, profile selection and runnable comparisons
Comparison with other RFC 8785 crates	how seven RFC 8785 crates on crates.io handle hostile input
Mutation sweep	how each refusal was shown to be tested
Contributing and changelog	how to propose a change, and what each release changed

License