Skip to content

v6.6.0

Latest

Choose a tag to compare

@github-actions github-actions released this 16 Nov 21:16
· 10 commits to main since this release

A feature release following 6.5.0, with the relying party's inputs for decision and outcome receipts and stricter checks across the verifiers and producers. decision verify and outcome verify take the inputs of the offline verification of draft-gruszka-audit-decision-receipts-07, a Trust Pack can bind an executor key to the executor ids it attests, and an experimental proofbundle scitt match reports the axes of draft-gruszka-scitt-statement-identification-03. The command line no longer reads an abbreviated long option as the option it prefixes, so a caller that used an abbreviation must write the full option, and every --new-key option refuses a key path that already exists with exit 2. Producers in the package now refuse, before signing, what their own verifiers would refuse over budget or at the wrong signature length; the CHANGELOG names each case and what stays with the verifier.

python -m pip install --upgrade proofbundle==6.6.0

Highlights

  • decision verify and outcome verify take the inputs the relying party supplies. decision verify checks the action bytes (--action), the case the relying party chooses (--case approval with --approval, or --case declined) and a consumption state it supplies (--consumed, --received), which proofbundle reads and never writes. outcome verify takes the expected executor, the effect bytes, the bound decision with its key and the evaluation time, and checks the executed case. Without an input its check is not performed, and these verifiers are not a complete implementation of the draft's procedure.
  • A Trust Pack key attests only the executor ids its pack names. A key entry may carry executorIds. An outcome under another identifier is not trusted (EXECUTOR_ID_NOT_ATTESTED), and a key entry without executorIds binds no identifier and says so (EXECUTOR_ID_NOT_BOUND). The schema states the bounds the validator holds on keys, keyIds and executorIds.
  • Stricter command line and binding checks. Every parser refuses an abbreviated long option with exit 2 instead of reading it as the option it prefixes. decision verify, outcome verify and relation-statement verify fail an attached --with-related target that does not verify or whose predicate fails the structure check of its type, also where no edge of the receipt names it, and refuse a --related-pub without its target.
  • Producers write only what their verifiers read, and five containers refuse members they do not name. The SD-JWT producers, emit_bundle and dsse.sign_envelope read what they sign as their verifiers will, and every producer of an Ed25519 signature writes a signer's output only at 64 bytes. The pre-tag receipt readers, verify_evidence_pack, measure_vector_set, row C10.4 of the audit matrix and measure_build each judge a closed set of members and refuse or name a member outside it.

Verify this release yourself

Use the checksums and build provenance to check the downloaded files. To check the signed pre-tag audit receipt, use a clone at the source commit identified by the build attestation. The commands, prerequisites and limits are in Verifying a published release.

What a receipt still does not prove

A valid signature binds the signed content to the signing key. It does not make a reported result true.

decision verify and outcome verify perform the steps of draft-gruszka-audit-decision-receipts only where their inputs are supplied, and they are not a complete implementation of the draft's procedure. Section 3.1 requires the expected executor.id and, for Case 1, the approval record bytes, so a pass without them is not a pass of the draft's procedure. Even with every input supplied, a receipt the draft rejects can pass them, for example with an evaluation time before decidedAt outside Case 1. What proofbundle does not claim lists measured examples.

proofbundle reads a supplied consumption state and never writes it. Honouring an approval at most once stays with the relying party. An identifier a Trust Pack names in executorIds is a permission the pack grants to the key, not proof that the signer is that executor.

Measured on the reference machine

The budget cost axis was measured on the reference machine on 2026-11-14 using the code at 397f517. The record identifies the run as a reference measurement (ist_referenzmessung=true). All 12 expected axes and all 7 expected combinations passed, and no axis was skipped. The recorded calibration factor maschinenfaktor_schnellstes_ende is 1.0, and the timing-limit setting is latte_aus_der_klammer=schnellstes_ende. These results apply to the listed axes and combinations, not to every reader or input. The measurement record lists every axis and combination.

Details

All 37 entries, one line each, as in the CHANGELOG

Added

  • proofbundle scitt match (EXPERIMENTAL) reports the axes of Section 6 of draft-gruszka-scitt-statement-identification-03 for a reference and a candidate COSE_Sign1. You name the scheme, ToBeSigned (Section 5.1, with --external-aad and --detached-payload) or WholeBytes (the digest of the candidate bytes as given, a local experimental scheme), and its hash function; there is no fallback to another scheme. The result gives ref_usable, match and is_scitt as the section defines them, and a signature axis under the Ed25519 profile of SPEC.md section 4a; sig_valid is reported as not evaluated, because this reader does not apply rule 2 of the section (A and R of order L). Exit 0 is MATCH and nothing else, 1 NO_MATCH, 3 INDETERMINATE, 2 an input that cannot be read or input the reader does not read, which gets no verdict. No verify path imports the reader. tests/test_scitt_match_reader.py runs the 14 cases of interop/scitt-statement-identification-03 and their variants through the command line, the counter-cases for missing inputs and for the scheme, the two inputs where signature and the draft's sig_valid differ, and single-byte mutants of three candidates against the checker of that folder (docs/SCITT_STATEMENT_MATCH.md).
  • _strict_cbor says which refusals are no statement about validity. CborUnrepresentable marks valid input with a map key the reader does not represent (an array, a map, a tag or a NaN as key, and two distinct keys that are one Python dict key, such as 1 and true or 0 and 0.0), CborBeyondLimits input over its byte, depth or width budget. Both are subclasses of CborInvalid with the same reasons as before, so every existing caller reads them unchanged (tests/test_strict_cbor_refusal_kinds.py).
  • decision verify checks the action bytes, the case the relying party chooses and a consumption state it supplies (draft-gruszka-audit-decision-receipts, step 10 of Section 3.2, Section 3.3 and Section 4). --action PATH (action_bytes): the SHA-256 of the bytes must equal proposedAction.parametersDigest; a mismatch, or a receipt without that digest, exits 2. --case approval with --approval PATH, or --case declined (case, approval_record): the receipt must hold under the chosen case, the receipt never chooses it; a case that does not hold exits 2. --consumed PATH and --received PATH (consumed_state, received_copies) are read only. With the approval case, an approval whose identity (approvalId, actionDigest and session) is in any generation of the state, a state holding an entry that is no such identity, a received copy without an identity or a readable validUntil, and an evaluation time at or after the earliest validUntil of the copies of that approval exit 3. proofbundle never writes the state and never marks an approval consumed; an OK says only that the identity is not in the state given.
  • outcome verify takes the inputs of Section 3.4 and checks Case 3 of Section 3.3. --executor-id (expected_executor_id), --effect PATH (effect_bytes), --decision PATH with --decision-pub (decision_envelope, decision_public_key), --verification-time (now) and --case executed (case). The bound decision must pass decision verify under its key at the evaluation time, strict, with a derived subject and its freshness included, and its decisionMaker.id must be the --decision-maker-id the relying party expects. Then the outcome must name its content root and its parametersDigest, the keys and the identities must differ, and decidedAt <= performedAt < validity.expiresAt of the decision must hold. Case executed asks, before the status, for the outcome's structure, a subject that is the digest of the predicate, the bound decision, the expected executor, a non-null effectDigest on an executed outcome, and matching effect bytes where given. Each failure exits 2. Rules of the draft that decision verify and outcome verify do not apply are not applied here either; docs/NON_CLAIMS.md gives measured examples. --verification-time takes a whole past second, as on decision verify.

Changed

  • The audit matrix reports the full 24-hour soak, row C6.3, as informative, as decided for the release on 2026-09-08. RESTRISIKO_600.md (S21) and RESTRISIKO_650.md name the 24-hour soak a residual risk that runs beside the release and does not hold the tag, but scripts/audit_candidate_matrix.py still counted C6.3 among the release-deciding rows, so without a signed 24-hour run it reported the candidate as not ready. C6.3 now stands in _INFORMATIVE_CHECKS and its inventory row says release_deciding: False. Its reader is unchanged: it admits only signed, candidate-bound evidence, and an invalid artefact is still a FAIL in its row. C6.2, the recorded short soak on the same artefact, stays release-deciding. A test holds that C6.3 alone, without the 24-hour run, no longer withholds readiness, and a mutant that moves C6.3 back among the deciding rows turns the contract red.
  • docs/NON_CLAIMS.md, docs/predicates/decision-receipt.md and docs/predicates/action-outcome.md say that the checks of the draft run when their inputs are supplied, and name what stays outside. They said the verifiers take neither action bytes, approval record bytes, effect bytes nor an expected executor.id. They now say when a missing input fails instead of being skipped, and that these verifiers are not a complete implementation of the draft's procedure: even with every input given, a receipt the draft refuses can pass them, with measured examples. A trust policy for executor.id other than the relying party's own statement, and honouring an approval at most once, stay with the relying party.
  • The inspect extra admits inspect_ai up to 0.3.288, and INTEGRATIONS.md says what proofbundle verify does with a re-signed receipt. 0.3.282 to 0.3.288 were each run in a fresh environment against tests/test_inspect_hook.py and tests/test_adapters.py, as pyproject.toml records; the ceiling moves in the inspect extra, the dev extra and INTEGRATIONS.md together. INTEGRATIONS.md now says that verify checks a receipt against the key it carries, so a receipt changed and re-signed with another key verifies, and that show-eval --expect-issuer refuses it. tests/test_inspect_extra_ceiling_and_resigned_receipt.py holds the three ceilings to one number and to the newest measured bump, and holds the sentence to the code. No verdict changes.
  • CONTRIBUTING.md names UV_CACHE_DIR and UV_OFFLINE, the two uv names the plugin tests take from their caller. tests/_plugin_env.py passes both through to every process a plugin test starts, and CI sets both; one sentence each now says what they do. tests/test_contributing_names_uv_cache_and_offline.py reads the uv names of FIXED and fails when CONTRIBUTING.md does not name one. No verdict changes.

Fixed

  • The command line no longer reads an abbreviated option as a longer one. Every parser of proofbundle, the 43 parsers and subparsers that proofbundle.cli.build_parser builds, accepted a unique prefix of a long option as that option, because argparse does so unless a parser is built with allow_abbrev=False, and a subparser does not inherit the setting. Measured on 6.5.0: proofbundle outcome verify RECEIPT --pub KEY --decision X was read as --decision-maker-id X, and proofbundle verify BUNDLE --pol P as --policy P, so a word the caller did not write could change what a check compares; --decision is an option of its own since this release, and --decision-m X was read as --decision-maker-id X in the same way. Each parser now sets allow_abbrev=False, and an abbreviation exits 2 with unrecognized arguments naming it; the full options, the help texts and the exit codes of full options are unchanged. A caller that used an abbreviation must write the full option. tests/test_cli_rejects_abbreviated_options_b23.py generates one abbreviation for each long option of the parser tree that has a proper prefix, and one full-option control for every long option, with a value that differs from the option's default; it fails for a parser under src/ built without the setting. CROSS_IMPLEMENTATION_REPORT.md no longer names an abbreviation of --help among the help words of R1, and names the new difference as R3: the Rust verifier in tools/pb_verify_rs still reads abbreviations as argparse with allow_abbrev=True does, and follows as an item of its own.
  • decision verify fails an attached --with-related target that does not verify, also when no edge names it (B22). The command checked an attached target only where an edge of the receipt names it. A target signed under another key than --pub, or than its paired --related-pub, was ignored when the receipt has no edge to it: exit 0, "ok": true, automation.referencesResolved true. Such a target now sets lineage_ok false with the error relation:target_verification_failed, so ok is false, referencesResolved is false, safeForAutomation is false and the command exits 2. The JSON report now carries lineage_ok beside the other binding fields. A --related-pub without the --with-related target it pairs with, which no key reading reached before, is refused with exit 2. A new test reads the options of decision verify from the parser and holds a counter-case for each binding option, so a binding option added later without a counter-case fails it. The lineage label is unchanged, outcome verify and relation-statement verify apply the same rule since the deep gate of this release (see below), and so does the Rust verifier pb_verify_rs since then.
  • An attached --with-related receipt counts as verified only when its predicate passes the structure check of its type, and outcome verify and relation-statement verify fail an attached target that does not verify, as decision verify does. _load_related checked the signature, the strict reading and the shape of the predicate, so a correctly signed decision receipt without its decision member was loaded as verified, and with no edge naming it decision verify --with-related ended with exit 0 and ok true, while the same bytes alone give structure_ok false and exit 2, as measured at d8881ed in the deep gate of this release. A decision, outcome or relation-statement predicate that fails the structure check its standalone verifier applies now makes the attached target malformed and not verified. The relationships member of a decision or outcome attachment is left out of that check and judged by the relation profile with its own codes, as docs/predicates/relation.md says (null counts as absent, an unreadable block gives RELATION_MALFORMED_SUCCESSOR on a neighbour and relation:malformed_ancestor in a chain); for a relation-statement it is the required content and stays in. The conformance cases relation/target-subject-ambiguous and relation/target-subject-missing attached a target whose decision predicate was a skeleton, which the new check rightly refuses before the subject pin each case exists for; their targets now carry a valid predicate, rebuilt by conformance/relation/subject_pin_targets.py, with the subjects, pins and expectations unchanged. The rule of B22, that such a target fails the requested lineage check also where no edge names it, now also holds in verify_outcome_receipt and verify_relation_statement, which read the attachments once for the edges and for this rule, and outcome verify and relation-statement verify name lineage_ok in --json and exit 2 when it is false. A predicate of another type is judged as before, also when it is missing. The Rust verifier pb_verify_rs now applies the rule of B22 in verify-relation and verify-relation-statement as well, which tools/pb_verify_rs/crosscheck.py holds at all three surfaces; it does not apply the structure check to an attachment, a difference that CROSS_IMPLEMENTATION_REPORT.md names as R4 (tests/test_an_attached_receipt_is_judged_as_its_own_verifier_judges_it.py).
  • outcome verify and relation-statement verify refuse a --related-pub without its --with-related target, as decision verify does. B22 placed the check in decision verify only. The other two commands read the same options through the same reader and ended with exit 0, also for a value that is no Base64, which docs/predicates/relation.md calls malformed input with exit 2, as measured at d8881ed. The check now lives in that reader, so each of the three commands refuses such a key with exit 2 (tests/test_every_command_refuses_a_related_key_without_its_target.py). pb_verify_rs refuses it the same way in verify-relation and verify-relation-statement, with exit 2 and the same reason, where it answered 0 or 1; the crosscheck holds the case at all three surfaces with a control that pairs one key with each target. Found by the deep gate at c71eeb1 (lens L6, Z11A).
  • An anchored executor key is trusted only for the executor ids its Trust Pack names for it. verify_outcome_receipt bound executor.keyId to the signing key and to the outcomeExecutors role, and a Trust Pack named no identifier per key, so one anchored key could sign outcomes under any executor.id it wrote, and each verified with executor_role_trusted true. A keys[kid] entry may now carry executorIds, the identifiers that key attests; an outcome whose executor.id is not among them reports executor_id_bound false, executor_role_trusted false and the blocker EXECUTOR_ID_NOT_ATTESTED. A key entry without executorIds binds no identifier: executor_id_bound stays null, the warning EXECUTOR_ID_NOT_BOUND says that executor.id is the signer's own statement, and the verdict is unchanged. validate_trust_pack_predicate refuses an executorIds that is not a list of 1 to 256 distinct non-empty strings. The schema now states the bounds the validator holds on keys (1 to 256 entries), a role's keyIds and executorIds (at most 256 each); before, it accepted 257 where the validator refused them. docs/predicates/action-outcome.md, docs/predicates/trust-pack.md and docs/NON_CLAIMS.md say which packs bind executor.id and that a named identifier is a permission the pack grants, not proof that the signer is that executor. tests/test_an_executor_key_attests_only_the_executor_ids_its_pack_names.py holds the binding, owner option A, the bounds and the schema; 17 of its 24 cases fail against the earlier code; the 7 that pass there are the two controls, the four bounds the validator already held on keys and a role's keyIds, and the refusal of 257 executorIds, which the earlier validator refused as an unknown field.
  • The structure check of verify_trace_record keeps its memory in proportion to the record. _check_structure and every reader it calls gave each member a path string that copied the names of all its ancestors, and under appraisal.platform_measurement.layers one of them is a name the record chooses, so one layer with a long name and many members cost memory in proportion to the members times that name, and the paths of the members the schema does not name were kept in the findings and in unknown_fields. This is the trace record finding named under "Known limitations" in the tag note of v6.5.0; the structure check runs after the signature check and also when authentication fails, so its cost must stay bounded for an unauthenticated record. Measured at ac4129f: a record of 23,100 bytes with a layer name of 20,000 characters and 200 members needed about 8.3 MB of traced memory, and one of 233,931 bytes ended in a raw MemoryError under a 600 MiB address-space limit. The structure check now carries each path as a link and renders it only when a diagnostic or an unknown-member entry needs it, through budget._chain_text, as the two value walks of the same reader have done since 6.4.0. A rendered path of at most 256 characters is unchanged; a longer path is limited to 256 characters followed by …, for at most 257 characters in total: tests/test_trace_record_structure_paths_are_links.py compares the whole verdict of 2,431 error cases with the verdicts of 6.5.0, and holds the path text built to a constant per node and the 233,931-byte record under 600 MiB in a child process.
  • verify_sigstore_bundle refuses a leaf certificate whose subject does not decode, and raises nothing. _read_leaf read the subject of the leaf with len(cert.subject) outside its error handling, and cryptography decodes a Name only when it is first asked for, so a subject UTF8String with invalid UTF-8, or a TeletexString with bytes it does not take, raised a bare ValueError out of verify_sigstore_bundle before any chain or signature check. This is the first finding under "Known limitations" in the tag note of v6.5.0. The subject is now read with the certificate, inside the boundary that answers an unreadable certificate, so such a leaf fails the check certificate with exit 1 and the reason that it is not a well-formed X.509 certificate. A leaf whose subject decodes keeps its message. The issuer name of the leaf, a Name decoded the same way, is read in the same boundary; before, a leaf whose issuer name did not decode failed only later, at certificate-chain. tests/test_sigstore_leaf_fields_are_read_inside_the_reader.py holds three such subjects and one such issuer name at _read_leaf and through verify_sigstore_bundle.
  • verify_sigstore_bundle refuses a leaf certificate whose validity time has no date, and raises nothing. The neighbour of the subject finding in the same reader: cryptography converts the validity times of a certificate to a datetime on their first reading, and _read_leaf read them outside its error handling, so a leaf whose notBefore or notAfter is a GeneralizedTime of year 0000 raised a bare ValueError ("year 0 is out of range") before any chain or signature check, as measured at ac4129f. Both times are now read with the certificate, inside the same boundary, and such a leaf fails the check certificate with exit 1. The extensions, the version, the SAN, the Fulcio extension values and the public key were read inside a boundary already.
  • verify_sigstore_bundle reads an embedded SCT whose time is past year 9999 as an SCT that does not verify, and raises nothing. The same class one stage later: cryptography converts the 64-bit millisecond count of an SCT to a datetime on its first reading, and _sct_problem read it outside any boundary, so a leaf whose embedded SCT names a time past year 9999 raised a bare ValueError out of verify_sigstore_bundle, as measured at ac4129f. The reader reaches the SCT only after the signature and the chain verified, so such a leaf needs a trusted CA. The time is now read inside a boundary: such an SCT is a failed candidate, named with its log, verification continues with any remaining SCT, and the check sct fails if none verifies under a trusted CT log. _iso, which writes a verified time into a reason, no longer raises for a time past year 9999 either, and a signed entry timestamp whose integratedTime is past year 9999 now fails the check tlog-set: once _iso stopped raising, an npm-publish bundle with such a time under an open-ended log key and a registry key without expiry would otherwise have verified.
  • verify_sigstore_bundle reads the dates and names of every trusted-root CA and TSA certificate inside its boundary, and raises nothing. The leaf-side fixes above left the certificates of the trusted root: _chain_problem read their validity times outside any boundary, so a CA whose notAfter or notBefore is a GeneralizedTime of year 0000 raised a bare ValueError ("year 0 is out of range") out of verify_sigstore_bundle, as measured at d8881ed. The dates, the subject and the issuer name of each certificate of a CA or TSA chain are now read when the trusted root is read, and such a root is trust material that cannot be read, exit 2 (tests/test_sigstore_trusted_root_certificate_fields_are_read_inside_the_reader.py).
  • An eval-result v0.1 statement verifies only when each claim entry carries metric, comparator and threshold. docs/IN_TOTO_PROFILE.md lists claims[] of v0.1 as one or more {metric, comparator, threshold, passed} and names passed as the one optional member. The claim rule judged the fields an entry carried and the member check only that claims was not empty, so a validly signed v0.1 statement with claims [{}] verified, and proofbundle intoto --verify printed PASS with exit 0, as named under "Known limitations" in the tag note of v6.5.0 and measured again at ac4129f. Such a statement now does not verify, with predicate_claim_ok False and a reason naming the entry by its index, such as predicate claims[0].metric, and the command answers FAIL with exit 1. An entry without passed still verifies, an entry that is no object keeps the claim rule's reason, and the missing members are checked after the existing claim-field rules: the verifier names them, in content_root_detail and in a field of their own, predicate_member_detail, only where the previous checks found no violation, and proofbundle intoto --verify prints them after a signature failure, so every reason it printed before keeps its place. The 14 statements of tests/fixtures/eval_result_v0_1/corpus.json carry all three in every entry and verify as before.
  • issue_sd_jwt signs only a payload that check_binds_bundle and verify_sd_jwt can read. check_binds_bundle reads the always-open payload with the strict reader under the verification budget, at most 1,000,000 characters per string and 8 MiB per document, and verify_sd_jwt first refuses a base64url segment longer than the same 8 MiB, but issue_sd_jwt signed without that reading. A vct of 1,000,001 characters, as named under "Known limitations" in the tag note of v6.5.0, one of 900,000 characters outside the BMP and a root_b64 of 1,000,001 characters were signed and then refused by check_binds_bundle, and a vct of 600,000 such characters was bound by check_binds_bundle and refused by verify_sd_jwt, as measured at ac4129f. The issuer now reads the payload segment as both verifiers read it, with their own functions and the same budget, before the signature exists, and refuses such a payload with a ValueError. At the bounds, a vct or root_b64 of 1,000,000 characters, it signs as before.
  • issue_sd_jwt signs only disclosures that verify_sd_jwt can read. The neighbour of the payload finding in the same function: verify_sd_jwt reads each disclosure with the strict reader under the verification budget, and the openings were written unjudged, so a model_id_opening or dataset_id_opening whose identifier has 1,000,001 characters was signed and verify_sd_jwt answered structure_ok False with the reason string_len, as measured at ac4129f, and openings nested about 990 levels deep were signed past the depth bound of 64. The issuer now reads each disclosure as verify_sd_jwt reads it before anything is signed, and refuses such an opening with a ValueError; an identifier of 1,000,000 characters is signed and verifies as before.
  • present_with_key_binding signs only a KB-JWT that verify_key_binding can read. The neighbour of the SD-JWT finding at the holder: verify_key_binding reads the KB-JWT payload with the strict reader under the verification budget, and the holder signed without that reading, so an aud or a nonce of 1,000,001 characters was signed and verify_key_binding answered ok False with the reason string_len, as measured at ac4129f. The holder now reads the payload segment as verify_key_binding reads it before signing, and refuses such a value with a ValueError; at 1,000,000 characters the presentation is signed and verifies as before.
  • emit_bundle applies the structural budget of verify_bundle before it signs. The native-bundle neighbour of the SD-JWT finding, found in the review of this fix: verify_bundle reads a bundle dict with enforce_structural_budget under the verification budget, at most 1,000,000 characters per string, and emit_bundle signed without that reading, so a payload of 750,001 bytes, whose payload_b64 has 1,000,004 characters, was emitted and then refused by verify_bundle with BundleFormatError, as measured at 4229973. Before signing, emit_bundle applies the structural budget used by verify_bundle for dictionary input. An over-budget bundle raises BundleFormatError before the signer is called. This includes payloads larger than 750,000 bytes and over-budget sd_jwt_vc values. The verifier's limits are unchanged, and the byte limit of a serialized file is not part of this check. Callers that previously emitted such bundles now receive this error; proofbundle emit returns exit 2. A payload of 750,000 bytes is emitted and verifies as before. The budget reading measures the signature and the public key at the Ed25519 lengths of 64 and 32 bytes and asks the signer nothing; afterwards the signer is asked as before, it signs and then its public key is read, and a signer whose signature or public key has another length is refused with BundleFormatError and no bundle is returned.
  • Every producer of an Ed25519 signature writes only a signer's output of 64 bytes. The neighbours of the emit_bundle finding across the package: dsse.sign_envelope, sign_trust_pack, sign_checkpoint, cosign_checkpoint, issue_status_list_token, issue_sd_jwt, present_with_key_binding, the Ed25519 signature of an archive timestamp and the experimental issue_enclave_attestation wrote what a signer returned, unchecked, into something their own verifier reads, so a signer of another kind that returned 750,001 bytes gave a DSSE envelope or a Trust Pack that the verifier refuses at string_len, and one that returned 6,500,000 bytes gave a status list token past the verifier's segment bound. Each now reads the output once as the bytes of the buffer it holds, and refuses anything that is not 64 bytes with the error it already uses for a refusal (BundleFormatError, TrustPackError, RenewalError, or ValueError for the SD-JWT producers). A signer that returns a real Ed25519 signature in a buffer, as bytes, a bytearray, a memoryview (also one that is not contiguous) or an array.array, writes what it wrote before. An output that exports no buffer, such as a list of byte values or an object that only answers bytes(), is refused; the archive timestamp took both before. The ML-DSA signatures of cosign_checkpoint_mldsa and pqsig.sign_mldsa are not part of this rule.
  • dsse.sign_envelope signs only an envelope that verify_envelope reads within its budget. The DSSE primitive every statement producer signs through wrote the caller's values unjudged, so a keyid of 1,000,001 characters, and a decision receipt whose statement encodes to more than 1,000,000 base64 characters, were signed and then refused by verify_envelope with string_len, as measured at d8881ed. Before the signer is asked, the producer now reads the envelope as the verifier reads it: the structural budget of the whole envelope, the input_bytes bound on the base64 payload and, for a payload type with the +json suffix, the structural budget of the parsed payload, with the signature and the default keyid measured at their fixed lengths. Such an envelope raises BundleFormatError and nothing is signed, and the decision, outcome, relation-statement, run-ledger, verification-summary, agent-review, in-toto and verifier-block producers inherit the check. The in-toto exporters were the measured neighbour: at d8881ed export_intoto_dsse, export_eval_result_dsse and export_svr_dsse wrote payloads 984 to 987 levels deep that their own verifiers answered with ok false, and the deepest they write now is the deepest those verifiers read. Only the budget is judged: a body that is not JSON, a JSON text with a lone surrogate and a keyid with a lone surrogate are left to the verifier as before. A payload type that is not UTF-8 text, for which no PAE can be formed, is refused with BundleFormatError instead of the raw UnicodeEncodeError it raised. Tests and tools/pb_verify_rs/crosscheck.py that hand a verifier an envelope past its budget on purpose build it without the producer (tests/_dsse_ohne_budget.py; tests/test_dsse_producer_reads_as_its_verifier.py).
  • verify_evidence_pack (EXPERIMENTAL) judges a pack as the closed set that the builder of its pack version writes. It read proof and canonicalRoot and handed them to the OpenTimestamps verifier, and never compared type or packVersion, so a pack of another type or version, or one carrying a member the builder never writes, came back with the verdict of its proof. A pack must now be a JSON object with type opentimestamps-evidence-pack, a packVersion the builder has written, and no member outside the set of that version: v0.2, written since 3.6.0, has the 13 members build_evidence_pack writes, and v0.1, written by 3.2.0 to 3.3.0, has the nine members of that builder, read from its source at each tag. Anything else is malformed_pack, and a foreign member is named. A pack in the form 3.2.0 to 3.3.0 wrote keeps the verdict of its proof, as before, and a member of the other version is foreign to it. A pack built by hand without type and packVersion is now malformed_pack. tests/test_evidence_pack_refuses_foreign_members.py holds both sets; its cases for v0.1 fail against the strict v0.2 set alone.
  • measure_vector_set refuses a case directory that the manifest does not name. It hashed the manifest and every file of every case directory the manifest names, so a directory with a case.json, which is what conformance/cross_format.py loads as a case, moved neither the digest nor cases when the manifest left it out. Such a directory now raises VerifierBlockError and is named. Directories without case.json, such as generators and regression inputs, stay outside the set; the corpus in conformance/ has 148 case.json for 148 named cases and measures as before (tests/test_vector_set_refuses_an_unnamed_case.py).
  • measure_build reports an installed build only when the package directory holds exactly the files its RECORD names. Every RECORD row was held to its bytes, but the directory was not held to the rows, so an added proofbundle/signature/__init__.py, which Python imports in place of signature.py, left the installed-record digest and report those of the wheel. A file, a link or bytecode outside __pycache__ in the package that RECORD does not name now makes the build measure as source-tree; the interpreter's cache stays outside the identity. The source-tree measurement counted .py, .json and .typed only, so bytecode outside the cache, an extension module or __init__.PY on a file system that does not tell upper from lower case could take an import while the digest stayed; it now counts every file of the tree except the interpreter's cache (the package in this repository has 91 files under both rules, so its identity does not change), and refuses a link to a directory wherever it points: one outside brings code the tree does not hold, and one inside decides which code a name imports while every file stays the same. Both build measurements and measure_vector_set walked their tree with Path.rglob, which drops the error of a directory it cannot list, so a package directory in mode 0111, whose __init__.py the importer still loads, and a corpus directory of the same kind left the measurement as it was; the walk now stops at such a directory and the measurement is refused. A wheel install of 6.0.0 measures as installed-record as before (tests/test_installed_build_is_the_closed_set_record_names.py).
  • The pre-tag release gate and the third-party verifier refuse a rejected receipt beside a valid one and read a receipt file the same way, and the receipt library refuses a member outside the signed set. scripts/pre_tag_audit_gate.py set ok from the valid receipts alone, and scripts/verify_pre_tag_receipt.py answered VERIFIED as soon as one receipt verified, so a broken or untrusted receipt in audit_artifacts/<version>/ beside a genuine one gave ok and exit 0, against the gate's own rule that one known-bad artefact in the folder is a finding. A rejected candidate now outranks a valid one in both, and the reason names each rejected path. The verifier tells a genuine receipt of another tree from a bad one as the gate does, and lists it under other_tree, so the receipt of an earlier candidate of the same version beside the receipt of this commit still verifies; it also takes a directory or a submodule named like a receipt as a rejected candidate, as the gate does. A symbolic link named like a receipt, which the gate read through to the receipt it names while the verifier read the link text, and a subdirectory of the receipt folder that the gate cannot list are rejected candidates in both readers. So is a submodule under the receipt folder, by any name: its files are not in the commit's tree, which the verifier reads, while the gate walked into an initialised one on disk. Both read a receipt file with strict UTF-8 and refuse a member named twice in one object: the gate dropped bytes that are not UTF-8 where the verifier refused them, and json.loads kept the last of two equal names, so a receipt carrying audit_exit_code 17 before the signed 0 verified. verify_receipt in scripts/pre_tag_receipt_lib.py signs and checks nine fields and read no other member, so a member beside them travelled unsigned under a valid receipt; it now refuses any member besides those nine, signature and signer_pubkey, and names it. The receipt of 5.0.0 carries such a member, _informational_not_signed: the gate of the v5.0.0 tag still verifies it against its own tree, and the gate of this release, run against that tree, rejects it for this member. The gate source changes, so a receipt of 5.1.0 or later bound to an earlier gate reads as other_tree; the receipt for this release is made with the gate of its own tree (tests/test_pretag_gate_state_typed_l5_g6_01.py, tests/test_verify_pre_tag_receipt_third_party.py, tests/test_pre_tag_receipt_refuses_foreign_members.py, tests/test_pre_tag_receipt_readers_read_one_receipt.py).
  • Row C10.4 of the audit matrix passes only on the two files of the self-receipt. c10_4_manifest_self_receipt returned PASS as soon as docs/readiness_pack/proofbundle/ held any entry, so a stray file stood in for the self-receipt. The folder must now hold exactly readiness_pack.bundle.json and readiness_pack.pub.b64 as regular files, as scripts/readiness_pack_manifest.py writes them; a missing one, or an entry beside them, is FAIL and named, and an empty or missing folder stays PENDING (tests/test_c10_4_self_receipt_folder_is_closed.py).
  • An attached --with-related receipt of one of our types without a predicate, or with predicate: null, fails the requested lineage check. The structure check of its own type, which the entry above on attached --with-related receipts gives every attached receipt, ran only for a predicate that is an object, so a correctly signed statement of the decision, outcome or relation-statement type without a predicate stayed verified, and an edge-free decision verify --with-related exited 0 while the same bytes alone exit 2 (predicate must be a JSON object). The check now runs for every attached statement it can read. A statement of a foreign type may carry no predicate, as in-toto allows, and stays a statement without edges. Found by the deep gate at c3472f6 (lens L6, Z4).
  • decision verify, outcome verify and relation-statement verify close with the sentence of a verified receipt only when they exit 0. The sentence was chosen by the signature alone, so a correctly signed statement of a foreign predicate type, which decision verify refuses with exit 2, was told "This proves the signed decision claim has not been altered." Each command now computes its exit code before it prints, and a signature that holds beside a check that does not says so and names the exit code. The --json output and the exit codes are unchanged. Found by the deep gate at c3472f6 (lens L6, Z6).
  • sign_trust_pack, issue_status_list_token and issue_enclave_attestation sign only what their own verifiers read within the verification budget. The entry above on dsse.sign_envelope put the DSSE primitive under the budget of its verifier. sign_trust_pack builds its multi-signature envelope itself and never passed that check, so a pack whose nonClaims holds 800,000 characters was signed and verify_trust_pack refused it. The check now takes several signatures, each at the length its key's algorithm writes, and their count. A probe over every producer that signs outside the DSSE primitive found two producers of the same class: a status list uri and an enclave binding of 1,100,000 characters were signed and refused by verify_status_snapshot and verify_enclave_attestation. Each now measures both segments against the budget its verifier reads them under before it signs, and the status list issuer also refuses a packed list above the size its verifier inflates. A question of form, such as an integer outside the I-JSON range, stays with the verifier, as it does for the DSSE primitive: the first form of this check read both segments with the whole strict reader and refused an iat of 2**53, found by the deep gate at c71eeb1 (lens L6, Z7B). The DSSE primitive and both issuers share one definition of that budget, _strict_json.enforce_budget_only. It judges an integer literal too long for the interpreter to convert by its digit count, which the DSSE primitive did not: a +json body holding 4301 nines was signed, and the strict reader of its verifier refuses it. sign_checkpoint and cosign_checkpoint were measured to agree with their verifiers on this budget and are unchanged; that cosign_checkpoint can append a 513th signature line, which verify_checkpoint refuses, is named in RESTRISIKO_660.md. sign_trust_pack also refuses a signer for a hybrid-ed25519-mldsa65 key before anything is signed. It writes one signature per key, and verify_trust_pack counts a hybrid key only with both legs, so the hybrid signature it wrote never counted, and the pack failed whenever the other signers did not meet the threshold on their own. A call that passes such a signer beside enough other signers, which returned a pack that verified without it, now fails as well; leave the hybrid signer out, or build the pack with both legs outside the producer. A pack may still declare a hybrid key that does not sign. Found by the deep gate at c3472f6 (lens L6, Z7).
  • verify_sigstore_bundle reads every certificate under one set of read errors, and raises nothing for a trusted-root certificate of an unknown version. The leaf reader caught InvalidVersion and the reader of the trusted root's CA and TSA chains did not, so a CA certificate whose version field holds 3 raised a bare InvalidVersion, where the entry above on the trusted-root certificates calls such a chain a trusted root that cannot be read. All four readers now catch the same set, and the chain reader also reads the version and the extensions inside its boundary. A generator that replaces every byte of a CA and of a leaf certificate by four values found two more forms present at c3472f6, a KeyError and a TypeError from the name decoder of cryptography, and the set holds them as well. Found by the deep gate at c3472f6 (lens L6, Z8).
  • measure_vector_set leaves no directory of the corpus out of its measurement. The walk skipped every directory named __pycache__, a rule of the package measurement it shares, so an unnamed case directory under that name was not refused as the entry above on unnamed case directories requires, and a file under <case>/__pycache__/ did not move the digest. Only the package measurement leaves the interpreter's cache out now. The neighbour in the same walk: a link to a directory inside a named case directory was skipped, so a runner could read through it bytes that moved neither the digest nor a refusal. It is refused now (CONFORMANCE.md rule 1). Found by the deep gate at c3472f6 (lens L6, Z9).
  • pb_verify_rs refuses a primary statement that is not RFC 8785 canonical, and a relation statement without schemaVersion or statementId or with one of the wrong form, as the Python verifiers do. verify-relation and verify-relation-statement parsed the primary payload without comparing it with its JCS form, so a signed statement with a trailing newline exited 0 there and 2 in Python, and verify-relation-statement checked only which members the predicate may carry. Both now apply the comparison, and verify-relation-statement the required members and their forms. tools/pb_verify_rs/crosscheck.py holds both surfaces with a canonical control. The full predicate schema of a decision or outcome receipt stays Python-only (CROSS_IMPLEMENTATION_REPORT.md, Pending). Found by the deep gate at c3472f6 (lens L6, Z11).
  • save_signer writes the seed with mode 0600 every time and follows no link, and --new-key no longer replaces an existing key file. Its docstring promised mode 0600, but the file was opened with O_CREAT | O_TRUNC, which sets the mode only when it creates the file: an existing file kept its mode (0644 measured), a symbolic link at the path was followed and its target received the seed, and --new-key in seven commands replaced an existing key file and exited 0. The seed is now written into a new file in the same directory, created with mode 0600, which then takes the place of the path; a link there is replaced, not followed, and the file it pointed to keeps its bytes. save_signer takes overwrite (default True, the behaviour callers had), counted only as an exact bool like every switch that lifts a refusal: with overwrite=False an existing path, a link included, raises FileExistsError in the same step as the write. Every --new-key option writes with overwrite=False, so an existing path ends the command with exit 2 and a message that names it. Found by the deep gate of 6.6.0 at 41959070.

Full changelog · Known limitations for 6.6.0 · Earlier risk record · Release scope · proofbundle.dev

The plugins under plugins/ are not part of this package. They are released on their own, with release notes of their own.

Assisted by little helpers.