#!/usr/bin/env python3
# PHOENIX verifier v0.2 — continuite de cle. Autonome, aucune dependance a LEGION. Ne plante jamais.
# python3 phoenix_verify2.py [--pin SHA256_CLE] [--keyring keyring.jsonl] [--head HASH_TETE_ANCREE] [objet.json ...]
# rc: 0 intact + emetteur epingle | 3 preuves manquantes | 4 emetteur non epingle | 1 au moins un INVALID | 2 usage
#     5 keyring fourni mais rejete (troncature, fork, entree invalide) — prioritaire: une revocation a pu etre effacee
# Limite: signed_at n'est pas couvert par la signature 0.1; la preuve de date vient de l'ancrage du registre d'empire.
import sys, os, json, glob, hashlib, base64
F = ("phoenix", "subject", "observation", "claim", "evidence")
def canon(o): return json.dumps({k: o[k] for k in F}, sort_keys=True, separators=(",", ":"), ensure_ascii=False).encode()
def ehash(e): return hashlib.sha256(json.dumps({k: v for k, v in e.items() if k != "hash"}, sort_keys=True, separators=(",", ":")).encode()).hexdigest()
def fp(b64): return hashlib.sha256(base64.b64decode(b64)).hexdigest()
def kid(b64): return "k1:" + fp(b64)[:32]
def vsig(b64, sig, msg):
    try:
        from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PublicKey
        Ed25519PublicKey.from_public_bytes(base64.b64decode(b64)).verify(base64.b64decode(sig), msg.encode()); return True
    except Exception: return False
def lineage(keys, roots):
    s = set(roots); ch = True
    while ch:
        ch = False
        for x, v in keys.items():
            if x not in s and v["prev"] in s: s.add(x); ch = True
    return s
def tip(path):
    try: return json.loads([l for l in open(path).read().splitlines() if l.strip()][-1]).get("hash")
    except Exception: return None
def load_keyring(path):
    keys, probs, prev = {}, [], "0" * 64
    try: lines = [l for l in open(path).read().splitlines() if l.strip()]
    except Exception as x: return {}, ["keyring illisible: %s" % type(x).__name__]
    for i, l in enumerate(lines):
        try: e = json.loads(l); assert isinstance(e, dict)
        except Exception: probs.append("ligne %d illisible" % i); continue
        if e.get("prev_hash") != prev: probs.append("chaine cassee ligne %d" % i)
        if e.get("hash") != ehash(e): probs.append("hash invalide ligne %d" % i)
        prev = e.get("hash", ""); t = e.get("type")
        try:
            if t == "key_register":
                pk = e.get("public_key_b64", "")
                if e.get("key_id") != kid(pk) or not vsig(pk, e.get("self_sig", ""), "PHOENIX_KEY_REGISTER|%s|%s|%s" % (e.get("key_id"), e.get("issuer_claimed"), e.get("valid_from"))):
                    probs.append("enregistrement invalide ligne %d" % i); continue
                keys[e["key_id"]] = {"pub": pk, "issuer": e.get("issuer_claimed"), "valid_from": e.get("valid_from"), "prev": None, "revoked_at": None, "reason": None}
            elif t == "key_rotate":
                o, n, npk = e.get("old_key_id"), e.get("new_key_id"), e.get("new_public_key_b64", ""); m = "PHOENIX_KEY_ROTATE|%s|%s|%s" % (o, n, e.get("at"))
                if o not in keys or n != kid(npk) or not vsig(keys[o]["pub"], e.get("sig_old", ""), m) or not vsig(npk, e.get("sig_new", ""), m):
                    probs.append("rotation invalide ligne %d" % i); continue
                keys[n] = {"pub": npk, "issuer": keys[o]["issuer"], "valid_from": e.get("at"), "prev": o, "revoked_at": None, "reason": None}
            elif t == "key_revoke":
                k = e.get("key_id"); m = "PHOENIX_KEY_REVOKE|%s|%s|%s" % (k, e.get("at"), e.get("reason"))
                if k not in keys or not any(vsig(keys[x]["pub"], e.get("sig", ""), m) for x in lineage(keys, {k})):
                    probs.append("revocation invalide ligne %d" % i); continue
                keys[k]["revoked_at"], keys[k]["reason"] = e.get("at"), e.get("reason")
            else: probs.append("type inconnu ligne %d" % i)
        except Exception as x: probs.append("ligne %d: %s" % (i, type(x).__name__))
    return keys, probs
def tombstone_ok(p, expected_sha256, pub_b64):
    """Pièce retirée : tombstone phoenix-tombstone/0.1 signé par la clé de l'objet et portant l'empreinte de l'original."""
    try:
        t = json.load(open(p))
        sg = t.get("signature") or {}
        body = {k: v for k, v in t.items() if k != "signature"}
        d = hashlib.sha256(json.dumps(body, sort_keys=True, separators=(",", ":"), ensure_ascii=False).encode()).hexdigest()
        if not (t.get("schema") == "phoenix-tombstone/0.1" and t.get("status") == "RETRACTED" and t.get("original_sha256") == expected_sha256
                and sg.get("public_key_b64") == pub_b64 and sg.get("signed_message") == "PHOENIX_TOMBSTONE_V0.1|" + d): return False
        from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PublicKey
        Ed25519PublicKey.from_public_bytes(base64.b64decode(pub_b64)).verify(base64.b64decode(sg.get("sig", "")), sg["signed_message"].encode())
        return True
    except Exception: return False
def check(path, edir, keys, pinset, pin):
    flags, fail = [], []
    try:
        obj = json.load(open(path))
        if not isinstance(obj, dict) or any(k not in obj for k in F + ("attestation",)): return ["INVALID"], ["structure"]
        c, att, ev = obj["claim"], obj["attestation"], obj["evidence"]
        if not (isinstance(c, dict) and isinstance(att, dict) and isinstance(ev, list)): return ["INVALID"], ["structure"]
        print("\n%s | %s" % (os.path.basename(path), str(c.get("text", ""))[:90]))
        d = hashlib.sha256(canon(obj)).hexdigest(); pk = str(att.get("public_key_b64", ""))
        (flags.append("CONTENT_INTACT") if att.get("digest") == d else fail.append("contenu modifie"))
        (flags.append("SIGNATURE_VALID") if vsig(pk, att.get("signature", ""), "PHOENIX_V0.1|" + d) else fail.append("signature invalide"))
        miss = retr = 0
        for e in ev:
            p = None
            if isinstance(e, dict) and edir:
                u = str(e.get("uri", ""))
                for q in (os.path.join(edir, u), os.path.join(edir, os.path.basename(u))):
                    if os.path.isfile(q): p = q; break
            if not p: miss += 1; continue
            if hashlib.sha256(open(p, "rb").read()).hexdigest() != e.get("sha256"):
                if tombstone_ok(p, e.get("sha256"), pk): retr += 1; continue
                fail.append("preuve alteree: " + os.path.basename(p))
        flags.append("EVIDENCE_MISSING" if miss else "EVIDENCE_ALTERED" if any(f.startswith("preuve") for f in fail) else "EVIDENCE_RETRACTED" if retr else "EVIDENCE_INTACT")
        try: k, f = kid(pk), fp(pk)
        except Exception: k = f = None
        flags.append("ISSUER_KEY_PINNED" if k and (k in pinset or (pin and f == pin)) else "ISSUER_NOT_PINNED")
        if k in keys:
            flags.append("KEY_IN_KEYRING"); ra = keys[k]["revoked_at"]
            if ra:
                if str(att.get("signed_at", "")) < ra: flags.append("KEY_REVOKED_AFTER_SIGNING")
                else: flags.append("KEY_REVOKED_BEFORE_SIGNING"); fail.append("signe apres revocation de la cle (%s)" % keys[k]["reason"])
    except Exception as x: return ["INVALID"], ["illisible: %s" % type(x).__name__]
    return flags, fail
def main():
    a, pin, kr, head, objs, i = sys.argv[1:], None, None, None, [], 0
    while i < len(a):
        if a[i] == "--pin" and i + 1 < len(a): pin = a[i + 1].lower(); i += 2
        elif a[i] == "--keyring" and i + 1 < len(a): kr = a[i + 1]; i += 2
        elif a[i] == "--head" and i + 1 < len(a): head = a[i + 1].lower(); i += 2
        else: objs.append(a[i]); i += 1
    objs = objs or sorted(glob.glob("objects/*.json"))
    if not objs: print("usage: phoenix_verify2.py [--pin H] [--keyring F] [--head H] [objet.json ...]"); return 2
    edir = "evidence" if os.path.isdir("evidence") else None
    keys, kr_bad = {}, False
    if kr:
        keys, probs = load_keyring(kr)
        if head and tip(kr) != head: probs.append("tete du keyring differente de la tete ancree (troncature ou fork)")
        print("keyring: %d cle(s) | %s" % (len(keys), "valide" if not probs else "REJETE: " + "; ".join(probs)))
        if probs: keys, kr_bad = {}, True
    elif head: print("--head ignore sans --keyring")
    pinset = lineage(keys, {k for k, v in keys.items() if pin and fp(v["pub"]) == pin}) if keys else set()
    n = {"invalid": 0, "unpinned": 0, "missing": 0}
    for o in objs:
        fl, fa = check(o, edir, keys, pinset, pin)
        print("  ->", " ".join(fl) + ("" if not fa else " | INVALID: " + "; ".join(fa)))
        if fa or "INVALID" in fl: n["invalid"] += 1
        elif "ISSUER_NOT_PINNED" in fl: n["unpinned"] += 1
        elif "EVIDENCE_MISSING" in fl or "EVIDENCE_RETRACTED" in fl: n["missing"] += 1
    print("\nBILAN: %d objet(s) | invalides %d | emetteur non epingle %d | preuves manquantes ou retirees %d%s" % (len(objs), n["invalid"], n["unpinned"], n["missing"], "" if pin else " (aucun --pin)"))
    if kr_bad: print("KEYRING REJETE: une revocation a pu etre effacee; resultat non fiable (rc=5)"); return 5
    return 1 if n["invalid"] else 4 if n["unpinned"] else 3 if n["missing"] else 0
if __name__ == "__main__": sys.exit(main())