#!/usr/bin/env python3 """Verify a CAIN-42 Evolution #8/#9 governance bundle without trusting any CAIN website or importing CAIN code. Needs Python 3.8+, `cryptography`, and verify_pbft_qc_bundle.py (published next to this file). The PBFT membership is pinned from membership.json; the hypervisor and human keys from GOVERNANCE_RUN.json. python3 verify_e8_governance.py DECISION the real CAIN decision the ZoD rests on is quorum-certified by the live cluster ACTIVATION each policy activation re-hashes, is signed by the hypervisor, links to the previous one, and its policy hashes to its root; its commit QC (>= 3 pinned signers) is over exactly that activation APPROVAL every activation that widens authority (diff recomputed HERE from the policies) carries a valid signature by a registered human who is not the proposer; a narrowing one needs none SELF-APPROVAL the agent's own approval of its expansion was refused and that proposal was never activated ZOD the one ZoD authorized in the run was ordered by the live cluster (certificate + QC) RESTRICTION after the restriction's activation the running ZoD was refused and no tool ran for it CEILING the ZoD requested above the active ceiling was refused at authorization NON-FABRICATION across the whole signed chain exactly ONE ZoD ever reached AUTHORIZED and exactly ONE tool call was served, although four more authorizations were attempted on a world-model prediction, a simulated ALLOW, a 10-agent vote and a replayed memory; each was refused because the live cluster had not certified it CHAIN the evidence chain re-hashes, links and is signed by the hypervisor RESULTS every result row is signed by the hypervisor and agrees with the checks above """ from __future__ import annotations import base64 import hashlib import json import sys from pathlib import Path sys.path.insert(0, str(Path(__file__).resolve().parent)) from cryptography.exceptions import InvalidSignature # noqa: E402 from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PublicKey # noqa: E402 D_EVIDENCE, D_ZOD_AUTH, D_ZOD_ORDER = ("CAIN45/EVIDENCE/v1", "CAIN45/ZOD-AUTHORIZATION-CERTIFICATE/v1", "CAIN45/ZOD-AUTHORIZATION-ORDER/v1") D_ACTIVATION, D_POLICY_APPROVAL, D_POLICY_ORDER = ("CAIN42/POLICY-ACTIVATION/v1", "CAIN42/POLICY-APPROVAL/v1", "CAIN42/POLICY-ACTIVATION-ORDER/v1") D_RESULT = "CAIN42/E8-GOVERNANCE-RESULT/v1" def canon(o): return json.dumps(o, sort_keys=True, separators=(",", ":"), ensure_ascii=True).encode() def h(o): return hashlib.sha256(canon(o)).hexdigest() def digest(domain, fields): return hashlib.sha256(canon({"domain": domain, **fields})).hexdigest() def sig_ok(pub, sig, domain, fields): try: Ed25519PublicKey.from_public_bytes(base64.b64decode(pub)).verify(base64.b64decode(sig), digest(domain, fields).encode()) return True except (InvalidSignature, ValueError, TypeError): return False def policy_root(p): return h({"tenant_id": p["tenant_id"], "version": p["version"], "capabilities": sorted(p["capabilities"]), "max_risk_budget": p["max_risk_budget"], "max_blast_radius_budget": p["max_blast_radius_budget"]}) def expands(cur, new): if cur is None: return True return bool(set(new["capabilities"]) - set(cur["capabilities"])) or new["max_risk_budget"] > cur["max_risk_budget"] \ or new["max_blast_radius_budget"] > cur["max_blast_radius_budget"] def load(base, name): return json.loads((Path(base) / name).read_text()) def verify(base): import verify_pbft_qc_bundle as Q run, chain, decision = load(base, "GOVERNANCE_RUN.json"), load(base, "EVIDENCE_CHAIN.json"), load(base, "decision.json") qcs, membership = load(base, "qcs.json"), load(base, "membership.json") mb = Q.Membership(membership["membership"]) hv, humans, out = run["hypervisor_public_key_b64"], run["humans"], [] dq, c = qcs["cain_decision"], decision["consensus"] dop = {"action": "fabric_decision", "resource": f"fabric/{decision['decision_id']}", "data": {"decision_id": decision["decision_id"], "commitment_sha256": c["commitment_sha256"], "pre_verdict": c["pre_verdict"]}} ok, why = Q.verify_qc(dq, mb) out.append(("DECISION", ok and dq["proposal_digest"] == Q.proposal_request_digest( {"operation": dop, "request_id": decision["decision_id"], "client_id": "cain-hosted-fabric"}) and dq["sequence"] == c["sequence"], f"{decision['decision_id']} pre-verdict {c['pre_verdict']}, QC seq {dq['sequence']}: {why or 'quorum ok'}")) prev, prev_policy = "0" * 64, None for i, a in enumerate(run["activations"]): body = {k: v for k, v in a.items() if k not in ("activation_digest", "signature_b64", "consensus")} good = a["n"] == i and a["prev_activation"] == prev and digest(D_ACTIVATION, body) == a["activation_digest"] \ and sig_ok(hv, a["signature_b64"], D_ACTIVATION, body) and policy_root(a["policy"]) == a["policy_root"] con = a["consensus"] op = {"action": "policy_activation", "resource": f"policy/{a['tenant_id']}", "data": {"tenant_id": a["tenant_id"], "activation_digest": a["activation_digest"], "domain": D_POLICY_ORDER}} qc = qcs.get(f"policy_activation_{i}") qok, qwhy = Q.verify_qc(qc, mb) if qc else (False, "no QC in bundle") qok = qok and qc["proposal_digest"] == Q.proposal_request_digest( {"operation": op, "request_id": con["request_id"], "client_id": con["client_id"]}) and qc["sequence"] == con["sequence"] out.append(("ACTIVATION", good and qok, f"#{i} v{a['policy']['version']} root {a['policy_root'][:12]}: " f"QC seq {con['sequence']} {qwhy or 'quorum ok, digest matches'}")) wide = expands(prev_policy, a["policy"]) ap = a.get("approval") if wide: f = {k: (ap or {}).get(k) for k in ("human_id", "proposal_id", "policy_root", "base_root", "diff_hash", "expires_at")} aok = bool(ap) and ap["human_id"] in humans and ap["human_id"] != a["proposer_id"] \ and f["policy_root"] == a["policy_root"] and f["proposal_id"] == a["proposal_id"] \ and f["diff_hash"] == h(a["diff"]) and sig_ok(humans[ap["human_id"]], ap["signature_b64"], D_POLICY_APPROVAL, f) out.append(("APPROVAL", aok, f"#{i} widens authority: approved by {ap and ap['human_id']} (proposer {a['proposer_id']})")) else: out.append(("APPROVAL", a["diff"]["expands_authority"] is False, f"#{i} narrows authority (recomputed): no human required, proposer {a['proposer_id']}")) prev, prev_policy = a["activation_digest"], a["policy"] g2 = next(r for r in run["results"] if r["case"].startswith("G2")) refused = [e for e in chain if e["event"] == "POLICY_APPROVAL_REFUSED" and e["data"].get("proposal_id") == g2["proposal_id"]] never = all(a["proposal_id"] != g2["proposal_id"] for a in run["activations"]) out.append(("SELF-APPROVAL", bool(refused) and never, f"{g2['proposal_id']}: " + (refused[0]["data"]["why"] if refused else "no refusal entry") + ("; never activated" if never else "; ACTIVATED"))) zd = run["zod_g1"] cert = zd["consensus_certificate"] body = {k: v for k, v in cert.items() if k not in ("consensus", "certificate_digest", "signature_b64", "issuer_public_key_b64")} con = cert["consensus"] op = {"action": "zod_authorization", "resource": f"zod/{zd['zod_id']}", "data": {"zod_id": zd["zod_id"], "certificate_digest": cert["certificate_digest"], "domain": D_ZOD_ORDER}} ok, why = Q.verify_qc(qcs["zod_g1"], mb) out.append(("ZOD", digest(D_ZOD_AUTH, body) == cert["certificate_digest"] and sig_ok(hv, cert["signature_b64"], D_ZOD_AUTH, body) and ok and qcs["zod_g1"]["proposal_digest"] == Q.proposal_request_digest( {"operation": op, "request_id": con["request_id"], "client_id": con["client_id"]}) and cert["policy_hash"] == run["activations"][0]["policy_root"], f"{zd['zod_id']} under policy #0, QC seq {con['sequence']}: {why or 'quorum ok'}")) zid = zd["zod_id"] act_last = max(i for i, e in enumerate(chain) if e["event"] == "POLICY_ACTIVATED") after = [e for e in chain[act_last:] if e["zod_id"] == zid] den = [e for e in after if e["event"] == "DENIED" and "policy root changed" in e["data"].get("reason", "")] out.append(("RESTRICTION", bool(den) and not any(e["event"] == "TOOL_RESULT" for e in after), f"{zid}: " + (den[0]["data"]["reason"] if den else "no refusal after the restriction"))) ceil = [e for e in chain if e["event"] == "DENIED" and "exceeds the policy ceiling" in e["data"].get("reason", "")] out.append(("CEILING", bool(ceil), ceil[0]["data"]["reason"] if ceil else "no ceiling refusal")) authorized = [e for e in chain if e["event"] == "TRANSITION" and e["data"].get("to") == "AUTHORIZED"] served = [e for e in chain if e["event"] == "TOOL_RESULT"] unverified = [e for e in chain if e["event"] == "DENIED" and e["data"].get("operation") == "authorize" and "consensus certificate did not verify" in e["data"].get("reason", "")] out.append(("NON-FABRICATION", len(authorized) == 1 and authorized[0]["zod_id"] == zid and len(served) == 1 and len(unverified) >= 4, f"{len(authorized)} ZoD authorized, {len(served)} tool call served, {len(unverified)} authorizations refused " f"because the live cluster had not certified the decision presented")) prev, bad = "0" * 64, [] for i, e in enumerate(chain, 1): f = {k: e[k] for k in ("seq", "prev_hash", "at", "zod_id", "event", "data")} if e["seq"] != i or e["prev_hash"] != prev or digest(D_EVIDENCE, f) != e["entry_hash"] or not sig_ok(hv, e["signature_b64"], D_EVIDENCE, f): bad.append(i) prev = e["entry_hash"] out.append(("CHAIN", not bad, f"{len(chain)} entries" + (f"; broken at {bad[:5]}" if bad else ""))) derived = {"G1": len(authorized) == 1 and len(served) == 1, "G2": bool(refused) and never, "G3": bool(den), "G4": bool(ceil), "N": len(unverified) >= 4} for r in run["results"]: f = {k: v for k, v in r.items() if k != "signature_b64"} key = r["case"][:2] if r["case"].startswith("G") else "N" out.append(("RESULT", sig_ok(hv, r.get("signature_b64", ""), D_RESULT, f) and r["result"] == "PASS" and derived[key], f"{r['case'][:70]}: {r['outcome']}")) return out def main(argv): if len(argv) != 1: print(__doc__) return 2 res = verify(argv[0]) for name, ok, detail in res: print(f"[{'PASS' if ok else 'FAIL'}] {name:15s} {detail}") good = all(ok for _, ok, _ in res) print(f"\n{sum(ok for _, ok, _ in res)}/{len(res)} checks") print("VERIFIED" if good else "NOT VERIFIED") return 0 if good else 1 if __name__ == "__main__": sys.exit(main(sys.argv[1:]))