#!/usr/bin/env python3
"""Standalone CAIN-42 free evidence verifier. Standard library + cryptography only; imports no CAIN code.

  python3 verify_offline.py evidence_manifest.json --pinned-key public_key.pem .
  python3 verify_offline.py evidence_manifest.json --pinned-key <base64 public key>

Checks the manifest Ed25519 signature, every file SHA-256, the content Merkle root, every signed-sample
record signature, the record hash chain, and the optional quorum receipt digest. It does not import CAIN.
"""
import argparse, base64, hashlib, json, sys, tarfile, tempfile
from pathlib import Path
from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PublicKey

def canon(o):
    return json.dumps(o, sort_keys=True, separators=(",", ":"), ensure_ascii=True).encode()
def sha(b): return hashlib.sha256(b).hexdigest()
def tree(leaves):
    if not leaves: return sha(b"")
    cur=list(leaves)
    while len(cur)>1:
        nxt=[]
        for i in range(0,len(cur),2):
            nxt.append(sha((cur[i]+(cur[i+1] if i+1<len(cur) else cur[i])).encode()))
        cur=nxt
    return cur[0]
def verify(pub_b64,sig_b64,data):
    try:
        Ed25519PublicKey.from_public_bytes(base64.b64decode(pub_b64)).verify(base64.b64decode(sig_b64),data); return True
    except Exception: return False

def main(argv):
    ap=argparse.ArgumentParser()
    ap.add_argument("manifest", nargs="?", default="evidence_manifest.json")
    ap.add_argument("--pinned-key", required=True)
    ap.add_argument("root", nargs="?", default=".")
    a=ap.parse_args(argv)
    mp=Path(a.manifest); root=Path(a.root)
    if mp.is_file() and (mp.suffix in (".gz", ".tgz") or tarfile.is_tarfile(mp)):
        td=tempfile.mkdtemp(prefix="cain-free-verify-")
        with tarfile.open(mp, "r:gz") as tf: tf.extractall(td)
        found=list(Path(td).rglob("evidence_manifest.json"))
        if not found:
            print("VERDICT: TAMPERED OR INVALID\n - archive has no evidence_manifest.json"); return 1
        mp=found[0]; root=mp.parent
    man=json.loads(mp.read_text())
    body={k:v for k,v in man.items() if k!="signature_b64"}
    pin=a.pinned_key
    if Path(pin).is_file():
        text=Path(pin).read_text().strip()
        if "BEGIN PUBLIC KEY" in text:
            from cryptography.hazmat.primitives import serialization
            raw=serialization.load_pem_public_key(text.encode()).public_bytes(serialization.Encoding.Raw,serialization.PublicFormat.Raw)
            pin=base64.b64encode(raw).decode()
    bad=[]
    if pin!=man.get("public_key_b64"): bad.append("PINNED_KEY_DIFFERS_FROM_MANIFEST")
    if not verify(man.get("public_key_b64",""),man.get("signature_b64",""),canon(body)): bad.append("MANIFEST_SIGNATURE_INVALID")
    if sha(base64.b64decode(man.get("public_key_b64","")))!=man.get("fingerprint_sha256"): bad.append("KEY_FINGERPRINT_MISMATCH")
    files=man.get("files") or {}
    for p,spec in files.items():
        f=root/p
        if not f.is_file(): bad.append(f"MISSING:{p}"); continue
        b=f.read_bytes()
        if sha(b)!=spec.get("sha256"): bad.append(f"HASH:{p}")
        if len(b)!=spec.get("bytes"): bad.append(f"SIZE:{p}")
    content={p:v for p,v in files.items() if not p.startswith("quorum_receipt")}
    content_root=tree([sha(f"{p}:{content[p]['sha256']}".encode()) for p in sorted(content)])
    if content_root!=man.get("content_merkle_root"): bad.append("CONTENT_MERKLE_ROOT_MISMATCH")
    sigs=0
    sample_dirs=sorted((root/"samples").glob("CAIN-A75-*")) if (root/"samples").is_dir() else []
    for d in sample_dirs:
        sm=d/"manifest.json"
        if not sm.is_file(): bad.append(f"SAMPLE_MANIFEST_MISSING:{d.name}"); continue
        smj=json.loads(sm.read_text())
        for p,spec in (smj.get("files") or {}).items():
            f=d/p
            if not f.is_file(): bad.append(f"SAMPLE_MISSING:{d.name}/{p}"); continue
            want=spec.get("sha256") if isinstance(spec,dict) else spec
            if sha(f.read_bytes())!=want: bad.append(f"SAMPLE_HASH:{d.name}/{p}")
        rec_name="run.json" if (d/"run.json").is_file() else "attestation.json"
        rec=json.loads((d/rec_name).read_text())
        if rec_name=="run.json":
            for r in rec.get("records",[]):
                sigs+=1
                if not verify(r.get("public_key_b64",""),r.get("signature_b64",""),str(r.get("record_hash","")).encode()):
                    bad.append(f"SAMPLE_SIGNATURE:{d.name}")
                rb={k:v for k,v in r.items() if k not in ("record_hash","signature_b64")}
                if sha(canon(rb))!=r.get("record_hash"): bad.append(f"SAMPLE_RECORD_HASH:{d.name}")
                if r.get("subject_sha256") and sha(canon(r.get("subject")))!=r.get("subject_sha256"): bad.append(f"SAMPLE_SUBJECT_HASH:{d.name}")
            if rec.get("run_hash") and sha(canon([x.get("record_hash") for x in rec.get("records",[])]))!=rec["run_hash"]:
                bad.append(f"SAMPLE_RUN_HASH:{d.name}")
        else:
            sigs+=1
            rb={k:v for k,v in rec.items() if k!="signature_b64"}
            if not verify(rec.get("public_key_b64",""),rec.get("signature_b64",""),canon(rb)): bad.append(f"ATTESTATION_SIGNATURE:{d.name}")
            ib={k:v for k,v in rb.items() if k!="attestation_id"}
            if rec.get("attestation_id") and sha(canon(ib))!=rec["attestation_id"]: bad.append(f"ATTESTATION_ID:{d.name}")
    qr=root/"quorum_receipt.json"
    qstatus="ABSENT"
    if qr.is_file():
        q=json.loads(qr.read_text()); qstatus=q.get("status","UNKNOWN")
        if qstatus=="NOTARIZED" and q.get("digest")!=man.get("content_merkle_root"): bad.append("QUORUM_DIGEST_MISMATCH")
    print("manifest:      ", man.get("bundle"))
    print("content root:  ", man.get("content_merkle_root"))
    print("files checked: ", len(files))
    print("samples:       ", len(sample_dirs))
    print("signatures:    ", sigs)
    print("quorum:        ", qstatus)
    if bad:
        print("VERDICT: TAMPERED OR INVALID")
        for b in bad[:40]: print(" -",b)
        return 1
    print("VERDICT: VERIFIED")
    print("VERDICT: CRYPTOGRAPHICALLY VALID")
    return 0

if __name__=="__main__":
    sys.exit(main(sys.argv[1:]))
