Authority Proof

Authority Proof is a feature of the Authority engine. It signs a statement that an event is in a journal, and lets anyone holding the right files check that statement offline. It is not an automatic proof that events happened or that an action was executed.

Status: Experimental · V1 under construction. Not independently reviewed or audited. Written against the authority-graph commit 397ba8c; the source remains authoritative.

What an attestation is

An attestation (authority-attestation/v1) is a JSON document signed with Ed25519. It says: the holder of key K asserts that this CAPABILITY_ISSUED or CAPABILITY_REDEEMED event is in the journal whose chain head is H, and that Authority’s own validator accepted it when the attestation was built.

It is not a proof that the decision was right, that the journal’s events are true or complete, that the signer is who you think, or that an effect happened.

What it contains

  • proof_version and kind: ISSUANCE or REDEMPTION.
  • engine: a fixed identifier with the protocol and event-schema versions. It is not a software version.
  • statement: the event (sequence, identifier, authority time), the capability, the action and its fingerprint, the principal, the decision sequence and the enforcement point. An issuance also carries the granted chain and the expiry.
  • journal: the scheme authority-journal-chain/v1, the head sequence and the head hash.
  • signature: Ed25519, a key_id and the signature itself.

Every object is closed: an unknown member at any level is an error. principal_id is the identity the caller asserted, not a verified identity.

How it is signed

bytes = utf8("authority-attestation/v1\n") || utf8( JCS( attestation with signature = { alg, key_id } ) )

JCS is RFC 8785. Everything except signature.sig is signed, and the prefix separates this use from any other. Signatures are Ed25519 computed through node:crypto.

key_id is the base64url form of the SHA-256 of the raw public key. It names a key, not a person, a service or an organization. Which keys to trust is decided by the verifier in a trusted-keys file; an attestation never adds a key to it. Keys are Ed25519 JWK only.

The journal hash chain

digest_i = SHA-256( "authority-journal-event/v1\n" || JCS(event_i) )
h_0      = SHA-256( "authority-journal-chain/v1" )
h_i      = SHA-256( h_{i-1} || digest_i )

The head says that this exact sequence of events hashes to this value. It does not say that the events are true, that the journal is complete, or that no other journal exists with a different history.

Verification levels L0 to L3

What each level checks
LevelWhat it checksResult word
L0 formStrict JSON (no duplicate keys, exact integers only, bounded size and depth), closed schema, canonical encodings, and a statement consistent with itself.none; a failure is REJECTED
L1 signatureA fixed algorithm, a key_id among the verifier’s trusted keys, the key’s window and revocation, and the Ed25519 signature over the signing input.CONSISTENT_L1
L2 contextThe attestation matches the context the verifier expects: kind, capability, action, fingerprint, principal, enforcement point, journal head. An empty expected context is refused, never passed vacuously.CONSISTENT_L2
L3 replayReplays the journal you supply with the engine’s own validators, checks that it hashes to the attested head, re-derives the statement and re-validates the decision. It never runs when L1 or L2 failed.CONSISTENT_L3

A failure at a level leaves the next levels NOT_CHECKED. There is no plain “valid”: the overall result is REJECTED or one of the CONSISTENT_L* words, and every result lists what it does not establish. A key revoked ALWAYS, or outside its window, stays rejected: L3 is never used to rescue it.

Verify it yourself

You need a clone of the repository and Node.js 20 or 22. Installing the dependencies needs a network.

git clone https://github.com/theoadam2506-rgb/authority-graph.git
cd authority-graph && npm ci

Then verify the published redemption attestation against the published journal and trusted key:

npm run authority -- proof verify proof/vectors/redemption.json \
  --keys proof/vectors/trusted-keys.json \
  --journal proof/vectors/journals/journal.json

It prints result: CONSISTENT_L3, the levels (L0 PASS | L1 PASS | L2 NOT_CHECKED | L3 PASS), each check, the scope (FULL_JOURNAL), anchored: NO, and the list headed “NOT ESTABLISHED by this result”. Exit codes: 0 consistent, 1 rejected, 2 unreadable input, 64 usage. We ran this command with no network access at all, on Linux with Node.js 22, after installing the dependencies.

To also check an expected context (this turns L2 from NOT_CHECKED to PASS):

npm run authority -- proof verify proof/vectors/redemption.json \
  --keys proof/vectors/trusted-keys.json \
  --journal proof/vectors/journals/journal.json \
  --expect-kind REDEMPTION --expect-capability-id cap-proof-1 \
  --expect-enforcement-point ep-proof-1

To supply an anchor, a list of heads you chose to trust:

npm run authority -- proof verify proof/vectors/redemption.json \
  --keys proof/vectors/trusted-keys.json \
  --journal proof/vectors/journals/journal.json \
  --trusted-heads proof/vectors/trusted-heads.json

The report then says anchored: YES, and in the same line independence NOT_ESTABLISHED: the tool cannot tell where your anchor came from. To see the hash-chain head of a journal on its own:

npm run authority -- proof head proof/vectors/journals/journal.json

Test vectors

proof/vectors/ holds a fixed test key, a trusted-keys file, a five-event journal with its head after every prefix, a genuine issuance and a genuine redemption attestation, the exact signing inputs, and 15 negative cases with the expected failing check. npm run proof:vectors regenerates them and the test suite fails if they drift. The test key is RFC 8032’s test key: its private half is public knowledge, so it protects nothing and must never be trusted for a real attestation.

Two negative cases, as we ran them: the document with one signature bit changed is REJECTED at L1; validly-signed-lie, a statement signed by the trusted key but unsupported by the journal, passes L1 and is REJECTED at L3.HEAD.

The project’s own test suite also runs interoperability test cases: the signing inputs are checked with OpenSSL, and the journal chain, the key identifier and the signing inputs are recomputed with Python’s standard library, sharing no code with the repository. These are our own tests, not an independent validation.

What CONSISTENT_L3 means

It means that the statement was signed by a key you trust, that the journal you supplied replays under the engine’s rules, that its first events hash to the attested head, that the signed statement equals what the engine derives from them, and that the engine’s validator accepts the decision over that prefix.

It does not mean that a real action was executed, that the events really happened, that the journal is complete, or that no other history exists. A journal fabricated consistently, with an attestation signed by a trusted key, passes. Without an anchor, the report says exactly that.

What is not established

  • The authenticity of the journal’s events: they are asserted and unauthenticated. The identity of any principal is not verified.
  • The completeness of the journal: a truncated journal, a journal rolled back to an older state, or an omitted event (a revocation, for instance) is invisible without a witness outside Authority Proof.
  • The independence of an anchor: an anchor is chosen by the verifier, reported as SUPPLIED_BY_VERIFIER, and its independence is NOT_ESTABLISHED.
  • The identity of the signer: a key names a key. The instant of signing is the signer’s own claim, and key windows and revocation are evaluated on that claimed time.
  • Equivocation: a signer holding two incompatible journals can sign attestations against each, and each is internally consistent.
  • Non-repudiation, trusted timestamping and certification are not provided, and no conformance with JWS, COSE or WIMSE is claimed.
  • That an effect happened, or happened once.

A stolen key can sign today a statement that claims an earlier time. revoked_from: "ALWAYS" rejects everything signed by that key, genuine past attestations included. The corroborate command, meant to help sort them out, is deferred and not available.

Replay is bounded

Replay cost grows faster than linearly with the number of events. The default ceiling is 10,000 events (--max-events changes it); a larger journal is refused, not truncated. Measured once on a development machine with a synthetic journal, 10,000 events took about 7 seconds end to end and 277 MB at peak. Read the ratios, not the absolutes.

Review status

Authority Proof has not been independently reviewed. An independent cryptographic review is prepared and has not started. No security guarantee is claimed.

Sources at the pinned commit