Skip to content

Releases

omega-evidence 0.11.4 — an RFC 3161 check that openssl cannot start, finish in time or read here is not a verdict

Choose a tag to compare

@robertolocatelli81-dev robertolocatelli81-dev released this 13 Oct 17:19

Measured on 0.11.3 (6d712c8) on 13 October 2026 with Python 3.11.2 and a token from a local TSA built with openssl.
timestamp.verify(tsr_b64, digest, ca_file=...), on a valid token, returned verified: False — a verdict on the
token — when openssl could not be started (fork refused under RLIMIT_NPROC 1; the binary gone since which), when it
gave no answer within the timeout (15 s), and when the token's temporary file was refused (EFBIG under RLIMIT_FSIZE
0); with no usable temporary directory it raised a bare FileNotFoundError. preservation.verify_evidence_record(..., tsa_ca_file=...) made the record carrying that token valid: false in the same four cases, and
python -m omega_evidence.interop.aat verify ... --tsa-ca exited 1 under RLIMIT_NPROC 1, for a token in an epoch
anchor ("does not verify") and for one in a record's external_timestamp ("not verified"). Now each case raises
timestamp.CheckNotRun (an OSError) with cannot run openssl here: <reason> (... no answer within 15 s for the
timeout) or cannot write a temporary file for openssl: <reason>, and the AAT CLI exits 74 with that message after
receipt not written: as its one line on stderr, and nothing on stdout. Unchanged: without openssl
the result is verified: None (a SKIP layer), and a token that is not base64 is verified: False. Not covered: an
openssl that starts and then ends without an answer (killed by a signal, or exit 127 when it cannot load its
libraries; both measured with a stand-in for openssl) still gives verified: False. The pack CLI
python -m omega_evidence passes no trust anchor to timestamp.verify and starts no openssl: under RLIMIT_NPROC 1
its receipt for a pack with an RFC 3161 sidecar is byte for byte the one without the limit, before and after.

tests/test_check_not_run_20261013.py (now in CI) runs these cases as real processes: at 6d712c8 it fails 9 of its
14 tests on Python 3.9, 3.11, 3.13 and 3.14 (the other five are controls: a valid token, the two AAT runs without a
limit, openssl absent, a token that is not base64); none fail now. Of 14
mutants of the new lines, 14 are killed. Not changed by this release: the 188 cases of the differential oracle in the
four verifiers (and Python under PYTHONUNBUFFERED), 940 receipts written to a file, are byte for byte those of 0.11.3
(only verified_utc normalised), and the oracle still reports 0/206 disagreements. Measured on Linux, 13 October 2026.

Known limitation, not changed (measured on 6d712c8, 13 October 2026): a run under a file size limit can leave
Python's own bytecode cache cut. CPython 3.9 and 3.11 write each .pyc with one raw write: from a copy without
__pycache__, one run of python -m omega_evidence (also -m omega_evidence.verifier and
-m omega_evidence.interop.aat verify) under a limit smaller than a module's .pyc (bash ulimit -f 1, or 512 bytes;
the package's .pyc files are 292 + n to 86 558 + n bytes on 3.9.25 and 343 + n to 159 519 + n on 3.11.2, n being the
length of the path of the directory that holds the package) left 19 of them cut (20 for
the AAT command) with cryptography installed, one more without it (_ed25519_pure is imported then; measured on
3.9.25), while the .pyc files under 1 024 bytes were written whole; and every later run, and every import, exited 1
with EOFError: marshal data too short. The failure
is loud — no receipt and no exit code of a verdict comes from a cut file — and lasts until __pycache__ is removed, or
is avoided with python -B or PYTHONDONTWRITEBYTECODE=1. Python 3.13.15 and 3.14.8 wrote no cut file in the same
runs; a cut file put there stops them as well. CPython fixed this upstream as GH-126606 ("don't write incomplete pyc
files"), backported to the 3.12 and 3.13 branches on 13 November 2024 (commits df59b64589 and ad1b23bf29); the 3.9,
3.10 and 3.11 branches do not have it (read in their sources); the first point release carrying it was not checked
here. With pip's default install every .pyc is compiled at install time: a
run of omega-evidence-verify under ulimit -f 1 left all 24 in place and the next run gave the receipt; installed
with pip install --no-compile (measured on 3.11) the console script behaves as python -m above.

omega-evidence 0.11.3 — a receipt that was not written is exit 74, never the verdict's code

Choose a tag to compare

@robertolocatelli81-dev robertolocatelli81-dev released this 13 Oct 05:27

Measured on 0.11.2 (864bef4) on 12 October 2026 with real processes, on a valid and on a tampered signed pack, with stdout
on /dev/full, on a pipe whose reader had gone (| head -c 0) and closed (>&-) — the receipt never arrives in these
three: Node (oeverify.mjs) and Java (OeVerify.java) exited 0 on the valid pack and 1 on the tampered one with an empty
stderr (the Node write callback received the error and ignored it); Go did the same on /dev/full and died of SIGPIPE
(141) on the pipe; Python — python -m omega_evidence and python -m omega_evidence.interop.aat verify|csv — exited 120
with "Exception ignored … OSError" from the interpreter's last flush on a full stdout or a gone reader (1 with a traceback
when the receipt was over 64 KiB), and with stdout closed the outcome's own code (0 / 1, 2 for an AAT input error) in silence.

Measured again on 13 October 2026 on the first version of this fix (5520cd8, not released), with Python 3.9.25, 3.11.2 and
3.13.15: under python -u / PYTHONUNBUFFERED stdout is a raw file whose short write Python's text layer drops in silence —
appended to a file of 1 000 bytes under ulimit -f 1, both Python CLIs exited with the verdict's code (0, 1 or 2) and 24
bytes of the receipt, and a 71 162-byte receipt through | head -c 100 exited 0; on a non-blocking stdout read 1 s late,
Python and Java exited 74 with 65 536 bytes of the receipt (71 162 and 70 996) in the pipe, where a blocking write would have
delivered it whole, and Python unbuffered exited 0 with them; a usage error with stderr full or its reader gone exited 120,
and with stderr closed the usage went to stdout (exit 1 on 3.9 and 3.11, 2 on 3.13); the AAT -h on a full stdout or a gone reader exited 120 (under -u 1 on 3.9 and 3.11, 0 on 3.13), and with stdout
closed exited 0 with the help on stderr.

Now, the same rule in the four pack CLIs and the AAT CLI: the receipt is written and flushed before the exit code is
decided; if the write fails, one line receipt not written: <reason> goes to stderr (if stderr fails too, nothing is
raised) and the exit is 74 (sysexits EX_IOERR), whatever the verdict. Python encodes the receipt as its stdout text
layer would (encoding, error handler, a byte order mark only where that layer writes one as the first thing written;
in process, after text the caller wrote to a utf-8-sig pipe, the receipt carries a second one) and writes the bytes to
sys.stdout.buffer in a loop that sees the count — a short count continues, a full non-blocking stdout is waited for in
select, nothing taken without waiting is an error — flushes before the exit code is decided and, after a failure, points
the descriptor behind the failed stream (from stream.fileno(), never the number 1 or 2) at the null device, so the
interpreter's last flush can no longer turn the code into 120; argparse's usage and errors go through a stderr write that
never raises (exit 2, nothing on stdout) and the AAT help through the receipt's writer (74 when lost); in process, a
sys.stdout with no bytes below it (StringIO) or no descriptor (a TextIOWrapper over io.BytesIO) gets the receipt; Node
exits from the write callback, with 74 when the callback carries an error, and on a regular file writes the receipt itself
in a loop until it is whole (Node's stdout on a file makes one writeSync and dropped what a short write left: 4 096 bytes
of a receipt over 64 KiB in a file limited to 4 096 bytes, exit 0, measured on 0.11.2 and on Node 22.23.2 and 24.19.0); Go checks the error of its write and receives
SIGPIPE on a channel, so a gone reader is an EPIPE error, not a signal; Java writes to fd 1 through the FileChannel of a
FileOutputStream (System.out swallows write errors) in a loop that sees the count, and waits out a full non-blocking
stdout (0 bytes taken) in sleeps of 1 to 50 ms, since the JDK's public API cannot poll fd 1 — the receipt is ASCII, so in any ASCII-compatible stdout encoding (the default,
Windows code pages included) the bytes are the ones println wrote; with a non-ASCII-compatible -Dstdout.encoding
(UTF-16) println wrote two bytes per character, and the receipt is now ASCII there too (measured on one receipt: 1 548 →
773 bytes). The exit codes 0, 1, 2
and 77 keep their meaning. Declared limit: with >&-, Node and Go reopen fd 1 on /dev/null before the program runs; there
the exit stays the verdict's (the table above).

Tests: tests/test_receipt_exit74.py (39 tests) runs the four pack CLIs and the AAT CLI as real processes on a valid and an
invalid input, with stdout to a file (the control: the verdict's code and the whole receipt), on /dev/full, on a pipe closed
before the start, through | head -c 0 (the producer started 0.2 s after head: started together, a fast producer can write
into the pipe buffer before head exits — the kernel accepted the bytes, the write succeeded, and no program can know they
were never read; measured on Go, 1 run of 50), on /dev/full with stderr there too, and closed where the runtime sees it,
plus a 71 KB receipt on a pipe read 0.5 s late (whole, the same bytes as in a file apart from the verified_utc second) and in
a file limited to 4 096 bytes (ulimit -f 4: a short write, then EFBIG — 74); a short write of 24 bytes (a file of 1 000 bytes
under ulimit -f 1) in the four runtimes and, for Python, unbuffered too; a stdout that is non-blocking and already full when
the process starts, small receipts and the 71 KB one, buffered and unbuffered, in the four runtimes — the process must wait
asleep (in some 1-second window under 0.2 s of CPU; a loop retrying EAGAIN uses about 1 s) and, once the pipe is read, deliver
the whole receipt with the verdict's code within 0.5 s (the reader coming back at three phases a third of a second apart); a usage error with stderr full, closed and on a pipe whose reader has gone (exit 2,
nothing on stdout) in the four runtimes and the AAT CLI; the AAT -h lost (74); the receipt's bytes in five stdout encodings
and one error handler, to a new file, appended to one and to a pipe, buffered and unbuffered, against a second process that
writes the same text through Python's own text layer; main() in process with sys.stdout a StringIO, a TextIOWrapper
over io.BytesIO (with and without write_through) and after text the caller wrote first (also left
unflushed on a full non-blocking pipe: waited for, not 74); for the AAT CLI also the --key,
--pubkey and --epochs error objects and a CSV that an ASCII stdout cannot encode (74). Measured on this line on 13 October
2026 with Python 3.9.25, 3.11.2 and 3.13.15, Node 22.23.2 and 24.19.0, Go 1.27.1 and JDK 27: 39 tests green; the same file on
the 0.11.2 code: 34 do not pass (33 failures, 1 error: the positive control); on 5520cd8: 9 fail. 53 mutants of the lines that write — among them the
text layer back in place of the byte loop, the count ignored, EAGAIN not waited for or retried in a spin (in the write, in the
flush, select with a zero timeout, Java's sleep replaced by a spin, Java's FileOutputStream.write back), the descriptor asked
for before writing, no fallback for a StringIO, a fixed encoding or error handler, the byte order mark always or never
dropped, argparse's own usage, help and exit back — 51 killed; the two alive are a guard no input reaches here (a write that
takes 0 bytes without EAGAIN) and the explicit flush of the stderr line, equivalent because Python's stderr is line-buffered
(3.9 on) or write-through and every line ends in \n. Six more on the review's additions: the caller's unflushed text not
waited for, or retried in a spin, Java's sleep uncapped, or 1 s — killed; alive, below the test's 0.5 s resolution, a cap of
400 ms and a sleep not reset after a write that took bytes (still at most 50 ms). Not reached by any input here, so not covered: the two verifier error
objects of the AAT CLI and the last-resort handlers of Go (recover) and Java (catch (Throwable)). A generative bench (not in
this repository) ran every CLI on four inputs (valid, tampered, a receipt over 64 KiB, a directory; for the AAT CLI an
unreadable chain and the CSV) × 13 stdout modes × stderr ok, full and closed × Python buffered and unbuffered — 588 runs per
tree with Python 3.11, Node 24, Go and Java, 336 with Python 3.9 and 3.13 alone, 84 with Node 22 — and counted the runs where
a receipt was lost without 74, a deliverable one did not arrive whole, a whole one carried another code, a 74 came without its
stderr line, or a traceback appeared: on 0.11.2 351 of 588 (Python 107 of 168 buffered and 107 of 168 unbuffered, Node 41 of
84, Go 41 of 84, Java 55 of 84), 214 of 336 on 3.9 and on 3.13, 41 of 84 on Node 22; on 5520cd8 13 of 588 (Python unbuffered
11, Python and Java on the non-blocking pipe read late 1 each), 12 of 336 on 3.9 and 3.13, 0 of 84 on Node 22; on this line 0
in every one of them. Receipts to a regular file, the 188 pack cases of the differential oracle (its other 18
cases are command-line ones) in the four runtimes and once
more in Python unbuffered (against 0.11.2 buffered), 940 runs: the same exit code and the same bytes on 0.11.2 and on this line
apart from the verified_utc second (0 differences; the same comparison with one space added before the receipt's newline
finds 188 of 188).

omega-evidence 0.11.2 — closed sidecars and ledger entries: a field nobody defined is never silent

Choose a tag to compare

@robertolocatelli81-dev robertolocatelli81-dev released this 11 Oct 10:36

Measured on 0.10.0 on 2026-10-10 and again on 0.11.1 on 2026-10-11 (the same three cases, the same silence) with a signed, anchored pack built by this toolkit: a .sig.json sidecar carrying a key
nobody defined (x_unknown_2026) verified valid: true, authenticated: true with no trace in the receipt (the sidecar
lies outside every digest, so nothing ever read that key); a ledger entry written with an extra top-level key — hash
recomputed over it — verified too; a pack WRITTEN with an extra top-level key, re-signed and re-anchored, verified
(its body is kind-defined, so the verifier cannot know the key is foreign). Now (verifier.py): the signature sidecar is
a closed object (SIG_SIDECAR_KEYS: signer_id, sig_alg, public_key_b64, fingerprint, signed_pack_sha3,
signature_b64, signed_utc, pq_sig_alg, pq_public_key_b64, pq_signature_b64) and so is the RFC 3161 sidecar
(TSR_SIDECAR_KEYS: digest_sha256, tsa, tsr_b64, stamped_utc, validation_material) — any other field is a
producer-signature / rfc3161 FAIL that names it; every ledger entry's top level is exactly idx, ts, data, prev_hash, self_hash plus the two anchor fields the r4 rule reads there (anchored_pack_sha3, anchored_utc) (LEDGER_ENTRY_KEYS)
— a foreign field is a ledger-chain FAIL naming the entry and the field; the pack's
own top level keeps its kind-defined body and the receipt now carries a pack-fields layer (SKIP) that LISTS the body
keys beside the format's four, so an auditor sees what the format did not judge. Tests: tests/test_closed_schema_20261010.py (5), each case built in a
temporary directory removed at the end; the intact pack is the positive control.

Go, Java and Node aligned (11 October 2026). verifiers/go/pack.go, verifiers/java/OeVerify.java and
verifiers/js/oeverify.mjs apply the same three closures with the same lists (SIG_SIDECAR_KEYS, TSR_SIDECAR_KEYS,
LEDGER_ENTRY_KEYS, PACK_FORMAT_KEYS), the same detail text (malformed sidecar: field(s) outside the closed schema: <keys>,
<ledger>: N entry(ies) with a top-level field outside the closed schema, first at idx I: <keys>, keys in code-point order, cut
as the reference cuts them — the keys at 120 code points, the ledger path never: until the review of 11 October 2026 the whole
detail was cut at 200, and under a ledger path of about 150 characters the key fell out of it in the four) and the same pack-fields SKIP layer; the RFC 3161 closure sits in their timestamp layer, the
reference's rfc3161 (a naming difference older than this change, declared). verifiers/differential_oracle.py carries thirteen
closed-* cases (one under a path longer than 200 characters, two with keys past the 120-code-point cut, one outside the BMP), each with its expected verdict and with the (status, detail) of the layer that carries the rule compared across
the four; verifiers/closed_schema_mutants.py is a generative, differential bench over the same rule (random keys at every
closed level, wrong types, duplicates, the controls that must stay PASS; the expected class comes from this section, never from a
verifier; the foreign key must be NAMED), run by tests/test_closed_schema_mutants.py, which also proves the bench can go
red; the CI workflow runs the oracle with its closed-* cases, not this test. Measured on this line on 11 October 2026: the
oracle 0/206 on Python, Node, Go and Java 27 (10/206 against the Go/Java/Node of 0.11.1, the positive control); the bench 100
mutations GREEN on the four; the three silent cases of 0.11.1 are three named FAILs.

omega-evidence 0.11.1 — deep JSON is refused by a bound, not by the interpreter

Choose a tag to compare

@robertolocatelli81-dev robertolocatelli81-dev released this 04 Oct 15:03

The release build of 0.11.0 ran its tests on the newest Python (3.14) and two failed. An SD-JWT whose payload is valid
JSON nested 100000 levels deep, correctly signed, verified as verified: true there
, while Python 3.9, 3.11 and 3.13
refused it: the refusal rested on RecursionError, whose depth varies with the Python version and, since 3.14, with the C
stack of the host (on this author's machine Python 3.14.8 still raised; on the CI runner it parsed). The DSSE reader was
affected the same way (its verdict stayed a reject, its reason changed).

  • One explicit bound, the one loads_strict already applied to packs: 512 levels, checked by a linear pre-scan before
    parsing
    (ledger.loads_bounded). It is now used wherever untrusted JSON decides a verdict: DSSE envelopes, SD-JWT
    payloads, headers and Disclosures, OpenTimestamps sidecars, AAT JSONL and epoch files, chip_registry updates and
    online discovery, and the packs bound by a preservation record.
  • Tests: 600 levels — which every Python parses — are refused in DSSE and SD-JWT; 500 levels still verify (control). On
    0.11.0 the 600-level cases fail on all four Pythons (3.9, 3.11, 3.13, 3.14).
  • The bound is measured at its edge: 512 levels verify and 513 are refused, for arrays and for objects; brackets inside
    strings and behind escapes are not nesting; 600 sibling arrays or objects are not depth.
  • SD-JWT: the walk that applies the Disclosures used a dict comprehension, which on Python 3.9 and 3.11 is a call of its
    own (two frames per level): a payload of 498 to 512 nested objects, inside the bound, was refused there with
    RecursionError and verified on 3.13 and 3.14. It is a loop now; 512 nested objects verify on all four.
  • CI runs the test matrix on Python 3.14 as well.

Measured before the tag: tests/test_toolkit.py 161 tests and tests/test_stamp_granted.py 6 on Python 3.9.25, 3.11.2,
3.13.15 and 3.14.8, each with and without cryptography.

omega-evidence 0.11.0 — malformed inputs rejected as the specs say; an RFC 3161 mark only for a token for this digest

Choose a tag to compare

@robertolocatelli81-dev robertolocatelli81-dev released this 04 Oct 13:51

An audit of the verifiers (30 September 2026) and its review rounds. Each change of behaviour in the Python package has a
test that fails on the code before it; the new note of the Go, Java and Node verifiers was measured on a bench, not by a test.
What changes for a user of 0.10.0 is listed at the end of the entry.

  • DSSE (interop/dsse.py): base64 as DSSE v1.0.0 asks verifiers to accept it — standard or URL-safe, one alphabet per
    string, padding only at the end, length a multiple of 4, no whitespace — with the same verdict on Python 3.9, 3.11 and
    3.13. payload, payloadType and signatures are required; a payloadType other than application/vnd.in-toto+json
    is rejected; a body that cannot be parsed as UTF-8 JSON is rejected even under a valid signature; NaN and Infinity are
    not JSON. A malformed envelope is verified: false, never a traceback.
  • SD-JWT (interop/sdjwt.py): verify() applies RFC 9901 §7.1 and rejects the whole token when a step fails (an alg
    other than EdDSA, an _sd_alg other than sha-256, a Disclosure of the wrong shape or not referenced, a repeated
    digest, a claim name that is not a string, is _sd or ..., or is already present, an exp or nbf that is not a
    finite number or not satisfied), and the format rules of §4.2.1 and §4.2.4.1; BASE64URL is read strictly (RFC 7515).
    issue() refuses what verify() would reject: keys that are not strings or are _sd, ... or _sd_alg anywhere, a
    disclosed name already in clear, NaN or Infinity.
  • Preservation records (preservation.py): an RFC 3161 token is checked as timestamp.verify reports it — PASS or
    FAIL against tsa_ca_file (new, optional), SKIP when it is recorded but not verified. Up to 0.10.0 the layer read a
    key that verify() never returns, so a record with an RFC 3161 token was always FAIL. Verdict change: an archive
    timestamp that declares time_source: rfc3161 with tsr_b64 missing, empty or not a string is a FAIL, not a SKIP: the
    token is what makes the claim of trusted time verifiable (RFC 4998 §4.1 makes timeStamp the one field of an
    ArchiveTimeStamp that is not OPTIONAL). A malformed record is valid: false, never an exception.
  • timestamp.stamp records anchored: true only for a reply carrying a token whose imprint is the requested digest.
    Any HTTP body — an error page, a rejection, a genuine token for another digest — was recorded as anchored with its bytes
    as tsr_b64. The reply is read with openssl ts -reply -text (one parser, shared with verify). A token whose CMS
    signature is broken is still anchored at stamp time and refused by verify with the TSA roots: proving the signature
    needs the trust anchor, which is the verifier's job. tests/test_stamp_granted.py (a local TSA built with openssl behind
    a local HTTP server) now runs in CI.
  • timestamp.verify notes say what happened: «no token recorded» when tsr_b64 is missing, empty or not a string;
    «token recorded, not decoded or verified» without a trust anchor (it said «token decoded» before any decoding). The Go,
    Java and Node verifiers said «RFC 3161 token present and bound to the pack» for a sidecar with no token; they now say
    «no RFC 3161 token recorded», as Python does (status SKIP in the four, unchanged).
  • ots.py: a sidecar that cannot be read or parsed is status malformed; the docstring no longer says the
    opentimestamps package verifies on Bitcoin when installed, which the code does not do.
  • timestamp, chip_registry and interop.aat close every file and HTTP response they open.

What changes for a user of 0.10.0. An archive timestamp declaring rfc3161 without a token now fails
verify_evidence_record; a preservation record with a genuine token is no longer always FAIL; DSSE envelopes and SD-JWTs
that 0.10.0 accepted against the specifications are rejected; a digest spelled with colons (aa:bb:…) is no longer
anchored by stamp() (verify already treated it as another digest).

Measured before the tag: tests/test_toolkit.py 160 tests and tests/test_stamp_granted.py 6 on Python 3.9.25, 3.11.2
and 3.13.15, each with and without cryptography; tests/fuzz_toolkit.py 3000 iterations, 0 violations;
verifiers/differential_oracle.py 0 disagreements of 193 here (Node 22, Go 1.24, Java 17: 9 cases not assessable on
this host); the CI run on the tagged commit measures Node 24, Go 1.27 and Java 27.

omega-evidence 0.10.0

Choose a tag to compare

@robertolocatelli81-dev robertolocatelli81-dev released this 29 Sep 08:22

0.10.0 — two limits that were not declared, and a silent downgrade (28–29 September 2026)

(a) and (b) were found on 28/09/2026 by an independent review of 0.9.1 and confirmed by measurement before any code was
written; neither was stated anywhere in the 0.9.1 documentation. (c) was found the same day by the fuzzer added in this
release. The fixes are in this release; the description of what was wrong is this entry. What changes for a user of
0.9.1
is listed at the end of the entry.

  • (a) Several processes appending to the same ledger corrupted it. Up to 0.9.1 Ledger.append was guarded by a
    threading.Lock only, so two processes (not threads) writing the same file interleaved their lines: measured on
    commit 6728ced, 4 processes × 200 appends left 601 lines of 801, verify() FAIL, 399 duplicate idx; another run
    gave 401 lines and 200 duplicates. 0.10.0 holds an exclusive advisory fcntl.flock on the open ledger file for each
    append (shared for a load); under it the instance first replays what other writers appended since its last write, so
    every entry links to the last hash on disk and carries the next idx. POSIX only: on Windows there is no fcntl and
    the ledger has one writer process, advisory only, not reliable on NFS — all stated in ledger.py and below. The test
    suite now has N threads and N processes appending to one ledger, plus a positive control that disables the lock and
    must break the chain. Cost and the full measurement: "Performance and robustness" below.

  • (b) The AAT export (aat.jcs, strict mode) accepted exactly ±2^53. omega_evidence/interop/aat.py refused
    abs(x) > 2**53, so 9007199254740992 and −9007199254740992 went through the export while canonical.py, ledger.py
    and the Go, Java and Node verifiers refuse anything outside ±(2^53−1) — the I-JSON bound (RFC 7493 §2.2; RFC 8785
    Appendix B note 1). The exported text was still correct (2^53 is exact as a double, ES6 prints it as
    9007199254740992), so no hash changed; what was wrong is that one bound in the package was one integer wider than the
    other, and the docstrings said "beyond 2^53" where the rest says "outside ±(2^53−1)". 0.10.0 imports the package
    constant (canonical._SAFE_INT) into aat.py instead of a second hand-written number; strict export now refuses
    ±2^53, accepts ±(2^53−1); the verify path (strict=False) is unchanged (an out-of-range integer is serialised as ES6
    would serialise the double). Test test_jcs_strict_integer_bound_20260928 covers 2^53−1 / 2^53 / −2^53 / 2^53+1 and
    contains its own positive control (with the 0.9.1 bound put back, the test sees 2^53 accepted). The text of the AAT
    Internet-Draft -04 (IETF archive, 115 736 bytes, SHA-256 c75a8fdf…, read on 28/09/2026) contains no integer of 16
    digits or more and no test vector, so no published AAT vector sits on this boundary; no fixture in this repository
    uses 2^53 exactly. Nothing that verified before verifies differently now: only an export of a record carrying exactly
    ±2^53 changes, from accepted to refused. ledger.py had its own copy of the same number; it now imports the one
    constant too (no behaviour changes; the test asserts the three names are one object).

  • (c) A one-bit change of sig_alg downgraded a signed pack silently. Since 0.7.0 the producer-signature layer
    accepted sig_alg: "ed25519" only and reported any other string as an "unsupported algorithm" SKIP — in the four
    verifiers alike. Measured on 28/09/2026 by the seeded fuzzer (seeds 1 and 2: "eD25519", "ed2 5519"): on a pack that
    was signed AND anchored, that SKIP left the verdict PASS / exit 0, with authenticated: false — the pack fell from
    signed to anchored and nothing but the authenticated field said so. No forgery, but a silent downgrade of the
    tier that a relying party reading the exit code would not see. 0.10.0, the same in Python, Go, Java and Node:

    • a sig_alg that is a non-canonical spelling of a supported name — the name folded to ASCII lowercase letters and
      digits, everything else dropped, equals ed25519: "eD25519", "ED25519", "ed2 5519", "ed-25519",
      "ed25519\n", " ed25519", a zero-width space appended — is a FAIL of the producer-signature layer ("sig_alg is
      not the canonical name of a supported algorithm"): no producer writes such a name, so it is a judgment about the
      sidecar, not an absence;
    • a genuinely unknown name ("rsa-pss", a post-quantum name in the classical field, a name with a non-ASCII
      look-alike letter — declared limit: such a letter makes the name unknown, not a variant) stays a SKIP, the pack
      earns the tier its other layers give it, and the SKIP is never silent: the layer reads "signature present, algorithm
      unsupported, not verified: " and the authenticity layer carries "— a signature is present but its algorithm is
      unsupported and was not verified" (also when the pack then fails for want of an anchor);
    • --require-signed in the four CLIs (verify_pack(..., require_signed=True) in the library; one dash or two, no
      value on the flag, as the other boolean) is fail-closed on the classical layer: a pack with no signature sidecar
      ("signature required but the pack is not signed") or with a signature that could not be verified is FAIL, never
      anchored; a verified signature (canonical name, or the legacy sidecar without sig_alg) satisfies it.

    Measured on 29/09/2026 on this tree, the four verifiers on 32 sidecar / flag shapes: the same verdict, exit code,
    authenticated and the same two layer texts in all four. The differential oracle gained 32 sig_alg cases with an
    expected verdict each — for every sig-alg- case the oracle also compares the (status, detail) of the producer-signature
    and authenticity layers, so the reason is one reason in the four — and one CLI-grammar case: 0 disagreements over 193
    cases with the four verifiers on 29/09/2026; 37 of the sig-alg- cases run against the four 0.9.1 verifiers
    (Python, Go, Java and Node built from commit 6728ced) are red on 32 of them and green only on the 5 whose behaviour
    did not change (positive control). The fuzzer gained the property "no silent downgrade" (a mutator that produces
    spellings and unknown names, and a second require_signed call on every mutant) and two positive controls that
    disable the canonical-name rule and the requirement (26 and 160 violations seen on the smoke seed); the unit tests a
    class that is red on 0.9.1 (11 spellings verify valid there) and carries its own positive control.

    What changes for a user of 0.9.1. (1) Any sidecar whose sig_alg folds to ed25519 without being exactly
    ed25519 now verifies FAIL where it verified SKIP + the tier of its other layers. The producer of this toolkit has
    only ever written "ed25519"; only hand-written or altered sidecars are affected. (2) The text of the SKIP for an
    unknown algorithm changed from "unsupported sig_alg: X" to "signature present, algorithm unsupported, not verified: X",
    the authenticity texts changed as described above, and Python's "anchored … — ledger" is now the wording of the other
    three (layer detail strings are declared non-normative; the verdict tuple is unchanged for these). (3) A new flag
    and a new keyword argument, both opt-in; nothing changes for a caller who does not pass them. (4) verify_pack's
    authenticated is computed from the same three booleans as in Go, Java and Node (signature PASS, registry not
    refusing, integrity PASS) instead of being read off the wording of the authenticity layer — the same value in every
    case the oracle and the tests exercise. (5) A ledger truncated or replaced under an open Ledger instance is refused:
    the next append() raises RuntimeError("ledger truncated by another writer …"), and so does every later one from that
    instance — recreate the Ledger after a log rotation (os.rename + a new file) or any external truncation. 0.9.1 went
    on writing a fresh file starting at the next idx with a broken chain, silently (measured on 6728ced by the 29/09
    review). In batch mode both versions keep writing to the old inode through their open handle. A filesystem that
    refuses flock makes append() raise OSError (not wrapped). (6) Go: the exported VerifyPack keeps its 0.7.0
    signature; the requirement is VerifyPackRequireSigned(…, requirePQ, requireSigned). Java keeps the 5-argument
    verifyPack and adds a 6-argument one; Node takes requireSigned in its options object. (7) The private Python helper
    verifier._check_signature_and_trust returns a 4-tuple (a fourth element saying why the layer is not PASS) instead of
    a 3-tuple. (8) Ledger.entries() and raw_entries() read the file as one snapshot under the shared file lock, like
    verify() (0.9.1 read line by line with no lock, so a concurrent writer's half-written line could in principle be
    seen); the lock is released before the first entry is yielded, so appending while iterating cannot deadlock, and the
    text is held in memory while iterating. (9) The Node verifier writes its receipt and exits only once the write is
    drained: with a receipt longer than a pipe buffer (64 KiB, e.g. a layer detail quoting a 70 000-byte sig_alg) a piped
    reader got 65 536 bytes of unparsable JSON in 0.9.1; the oracle now carries that case (the four write it whole).

omega-evidence 0.9.1 — inputs, sidecar fields, verifier faults and memory

Choose a tag to compare

@robertolocatelli81-dev robertolocatelli81-dev released this 26 Sep 16:23

Correction (2026-09-26) to the note "Small-order Ed25519 keys refused" below. The 0.9.1 note said that, for the small-order points other than the identity, a forgery holds only "on a share of messages". By the verification equation, that is true of one fixed construction (R = identity, S = 0), but it understated the risk: with any small-order public key A, of order n = 2, 4 or 8, anyone can produce a signature on any message. Pick S and a guess g for k mod n, set R = [S]B − [g]A, compute k = H(R ‖ A ‖ M) mod L as the verifier does, and retry until k ≡ g (mod n); each try succeeds with probability about 1/n. Measured on 2026-09-26 with curve arithmetic written for the measurement, not this repository's code: for each of the 8 small-order public keys, a signature on one message chosen in advance verified under OpenSSL, through Python cryptography (1 to 16 tries) and through Node 22 crypto (1 to 17 tries) — the same backend, so one measurement, not two independent ones. In the Python probe, the same construction against an ordinary key verified 0 times in 2000 (null control). The refusal of these keys added in 0.9.1 is unchanged; this corrects only the description of what it prevents.

Found by an adversarial review (NEMESIS) of 0.9.0 on 25/09 and by an independent review of the ledger reading on 26/09.
The verdicts below are the same in the Python reference, Node, Go and Java; where the four differ in how they get there,
it is said. Numbers dated 25/09 come from the author's measurement records, which are not part of this repository, and
were not re-measured for 0.9.1; the oracle cases and tests that exercise each rule are in the repository and run with it.

  • Small-order Ed25519 keys refused (25/09). With the identity key as public key, R=identity, S=0 is a valid
    signature on every message; the other small-order points admit such forgeries on a share of messages (the hash depends
    on R, so not on every one; not measured here); a non-canonical encoding (y >= p) is refused because the key has no
    unique encoding. Measured with the identity key through Python cryptography and Node: a forged pack signed that way,
    with that key pinned by the relying party, verified as valid and authenticated; the Go and Java verifiers received the
    same guard without a measurement of their behaviour without it. The four now refuse those keys with the same list (8
    small-order encodings, 2 with the sign bit on x = 0, every y >= p). The list was checked against curve arithmetic in
    Python (0 disagreements on 48 special and 200 000 random keys); that the four verifiers apply it alike rests on 6 oracle
    cases, all FAIL in the four.
  • Only regular files are read, without blocking, and read once (25/09). A FIFO in place of the pack, a sidecar, the
    ledger or the trust store blocked all four verifiers; a symlink to /dev/zero exhausted memory in at least one verifier (Java reported the
    OutOfMemoryError as a FAIL of the pack). Each file is now opened with O_NONBLOCK (Python, Node, Go) and accepted
    only if the opened descriptor is a regular file; anything else fails its layer exactly as an unreadable file does
    (pack-json, producer-signature, ledger-chain, rfc3161/timestamp, trusted-signer FAIL — the outcome a
    directory in that position already had). The JDK has no O_NONBLOCK: Java checks the type on the path right before
    opening, so a FIFO in place is never opened, but one swapped in between that check and the open can still block it (a
    race the other three close by checking the descriptor).
  • One input bound, the same number in the four: 64 MiB (67 108 864 bytes) per file (25/09) — and therefore per
    ledger line. Before: 256 MiB in Node and Java, a 64 MiB line buffer in Go that no document mentioned (its pack and
    sidecar reads were unbounded), no bound in Python. A file of 64 MiB + 1 byte now fails its layer in all four; files
    between 64 and 256 MiB that the previous limit of Node and Java admitted are refused. On the input shapes of the 25/09
    record (one ledger line of 64 MiB, a ledger of 161 200 lines, a pack field and a sidecar field of 64 MiB, in ASCII,
    with é escapes and with raw 3-byte UTF-8), measured on 25/09 before the line reader of 26/09, peak RSS: Python 3.11
    397 MiB, Go 1.27.1 517 MiB, Node 22.23.2 501 MiB, Java 27 1325 MiB — the JVM grows its heap lazily up to its default
    maximum (1618 MiB on that 6.3 GiB host), so what Java needs is the smallest heap that still verifies every shape: 389
    MiB (-Xmx); for Node, 304 MiB (--max-old-space-size). Below that heap Java answers NOT_ASSESSED (see "A fault of the verifier" below); a
    V8 heap exhaustion or a Go runtime out-of-memory is fatal in the runtime itself and cannot be turned into a receipt.
    To stay within the bound, three copies were removed: Node hashes the canonical form part by part instead of joining it
    (and escapes strings in bounded chunks), Java validates UTF-8 in a streaming pass, decodes each file once and hashes in
    64 KiB spills; the bytes produced are the same as before (checked on 25/09, record not published).
  • The ledger is read one line at a time (26/09). The bound alone did not keep memory in check: a ledger of 64 MiB
    made of many short lines was split into all its lines at once. Measured on the code of this release before the line
    reader (474122b, which already has the bound and the fault guard), under prlimit --data 2.5 GB, peak RSS:
    67 108 864 empty lines — Python, Node and Go answered FAIL at 611, 1018 and 1701 MiB, Java answered NOT_ASSESSED (out
    of memory, 1761 MiB); 22 M lines {} — Go crashed with no verdict (2307 MiB), Python and Java answered NOT_ASSESSED
    (2365 and 1786 MiB), Node answered FAIL at 2170 MiB. Node, Go and Java now stop at the first break of the chain (no
    caller reads the entries of a broken chain), Python after 1 000 bad lines, which it reports (agent.verify() adds
    bad_entries_truncated). After (8956528), same cap, both shapes: every verifier answers FAIL at 157–254 MiB; Python
    on the {} shape takes 0.3–0.5 s, where before it ran 84 s and then answered NOT_ASSESSED for want of memory. Python's line reader is ~3× slower than split on the empty-line
    shape (12.9 s against 4.7 s in-process). Still open: a VALID document of 64 MiB holding one container with tens of
    millions of elements (measured: one ledger line with 33.5 M zeros; a pack field of that kind behaves the same in Go and
    Java) under a 2.5 GB cap — Python PASS at 544 MiB, Node PASS at 1813 MiB, Go crashes with no verdict at 2396 MiB, Java
    answers NOT_ASSESSED at 1765 MiB; Go and Java measured identical before this change (Python and Node: no before). A bound on the number of JSON values is the candidate
    fix, not made.
  • The sidecar fields the producer writes are read (25/09). fingerprint and signed_utc were never looked at, so
    "", 0, null, true, [] or {} left a signed pack PASS and authenticated. Absent, they are still accepted
    (legacy sidecars); present, they must be what pack.sign_pack writes — fingerprint equal to the one derived from
    public_key_b64 ("ed25519:" + the first 8 and last 8 hex digits of SHA-256 of the raw key, joined by U+2026), and
    signed_utc of the form YYYY-MM-DDTHH:MM:SS+00:00 in ASCII digits naming a real calendar instant (year ≥ 1, second ≤
    59) — else producer-signature is FAIL ("malformed sidecar field").
  • "" is a present, malformed algorithm name (25/09). pq_sig_alg: "" read as absent while null was a FAIL, and
    sig_alg: "" was an "unsupported algorithm" SKIP while null was a FAIL: both are now FAIL of their layer.
  • A fault of the verifier is not a finding about the pack (25/09). Java turned any Throwable into verdict: FAIL /
    exit 1; the Python CLI and Node exited 1 on an uncaught exception (the code of FAIL) and Go 2 on a panic (the code of a
    usage error). Each verifier now catches its own faults and adds a layer internal, status FAIL with assessed: false:
    the run is NOT_ASSESSED / exit 77, unless a layer judged before the fault is adverse (then FAIL, as ever: an absence
    never hides a finding); authenticated and pq_protected are false. The library verify_pack returns that receipt
    instead of raising. Test hook, the same in the four: OEVERIFY_INJECT_INTERNAL_ERROR=1 raises an internal error right
    after the pack-sha3 layer (it can only lower a verdict to NOT_ASSESSED or keep a FAIL, never produce a PASS).

Oracle and tests. The differential oracle compares the four verifiers and, for the new cases, a DECLARED expected
verdict, so four verifiers wrong the same way are red. Recorded on 25/09: 48 new cases for the 25/09 rules other than the key list; 0.9.0 was red on
43 of them against the expected verdicts; 135 pack cases plus 17 CLI cases at 0 disagreements after the change; each check of that set (not the key list)
removed in turn, in each verifier, turned red its own cases. A verdict that is not one (crash, timeout, missing
JSON, an exit code other than 0/1/77) counts as a disagreement even when all four share it. The cases that used to
block or exhaust memory ran on 25/09 under a systemd-run MemoryMax cap that turned out not to limit on this host (500
MB allocated under MemoryMax=100M, measured 26/09); since 26/09 they run under prlimit --data 1.5 GB, which does limit
(at that cap the old Node ledger reader crashes on the {} case and the row turns red). Totals on 26/09 on the commit tagged v0.9.1: 160
oracle cases with 0 disagreements over Python, Node, Go and Java (the 6 small-order-key cases and 2 many-line ledgers
added after the 152 above), 124 tests (1 skipped).

omega-evidence 0.9.0 — the absence side of the verdict

Choose a tag to compare

@robertolocatelli81-dev robertolocatelli81-dev released this 24 Sep 06:14

omega-evidence 0.9.0 — the absence side of the verdict

Behaviour change. A check that could not run on this host is no longer reported with the value of a finding about
the pack, and it can no longer read as a pass. If you consume the CLI's exit code, note the new 77.

Measured 24/09/2026, the same OeVerify.java on the same signed pack with -require-pq: on JDK 17, which has no
ML-DSA, it answered FAIL / exit 1 — declaring a defect it had never checked — and on JDK 27, which has ML-DSA, also
FAIL, because there the co-signature really is invalid. The differential oracle read that agreement as consensus.

The fail-open half was worse. With the PQ layer optional and a co-signature present but unverifiable here, a
runtime without the backend answered PASS / exit 0 on the very pack a capable runtime rejects:

before  python FAIL/1  node22.23 FAIL/1  java27 FAIL/1 | java17 PASS/0  node22.14 PASS/0
after   python FAIL/1  node22.23 FAIL/1  java27 FAIL/1  go1.27 FAIL/1
        java17 NOT_ASSESSED/77  node22.14 NOT_ASSESSED/77  go1.26 NOT_ASSESSED/77

What changed

One total order in all four verifiers — FAIL > NOT_ASSESSED > PASS:

verdict exit meaning
PASS 0 every layer that ran passed, and every present layer could be read
FAIL 1 at least one layer was checked and is adverse
NOT_ASSESSED 77 nothing adverse was found, and a present layer could not be read here
  • valid keeps its meaning and stays false under NOT_ASSESSED (fail-closed); the library returns valid and
    assessed, and verdict is the CLI's rendering of the pair.
  • A layer carries assessed: false only when it failed or was skipped because this runtime lacks the capability —
    a PQ algorithm the project knows with no backend registered here. An unknown algorithm name stays a judgment: it
    can never be pq-protected. A layer genuinely absent from the pack changes nothing.
  • Form is judged before capability. Whether a co-signature is well-formed base64 needs no backend, so a required
    co-signature of a known algorithm that is not strict base64 is a FAIL on every runtime, capable or not.
  • The differential oracle no longer counts a shared incapacity as agreement: it probes which runtimes can actually run
    the check, excludes a genuine NOT_ASSESSED from the comparison and reports it with its own denominator — while
    counting NOT_ASSESSED from a capable runtime as a disagreement.

Verified

114 tests pass (four new, red against 0.8.3). Differential oracle: 0 disagreements over 104 cases across Python, JS,
Go and Java, including a new host-side case. Measured on runtimes that genuinely cannot do it — Node 22.14 on OpenSSL
3.0, JDK 17, a Go 1.26.8 build, Python with the backend removed.

Honest limits

Of the eight absence branches (two per port), the slh-dsa one was executed in all four; the ml-dsa-without-backend
one in Java, Node and Go on their older runtimes. Nothing here changes what a corpus written from the artifact's side
can observe: this separation is still only checkable by running a verifier on a host that lacks the capability.

omega-evidence 0.8.3 — verifier hygiene (14 review rounds, oracle 103/0)

Choose a tag to compare

@robertolocatelli81-dev robertolocatelli81-dev released this 21 Sep 14:39

omega-evidence 0.8.3 — verifier hygiene from the cra-evidence review

Propagation of the defect classes found by the cra-evidence 0.3.0 review to the four pack verifiers (Python reference, Go, Java, Node), followed by 14 review rounds on this release (Opus 5 / Sonnet 5 / Haiku 4.5; Gemini Pro out of credits) — every finding re-measured, then fixed or made a case of the differential oracle.

Measured on 2026-09-21 (commit 8c4f8a2fd4ab125dd9d51565d140178619d8dd98, CI run 35613453517):

  • differential oracle: 103 cases (86 pack/ledger/sidecar/trust + 17 CLI-grammar), 0 disagreements between the four verifiers (Go 1.27, JDK 27, Node 24 in CI; measured also locally on Node 22.23)
  • the same oracle against the four 0.8.2 verifiers: 46 red (positive control); against a deliberately lenient Python (verifiers/lax_python_ablation.sh): 13 red
  • 109 tests green on Python 3.9/3.11/3.13, with and without cryptography

What was wrong in 0.8.2 (verdicts, not cosmetics): Node dropped an own __proto__ key while copying (PASS on a tampered entry, alone); Node and Java decoded non-UTF-8 lossily (PASS where the hash was computed over U+FFFD); the Python reference raised instead of answering on hostile ledgers/sidecars/trust stores (UnicodeDecodeError, AttributeError, RecursionError, TypeError), read the RFC 3161 sidecar with the loose parser, had no lone-surrogate rule (an entry the 0.8.2 producer itself wrote was PASS here alone), read the anchoring entry at a different level than the three, refused the reserved type-tag key as a verifier, and used Unicode regex semantics in the honest_scope gate (i ≡ ı, Unicode \b); Node accepted float lexemes with an integer value (1.0 hashed as 1), counted UTF-16 units in the scope quantifier, kept the trust state on Object.prototype, and crashed on a missing --ledger path; the four CLIs had four grammars (unknown flag, ""/missing/flag-like/repeated value, abbreviation, second positional, --, -h, one dash vs two: now one grammar, usage exit 2). Full list with the per-round attribution in the README section "0.8.3 — verifier hygiene".

Verdicts that change for existing archives (counted by script from the positive-control table): Python on twelve well-formed inputs, Node on seven, Go and Java on none — each toward the verdict of the other three; three classes of input the 0.8.2 producer wrote change verdict (listed in the README). Declared, not aligned: Go flag order, size bounds, Ed25519 non-canonical points (not measured).

Assets: wheel + sdist (hashes in SHA256SUMS), CycloneDX SBOM, CRA evidence pack (ledger, pack, AWS KMS Ed25519 signature 86db2b72…, trust registry) — verify offline with python -m omega_evidence omega-evidence-0.8.3-cra_pack.json --trust-store omega-evidence-0.8.3-trust.json or with any of the three independent verifiers.

Install: pip install --extra-index-url https://robertolocatelli81-dev.github.io/pypi/ omega-evidence==0.8.3

omega-evidence 0.8.2 — no lifecycle record is ever tombstoned

Choose a tag to compare

@robertolocatelli81-dev robertolocatelli81-dev released this 20 Sep 08:40

omega-evidence 0.8.2 — the 0.8.1 close-tombstone guard was bypassable; closed (20 September 2026)

Round 8 measured, against the shipped 0.8.1, that original_event is written by the deleter: a deleting authority could
tombstone the session close claiming "pause", append records and a new close, and verify ok: true. 0.8.2 closes it
without trusting the deleter: no lifecycle record is ever tombstoned (tombstone() raises; a chain carrying one is
refused anywhere in the chain — lifecycle records carry no erasable content, §9.3 exists for content), and a tombstone as
the last record is a problem (its tombstone_hash is bound to nothing). Also in 0.8.2: a self-recorded session without
agent_kid pins the genesis signer as the agent; every pin is compared with the PRIMARY signer (a hybrid record whose
classical half is the agent's key while the primary is foreign is not the agent's); re-tombstoning keeps the original
record's signature as evidence (original_signature) and lists the deleters' signatures; the export verifies its own
chains with the keys it just used before returning them; inference_config / environment values are typed.

Rounds are closed by the author's decision after round 8; its findings were applied and re-measured (every guard ablated in
the tests). Tests: 107 (cryptography 50 / 49 / none). Deposit: Zenodo concept DOI
10.5281/zenodo.22539633; this version: 10.5281/zenodo.22855412.


0.8.1 notes (for the record) — round 7 and 8 fixes on the Agent Audit Trail verifier (20 September 2026)

0.8.0 shipped on 20 September at 10:11 UTC; review rounds 7 and 8 (run the same morning after the weekly Claude limit
reset; Gemini 3.1 Pro present in round 8) found and we fixed, each re-measured and ablated in the tests:

  • The recorder of an independent session is pinned (recorder_kid, or the first signing key of the session): in 0.8.0 a
    deleting-only key — or any non-agent key in the verifier's key set — could rewrite the tail of an independent session
    with ok: true; the 0.8.0 sentence "who may delete is pinned" held only for self-recorded sessions. Corrected.
  • A self-recorded session without agent_kid now pins the genesis signer as the agent (warning), so the same rewrite by a
    second key in the key set is a problem there too.
  • The -03 fallback key is judged by its thumbprint like any other, so agent_kid and the deleting authorities bind legacy
    records; a tombstone whose signer_kid_classical is not a string is a verdict, not a TypeError; tombstone_kids is typed.
  • A tombstoned genesis or close is refused anywhere in the chain (0.8.1's first fix refused it only while it was the last
    record); lifecycle records of other kinds may be tombstoned and carry original_event.
  • tool_response.parent_call_id must name an earlier tool_call; inference_config / environment values are typed.
  • The RFC 6962 comparison with cryptovalid is vendored as 20 root/path vectors, so the README claim reproduces in any clone.

Reported to the draft's author alongside the 0.8.0 findings. Tests: 107 (cryptography 50 / 49 / none). Deposit: Zenodo
concept DOI 10.5281/zenodo.22539633; the version DOI of 0.8.1 is added here once
Zenodo has archived this release.


0.8.0 notes (for the record) — Agent Audit Trail draft -04, ML-DSA-65 in the Node verifier

Everything below was measured on 19 September 2026 with the tools named; the review dossier lists every finding.

  • interop.aat implements draft-sharif-agent-audit-trail-04 (15 September 2026; 0.7.0 implemented -00 of March). New in the record and enforced by the verifier: record_phase and the §4.2 pre-execution rules, the §7 REQUIRED action_detail fields per action type, signer_kid (RFC 7638 JWK thumbprint for P-256 — checked against jwcrypto 1.6.1 — and the AKP thumbprint of draft-ietf-cose-dilithium-11 for ML-DSA-65, which reproduces the draft's own example kid), ES256 / ML-DSA-65 / hybrid signatures, recording independence (§5), the §5.3 fail-safe trust level, nonces, tombstones (§9.3), session close with session_hash (§8.3), size bounds, §13 decision-reproducibility closure, Merkle batch anchoring (§6.4, RFC 6962 — roots and audit paths identical to cryptovalid's implementation for 1…20 leaves) with an RFC 3161 anchor over the root, JSONL and CSV exports (§10), a CLI (python -m omega_evidence.interop.aat verify|csv).
  • Correction to 0.7.0: its exports violated the draft's REQUIRED per-action action_detail fields (tool_name, parameters_hash, decision_type were not emitted and not checked). Fixed; -00 chains (no record_phase) are refused with an explicit reason — re-export them, the export is deterministic.
  • Declared deviation from the draft: a tombstone is signed anew by the deleting authority and verified like any record; the draft's "retains the signature field" would let anyone replace any signed record with a tombstone (found by the review, measured, reported to the author). Further declared choices (external_timestamp pre-image, epoch anchors outside the chain, §13 field placement, empty ML-DSA context, hybrid classical failure = problem) are in the module docstring.
  • Node verifier: verifies the ML-DSA-65 co-signature through the Node build's OpenSSL ≥ 3.5 (feature-detected; measured on Node 24.21.0 and 22.23.2); differential oracle 0/57 with four verifiers (Python, Go, Java, Node), 0 declared divergences on a capable Node. CI runs Node 24.
  • Review: four independent reviewers — Gemini 3.1 Pro, Claude Opus 5, Sonnet 5, Haiku 4.5 — in six rounds (19 September 2026; Gemini present in all six, and on the seventh Gemini's monthly spend cap and the weekly Claude limit stopped the round — it was skipped by the author's decision, after round 6 had ended with three of the four reviewers reporting no material issues and the fourth's findings applied and re-measured). Every finding was re-measured before being accepted and every guard is ablated in the tests (removing it turns the suite red). Among the real ones: the forged tombstone; crashes on hostile input (invalid calendar dates matching the RFC 3339 regex, lone surrogates, NaN, 600-deep nesting, integers beyond the double range, non-object action_detail, unhashable epoch ids); independent recording not required to be signed and keyed on a SHOULD field; a signed record without signer_kid accepted through the -03 fallback (now allow_legacy_03, never for an independent recorder); with keys a signed prefix could be continued unsigned; verify_epochs claimed a leaf_count check it did not do; conflicting anchors overwrote each other silently; booleans passed as numbers; a poisoned key map could relabel a key as the agent's (kids are now checked against the key's thumbprint); ECDSA high-S malleability changed a record's hash (low-S emitted, high-S reported); independence could be opted out of by omitting a field (now a session property); epoch membership by record_id instead of by leaf; an RFC 3161 anchoring that failed returned silently; any key in the key set could tombstone a record (deleting authorities are now pinned).
  • Stated limits: the mapping from omega records is lossy and derives only what the record carries (tool_call, decision); identifiers are deterministic UUID v4-format values; trust_level is what the caller declares; AAT chains are verified by the Python module only (Go/Java/JS verify packs); truncation of a chain to a valid prefix is undetectable without the close record or an external anchor; an unsigned tombstone in an unsigned chain can replace any record (the draft's design, reported); RFC 3161 tokens are verified only against a supplied trust anchor; the draft is an individual Internet-Draft and may change again.
  • Competitor table (primary sources of 19 September 2026: OpenTelemetry GenAI semantic conventions, OCSF 1.9.0, RFC 5848): in the dossier and the README.

Tests: 105 (cryptography 50 / 49 / none), every review guard asserted by its own message and ablated (removing it turns the suite red). Deposit: Zenodo concept DOI 10.5281/zenodo.22539633; this version: 10.5281/zenodo.22855040 (archived by Zenodo on 2026-09-20 at 08:11 UTC from the v0.8.0 tag).