| |
| |
| |
| |
| |
| |
| 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 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 = 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"): 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_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: n["missing"] += 1 |
| print("\nBILAN: %d objet(s) | invalides %d | emetteur non epingle %d | preuves manquantes %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()) |
|
|
