saymrwulf/proof-aware-crypto-tooling-agent
1
0
Fork 0
mirror of https://github.com/saymrwulf/proof-aware-crypto-tooling-agent.git synced 2026-09-03 19:53:43 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
proof-aware-crypto-tooling-.../evidence/betrusted-ed25519.receipt.yaml

48 lines
2 KiB
YAML
Raw Normal View History

REAL EVIDENCE: guarded replay of all four repos, attested, logged, dogfooded The provider ran its full honest replay against the four verified repositories on this machine - every Lean compile and axiom audit routed through lean-guard (memory-capped, core-pinned, single-flight, ~30 min per fork) - and the results are now shipped under evidence/: - 16/16 certificates proven per fork, every axiom cone boundary-exact (the four apex tiers carry their fork's documented SHA-512/wire boundary axiom-for-axiom), each attestation pinned to the exact repo commit (dalek 8ded7bc, anza 673c15e, risc0 98a13a6, betrusted 81f614a) and Ed25519-signed. - All four appended to the persistent transparency log. The log holds EIGHT leaves: the first four are the initial run's attestations, which honestly recorded an AUDIT FAILURE (the two pacta bugs fixed in e87f0e8) - an append-only trust ledger keeps its bad day, and the fixed run's leaves sit beside it. - Every receipt re-verified through the FULL stack: dogfood verifier (backend verified-dalek-serial recorded), STH pin store, freshness policy. Receipts are freshly issued against the final tree (a stale mid-run receipt tripped the pin store's rollback defense exactly as designed; the rollback diagnostic now hints at idempotent re-issue). - The capstone consequence ran for real: pacta agent with trusted provider + signature via the proven path + required receipt + pin store + --require-verified-verifier built the R4-gated library capsule from ATTESTED evidence (no local Lean replay needed by the consuming agent). Docs and teaching updated against the real artifacts: evidence/README (inventory + re-verify instructions), README "Real Evidence" section, lecture 5 now re-derives 16/16 verdicts from the REAL dalek attestation (signature checked on the proven path, provider labels ignored), and lecture 6 verifies all four REAL receipts and walks a fresh pin store over them. Every changed notebook cell executed before commit. 49/49 tests green. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-06 12:54:48 +00:00
schema_version: 1
type: pacta.transparency.receipt.v1
log_id: 205e4c389cb143e08f0d2d58bdc8e425e47e3cbe7f2108cc58bbe835d2cc41d7
hash_algorithm: RFC9162_SHA256
attestation_path: provider/out/betrusted-ed25519.attestation.yaml
attestation_digest_sha256: 5bd2a597d712a6a80e6ba82baabcdbbbd54bc913e8a77375a6ae42e2cb7b1c57
leaf_index: 7
leaf_hash: 2791c352956ebc620a4fe12b20bfd6faa0813238c5bc0563fa4eb0130d829247
tree_size: 8
inclusion_proof:
- bdde4e4b87cd263b5914dbbae0c85ceed468c3054596f6ca79121e54cc6a134e
- f3724e66715b582c384cf49928d4705458475ea4293749989c483ab7fe9496ce
- 04541cffd46cf5a97d7453ed8ae681b1a1fedb879eb8c7a262e05b3176159eed
consistency:
from_tree_size: 8
from_root_hash: 9a15b9a1379edc07ae43d3fc61b52dc4446b56770bff6538e88ed98746ac2283
proof: []
status: not_applicable
sth:
schema_version: 1
type: pacta.transparency.signed_tree_head.v1
log_id: 205e4c389cb143e08f0d2d58bdc8e425e47e3cbe7f2108cc58bbe835d2cc41d7
tree_size: 8
The provider eats its own dogfood: root signatures via the merkleized library The dogfood principle now runs in BOTH directions. Agents already verified signatures through the proven dalek path; now the provider SIGNS with it too, and proves to itself that the signing code is in its own log before every signature: - dogfood binary gains a `sign` mode (seed over stdin, never argv; ed25519_dalek::SigningKey from the same pinned merkleized workspace). Honesty ledger unchanged: the library's VERIFY path is certificate-covered; its signing path is declared trusted base - but it is the ATTESTED artifact, not an un-attested third implementation. - sign_payload_ed25519_detailed: signing dispatch mirroring the verify dispatch; the backend that actually signed is recorded in every attestation signature block and STH. - THE SELF-REFERENTIAL CHECK: before signing any tree head, the provider runs the SAME Merkle inclusion verification an agent runs - against the very tree it is about to sign - for the newest leaf attesting the signing library itself, and embeds the result in the signature block: signing_provenance: signing_backend: verified-dalek-serial signing_library_component: dalek-ed25519-verified signing_library_source_commit: aa0f6ab... self_inclusion: verified signing_library_leaf_index: 4 signing_library_certificates_proven: 16/16 A root signature that names the leaf vouching for the code that produced it. First-append chicken-and-egg is handled honestly (self_inclusion: library_not_in_log). - Evidence refreshed: all four receipts re-issued under dogfood-signed STHs; the full agent verify loop re-run green. 50/50 tests (new signing roundtrip test, skip-safe where unbuilt). Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-06 13:21:17 +00:00
timestamp: '2026-07-06T13:20:40Z'
REAL EVIDENCE: guarded replay of all four repos, attested, logged, dogfooded The provider ran its full honest replay against the four verified repositories on this machine - every Lean compile and axiom audit routed through lean-guard (memory-capped, core-pinned, single-flight, ~30 min per fork) - and the results are now shipped under evidence/: - 16/16 certificates proven per fork, every axiom cone boundary-exact (the four apex tiers carry their fork's documented SHA-512/wire boundary axiom-for-axiom), each attestation pinned to the exact repo commit (dalek 8ded7bc, anza 673c15e, risc0 98a13a6, betrusted 81f614a) and Ed25519-signed. - All four appended to the persistent transparency log. The log holds EIGHT leaves: the first four are the initial run's attestations, which honestly recorded an AUDIT FAILURE (the two pacta bugs fixed in e87f0e8) - an append-only trust ledger keeps its bad day, and the fixed run's leaves sit beside it. - Every receipt re-verified through the FULL stack: dogfood verifier (backend verified-dalek-serial recorded), STH pin store, freshness policy. Receipts are freshly issued against the final tree (a stale mid-run receipt tripped the pin store's rollback defense exactly as designed; the rollback diagnostic now hints at idempotent re-issue). - The capstone consequence ran for real: pacta agent with trusted provider + signature via the proven path + required receipt + pin store + --require-verified-verifier built the R4-gated library capsule from ATTESTED evidence (no local Lean replay needed by the consuming agent). Docs and teaching updated against the real artifacts: evidence/README (inventory + re-verify instructions), README "Real Evidence" section, lecture 5 now re-derives 16/16 verdicts from the REAL dalek attestation (signature checked on the proven path, provider labels ignored), and lecture 6 verifies all four REAL receipts and walks a fresh pin store over them. Every changed notebook cell executed before commit. 49/49 tests green. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-06 12:54:48 +00:00
root_hash: 9a15b9a1379edc07ae43d3fc61b52dc4446b56770bff6538e88ed98746ac2283
hash_algorithm: RFC9162_SHA256
signatures:
ed25519:
scheme: openssl-ed25519
The provider eats its own dogfood: root signatures via the merkleized library The dogfood principle now runs in BOTH directions. Agents already verified signatures through the proven dalek path; now the provider SIGNS with it too, and proves to itself that the signing code is in its own log before every signature: - dogfood binary gains a `sign` mode (seed over stdin, never argv; ed25519_dalek::SigningKey from the same pinned merkleized workspace). Honesty ledger unchanged: the library's VERIFY path is certificate-covered; its signing path is declared trusted base - but it is the ATTESTED artifact, not an un-attested third implementation. - sign_payload_ed25519_detailed: signing dispatch mirroring the verify dispatch; the backend that actually signed is recorded in every attestation signature block and STH. - THE SELF-REFERENTIAL CHECK: before signing any tree head, the provider runs the SAME Merkle inclusion verification an agent runs - against the very tree it is about to sign - for the newest leaf attesting the signing library itself, and embeds the result in the signature block: signing_provenance: signing_backend: verified-dalek-serial signing_library_component: dalek-ed25519-verified signing_library_source_commit: aa0f6ab... self_inclusion: verified signing_library_leaf_index: 4 signing_library_certificates_proven: 16/16 A root signature that names the leaf vouching for the code that produced it. First-append chicken-and-egg is handled honestly (self_inclusion: library_not_in_log). - Evidence refreshed: all four receipts re-issued under dogfood-signed STHs; the full agent verify loop re-run green. 50/50 tests (new signing roundtrip test, skip-safe where unbuilt). Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-06 13:21:17 +00:00
signing_backend: verified-dalek-serial
REAL EVIDENCE: guarded replay of all four repos, attested, logged, dogfooded The provider ran its full honest replay against the four verified repositories on this machine - every Lean compile and axiom audit routed through lean-guard (memory-capped, core-pinned, single-flight, ~30 min per fork) - and the results are now shipped under evidence/: - 16/16 certificates proven per fork, every axiom cone boundary-exact (the four apex tiers carry their fork's documented SHA-512/wire boundary axiom-for-axiom), each attestation pinned to the exact repo commit (dalek 8ded7bc, anza 673c15e, risc0 98a13a6, betrusted 81f614a) and Ed25519-signed. - All four appended to the persistent transparency log. The log holds EIGHT leaves: the first four are the initial run's attestations, which honestly recorded an AUDIT FAILURE (the two pacta bugs fixed in e87f0e8) - an append-only trust ledger keeps its bad day, and the fixed run's leaves sit beside it. - Every receipt re-verified through the FULL stack: dogfood verifier (backend verified-dalek-serial recorded), STH pin store, freshness policy. Receipts are freshly issued against the final tree (a stale mid-run receipt tripped the pin store's rollback defense exactly as designed; the rollback diagnostic now hints at idempotent re-issue). - The capstone consequence ran for real: pacta agent with trusted provider + signature via the proven path + required receipt + pin store + --require-verified-verifier built the R4-gated library capsule from ATTESTED evidence (no local Lean replay needed by the consuming agent). Docs and teaching updated against the real artifacts: evidence/README (inventory + re-verify instructions), README "Real Evidence" section, lecture 5 now re-derives 16/16 verdicts from the REAL dalek attestation (signature checked on the proven path, provider labels ignored), and lecture 6 verifies all four REAL receipts and walks a fresh pin store over them. Every changed notebook cell executed before commit. 49/49 tests green. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-06 12:54:48 +00:00
status: signed
The provider eats its own dogfood: root signatures via the merkleized library The dogfood principle now runs in BOTH directions. Agents already verified signatures through the proven dalek path; now the provider SIGNS with it too, and proves to itself that the signing code is in its own log before every signature: - dogfood binary gains a `sign` mode (seed over stdin, never argv; ed25519_dalek::SigningKey from the same pinned merkleized workspace). Honesty ledger unchanged: the library's VERIFY path is certificate-covered; its signing path is declared trusted base - but it is the ATTESTED artifact, not an un-attested third implementation. - sign_payload_ed25519_detailed: signing dispatch mirroring the verify dispatch; the backend that actually signed is recorded in every attestation signature block and STH. - THE SELF-REFERENTIAL CHECK: before signing any tree head, the provider runs the SAME Merkle inclusion verification an agent runs - against the very tree it is about to sign - for the newest leaf attesting the signing library itself, and embeds the result in the signature block: signing_provenance: signing_backend: verified-dalek-serial signing_library_component: dalek-ed25519-verified signing_library_source_commit: aa0f6ab... self_inclusion: verified signing_library_leaf_index: 4 signing_library_certificates_proven: 16/16 A root signature that names the leaf vouching for the code that produced it. First-append chicken-and-egg is handled honestly (self_inclusion: library_not_in_log). - Evidence refreshed: all four receipts re-issued under dogfood-signed STHs; the full agent verify loop re-run green. 50/50 tests (new signing roundtrip test, skip-safe where unbuilt). Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-06 13:21:17 +00:00
payload_digest_sha256: 72d9abbc5720f1c6f03ad6f6363a6c5587a2bfd46f67248282cdcfa8eeb8e1dd
signature_base64: Yz9T8akHXeiMJBKLgpoKTInfdV5WeuZgYzgWYEMkdaYS9NVKLpDjp1AcapJxUZ9Ft+2O2+n010yN7flODKqBBw==
REAL EVIDENCE: guarded replay of all four repos, attested, logged, dogfooded The provider ran its full honest replay against the four verified repositories on this machine - every Lean compile and axiom audit routed through lean-guard (memory-capped, core-pinned, single-flight, ~30 min per fork) - and the results are now shipped under evidence/: - 16/16 certificates proven per fork, every axiom cone boundary-exact (the four apex tiers carry their fork's documented SHA-512/wire boundary axiom-for-axiom), each attestation pinned to the exact repo commit (dalek 8ded7bc, anza 673c15e, risc0 98a13a6, betrusted 81f614a) and Ed25519-signed. - All four appended to the persistent transparency log. The log holds EIGHT leaves: the first four are the initial run's attestations, which honestly recorded an AUDIT FAILURE (the two pacta bugs fixed in e87f0e8) - an append-only trust ledger keeps its bad day, and the fixed run's leaves sit beside it. - Every receipt re-verified through the FULL stack: dogfood verifier (backend verified-dalek-serial recorded), STH pin store, freshness policy. Receipts are freshly issued against the final tree (a stale mid-run receipt tripped the pin store's rollback defense exactly as designed; the rollback diagnostic now hints at idempotent re-issue). - The capstone consequence ran for real: pacta agent with trusted provider + signature via the proven path + required receipt + pin store + --require-verified-verifier built the R4-gated library capsule from ATTESTED evidence (no local Lean replay needed by the consuming agent). Docs and teaching updated against the real artifacts: evidence/README (inventory + re-verify instructions), README "Real Evidence" section, lecture 5 now re-derives 16/16 verdicts from the REAL dalek attestation (signature checked on the proven path, provider labels ignored), and lecture 6 verifies all four REAL receipts and walks a fresh pin store over them. Every changed notebook cell executed before commit. 49/49 tests green. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-06 12:54:48 +00:00
public_key_fingerprint_sha256: 874c8a008a607021528b2493fa1caf059f9d5c123d29193dfabc09a6d1e7a56a
The provider eats its own dogfood: root signatures via the merkleized library The dogfood principle now runs in BOTH directions. Agents already verified signatures through the proven dalek path; now the provider SIGNS with it too, and proves to itself that the signing code is in its own log before every signature: - dogfood binary gains a `sign` mode (seed over stdin, never argv; ed25519_dalek::SigningKey from the same pinned merkleized workspace). Honesty ledger unchanged: the library's VERIFY path is certificate-covered; its signing path is declared trusted base - but it is the ATTESTED artifact, not an un-attested third implementation. - sign_payload_ed25519_detailed: signing dispatch mirroring the verify dispatch; the backend that actually signed is recorded in every attestation signature block and STH. - THE SELF-REFERENTIAL CHECK: before signing any tree head, the provider runs the SAME Merkle inclusion verification an agent runs - against the very tree it is about to sign - for the newest leaf attesting the signing library itself, and embeds the result in the signature block: signing_provenance: signing_backend: verified-dalek-serial signing_library_component: dalek-ed25519-verified signing_library_source_commit: aa0f6ab... self_inclusion: verified signing_library_leaf_index: 4 signing_library_certificates_proven: 16/16 A root signature that names the leaf vouching for the code that produced it. First-append chicken-and-egg is handled honestly (self_inclusion: library_not_in_log). - Evidence refreshed: all four receipts re-issued under dogfood-signed STHs; the full agent verify loop re-run green. 50/50 tests (new signing roundtrip test, skip-safe where unbuilt). Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-06 13:21:17 +00:00
signing_provenance:
signing_backend: verified-dalek-serial
signing_library_component: dalek-ed25519-verified
signing_library_source_commit: aa0f6abc327ba2a54a534b21608ca8996cf73682
self_inclusion: verified
signing_library_leaf_index: 4
signing_library_certificates_proven: 16/16
REAL EVIDENCE: guarded replay of all four repos, attested, logged, dogfooded The provider ran its full honest replay against the four verified repositories on this machine - every Lean compile and axiom audit routed through lean-guard (memory-capped, core-pinned, single-flight, ~30 min per fork) - and the results are now shipped under evidence/: - 16/16 certificates proven per fork, every axiom cone boundary-exact (the four apex tiers carry their fork's documented SHA-512/wire boundary axiom-for-axiom), each attestation pinned to the exact repo commit (dalek 8ded7bc, anza 673c15e, risc0 98a13a6, betrusted 81f614a) and Ed25519-signed. - All four appended to the persistent transparency log. The log holds EIGHT leaves: the first four are the initial run's attestations, which honestly recorded an AUDIT FAILURE (the two pacta bugs fixed in e87f0e8) - an append-only trust ledger keeps its bad day, and the fixed run's leaves sit beside it. - Every receipt re-verified through the FULL stack: dogfood verifier (backend verified-dalek-serial recorded), STH pin store, freshness policy. Receipts are freshly issued against the final tree (a stale mid-run receipt tripped the pin store's rollback defense exactly as designed; the rollback diagnostic now hints at idempotent re-issue). - The capstone consequence ran for real: pacta agent with trusted provider + signature via the proven path + required receipt + pin store + --require-verified-verifier built the R4-gated library capsule from ATTESTED evidence (no local Lean replay needed by the consuming agent). Docs and teaching updated against the real artifacts: evidence/README (inventory + re-verify instructions), README "Real Evidence" section, lecture 5 now re-derives 16/16 verdicts from the REAL dalek attestation (signature checked on the proven path, provider labels ignored), and lecture 6 verifies all four REAL receipts and walks a fresh pin store over them. Every changed notebook cell executed before commit. 49/49 tests green. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-06 12:54:48 +00:00
ml_dsa:
scheme: ML-DSA-65
standard: FIPS 204
status: not_configured
reason: A backend appears available, but no ML-DSA signing key was configured
for this log.
Reference in a new issue Copy permalink