1. Status, scope and licence
Document version: profile 1.4.1, 2026-10-21. The schema identifier is unchanged; profiles 1.2.1, 1.3, 1.4 and 1.4.1 resolve ambiguities found by independent clean-room reviews (see the changelog).
This is the specification of the work-acceptance record (also called a receipt), schema identifier trilatic.acceptance-receipt/1.2. The record is a signed, timestamped statement: these criteria, fixed in advance, were checked on this exact delivered file, by this checker, and these are the per-criterion outcomes.
What this page covers: the record, and how to verify it. What it does not cover: how any check or any remediation is performed. A record states outcomes only; it never states methods, and a conforming verifier needs no knowledge of them.
The key words MUST, MUST NOT, SHOULD and MAY are used as in RFC 2119. A verifier is any program implementing section 10. A checker is the party that issues the record. A producer is the party that made the delivered file. A buyer is the party deciding whether to accept the delivered file.
Licence. The text of this specification is licensed under Creative Commons Attribution 4.0 International (CC BY 4.0): share and adapt with attribution to Trilatic Desks. The test vectors are dedicated to the public domain under CC0 1.0. Earlier schema versions (/1 and /1.1) are out of scope here; a verifier MAY support them.
2. The artefacts
| Artefact | What it is |
|---|---|
receipt.json | The record: a JSON object with three members, receipt (the signed body), signature and timestamp. Section 3. |
receipt.tsr | Optional. The RFC 3161 TimeStampResp covering the record digest. Section 6. |
Criteria document and its .tsr | The buyer-facing requirements, published as canonical JSON, with an RFC 3161 timestamp over its SHA-256 made before any record cites it. Section 7. |
| Key list | The checker's public keys, published by the checker (for example at /.well-known/trilatic-receipt-key.json on the checker's own domain). Section 5. |
| The delivered file | The exact bytes the record is about. The record binds to them by SHA-256. |
3. Data model
All JSON is UTF-8. Numbers in a record are integers. Unknown members MUST be ignored for display but remain covered by the signature (the signature is over the whole receipt object, section 4).
3.1 Envelope (the top-level object of receipt.json)
| Member | Type | Req. | Meaning |
|---|---|---|---|
receipt | object | MUST | The signed body, section 3.2. |
signature | object | MUST | alg: the string Ed25519. key_id: string naming the signing key in the key list. value: standard base64 (with padding) of the 64-byte Ed25519 signature over the canonical bytes of receipt. |
timestamp | object | MUST | Not signed. status: granted or none. When granted: tsa (string, host of the time-stamp authority), gen_time (the authority's time as ASN.1 GeneralizedTime YYYYMMDDHHMMSSZ), digest_sha256 (lowercase hex of the record digest, section 6), tsr_file (name of the companion file), covers (human-readable). When none: reason (string). The record is valid without a timestamp; it then carries no independent time evidence. |
3.2 Body (receipt)
| Member | Type | Req. | Meaning |
|---|---|---|---|
schema | string | MUST | Exactly trilatic.acceptance-receipt/1.2. A verifier MUST reject an unknown value for this member rather than guess. |
canonicalization | string | MUST | Exactly JCS-RFC8785. Verifiers MUST reject any other value. No silent fallback to another rule. |
suite | object | MUST | Exactly {"digest":"sha-256","signature":"Ed25519"}. Declares the mechanisms; verifiers MUST reject anything else. |
receipt_id | string | MUST | Identifier assigned by the checker. Unique per checker. |
revision | integer | MUST | 1 for a first issue; incremented when the same receipt is re-issued (for example after a human review is added). |
supersedes_sha256 | string | MAY | Present when revision > 1: lowercase hex of the record digest of the revision this one replaces. |
issued_utc | string | MUST | ISO 8601 UTC with seconds and trailing Z, the checker's own clock. Used as the reference time when there is no timestamp (section 7). |
issuer | string | MUST | Display name of the issuing organisation. |
key_id | string | MUST | Identifier of the signing key. MUST equal signature.key_id and parties.checker.key_id. |
parties | object | MUST | checker and producer, each {"name": string, "key_id": string or null}. checker.key_id is the signing key. producer.key_id is the producer's own signing key if it has one, else null. Section 8. |
independence | string | MUST | One of independent, self-checked, undeclared. Derived from parties by the rule in section 8; a verifier recomputes it. |
criteria | object | MUST | id (criteria set identifier), version (string), sha256 (lowercase hex of the committed criteria document), committed_at (ISO 8601 UTC: the time-stamp authority's time for that commitment), commitment (the string rfc3161). Section 7. |
criteria_commitment | object | MAY | Optional binding to client-agreed terms: {"type":"signed_terms","digest":"<lowercase hex sha-256>"}. Verifiers display it; this specification defines no further check. |
payment | object | MAY | The payment the record concerns, inside the signed and timestamped body. For x402 exact on an EVM network: {"protocol":"x402","scheme":"exact","network":"eip155:<chain id>","asset":<token contract>,"payer":<address>,"pay_to":<address>,"amount":<atomic units, decimal string>,"nonce":<EIP-3009 nonce, 0x hex>}, optionally "settlement_tx". Every member is a string: network is eip155: and a decimal chain id without leading zeros (CAIP-2), amount a decimal string of atomic units, addresses 20 and nonce and settlement_tx 32 bytes of 0x hex; no other members. A member outside this form is still outcome-neutral (vector 55); a chain checker reports it unsupported. (network, asset, payer, nonce) names exactly one settlement. The member changes no outcome (section 10); a verifier with chain access MAY check it and report it separately. |
client_ref | string | MUST | Free text reference chosen by the requester; may be empty. Do not put personal data in it: the record is public. |
files | object | MUST | original and remediated, each {"name": string, "sha256": hex, "bytes": integer, "pages": integer}. remediated describes the delivered file the record is about; original is informational (the file the delivery was derived from). |
results | array | MUST | One entry per criterion of the committed criteria document: id, title, required (boolean), result (section 9), finding (short plain-language statement of the outcome). |
human_review | object | MUST | status: pending or complete; scope: array of strings stating what a human review covers. When complete: outcome (pass or fail), reviewer (string), reviewed_utc, notes_sha256 (hex SHA-256 of the reviewer's notes, which are not published). |
verdict | string | MUST | One of pass, fail, incomplete. Derived by the rule in section 9; a verifier recomputes it. |
tools | object | MUST | Informational: names and versions of third-party validators whose output a result relies on, so a reader can reproduce it. States no method. |
notice | string | MUST | The record's limitation statement: what it does not claim (for example, that it is not a compliance determination). |
4. Canonicalization (JCS) and what is signed
The signed bytes are the JSON Canonicalization Scheme, RFC 8785 (JCS) serialisation of the receipt member only (not the envelope), encoded as UTF-8. Verifiers MUST parse receipt.json and re-canonicalize the receipt member; they MUST NOT rely on the bytes of the file, which may be re-wrapped, re-indented or have its line endings changed in transit.
- Object members are sorted by their names compared as sequences of UTF-16 code units (not code points, not UTF-8 bytes).
- No whitespace between tokens.
- Numbers use the ECMAScript number-to-string rule (RFC 8785 §3.2.2.3): for example
0.00001,1e-7,123456789012345680000,1e+21. A JSON number is an IEEE double, so an integer beyond 253 is written as the double it parses to (vector 52). - Strings are written in UTF-8 with only these escapes:
\",\\,\b,\f,\n,\r,\t, and\u00xx(lower-case hex) for the other control characters below U+0020. All other characters, including U+007F and non-ASCII, are written literally. true,falseandnullare literal.
The record digest used for timestamping (section 6) and for citing a record elsewhere is sha256(JCS(receipt)), written as 64 lowercase hex characters.
Hexadecimal digests. A SHA-256 digest written in a record, such as criteria.sha256, MUST be exactly 64 lowercase hexadecimal digits (0-9, a-f). A verifier does not lower-case it: any other form, upper case included, matches no digest. For criteria.sha256 that means CRITERIA_HASH_MISMATCH when the criteria document is supplied and CRITERIA_TIMESTAMP_MISMATCH when a token is supplied (vector 67).
5. Signature and keys
- Take
receipt.key_id, the key identifier inside the signed bytes. The envelope'ssignature.key_idMUST equal it, elseSIGNATURE_INVALID(the envelope is not signed, so it cannot choose the key). Find the key with that identifier in the checker's published key list. If none: fail withSIGNATURE_INVALID. Whether the signer is the checker named inpartiesis a separate check (section 8,CHECKER_NOT_SIGNER). - Key rule. The public key MUST be the canonical 32-byte encoding (y < p; no x = 0 with the sign bit set) of a point of prime order L: not the neutral point, not of small order, not of mixed order. A verifier MUST check this before verifying and, for a key that fails it, report
KEY_REJECTEDand run no signature check.KEY_REJECTEDis a finding about the key list, not evidence that the record was altered. The rule applies to the key named by the signedreceipt.key_idonly: other entries in the key list do not change the outcome fields, and a verifier MAY report them separately (vector 28). (The cofactorless equation accepts a signature for any message under the neutral point, and common Ed25519 libraries accept such a key; vector 26.) - The key list is a JSON object
{"issuer": string, "keys": [{"key_id": string, "alg": "Ed25519", "public_key_base64": base64 of the 32-byte raw public key, "status": string, "created_utc": string}]}. How a verifier establishes that it is looking at the genuine key list (HTTPS to the checker's domain, a pinned key, an out-of-band exchange) is the verifier's trust decision and is outside the record. - Verify the Ed25519 (RFC 8032) signature
valueover the JCS bytes ofreceiptwith that public key. Any failure, including malformed base64 or a wrong-length value, isSIGNATURE_INVALID. When the signature fails, a verifier MUST NOT present the record's verdict or findings as results. - A key with a retired status still verifies records issued while it was active; a verifier SHOULD show the status.
- Canonical base64. Every base64 value a verifier reads MUST be canonical: only the characters
A-Z,a-z,0-9,+and/;=padding, so that the length is a multiple of four; no whitespace or any other character; and re-encoding the decoded bytes MUST give the input string exactly, so a value with non-zero trailing bits is refused. A signature value that is not canonical isSIGNATURE_INVALID. A public key that is not canonical isKEY_REJECTED. A token or criteria file in a vector that is not canonical base64 matches nothing: its imprint or hash check fails, and it is reported as the corresponding mismatch (CRITERIA_HASH_MISMATCH,CRITERIA_TIMESTAMP_MISMATCH, orimprint_mismatchfor the record's token), never as a refusal (vectors 60 to 63, 89 and 90). - Repeated key identifier. In a schema 1.2 record, a
key_idthat appears more than once in the key list names no single key, whichever entry comes first: the verifier reportsKEY_REJECTED(vectors 75 and 79). If the repeated identifier is the signing key's, no signature check is run. If it is the producer's or the checker's, independence is derived asself-checked(section 8).
6. RFC 3161 timestamp coverage
The checker sends the 32-byte record digest (section 4) to a public time-stamp authority as the messageImprint (SHA-256) of an RFC 3161 TimeStampReq. The authority's TimeStampResp is stored as receipt.tsr. The timestamp covers the record digest, and therefore every member of receipt; it does not cover the envelope's timestamp member itself.
A verifier checks, at increasing strength:
- Consistency (informative).
timestamp.digest_sha256equalssha256(JCS(receipt)). The envelope'stimestampmember is not signed; a verifier MAY show a disagreement, but the outcome is decided by the token (step 2), never by this field. - Imprint. The
messageImprintof the token's signed TSTInfo (TimeStampResp or ContentInfo → SignedData →encapContentInfoof typeid-ct-TSTInfo→ TSTInfo) hashashAlgorithmSHA-256 (OID 2.16.840.1.101.3.4.2.1, parameters absent or NULL) andhashedMessageequal to that digest. An imprint under any other algorithm is not a match, even when its value has the same length and the same bytes (SHA-384, SHA3-256, SHA-512/256: vectors 23 to 25). (The reference verifier on this site stops here and says so.)genTimeandaccuracyare read from the same TSTInfo. Nothing outside the signed TSTInfo is read for imprint or time: bytes elsewhere in a response, such asPKIStatusInfo.statusString, are not signed by the authority (vectors 50 and 51). Likewise, unsigned attributes of the SignerInfo (unsignedAttrs) are not read, and their presence or content is not a ground for refusal (vector 83). - Authority. The outcome fields of this profile cover imprint and time only; they do not say that the authority's signature was checked. A verifier that presents a time as evidence to a third party SHOULD also validate the CMS signature on the token and its certificate chain to an authority the relying party trusts, and report that result separately from the outcome fields. Which authorities are trusted is the relying party's decision, as for keys (section 5).
timestamp.gen_timeMUST equal the TSTInfogenTime. - Accuracy and ordering. When a token states
accuracy, its time is the intervalgenTime± accuracy, and comparisons in section 7 use the end of the interval that is least favourable to "committed before". A token that states no accuracy is taken at itsgenTime.orderingis ignored: it orders tokens from one authority only, and the two tokens compared here may come from different authorities. - Form of
genTime.genTimeMUST be a DER GeneralizedTime in UTC:YYYYMMDDHHMMSS, then optionally.and one or more digits of which the last is not0, thenZ. The letterZis required: a time with an offset, such as+0100, is refused. The separator is.only; a comma, an empty fraction and a fraction with a trailing zero (.5000,.000) are refused. The calendar fields MUST be real: month 01 to 12, a day that exists in that month (leap years included), hour 00 to 23, minute 00 to 59, second 00 to 59. AgenTimethat fails any of this is no usable time: the token is then treated as one that gives no time (section 7.3 step 4; vectors 70 to 74 and 78). A verifier never fails on it. A fraction is kept to the millisecond. In the comparison of section 7.3 step 5 the commitment time is rounded up to the next millisecond and the reference time down, so that a fraction can never make "committed before" easier, and the comparison is strict (<) at millisecond resolution (vectors 66 and 68). The comparison ofcommitted_atwithgenTime(CRITERIA_TIME_MISMATCH) is to the second.
Authority signature outcome (tsa_signature, profile 1.4). The outcome reports the
authority's signature for each token present, under the keys criteria (the criteria token) and receipt (the record token), in a field separate from receipt_timestamp, which covers the imprint only.
Without relying-party trust anchors (none supplied, or an empty list) the signature is not_evaluated; a verifier may omit the field, and
an absent field is read as not_evaluated for each token present. With anchors the value is one of:
verified (the CMS signature, the contentType signed attribute equal to an
eContentType of id-ct-TSTInfo (RFC 5652 §5.3), the ESS signing-certificate binding
(RFC 3161 §2.4.2, RFC 5816), id-kp-timeStamping, and a chain whose issuers are CAs reaching a
supplied anchor (matched by subject name and public key, RFC 5280 §6.1.1, not by certificate bytes, so a cross-signed copy of the anchor in the token still reaches it, and an anchor with the issuer's name but another key is not that issuer: if only such anchors fail, no chain reaches a supplied anchor, vector 53), with the signer and every issuer other than the anchor valid at genTime, all check out); failed (any of those checks fails, or the token is malformed);
untrusted (the signature is valid but no chain reaches a supplied anchor; a root carried inside the token is
not an anchor); unsupported (an algorithm the verifier does not implement, e.g. a curve other than P-256/P-384;
RSA PKCS#1 v1.5 and ECDSA P-256/P-384 are required, RSASSA-PSS is optional); no_signer (the token has no SignerInfo, or the signer certificate is neither in the token
nor among the supplied certificates). Nothing is reported for an absent token: receipt_timestamp is
already none for a missing record token, and CRITERIA_COMMITMENT_UNVERIFIED already flags a
missing criteria token. tsa_signature never changes any other outcome member. When a token has more than one defect, the value is failed if any check that can run fails; otherwise no_signer, then unsupported, then untrusted. A check that cannot run (no signer certificate, an algorithm the verifier does not implement) does not stop the others. An issuer in the token that fails a check (for example, not valid at genTime) is failed whether or not the chain reaches a supplied anchor (vector 54).
If timestamp.status is none, or no token is supplied to the verifier, the record is still valid but carries no verified time; the reference time for section 7 is then issued_utc, the checker's own claim. If a token is supplied but its imprint is not the record digest (step 2), the verifier reports receipt_timestamp: imprint_mismatch, MUST NOT use that timestamp as evidence of time (the reference time falls back to issued_utc) and SHOULD show the mismatch prominently. This profile defines no problem code for it; the outcome field receipt_timestamp carries it.
7. The criteria commitment rule
Criteria are fixed by the buyer or by a published criteria set before the check, and the commitment is publicly timestamped, so no party can adjust the criteria after seeing the result.
7.1 The criteria document
A JSON object with members: criteria_set (string, equals receipt.criteria.id), version (string, equals receipt.criteria.version), title, result_vocabulary (the array ["pass","fail","not-evaluated","error"]), and criteria: an array of {"id", "title", "requirement", "required"} where requirement is a plain-language statement of what must be true and required is a boolean. The published file is the JCS serialisation of that object with no trailing newline, so the file bytes are the canonical bytes.
7.2 Commitment
The commitment digest is the SHA-256 of the exact file bytes. It is timestamped with RFC 3161 and the token is published beside the file. A criteria document is immutable once committed: any change is a new version.
7.3 Verification
- Criteria hash. If the criteria document is supplied, compute SHA-256 of its bytes; it MUST equal
receipt.criteria.sha256, elseCRITERIA_HASH_MISMATCH. When the hash matches,criteria_setandversionin the document MUST equalcriteria.idandcriteria.version, and the set of(id, required)pairs in the document MUST equal the set of(id, required)pairs inresults, elseCRITERIA_RESULTS_MISMATCH. - Token over the claimed hash. If a timestamp token is supplied, its
messageImprintMUST equalcriteria.sha256(the hash the record claims, whether or not the document itself was supplied), withhashAlgorithmSHA-256 (section 6 step 2), elseCRITERIA_TIMESTAMP_MISMATCH(a token over other bytes, or under another algorithm). The authority's time (genTime) in the token is authoritative for when the criteria were committed. committed_atagainst the token.receipt.criteria.committed_atis the checker's own claim. If a token that coverscriteria.sha256is supplied andcommitted_atdiffers from itsgenTime(ISO 8601 UTC, to the second), the problem isCRITERIA_TIME_MISMATCH, and the token's time is used from here on.- No usable token. Without a token, or with a token that does not cover
criteria.sha256(step 2), or whosegenTimeis not usable (section 6 step 5), the verifier falls back tocommitted_atand MUST emit the warningCRITERIA_COMMITMENT_UNVERIFIED: the commitment time is then only the checker's own claim. - Committed before the check. The commitment time is the token's
genTimewhen a covering token was supplied, elsecommitted_at. The reference time is the earlier ofissued_utcand thegenTimeof the record's own token, when one was supplied that covers this record (section 6); elseissued_utc. A covering token proves the record existed by its time, so it bounds the check from above; it never moves the signed issue time later (vector 22). The criteria were committed before the check iff the commitment time is strictly earlier than the reference time, after widening each token time by its stated accuracy (section 6 step 4). If not, the result iscriteria_committed_before_check: noandCRITERIA_COMMITTED_AFTER_CHECK, which is a problem (it makes the record not acceptable as stated), never a warning. A verifier SHOULD display "criteria committed before check: yes/no". - Stated times.
committed_atandissued_utcMUST be RFC 3339 UTC times in the formYYYY-MM-DDTHH:MM:SS[.fff]Z: a fraction of one to three digits is optional,Zis required, and the calendar fields are real as in section 6 step 5. If one of them is present (not absent,nullor empty) but is not in this form, and it is used in step 5, the verifier reportsRECEIPT_TIME_UNREADABLEandcriteria_committed_before_check: no. It is not reported asCRITERIA_COMMITTED_AFTER_CHECK, and no other comparison is made with that time. A malformed time never makes a verifier fail (vector 76). When a covering token supplies the commitment time,committed_atis not used in step 5 and its difference from the token isCRITERIA_TIME_MISMATCHas before, also when it is not in this form (vector 88).
8. Independence and self-checked
A check by the party that produced the file is a self-check, not an independent check. The record declares both parties.
parties.checker.key_idMUST equal the key identifier the signature was checked under (section 5), elseCHECKER_NOT_SIGNER.- If
parties.checker.key_idandparties.producer.key_idare both non-null and equal, the record is invalid for independence purposes:KEY_COLLISION. - Derivation of
independence(verifiers recompute it and reportINDEPENDENCE_INCONSISTENTon mismatch): let p be the producer name trimmed and lower-cased. If p is empty,unspecifiedorunknown:undeclared. Else if p equals the checker name trimmed and lower-cased, or the producer's and the checker's key identifiers resolve to the same key (item 6):self-checked. Otherwiseindependent, subject to items 5 and 6. - A verifier MUST show a prominent warning,
SELF_CHECKED, forself-checkedrecords, and SHOULD showPRODUCER_UNDECLAREDforundeclaredones. A self-checked record is not an invalid record; it is a record that must not be read as independent. - Independence is checked by key only when a key identifier is stated. A producer with no
key_id(absent ornull) is the normal form, because producers do not sign: the claim then rests on the party names alone (vector 82). When a party'skey_idis stated and the record statesindependence: independent, thatkey_idMUST be non-empty and listed exactly once in the key list. Otherwise the derived independence isself-checked, which differs from the stated value and is reported asINDEPENDENCE_INCONSISTENT(vectors 80 and 81). - An independence claim requires the producer's and the checker's key identifiers, when both are stated, to resolve through the key list to distinct keys. The keys are compared as decoded bytes, not as strings: two identifiers whose entries decode to the same public key are one key, and are treated exactly as equal identifiers (
KEY_COLLISION,self-checked; vector 65). A key-list entry for a stated producer or checker identifier that is not canonical base64 isKEY_REJECTED, and independence is derived asself-checked(vector 69). - This specification checks independence as declared and as bound to keys. It cannot detect two legally related parties that use different names and keys; a buyer's contract should address that.
9. Result vocabulary and the overall verdict
result | Meaning |
|---|---|
pass | The requirement was evaluated and met. |
fail | The requirement was evaluated and not met. |
not-evaluated | The requirement could not be evaluated for this file or has not been evaluated yet (for example no human review). Stated, never hidden. |
error | An evaluation was attempted and failed to complete. Not a pass, not a fail. |
Any other value is RESULT_VOCABULARY.
Derivation of verdict
function verdict(results, human_review):
if human_review.status == "complete" and human_review.outcome == "fail": return "fail"
required = [r.result for r in results if r.required]
if "fail" in required: return "fail"
if required is empty or any(x != "pass" for x in required): return "incomplete"
return "pass"
So the verdict is pass only if every required criterion is pass. A required criterion that is not-evaluated or error yields incomplete: incomplete is never pass. A non-required criterion that is not evaluated does not change the verdict. A required fail takes precedence over incomplete: if any required criterion is fail the verdict is fail whatever else is not-evaluated or error; otherwise any required not-evaluated or error gives incomplete; otherwise pass. A verifier recomputes the verdict from results and human_review; if it differs from the stated verdict, the problem is VERDICT_MISMATCH, and the stated verdict MUST NOT be presented as established.
10. Verification procedure and reported outcome
- Parse JSON. Require the members of section 3.1. Require
schema,canonicalizationandsuiteto be exactly the values in section 3.2; otherwise reject the record as unsupported. Every object, array and string the procedure reads MUST have the type this specification gives it (for example a result'sidis a string and itsrequiredis a boolean or absent); a record or input of any other type is refused in the same way, with no outcome members, and never causes a verifier to fail (vector 77). - Verify the signature (section 5). On failure report
SIGNATURE_INVALID. A verifier SHOULD still run the remaining checks and report their outcome (they are diagnostics about an unsigned document), but MUST NOT present the record's verdict or findings to a reader as results. - If the delivered file is in hand: its SHA-256 MUST equal
files.remediated.sha256; otherwise the record is not about this file. - Verify the timestamp if present (section 6).
- Verify the criteria commitment (section 7).
- Check parties and independence (section 8).
- Check the vocabulary and recompute the verdict (section 9).
The record is accepted as stated when the signature is valid and the list of problem codes is empty. Warnings do not make it invalid but MUST be shown.
| Code | Kind | Raised when |
|---|---|---|
SIGNATURE_INVALID | problem | Unknown key id, or the signature does not verify. |
CHECKER_NOT_SIGNER | problem | parties.checker.key_id differs from signature.key_id. |
KEY_REJECTED | problem | The signing key is not a canonical, prime-order Ed25519 public key (section 5); no signature check was run. Also: a key identifier is listed more than once in the key list, or the key entry of a stated producer or checker identifier is not canonical base64. |
KEY_COLLISION | problem | Checker and producer declare the same key. |
INDEPENDENCE_INCONSISTENT | problem | Stated independence differs from the derived value. |
RESULT_VOCABULARY | problem | A result is not one of the four values. |
VERDICT_MISMATCH | problem | Stated verdict differs from the verdict recomputed by the rule in section 9. |
CRITERIA_HASH_MISMATCH | problem | The criteria document's SHA-256 differs from criteria.sha256. |
CRITERIA_RESULTS_MISMATCH | problem | Results do not correspond to the committed criteria (ids, required flags, set id or version). |
CRITERIA_TIMESTAMP_MISMATCH | problem | The criteria token's imprint is not criteria.sha256 (a token over other bytes). |
CRITERIA_TIME_MISMATCH | problem | criteria.committed_at differs from the genTime of the token over criteria.sha256 (the token is authoritative). |
CRITERIA_COMMITTED_AFTER_CHECK | problem | Commitment time is not strictly earlier than the reference time. A problem, not a warning. |
RECEIPT_TIME_UNREADABLE | problem | committed_at or issued_utc is present but is not an RFC 3339 UTC time YYYY-MM-DDTHH:MM:SS[.fff]Z with real calendar fields (section 7.3 step 6). criteria_committed_before_check is no. |
SELF_CHECKED | warning | independence is self-checked. |
PRODUCER_UNDECLARED | warning | The parties block declares no producer, so independence derives as undeclared, whatever the record states. A stated value that differs is also INDEPENDENCE_INCONSISTENT. |
CRITERIA_COMMITMENT_UNVERIFIED | warning | No usable timestamp token over criteria.sha256 was supplied (none, or one over other bytes), so committed_at (the checker's own claim) was used. |
Payment (receipt.payment, profile 1.4.1). Optional and outcome-neutral: no member of
the outcome depends on it. A verifier with access to the named network MAY report, separately: verified
(the token's EIP-3009 authorizationState(payer, nonce) is used and, given settlement_tx, that
transaction succeeded, emitted AuthorizationUsed(payer, nonce) and Transfer(payer, pay_to, amount)
from asset, in a block no later than issued_utc); authorization_used (the nonce is
used but no settlement_tx was given, so amount and payee are unchecked); not_found;
mismatch; or unsupported. The reference implementation is check_payment.py.
11. SAR profile: how the record answers a Supplemental Accessibility Conformance Report
The GSA model language on defining accessibility criteria (Section508.gov, reviewed March 2026) already asks the contractor to validate conformance, to provide a Supplemental Accessibility Conformance Report (SAR) before acceptance, and reserves the agency's right to test independently. The record is a verifiable output for that step. It does not replace the buyer's decision or its independent testing right.
| SAR need | Where the record answers it |
|---|---|
| What was tested | files.remediated: name, pages, bytes and sha256. The digest binds the statement to the exact delivered bytes. |
| Requirements tested against | criteria.id, criteria.version, criteria.sha256, criteria.committed_at and the committed criteria document (each criterion's id, title, requirement, required); optionally criteria_commitment for client-agreed terms. |
| Results and limitations | results[] (result, finding, required) including not-evaluated and error rows; human_review.scope and status; the notice statement. Limitations are the non-pass rows, the human-review scope and the notice. |
| Who checked | parties.checker (name, key identifier), tools (validator versions), independence relative to parties.producer. |
| Audit trail | signature, timestamp (RFC 3161), receipt_id, revision, supersedes_sha256, and the verification procedure in section 10 of this page. |
| Acceptance decision | Not in the record. The decision to accept or reject is the buyer's, made separately, and SHOULD cite the record digest sha256(JCS(receipt)) of the record it relied on. |
12. EARL export (optional)
A record can be exported as W3C EARL (Evaluation and Report Language) in JSON-LD. The export is a convenience view; the signed record is authoritative.
| EARL | Source in the record |
|---|---|
earl:Assertion | One per entry of results. |
earl:subject (earl:TestSubject) | The delivered file: dct:identifier is sha256: followed by files.remediated.sha256. |
earl:assertedBy | parties.checker (name, key identifier). |
earl:test | The criterion, identified by criteria set, version, criteria.sha256 and the criterion id. |
earl:outcome | pass to earl:passed; fail to earl:failed; error to earl:cantTell; not-evaluated to earl:untested. |
earl:mode | earl:automatic, except the human-review criterion: earl:manual. |
13. Test vectors (CC0)
Eighty-seven self-contained vectors let a clean-room verifier prove itself (01 to 05, 24 to 49, 51 to 55, 57 and 60 to 83 by Trilatic Desks; 06 to 11, 22 and 23 contributed by babyblueviper1; 12 to 21, 50, 58 and 59 contributed by Tetsurohhori; 56, a live receipt from another checker's key, by babyblueviper1; 84 to 87 contributed by actaseal; the cases in 60, 64 to 68 were proposed by actaseal). Each file holds the inputs (the record, a key list, the criteria document and its timestamp token as base64, and optionally the record's timestamp token) and the expected outcome. They are signed with a published test key; never trust a record signed by it. The timestamp tokens in the vectors are imprint-and-time fixtures, not valid RFC 3161 tokens: their SignedData carries no SignerInfo, so a CMS parser that requires a signer (OpenSSL does) refuses them. They exercise imprint and time handling (sections 6 and 7), not authority validation; the live record in the changelog's references carries real tokens. Licence: CC0 1.0.
| File | Case | Expected outcome |
|---|---|---|
| 01-valid.json | Valid record, independent checker, criteria committed before the check, with a record timestamp. | No problems, no warnings, verdict pass. |
| 02-criteria-committed-after-issue.json | Criteria timestamp later than the check. | CRITERIA_COMMITTED_AFTER_CHECK; committed before check: no. |
| 03-self-checked.json | Producer is the checker. | Warning SELF_CHECKED; independence self-checked; no problems. |
| 04-required-not-evaluated.json | A required criterion is not-evaluated. | No problems; recomputed verdict incomplete, never pass. |
| 05-checker-key-equals-producer-key.json | Producer declares the checker's own key. | KEY_COLLISION and warning SELF_CHECKED. |
| 06-receipt-edited-after-signing.json | A finding edited after signing. Contributed by babyblueviper1 (CC0). | SIGNATURE_INVALID; the other checks still report; receipt timestamp imprint_mismatch. |
| 07-criteria-file-swapped.json | Another criteria document is supplied. Contributed by babyblueviper1 (CC0). | CRITERIA_HASH_MISMATCH only; the token over the claimed hash still gives committed before check: yes. |
| 08-receipt-token-over-another-receipt.json | The record's timestamp token covers a different record. Contributed by babyblueviper1 (CC0). | No problem code; receipt timestamp imprint_mismatch (see section 6). |
| 09-stated-pass-recomputes-incomplete.json | Signed verdict pass with a required criterion not-evaluated. Contributed by babyblueviper1 (CC0). | VERDICT_MISMATCH; recomputed verdict incomplete. |
| 10-committed-at-contradicts-token.json | committed_at is before the check but the criteria token's genTime is after it. Contributed by babyblueviper1 (CC0). | CRITERIA_TIME_MISMATCH and CRITERIA_COMMITTED_AFTER_CHECK. |
| 11-required-criterion-fails.json | A required criterion fails. Contributed by babyblueviper1 (CC0). | No problems; verdict fail. |
| 12-signer-is-not-the-checker.json | The signed receipt.key_id and the envelope both name test-2; parties.checker.key_id names test-1. Contributed by Tetsurohhori (CC0). | CHECKER_NOT_SIGNER only. |
| 13-independent-but-same-party.json | Stated independent, but producer and checker are the same party. Contributed by Tetsurohhori (CC0). | INDEPENDENCE_INCONSISTENT. |
| 14-results-not-in-criteria.json | Results do not correspond to the criteria document. Contributed by Tetsurohhori (CC0). | CRITERIA_RESULTS_MISMATCH. |
| 15-criteria-token-over-other-bytes.json | The criteria token covers other bytes. Contributed by Tetsurohhori (CC0). | CRITERIA_TIMESTAMP_MISMATCH; fallback to committed_at with warning CRITERIA_COMMITMENT_UNVERIFIED. |
| 16-no-criteria-token.json | No criteria token. Contributed by Tetsurohhori (CC0). | Warning CRITERIA_COMMITMENT_UNVERIFIED. |
| 17-committed-at-equals-reference.json | Commitment time equals the reference time. Contributed by Tetsurohhori (CC0). | CRITERIA_COMMITTED_AFTER_CHECK (strictly earlier is required). |
| 18-mismatching-record-token-later-time.json | The record token covers other bytes and states a later time. Contributed by Tetsurohhori (CC0). | Not used as time; CRITERIA_COMMITTED_AFTER_CHECK. |
| 19-result-outside-vocabulary.json | A result passed. Contributed by Tetsurohhori (CC0). | RESULT_VOCABULARY and VERDICT_MISMATCH. |
| 20-producer-undeclared.json | No producer declared, stated independent. Contributed by Tetsurohhori (CC0); expectation amended, difference stated in the file. | INDEPENDENCE_INCONSISTENT and warning PRODUCER_UNDECLARED. |
| 21-unknown-schema.json | An unknown schema. Contributed by Tetsurohhori (CC0). | Refused: {"refused": true, "reason": ...}. |
| 22-matching-record-token-later-than-issued.json | A covering record token later than issued_utc, criteria between the two. Contributed by babyblueviper1 (CC0). | Reference time is issued_utc; CRITERIA_COMMITTED_AFTER_CHECK. |
| 23-criteria-token-imprint-oid-sha384.json | Criteria token imprint algorithm SHA-384, same length, same 32 bytes. Contributed by babyblueviper1 (CC0). | CRITERIA_TIMESTAMP_MISMATCH and the fallback warning. |
| 24-criteria-token-imprint-oid-sha3-256.json | As 23 with SHA3-256 (case from robertolocatelli81-dev). | As 23. |
| 25-criteria-token-imprint-oid-sha512-256.json | As 23 with SHA-512/256 (case from robertolocatelli81-dev). | As 23. |
| 26-key-small-order.json | The key list holds the neutral point; the signature (R = neutral, S = 0) satisfies the cofactorless equation for any message. | KEY_REJECTED; signature not valid. |
| 27-key-non-canonical-encoding.json | The key list holds a non-canonical encoding (y = p + 1) of the neutral point. | KEY_REJECTED; signature not valid. |
| 28-key-file-with-unrelated-bad-entry.json | The key list holds an unrelated small-order entry, listed before the valid signing key that the record names (case from robertolocatelli81-dev). | As vector 01: no problems. The key rule applies to the named signing key only. |
| 29-criteria-token-accuracy-flips-commitment.json | The criteria token's genTime is 30 s before the check, but the token states an accuracy of 60 s (case from robertolocatelli81-dev). | CRITERIA_COMMITTED_AFTER_CHECK; committed before check: no. A verifier that ignores accuracy reports yes. |
| 30-criteria-token-accuracy-millis-still-before.json | Control for 29: the same times with an accuracy of 500 ms (the millis field). | No problems; committed before check: yes. |
| 31-tsa-freetsa-verified.json | Live FreeTSA tokens over the criteria and the record; FreeTSA root as anchor. | tsa_signature: criteria and receipt verified; no problems. |
| 32-tsa-digicert-verified.json | Live DigiCert tokens over the criteria and the record; DigiCert Trusted Root G4 as anchor. | Both verified. |
| 33-tsa-unrelated-root-untrusted.json | Vector 31's tokens with an unrelated anchor (DigiCert root). | Both untrusted. |
| 34-tsa-tampered-signature-failed.json | Vector 31 with one bit flipped in the criteria token's signature; imprint and time unchanged. | Criteria failed, receipt verified; every other member as 31. |
| 35-tsa-token-without-signer-certificate.json | A live FreeTSA criteria token requested with certReq=false; no record token. | Criteria no_signer. |
| 36-tsa-no-anchors-not-evaluated.json | Vector 31's tokens with no anchors supplied. | Both not_evaluated (an omitted field reads the same). |
| 37-tsa-synthetic-control-verified.json | A criteria token from a test-only PKI (root, intermediate, TSA), test root as anchor; control for 38 and 39. | Criteria verified. |
| 38-tsa-intermediate-expired-failed.json | As 37, but the intermediate CA expired before genTime; the TSA certificate is still valid. | Criteria failed. |
| 39-tsa-content-type-mismatch-failed.json | As 37, but the signed contentType attribute is id-ct-authData; the signature itself is valid. | Criteria failed. |
| 40-tsa-rsassa-pss-verified.json | As 37, signed with RSASSA-PSS (SHA-256, MGF1-SHA-256, salt 32). | Criteria verified; unsupported also conforms (PSS is optional). |
| 41-tsa-ecdsa-p256-verified.json | As 37, with an ECDSA P-256 TSA key. | Criteria verified. |
| 42-tsa-ecdsa-p521-unsupported.json | As 37, with an ECDSA P-521 TSA key. | Criteria unsupported. |
| 43-tsa-empty-anchor-list-not-evaluated.json | Vector 31's tokens with tsa_roots_base64 present but empty. | Both not_evaluated, as 36. |
| 44-tsa-unsupported-curve-and-bad-digest-failed.json | As 42 (P-521), with a messageDigest attribute that does not match. | Criteria failed. |
| 45-tsa-no-certificates-and-bad-digest-failed.json | A test-PKI token without certificates (as 35), with a messageDigest attribute that does not match. | Criteria failed. |
| 46-tsa-unsupported-curve-and-ess-mismatch-failed.json | As 42 (P-521), with an ESS signing-certificate hash that does not match. | Criteria failed. |
| 47-receipt-payment-x402-exact.json | A passing receipt whose signed body carries payment (x402 exact on Base, synthetic values). | No problems; the same outcome as without the member. |
| 48-tsa-signer-without-timestamping-eku-failed.json | A test-PKI token (root B) whose signer certificate lacks id-kp-timeStamping; everything else holds. | Criteria failed. |
| 49-tsa-issuer-not-a-ca-failed.json | A test-PKI token (root B) whose TSA certificate is issued by a certificate without the CA flag; everything else holds. | Criteria failed. |
| 50-criteria-token-imprint-only-in-status-string.json | Contributed by Tetsurohhori. Vector 31 with the criteria token replaced by the record token; the criteria imprint and time sit only in the unsigned statusString. | CRITERIA_TIMESTAMP_MISMATCH, warning CRITERIA_COMMITMENT_UNVERIFIED; tsa_signature both verified. |
| 51-record-token-imprint-only-in-status-string.json | The record-token side of 50: the receipt's imprint and time sit only in the unsigned statusString of the criteria token placed as the record token. | receipt_timestamp imprint_mismatch; no problems. |
| 52-receipt-non-integer-numbers.json | A passing receipt whose signed body holds non-integer numbers. | No problems (a canonicalizer outside RFC 8785's number form reports SIGNATURE_INVALID). |
| 53-tsa-anchor-same-name-other-key-untrusted.json | Vector 37's token; the only anchor is root B, with root A's name and another key. | Criteria untrusted. |
| 54-tsa-expired-intermediate-no-anchor-failed.json | Vector 38's token (intermediate expired) with an unrelated anchor. | Criteria failed. |
| 55-receipt-payment-outside-the-form.json | As 47, with payment.amount a JSON number and an extra member. | No problems; the same outcome as without the member. |
| 56-third-party-checker-live-receipt.json | Contributed by babyblueviper1: a live receipt issued by their checker under its own key (a self-test, not a real job), kept as received. | No problems. |
| 57-receipt-integer-valued-doubles.json | A passing receipt whose signed body holds 1.0, 100.0, -0.0 and 300.0. | No problems; RFC 8785 writes them 1, 100, 0, 300. |
| 58-criteria-token-imprint-only-in-unsigned-attribute.json | As 50, with the criteria imprint and time in an unsigned attribute of the token's SignerInfo instead of the statusString (a well-formed response); contributed by Tetsurohhori. | CRITERIA_TIMESTAMP_MISMATCH; fallback with warning CRITERIA_COMMITMENT_UNVERIFIED. |
| 59-record-token-imprint-only-in-unsigned-attribute.json | The record-token side of 58, as 51; contributed by Tetsurohhori. | receipt_timestamp imprint_mismatch; no problems. |
| 60-signature-base64-invalid-character.json | A ! inside signature.value; a lax decoder discards it and the signature verifies. | signature_valid false; SIGNATURE_INVALID. |
| 61-signature-base64-internal-whitespace.json | A space inside signature.value. | signature_valid false; SIGNATURE_INVALID. |
| 62-signature-base64-noncanonical-trailing-bits.json | The last base64 character of signature.value carries non-zero trailing bits: the same 64 bytes under a different string. | signature_valid false; SIGNATURE_INVALID. |
| 63-signature-base64-missing-padding.json | signature.value with its = padding removed. | signature_valid false; SIGNATURE_INVALID. |
| 64-envelope-key-id-differs-from-signed-key-id.json | The envelope signature.key_id names another key from the one inside the signed receipt; the key list holds both, with the same public key. | signature_valid false; SIGNATURE_INVALID only. |
| 65-one-public-key-under-two-key-ids.json | The producer's key identifier differs from the checker's, but both entries in the key list hold the same public key. | KEY_COLLISION; warning SELF_CHECKED; independence self-checked. |
| 66-criteria-gentime-fraction-makes-it-after-issue.json | The criteria token's genTime is 12:00:00.5; issued_utc is 12:00:00.250. Read to the second the criteria are earlier; with the fraction they are later. | CRITERIA_COMMITTED_AFTER_CHECK; criteria_committed_before_check no. |
| 67-criteria-sha256-upper-case.json | criteria.sha256 written in upper-case hex (re-signed). | CRITERIA_HASH_MISMATCH, CRITERIA_TIMESTAMP_MISMATCH. |
| 68-criteria-time-equals-issue-time-at-millisecond.json | The criteria genTime 12:00:00.2495 rounds up to .250, which equals issued_utc 12:00:00.250. | CRITERIA_COMMITTED_AFTER_CHECK; no (strict <). |
| 69-key-alias-noncanonical-base64-dodges-same-key.json | The producer's key entry is the checker's key with its last character changed (non-canonical base64). | KEY_REJECTED; independence self-checked. |
| 70-criteria-gentime-with-offset.json | The criteria token's genTime is 20260301010000+0100. | No usable time: warning CRITERIA_COMMITMENT_UNVERIFIED; no problems. |
| 71-criteria-gentime-month-13.json | The criteria token's genTime has month 13. | No usable time: warning CRITERIA_COMMITMENT_UNVERIFIED; no problems. |
| 72-criteria-gentime-feb-30.json | The criteria token's genTime is 30 February. | No usable time: warning CRITERIA_COMMITMENT_UNVERIFIED; no problems. |
| 73-criteria-gentime-comma-fraction.json | The criteria token's genTime uses a comma as the fraction separator. | No usable time: warning CRITERIA_COMMITMENT_UNVERIFIED; no problems. |
| 74-criteria-gentime-trailing-zero-fraction.json | The criteria token's genTime fraction ends in a zero (.5000). | No usable time: warning CRITERIA_COMMITMENT_UNVERIFIED; no problems. |
| 75-duplicate-key-id-in-keys-file.json | The checker's key identifier is listed twice in the key list. | signature_valid false; KEY_REJECTED. |
| 76-committed-at-malformed.json | committed_at is 2026-13-01T00:00:00Z and no criteria token is supplied. | RECEIPT_TIME_UNREADABLE; criteria_committed_before_check no; warning CRITERIA_COMMITMENT_UNVERIFIED. |
| 77-result-id-is-an-object.json | A result's id is an object, not a string. | Refused, as for an unsupported schema. |
| 78-token-imprint-matches-gentime-unusable.json | The criteria token covers criteria.sha256 but its genTime is month 13. | As with no token: warning CRITERIA_COMMITMENT_UNVERIFIED; the time comes from committed_at; no problems. |
| 79-unrelated-duplicate-key-id.json | A key identifier that is neither the producer's nor the checker's is listed twice in the key list. | KEY_REJECTED; the signature is still valid. |
| 80-independent-claim-producer-key-id-empty.json | Independence is claimed; the producer's key_id is the empty string. | INDEPENDENCE_INCONSISTENT (derived self-checked). |
| 81-independent-claim-producer-key-id-unknown.json | Independence is claimed; the producer's key_id is not in the key list. | INDEPENDENCE_INCONSISTENT (derived self-checked). |
| 82-independent-claim-producer-key-id-absent.json | Independence is claimed; the producer states no key_id. The control for 80 and 81: independence rests on the names. | No problems, no warnings; independence independent. |
| 83-tsa-signer-info-unsigned-attributes-ignored.json | Vector 37's criteria token with an unsignedAttrs field holding one arbitrary attribute appended to its SignerInfo (DER lengths corrected; not covered by the signature). | Identical to vector 37: tsa_signature.criteria verified. |
| 84-receipt-exponent-numbers.json | Contributed by actaseal: a passing receipt whose signed body holds numbers that RFC 8785 writes in exponent form with more than one significant digit (1.5e-7, 1.25e+22, 1.234e-10, 9.87654321e-8, 2.5e+21). | No problems. |
| 85-receipt-key-outside-bmp.json | Contributed by actaseal: a passing receipt whose signed body has an object with keys z, U+1F600 and U+FF61. Sorting by UTF-16 code units puts U+1F600 before U+FF61; sorting by code point reverses them and breaks the signature. | No problems. |
| 86-envelope-key-id-differs-from-signed.json | Contributed by actaseal: signed with key A; the signed key_id and parties.checker.key_id name A; the unsigned envelope signature.key_id names B, which is also in the key list. | signature_valid false; SIGNATURE_INVALID only. |
| 87-same-key-under-two-ids.json | Contributed by actaseal: as 05, but the producer names a different key_id whose entry in the key list holds the same public key as the checker's. | KEY_COLLISION; warning SELF_CHECKED; independence self-checked. |
| 88-committed-at-malformed-with-token.json | Case proposed by Tetsurohhori: committed_at is 2026-13-01T00:00:00Z and a valid criteria token is supplied, so step 5 takes the time from the token. | CRITERIA_TIME_MISMATCH, not RECEIPT_TIME_UNREADABLE; criteria_committed_before_check yes. |
| 89-criteria-file-base64-noncanonical.json | The criteria file's base64 has a space inside. | It matches nothing: CRITERIA_HASH_MISMATCH; criteria_hash mismatch; not refused. |
| 90-criteria-token-base64-noncanonical.json | The criteria token's base64 has a space inside. | It matches nothing: CRITERIA_TIMESTAMP_MISMATCH; warning CRITERIA_COMMITMENT_UNVERIFIED; not refused. |
The expected object has these members: signature_valid (boolean), problem_codes and warning_codes (sorted arrays of codes from section 10), independence, criteria_hash (match, mismatch or unavailable), criteria_committed_before_check (yes, no or unknown), verdict_stated, verdict_recomputed, optionally tsa_signature (an object with keys criteria and/or receipt, section 6; vectors 31 to 46, 48 and 49 carry relying-party anchors as inputs.tsa_roots_base64, a list of base64 DER certificates; where a vector's top-level tsa_signature_accepted lists other values for a token, any of them also conforms), and receipt_timestamp (none, imprint_match or imprint_mismatch). A vector whose record must be refused at step 1 (vector 21) instead expects {"refused": true, "reason": "unknown schema, canonicalization or suite"}. A conforming verifier reproduces every member for every vector. problem_codes and warning_codes are sets: compare them without regard to order. receipt_timestamp is none when the record has no timestamp or no token was supplied. The key list in a vector's inputs is the key that signed it; keys differ between vectors, and every one is a test key.
Implementations
Verifiers written from this text, each run by its implementer on the published vectors. Every row links that implementer's own run file at a fixed commit; the result and the disclosure are theirs, as posted.
| Implementer | Code | Vectors | Result | As disclosed by the implementer |
|---|---|---|---|---|
| Tetsurohhori | Python, cryptography | 01 to 87 at 85a310d | 87/87 | Written from the 1.4.2 rule text; reference verifier not opened; answer-exposed (the 1.4.1 verifier was scored on the 87 first); 66, 68 and 77 corrected after seeing them. |
| Tetsurohhori | Python, cryptography | 01 to 57 at bc5a138 | 57/57 | Written from the text; reference verifiers not opened; expected objects visible while the inputs were read. |
| babyblueviper1 | Python, cryptography | 01 to 55 at 6b2f730 | 55/55 | Written from the text; reference not opened; expected objects visible while the inputs were read. |
| robertolocatelli81-dev | Python | 01 to 47 at 06d3b94 | 47/47 (441/441 fields) | Written from the text; reference verifiers not opened. |
| Reference | Python standard library; JavaScript (WebCrypto) on this page | 01 to 90 | 90/90 | Written with the vectors. |
The other direction: receipts issued by another checker under its own key (babyblueviper1's invinoveritas checker) pass the reference verifier unchanged, with the FreeTSA and DigiCert roots of vectors 31 and 32 as anchors (run); one of them is vector 56. To be listed, open an issue on the reference repository that links your code and a run file at a published commit.
15. Changelog
Profile 1.4.2, 2026-10-24 (schema identifier unchanged)
Closes readings that let a malformed or ambiguous input pass. Vectors 01 to 57 and their outcomes are unchanged; vectors 58 and 59 (contributed by Tetsurohhori) and 60 to 87 are added.
- Section 5: canonical base64 only; a key identifier listed more than once is
KEY_REJECTED. - Section 4: a SHA-256 digest in a record is exactly 64 lowercase hex digits.
- Section 6 step 5: the form of
genTime, millisecond precision, and the rounding of the two sides of the comparison. - Section 7.3 step 6 and section 10: stated times are RFC 3339 UTC; new problem code
RECEIPT_TIME_UNREADABLE. - Section 8: independence is checked by key when a key identifier is stated, and keys are compared as decoded bytes.
- Section 10: a record or input of the wrong type is refused.
- Section 8:
CHECKER_NOT_SIGNERcompares the checker's key identifier with the one the signature was checked under (the signedkey_id), never with the unsigned envelope's. A record whose envelope names another key isSIGNATURE_INVALIDonly (vector 64). - Section 6 step 2: unsigned attributes of the SignerInfo are not read and are no ground for refusal (vector 83).
- Clarification, 2026-10-27 (no change to the reference verifier or to any earlier outcome): vectors 88 to 90 pin two readings of the 1.4.2 text stated by Tetsurohhori. A non-canonical token or criteria file is a mismatch, never a refusal;
committed_atis read forRECEIPT_TIME_UNREADABLEonly when step 5 uses it.
Profile 1.4.1, 2026-10-21 (schema identifier unchanged)
Settles readings raised by clean-room verifiers of 1.4 (Tetsurohhori; robertolocatelli81-dev) in x402-foundation/tsc#4. Vectors 01 to 36 and their outcomes are unchanged. Vectors 37 to 42 and 44 to 46 use tokens from a test-only PKI (provenance in VECTORS_PROVENANCE.md).
- The
contentTypesigned attribute must equaleContentType, which must beid-ct-TSTInfo(RFC 5652 §5.3): vector 39. - The signer and every issuer other than the anchor must be valid at
genTime. A chain that reaches the anchor but fails a check isfailed, notuntrusted: vector 38 (control 37). - RSA PKCS#1 v1.5 and ECDSA P-256/P-384 are required; RSASSA-PSS is optional, so
verifiedandunsupportedboth conform on vector 40 (the new vector fieldtsa_signature_accepted). P-256: 41. Other curves areunsupported: 42. - An empty anchor list is no anchors, so
not_evaluated: vector 43. - A token with several defects is
failedif any check that can run fails; otherwiseno_signer, thenunsupported, thenuntrusted. A check that cannot run does not stop the others: vectors 44 to 46.
Not exercised by a live authority: RSASSA-PSS and ECDSA P-256 (the live vectors use RSA PKCS#1 v1.5 and ECDSA P-384). Revocation is not checked. No further outcome changes to profile 1.4.1 before 2026-11-21; reports of disagreement are collected and answered together.
Added 2026-10-21, outcome-neutral: the optional body member payment (section 3.2), so a record can
carry the x402 payment it concerns inside the signed and timestamped bytes (asked for by babyblueviper1 in
x402-foundation/tsc#4, from a live record paid on Base). Vector 47; chain check in check_payment.py.
Clarified 2026-10-21, outcome-neutral (from babyblueviper1's run in x402-foundation/tsc#4): the anchor is matched by
subject name and public key, not by certificate bytes (vector 32 separates the two readings); vectors 48 and 49
exercise the id-kp-timeStamping and CA-flag rules, which no earlier vector isolated.
Clarified 2026-10-22, outcome-neutral for every earlier vector (from Tetsurohhori and robertolocatelli81-dev in
x402-foundation/tsc#4): imprint, genTime and accuracy are read from the token's signed
TSTInfo only, never from other bytes of a response (vectors 50 and 51); numbers follow RFC 8785's ECMAScript form,
including non-integers (vector 52). Both reference verifiers follow these readings from this version.
Clarified 2026-10-22, outcome-neutral for every earlier vector (from robertolocatelli81-dev's run): an anchor with
the issuer's name but another key does not match, so only such anchors failing is untrusted (53); an
issuer in the token that fails a check is failed even when no chain reaches an anchor (54); the
payment form is stated, and a member outside it changes no outcome (55). An anchor itself is not checked
for validity at genTime, and keys outside RSA PKCS#1 v1.5, RSASSA-PSS and ECDSA P-256/P-384 (for example
Ed25519) are unsupported.
Added 2026-10-23, outcome-neutral: vector 56, contributed by babyblueviper1, the first receipt in the set issued by another checker under its own key; vector 57, integer-valued doubles and negative zero, which RFC 8785 writes without a fraction or sign (from stillmarcus24's note in x402-foundation/tsc#4).
Edited 2026-10-23: the descriptions of vectors 37-42, 44-46, 48, 49, 53 and 54 now point to the provenance on the spec site; inputs and expected outcomes are unchanged.
Profile 1.4, 2026-10-20 (schema identifier unchanged)
Adds the authority-signature outcome requested in x402-foundation/tsc#4 (magentixai), as committed there: an additive
outcome field tsa_signature per token present, not_evaluated without relying-party anchors
(an absent field reads the same), so vectors 01 to 30 and existing verifiers are unchanged. With anchors:
verified, failed, untrusted, unsupported or no_signer
(section 6), including the ESS signing-certificate binding and a CA check on intermediate issuers. Vectors 31 to 36 are
built from live FreeTSA and DigiCert tokens; their provenance is in VECTORS_PROVENANCE.md.
Profile 1.3, 2026-10-18 (schema identifier unchanged)
Resolves the questions raised by two more clean-room verifiers (Tetsurohhori; robertolocatelli81-dev) and a second run by babyblueviper1, in x402-foundation/tsc#4. Vectors 12 to 21 contributed by Tetsurohhori, 22 and 23 by babyblueviper1 (CC0); 24 to 27 added from robertolocatelli81-dev's cases.
- Section 5: the key is the one named by the signed
receipt.key_id; an envelopesignature.key_idthat differs isSIGNATURE_INVALID. Original vector 12 tested both at once and is replaced by its rebuilt form (12b). - Section 5: key rule. Public keys must be canonical encodings of prime-order points; others are
KEY_REJECTED, with no signature check run. - Section 7.3 step 5: the reference time is the earlier of
issued_utcand a covering token'sgenTime(vector 22). - Section 6: the imprint's hash algorithm must be SHA-256; same-length other algorithms are a mismatch (vectors 23 to 25).
timestamp.digest_sha256is informative; the token decidesreceipt_timestamp. - Section 6: the outcome fields cover imprint and time only; authority signature validation is reported separately, against roots the relying party trusts. Stated
accuracywidens the comparison against "committed before";orderingis ignored. - Section 7.3 step 4: a criteria token over other bytes falls back to
committed_atwithCRITERIA_COMMITMENT_UNVERIFIED, as with no token. - Section 10:
PRODUCER_UNDECLAREDfollows the parties block, not the stated value. Vector 20 is published with that expectation and the contributor's differing one stated in the file. - Section 13: refusal shape for step 1; the vector tokens are described accurately (no SignerInfo).
- Section 5 (clarified 2026-10-18): the key rule applies to the key named by the signed
receipt.key_idonly; other key-list entries do not change the outcome fields. Vector 28 added. Outcomes for vectors 01 to 27 are unchanged. - Vectors 29 and 30 added (2026-10-19): the first vectors whose tokens state an
accuracy, testing section 6 step 4.
Profile 1.2.1, 2026-10-17 (schema identifier unchanged)
Resolves ambiguities reported by an independent clean-room verifier, written from this specification alone and run against the first five vectors; credit to babyblueviper1, who also contributed vectors 06 to 11 (CC0).
CRITERIA_COMMITTED_AFTER_CHECKis a problem everywhere, not a warning (section 7.3 step 5, section 10).- When a timestamp token over
criteria.sha256is supplied, itsgenTimeis authoritative for "committed first". Acommitted_atthat disagrees with it isCRITERIA_TIME_MISMATCH. The token is compared with the claimed hash, independently of the criteria document. Without a token,committed_atis used with the warningCRITERIA_COMMITMENT_UNVERIFIED(renamed fromCRITERIA_UNVERIFIED). - Verdict rule completed: a required fail gives fail and takes precedence over incomplete; otherwise a required not-evaluated or error gives incomplete; else pass. A stated verdict that differs from the recomputed one is
VERDICT_MISMATCH(renamed fromVERDICT_INCONSISTENT). - The reference time uses the record's own token time only when a token covering the record is supplied; otherwise
issued_utc. A token that does not cover the record is reported asreceipt_timestamp: imprint_mismatch. - After a failed signature a verifier still reports the other checks (as diagnostics) but must not present the contents as results.
receipt_timestampisnonewhen no token was supplied.- Vectors 06 to 11 added (contributed, CC0).
Profile 1.2, 2026-10-17
First published profile, with vectors 01 to 05.
14. Security considerations and limits
- A valid record proves who issued which statement about which bytes, and when (if timestamped). It does not prove the statement is correct, and it is not a compliance determination.
- Trust in a checker is trust in its key and its conduct. The record makes the checker accountable and its independence declared; it does not make the checker trustworthy.
- The record states outcomes only. It reveals nothing about how any criterion is evaluated, so a verifier can confirm the record without being able to reproduce the evaluation; a buyer who wants to reproduce it exercises its independent testing right.
- The reference verifier here checks time-stamp imprints, not the authority's signature; production verifiers SHOULD validate the CMS signature and chain (section 6).
- Everything in a record is public once published. Do not put personal or confidential data in
client_refor file names.
See also the in-browser verifier (nothing is uploaded), the model acceptance clause, and the acceptance criteria. Specification text © Trilatic Desks, CC BY 4.0. Test vectors CC0 1.0.