openentity 0.3.0__tar.gz → 0.4.0__tar.gz

{openentity-0.3.0 → openentity-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: openentity
-Version: 0.3.0
+Version: 0.4.0
 Summary: Open Entity (OEIS-1) client: JCS, did:key, eddsa-jcs-2022, Merkle proofs, adopt().
 Project-URL: Homepage, https://openentity.org
 Project-URL: Documentation, https://oeis.dev
@@ -37,8 +37,10 @@ openentity find --capability C [-q TEXT --alias-type T --level L1]
 openentity withdraw --force
 ```
 
-Exit codes match the npm CLI: 0 ok, 1 usage, 2 network, 3 verification failed, 4 registry rejected, 5 local state. `verify` checks signatures, the signer, the Declaration hash and the record chain, not the log checkpoint (use the npm CLI for that).
+Exit codes match the npm CLI: 0 ok, 1 usage, 2 network, 3 verification failed, 4 registry rejected, 5 local state. `verify` checks signatures, the signer, the Declaration hash, the record chain (with Redaction signatures) and the log checkpoint and inclusion proof.
 
 Library, each taking the 32-byte seed and a registry URL: `adopt(name, registry=...)`, `withdraw(seed, registry)`, `record(seed, [(kind, payload), ...], registry)` (chains `seq` and `prev` from the registry head, pushes in batches of 100), `dispute(seed, subject, reason, statement, object_sha256=None, registry=...)`, `find(registry, capability=..., q=..., alias_type=..., level=...)`, `present(seed, audience, nonce, registry=None)`. Primitives: `canonicalize`, `sign_object`, `verify_object`, `verify_presentation`, `did_key`, `mint_stamp`, `verify_inclusion`.
 
+Shared core: `Identity.load_or_create()` (key in the OS keychain, else `~/.openentity/identity.key` at 0600; pass `.seed` to the calls above), `adopt(..., client="adk")` (an unsigned label: adk, goose, langchain, ui-tars, cli, other), `trust(eid)` (a `TrustReport` from registry reads only, every signature verified locally, cached 5 minutes, `ok=False` on any failure), and `openentity.issuer` (`attestation`, `revocation`, `did_document`, `openentity_json`).
+
 Written from the spec text alone, independent of the TypeScript SDK.

{openentity-0.3.0 → openentity-0.4.0}/README.md

@@ -24,8 +24,10 @@ openentity find --capability C [-q TEXT --alias-type T --level L1]
 openentity withdraw --force
 ```
 
-Exit codes match the npm CLI: 0 ok, 1 usage, 2 network, 3 verification failed, 4 registry rejected, 5 local state. `verify` checks signatures, the signer, the Declaration hash and the record chain, not the log checkpoint (use the npm CLI for that).
+Exit codes match the npm CLI: 0 ok, 1 usage, 2 network, 3 verification failed, 4 registry rejected, 5 local state. `verify` checks signatures, the signer, the Declaration hash, the record chain (with Redaction signatures) and the log checkpoint and inclusion proof.
 
 Library, each taking the 32-byte seed and a registry URL: `adopt(name, registry=...)`, `withdraw(seed, registry)`, `record(seed, [(kind, payload), ...], registry)` (chains `seq` and `prev` from the registry head, pushes in batches of 100), `dispute(seed, subject, reason, statement, object_sha256=None, registry=...)`, `find(registry, capability=..., q=..., alias_type=..., level=...)`, `present(seed, audience, nonce, registry=None)`. Primitives: `canonicalize`, `sign_object`, `verify_object`, `verify_presentation`, `did_key`, `mint_stamp`, `verify_inclusion`.
 
+Shared core: `Identity.load_or_create()` (key in the OS keychain, else `~/.openentity/identity.key` at 0600; pass `.seed` to the calls above), `adopt(..., client="adk")` (an unsigned label: adk, goose, langchain, ui-tars, cli, other), `trust(eid)` (a `TrustReport` from registry reads only, every signature verified locally, cached 5 minutes, `ok=False` on any failure), and `openentity.issuer` (`attestation`, `revocation`, `did_document`, `openentity_json`).
+
 Written from the spec text alone, independent of the TypeScript SDK.

openentity-0.4.0/openentity/__init__.py

@@ -0,0 +1,7 @@
+from .client import adopt, dispute, find, present, record, rotate, withdraw  # noqa: F401
+from .core import *  # noqa: F401,F403
+from . import issuer  # noqa: F401
+from .identity import Identity  # noqa: F401
+from .report import TrustReport, trust  # noqa: F401
+
+__version__ = "0.4.0"

{openentity-0.3.0 → openentity-0.4.0}/openentity/cli.py

@@ -2,6 +2,7 @@ import argparse
 import json
 import os
 import pathlib
+import re
 import sys
 import urllib.error
 
@@ -121,7 +122,7 @@ def _parser() -> argparse.ArgumentParser:
     p.add_argument("--audience", required=True)
     p.add_argument("--nonce", required=True)
     p.add_argument("--no-attestations", action="store_true")
-    v = add("verify", "verify an EID, URL or file: signatures, signer, Declaration hash, record chain", key=False)
+    v = add("verify", "verify an EID, URL or file: signatures, signer, Declaration hash, record chain, log checkpoint and inclusion", key=False)
     v.add_argument("target")
     w = add("withdraw", "withdraw the Declaration (cannot be undone)")
     w.add_argument("--force", action="store_true")
@@ -142,7 +143,7 @@ def _adopt(args):
     if not args.agree:
         raise CliError(EXIT_USAGE, "adopt signs the Open Entity Declaration. Read it, then re-run with --agree:\n\n" + core.DECLARATION_TEXT)
     reg = _registry(args)
-    res = client.adopt(args.name, args.description, reg)
+    res = client.adopt(args.name, args.description, reg, client="cli")
     key_path = _save_key({**res, "name": args.name, "registry": reg})
     if not res["record_pushed"]:
         print("warning: the declaration record entry was not accepted; push it later", file=sys.stderr)
@@ -220,7 +221,14 @@ def _chain_checks(entries: list[dict], eid: str) -> list[dict]:
             why.append("seq breaks the sequence")
         if e.get("prev") != ((prev.get("hash") if prev.get("redacted") else core.canonical_hash(prev).hex()) if prev else None):
             why.append("prev hash breaks the chain")
-        if not e.get("redacted"):
+        if e.get("redacted"):
+            if not re.fullmatch(r"[0-9a-f]{64}", e.get("hash") or ""):
+                why.append("placeholder hash is not SHA-256 hex")
+            if r := e.get("redaction"):  # the entity's signed request for this entry
+                ok, who = core.verify_object(r)
+                if not (ok and who == eid and r.get("eid") == eid and r.get("seq") == e["seq"] and r.get("entry_sha256") == e.get("hash")):
+                    why.append("redaction is not the entity's signed request for this entry")
+        else:
             if e.get("eid") != eid:
                 why.append("eid mismatch")
             ok, err = core.verify_object(e)
@@ -232,7 +240,27 @@ def _chain_checks(entries: list[dict], eid: str) -> list[dict]:
     return bad + [{"name": f"record chain ({len(entries)} entries)", "ok": not bad}]
 
 
-# ponytail: no checkpoint or log-inclusion check here; `npx openentity verify <eid>` does those.
+def _log_checks(reg: str, index: int | None) -> list[dict]:
+    """Checkpoint note signature against the registry key from /v1/spec, then the RFC 9162 inclusion proof of `index`."""
+    if index is None:
+        return [{"name": "log inclusion", "ok": False, "detail": "registry did not report a log index"}]
+    try:
+        r = _get(reg, "/v1/spec").get("registry") or {}
+        sth = _get(reg, "/v1/log/sth")
+        if not r.get("publicKeyMultibase"):
+            return [{"name": "checkpoint", "ok": False, "detail": "registry publishes no checkpoint key in /v1/spec"}]
+        ok = core.verify_note(sth["signature"], r.get("log_origin", "openentity.org/log"), core.b58decode(r["publicKeyMultibase"][1:])[-32:])
+        out = [{"name": "checkpoint", "ok": ok, "detail": f"checkpoint signature valid, tree size {sth['tree_size']}" if ok else "checkpoint signature INVALID"}]
+        size = sth["tree_size"]
+        leaf = _get(reg, f"/v1/log/entries?start={index}&end={index + 1}")["entries"][0]["leaf"]
+        p = _get(reg, f"/v1/log/proof/{index}?tree_size={size}")
+        lh = core.leaf_hash(core.canonicalize(leaf).encode())
+        good = ok and lh.hex() == p["leaf_hash"] and core.verify_inclusion(index, size, lh, [bytes.fromhex(h) for h in p["proof"]], bytes.fromhex(sth["root_hash"]))
+        return out + [{"name": "log inclusion", "ok": good, "detail": f"leaf {index} included in tree of {size}" if good else f"inclusion proof for leaf {index} FAILED"}]
+    except (client.RegistryError, urllib.error.URLError, KeyError, IndexError, ValueError, TypeError) as e:
+        return [{"name": "log inclusion", "ok": False, "detail": f"{type(e).__name__}: {e}"}]
+
+
 def _verify(args):
     t, reg = args.target, _registry(args)
     if t.startswith(("did:", "eid:")):
@@ -244,6 +272,7 @@ def _verify(args):
         while page := _get(reg, f"/v1/entities/{eid}/record?after={entries[-1]['seq'] if entries else 0}")["entries"]:
             entries += page
         checks += _chain_checks(entries, eid)
+        checks += _log_checks(reg, ent.get("log_index", ent.get("declaration_log_index")))
     elif t.startswith(("http://", "https://")):
         checks = _checks_of(client._request(t))
     else:

{openentity-0.3.0 → openentity-0.4.0}/openentity/client.py

@@ -8,6 +8,7 @@ import urllib.request
 from . import core
 
 DEFAULT_REGISTRY = "https://openentity.org"
+CLIENTS = ("adk", "goose", "langchain", "ui-tars", "cli", "other")  # the registry's allowlist for the unsigned `client` label
 
 
 class RegistryError(Exception):
@@ -59,13 +60,16 @@ def build_adoption(kp: core.KeyPair, name: str, description: str, registry: str)
 
 
 def adopt(name: str, description: str = "An Open Entity adopted through the Python client.",
-          registry: str = DEFAULT_REGISTRY, seed: bytes | None = None) -> dict:
-    """Adopt on `registry`. Returns the registry response plus `did` and `seed_hex` (keep the seed)."""
+          registry: str = DEFAULT_REGISTRY, seed: bytes | None = None, client: str | None = None) -> dict:
+    """Adopt on `registry`. Returns the registry response plus `did` and `seed_hex` (keep the seed).
+    `client` is an optional label (one of CLIENTS) for the registry's per-client count; it is not signed."""
+    if client is not None and client not in CLIENTS:
+        raise ValueError(f"client must be one of {', '.join(CLIENTS)}")
     registry = registry.rstrip("/")
     kp = core.KeyPair(seed)
     bits = int(_request(f"{registry}/v1/spec")["stamp_bits"])
     document, declaration = build_adoption(kp, name, description, registry)
-    out = _request(f"{registry}/v1/adopt", {"document": document, "declaration": declaration},
+    out = _request(f"{registry}/v1/adopt", {"document": document, "declaration": declaration, **({"client": client} if client else {})},
                    {"x-oe-stamp": core.mint_stamp(bits, kp.did)})
     # Seq-1 declaration entry (spec 7.3). The registry never writes entries; on failure the signed
     # entry is returned so the caller can push it later.

{openentity-0.3.0 → openentity-0.4.0}/openentity/core.py

@@ -1,4 +1,5 @@
 """Open Entity primitives, written from spec/OEIS-1.md (sections 3.3, 4, 6, 10.3, 10.4)."""
+import base64
 import hashlib
 import json
 import math
@@ -139,15 +140,16 @@ def _signing_input(obj: dict, proof: dict) -> bytes:
     return canonical_hash(config) + canonical_hash(doc)
 
 
-def sign_proof(obj: dict, kp: KeyPair, created: str | None = None) -> dict:
+def sign_proof(obj: dict, kp: KeyPair, created: str | None = None, method: str | None = None) -> dict:
+    """`method` names the verification method; it defaults to the did:key of `kp`, a did:web signer passes `did:web:x#key-1`."""
     proof = {"type": "DataIntegrityProof", "cryptosuite": "eddsa-jcs-2022", "created": created or now(),
-             "verificationMethod": verification_method(kp.did), "proofPurpose": "assertionMethod"}
+             "verificationMethod": method or verification_method(kp.did), "proofPurpose": "assertionMethod"}
     sig = kp.private.sign(_signing_input(obj, proof))
     return {**proof, "proofValue": "z" + b58encode(sig)}
 
 
-def sign_object(obj: dict, kp: KeyPair, created: str | None = None) -> dict:
-    return {**{k: v for k, v in obj.items() if k != "proof"}, "proof": sign_proof(obj, kp, created)}
+def sign_object(obj: dict, kp: KeyPair, created: str | None = None, method: str | None = None) -> dict:
+    return {**{k: v for k, v in obj.items() if k != "proof"}, "proof": sign_proof(obj, kp, created, method)}
 
 
 # ---- continuity (spec 9) ----
@@ -403,5 +405,25 @@ def verify_inclusion(index: int, size: int, leaf: bytes, proof: list[bytes], roo
     return sn == 0 and r == root
 
 
+def verify_note(note: str, origin: str, public: bytes) -> bool:
+    """C2SP signed note (the log checkpoint): a signature line by `origin` over the body, keyed by the registry key."""
+    body, sep, sigs = note.rpartition("\n\n")
+    if not sep or not note.endswith("\n"):
+        return False
+    keyid = sha256(origin.encode() + b"\n\x01" + public)[:4]
+    for line in sigs.splitlines():
+        parts = line.split(" ")
+        if len(parts) != 3 or parts[0] != "\u2014" or parts[1] != origin:
+            continue
+        try:
+            raw = base64.b64decode(parts[2], validate=True)
+            if len(raw) == 68 and raw[:4] == keyid:
+                Ed25519PublicKey.from_public_bytes(public).verify(raw[4:], (body + "\n").encode())
+                return True
+        except (ValueError, InvalidSignature):
+            continue
+    return False
+
+
 def log_leaf(type_: str, eid: str, object_sha256: str, received_at: str) -> dict:
     return {"type": type_, "eid": eid, "object_sha256": object_sha256, "received_at": received_at}

openentity-0.4.0/openentity/identity.py

@@ -0,0 +1,72 @@
+"""Identity.load_or_create(): the entity's key from the OS keychain, else ~/.openentity/identity.key (mode 0600).
+A fresh key goes to the keychain when one answers, otherwise to the file. Set OPENENTITY_KEYCHAIN=off to use the file only."""
+import os
+import pathlib
+import subprocess
+import sys
+
+from . import core
+
+SERVICE, ACCOUNT = "openentity", "identity"
+
+
+def _run(argv: list[str], stdin: str | None = None) -> str | None:
+    try:
+        r = subprocess.run(argv, input=stdin, capture_output=True, text=True, timeout=10)
+    except (OSError, subprocess.SubprocessError):
+        return None
+    return r.stdout.strip() if r.returncode == 0 else None
+
+
+def _keychain_get() -> str | None:
+    if os.environ.get("OPENENTITY_KEYCHAIN") == "off":
+        return None
+    if sys.platform == "darwin":
+        return _run(["security", "find-generic-password", "-s", SERVICE, "-a", ACCOUNT, "-w"])
+    if sys.platform.startswith("linux"):
+        return _run(["secret-tool", "lookup", "service", SERVICE, "account", ACCOUNT])
+
+
+def _keychain_set(seed_hex: str) -> bool:
+    if os.environ.get("OPENENTITY_KEYCHAIN") == "off":
+        return False
+    if sys.platform == "darwin":  # ponytail: the seed is briefly on argv, visible to this user's processes only
+        return _run(["security", "add-generic-password", "-U", "-s", SERVICE, "-a", ACCOUNT, "-w", seed_hex]) is not None
+    if sys.platform.startswith("linux"):
+        return _run(["secret-tool", "store", "--label=Open Entity key", "service", SERVICE, "account", ACCOUNT], seed_hex) is not None
+    return False
+
+
+def _file() -> pathlib.Path:
+    return pathlib.Path(os.environ.get("OPENENTITY_HOME", "~/.openentity")).expanduser() / "identity.key"
+
+
+class Identity:
+    def __init__(self, seed: bytes, source: str):
+        self.kp, self.source = core.KeyPair(seed), source
+
+    @property
+    def did(self) -> str:
+        return self.kp.did
+
+    @property
+    def seed(self) -> bytes:  # pass to adopt(), present(), record() and the other seed-keyed calls
+        return self.kp.seed
+
+    @classmethod
+    def load_or_create(cls) -> "Identity":
+        for source, read in (("keychain", _keychain_get), ("file", lambda: _file().read_text().strip() if _file().exists() else None)):
+            if h := read():
+                return cls(bytes.fromhex(h), source)
+        seed = os.urandom(32)
+        if _keychain_set(seed.hex()):
+            return cls(seed, "keychain")
+        path = _file()
+        path.parent.mkdir(parents=True, exist_ok=True, mode=0o700)
+        try:
+            fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
+        except FileExistsError:  # another process created it first
+            return cls(bytes.fromhex(path.read_text().strip()), "file")
+        with os.fdopen(fd, "w") as f:
+            f.write(seed.hex())
+        return cls(seed, "file")

openentity-0.4.0/openentity/issuer.py

@@ -0,0 +1,61 @@
+"""Issuer helpers (ADR 0003): sign attestations and revocations, build a did:web issuer's two well-known files.
+
+`issuer` defaults to the signer's did:key. A did:web issuer passes its DID; the proof then names `<issuer>#<key_id>`,
+the key `did_document` publishes. Registry submission stays with `client` (POST /v1/attestations, stamped, spec 10.4)."""
+from datetime import datetime, timedelta, timezone
+
+from . import core
+
+MAX_TTL = timedelta(days=365)  # spec 8.4
+
+
+def _ts(t: datetime) -> str:
+    return t.astimezone(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def _method(kp: core.KeyPair, issuer: str | None, key_id: str) -> str | None:
+    return f"{issuer}#{key_id}" if issuer and issuer != kp.did else None
+
+
+def attestation(kp: core.KeyPair, subject: str, claim_type: str, claim: dict, *, issuer: str | None = None,
+                key_id: str = "key-1", evidence: dict | None = None, confidence: float | None = None,
+                ttl: timedelta = timedelta(days=90), now: datetime | None = None) -> dict:
+    """A signed Attestation (spec 8.2). `ttl` is capped at one year."""
+    if not timedelta(0) < ttl <= MAX_TTL:
+        raise ValueError("ttl must be positive and at most 1 year")
+    t = now or datetime.now(timezone.utc)
+    created = _ts(t)
+    obj = {"spec": core.SPEC, "type": "Attestation", "issuer": issuer or kp.did, "subject": subject,
+           "claim_type": claim_type, "claim": claim, **({"evidence": evidence} if evidence else {}),
+           **({"confidence": confidence} if confidence is not None else {}), "created": created, "expires": _ts(t + ttl)}
+    return core.sign_object(obj, kp, created, _method(kp, issuer, key_id))
+
+
+def revocation(kp: core.KeyPair, attested: dict | str, *, issuer: str | None = None, key_id: str = "key-1",
+               reason: str | None = None, now: datetime | None = None) -> dict:
+    """A signed Revocation naming the attestation (the object, or its SHA-256 hex) (spec 8.4)."""
+    sha = core.canonical_hash(attested).hex() if isinstance(attested, dict) else attested
+    created = _ts(now or datetime.now(timezone.utc))
+    obj = {"spec": core.SPEC, "type": "Revocation", "issuer": issuer or kp.did, "attestation_sha256": sha,
+           **({"reason": reason} if reason else {}), "created": created}
+    return core.sign_object(obj, kp, created, _method(kp, issuer, key_id))
+
+
+def did_document(did: str, public: bytes, key_id: str = "key-1") -> dict:
+    """The body of `https://<domain>/.well-known/did.json` for a did:web issuer."""
+    vm = f"{did}#{key_id}"
+    return {"@context": ["https://www.w3.org/ns/did/v1", "https://w3id.org/security/multikey/v1"], "id": did,
+            "verificationMethod": [{"id": vm, "type": "Multikey", "controller": did,
+                                    "publicKeyMultibase": core.did_key(public).removeprefix("did:key:")}],
+            "assertionMethod": [vm], "authentication": [vm]}
+
+
+def openentity_json(did: str, public: bytes, name: str, description: str, *, key_id: str = "key-1",
+                    operator: dict | None = None, extensions: dict | None = None) -> dict:
+    """The unsigned body of `https://<domain>/.well-known/openentity.json`: the domain alias proof (spec 3.4) and,
+    under `extensions["openentity:observer"]`, an observer's methodology (spec 8.4)."""
+    return {"spec": core.SPEC, "eid": did, "name": name, "description": description,
+            "keys": [{"id": f"{did}#{key_id}", "type": "Multikey",
+                      "publicKeyMultibase": core.did_key(public).removeprefix("did:key:")}],
+            "operator": operator or {"kind": "organization", "name": name, "custody": "operator", "can_change": []},
+            **({"extensions": extensions} if extensions else {})}

openentity-0.4.0/openentity/report.py

@@ -0,0 +1,101 @@
+"""trust(eid): one TrustReport from registry reads only (ADR 0002). Every attestation and revocation is verified
+locally against its issuer's key; any failure returns an untrusted report (fail closed). Cached for 5 minutes."""
+import time
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from urllib.parse import unquote
+
+from . import client, core
+
+MOLTBOTDEN, CLAWGRC = "did:web:moltbotden.com", "did:web:api.clawgrc.com"
+SMA = ("did:web:securemyagent.ai", "did:pkh:eip155:8453:0x62fef02E2859726EC1c0B534853Ad2cdd5FdDE1a")
+TIER, POSTURE, VIOLATION = "trust_tier", "custom:securemyagent:security_posture", "custom:clawgrc:violation"
+ACCEPT = {TIER: (MOLTBOTDEN, CLAWGRC), POSTURE: SMA, VIOLATION: (CLAWGRC,)}  # claim_type -> issuers read; others are ignored
+CACHE_SECONDS = 300
+_cache: dict = {}
+
+
+@dataclass(frozen=True)
+class TrustReport:
+    eid: str
+    ok: bool  # False: a read failed or a signature did not verify. Treat the entity as untrusted.
+    error: str | None = None
+    level: str | None = None  # registry level, "L0" to "L3"
+    withdrawn: bool = False
+    trust_tier: dict = field(default_factory=dict)  # issuer DID -> newest live tier (0 to 4)
+    security_posture: dict | None = None  # claim of the newest live custom:securemyagent:security_posture
+    violations: list = field(default_factory=list)  # live custom:clawgrc:violation: issuer, severity, policy, observed_at, sha256
+    revocations: list = field(default_factory=list)  # verified revocations of the accepted attestations
+
+
+def did_web_resolver(fetch=client._request):
+    """did:web through /.well-known/did.json (or <path>/did.json); everything else offline."""
+    def resolve(did: str) -> dict:
+        if not did.startswith("did:web:"):
+            return core.default_resolver(did)
+        host, *path = [unquote(p) for p in did[8:].split(":")]
+        doc = fetch(f"https://{host}/{'/'.join(path) if path else '.well-known'}/did.json")
+        if doc.get("id") != did:
+            raise ValueError(f"{did} document names {doc.get('id')}")
+        keys = []
+        for vm in doc.get("verificationMethod", []):
+            try:
+                keys.append(core.public_from_did_key("did:key:" + vm["publicKeyMultibase"]))
+            except (KeyError, ValueError):
+                continue  # not an Ed25519 Multikey
+        return {"ed25519": keys}
+    return resolve
+
+
+def trust(eid: str, registry: str = client.DEFAULT_REGISTRY, *, now: datetime | None = None, fetch=client._request,
+          resolver=None) -> TrustReport:
+    key = (registry, eid)
+    hit = _cache.get(key)
+    if hit and time.monotonic() - hit[0] < CACHE_SECONDS:
+        return hit[1]
+    try:
+        report = _read(eid, registry.rstrip("/"), now or datetime.now(timezone.utc), fetch, resolver or did_web_resolver(fetch))
+    except Exception as e:  # fail closed on anything: network, registry, schema, signature
+        return TrustReport(eid, False, f"{type(e).__name__}: {e}")
+    _cache[key] = (time.monotonic(), report)
+    return report
+
+
+def _read(eid, base, now, fetch, resolver) -> TrustReport:
+    if not eid.startswith("did:"):
+        raise ValueError("eid must be a DID")
+    ent = fetch(f"{base}/v1/entities/{eid}")
+    if ent["eid"] != eid:
+        raise ValueError(f"registry answered for {ent['eid']}")
+    rows = fetch(f"{base}/v1/entities/{eid}/attestations")["attestations"]
+    tiers, posture, violations, revocations = {}, None, [], []
+    for r in sorted(rows, key=lambda r: r["attestation"]["created"], reverse=True):
+        a, ct = r["attestation"], r["attestation"].get("claim_type")
+        if a.get("issuer", "").lower() not in {i.lower() for i in ACCEPT.get(ct, ())}:
+            continue
+        if r.get("inherited_from") and ct != VIOLATION:
+            continue  # a rotation does not carry positive claims; a strike follows the entity
+        sha, ended = r["sha256"], core._ts(a["expires"]) <= now
+        if a["subject"] != (r.get("inherited_from") or eid) or core.canonical_hash(a).hex() != sha:
+            raise ValueError(f"attestation {sha} does not match what the registry served")
+        ok, signer = core.verify_object(a, resolver)
+        if not ok or signer != a["issuer"]:
+            raise ValueError(f"attestation {sha}: {signer}")
+        rv = r.get("revocation")
+        if rv:
+            ok, signer = core.verify_object(rv, resolver)
+            if not ok or signer != a["issuer"] or rv["attestation_sha256"] != sha:
+                raise ValueError(f"revocation of {sha}: {signer}")
+            revocations.append({"sha256": sha, "claim_type": ct, "issuer": a["issuer"], "reason": rv.get("reason"), "at": rv["created"]})
+        elif r.get("revoked_at"):
+            raise ValueError(f"registry reports a revocation of {sha} it does not carry")
+        if ended or rv:
+            continue
+        c = a["claim"]
+        if ct == TIER:
+            tiers.setdefault(a["issuer"], c["tier"])
+        elif ct == POSTURE:
+            posture = posture or c
+        else:
+            violations.append({"issuer": a["issuer"], "severity": c["severity"], "policy": c["policy"], "observed_at": c["observed_at"], "sha256": sha})
+    return TrustReport(eid, True, None, ent["level"], bool(ent.get("withdrawn")), tiers, posture, violations, revocations)

{openentity-0.3.0 → openentity-0.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "openentity"
-version = "0.3.0"
+version = "0.4.0"
 description = "Open Entity (OEIS-1) client: JCS, did:key, eddsa-jcs-2022, Merkle proofs, adopt()."
 readme = "README.md"
 license = "MIT"

{openentity-0.3.0 → openentity-0.4.0}/tests/test_client.py

@@ -1,4 +1,5 @@
 """withdraw, record, dispute, find, present against a stub registry (same pattern as test_core.py)."""
+import base64
 import json
 import threading
 from http.server import BaseHTTPRequestHandler, HTTPServer
@@ -11,6 +12,8 @@ from openentity import cli, client, core
 SEED = bytes.fromhex("9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60")  # RFC 8032 test 1, public
 SUBJECT = "did:key:z6MkhaXgBZDvotDkL5257faiztiGiC2QtKLGpbnnEGta2doK"
 BITS = 8
+ORIGIN = "openentity.org/log"
+LOG_KEY = core.KeyPair(b"\7" * 32)  # throwaway registry checkpoint key
 
 
 class Stub(BaseHTTPRequestHandler):
@@ -19,6 +22,8 @@ class Stub(BaseHTTPRequestHandler):
     attestations: list = []
     entity: dict | None = None  # overrides GET /v1/entities/<eid>
     refuse = False  # refuse every continuity link
+    leaves: list = []  # the stub log's leaf objects; the checkpoint is signed by LOG_KEY
+    forge_note = False
 
     def log_message(self, *a):
         pass
@@ -35,7 +40,23 @@ class Stub(BaseHTTPRequestHandler):
         u = urlparse(self.path)
         Stub.log.append(("GET", self.path, None, None))
         if u.path == "/v1/spec":
-            return self._send(200, {"spec": core.SPEC, "stamp_bits": BITS})
+            reg = {"log_origin": ORIGIN, "publicKeyMultibase": "z" + core.b58encode(b"\xed\x01" + LOG_KEY.public)}
+            return self._send(200, {"spec": core.SPEC, "stamp_bits": BITS, "registry": reg})
+        hs = [core.leaf_hash(core.canonicalize(lf).encode()) for lf in Stub.leaves]
+        if u.path == "/v1/log/sth":
+            root = core.merkle_root(hs)
+            body = f"{ORIGIN}\n{len(hs)}\n{base64.b64encode(root).decode()}\n"
+            keyid = core.sha256(ORIGIN.encode() + b"\n\x01" + LOG_KEY.public)[:4]
+            sig = base64.b64encode(keyid + (KP if Stub.forge_note else LOG_KEY).private.sign(body.encode())).decode()
+            return self._send(200, {"tree_size": len(hs), "root_hash": root.hex(), "signature": f"{body}\n\u2014 {ORIGIN} {sig}\n"})
+        if u.path == "/v1/log/entries":
+            i = int(parse_qs(u.query)["start"][0])
+            if i >= len(hs):
+                return self._send(200, {"entries": []})
+            return self._send(200, {"entries": [{"index": i, "leaf": Stub.leaves[i], "leaf_hash": hs[i].hex()}]})
+        if u.path.startswith("/v1/log/proof/"):
+            i = int(u.path.rsplit("/", 1)[1])
+            return self._send(200, {"leaf_hash": hs[i].hex(), "proof": [h.hex() for h in core.inclusion_proof(i, hs)]})
         if u.path == "/v1/entities":
             return self._send(200, {"entities": [{"eid": SUBJECT, "name": "N", "level": "L0"}], "page": 0, "next_page": None})
         if u.path.endswith("/record"):
@@ -83,7 +104,7 @@ class Stub(BaseHTTPRequestHandler):
 
 @pytest.fixture
 def url():
-    Stub.log, Stub.chain, Stub.attestations, Stub.entity, Stub.refuse = [], [], [], None, False
+    Stub.log, Stub.chain, Stub.attestations, Stub.entity, Stub.refuse, Stub.leaves, Stub.forge_note = [], [], [], None, False, [], False
     srv = HTTPServer(("127.0.0.1", 0), Stub)
     threading.Thread(target=srv.serve_forever, daemon=True).start()
     yield f"http://127.0.0.1:{srv.server_port}"
@@ -215,11 +236,21 @@ def test_cli_verify_entity_file_and_failures(url, home, capsys, tmp_path):
     decl = core.sign_object({"spec": core.SPEC, "type": "Declaration", "eid": KP.did, "declaration_version": "1.0",
                              "text_sha256": core.DECLARATION_SHA256, "name": "T", "created": core.now(), "nonce": core.nonce()}, KP)
     doc = core.sign_object({"spec": core.SPEC, "eid": KP.did, "name": "T", "layers": {}, "keys": []}, KP)
-    Stub.entity = {"document": doc, "declaration": decl}
+    Stub.leaves = [{"type": "Declaration", "eid": f"did:key:z{i}", "object_sha256": "00" * 32, "received_at": core.now()} for i in range(5)]
+    Stub.entity = {"document": doc, "declaration": decl, "log_index": 3}
     client.record(SEED, [("arc_opened", {"arc_id": "a", "title": "A"}), ("arc_opened", {"arc_id": "b", "title": "B"})], registry=url)
     code, out, _ = run(capsys, "verify", KP.did, "--json", *reg)
     res = json.loads(out)
-    assert code == 0 and res["ok"] and "record chain (2 entries)" in [c["name"] for c in res["checks"]]
+    names = [c["name"] for c in res["checks"]]
+    assert code == 0 and res["ok"] and "record chain (2 entries)" in names and "checkpoint" in names and "log inclusion" in names
+    Stub.forge_note = True  # checkpoint signed by a key other than the registry's
+    assert run(capsys, "verify", KP.did, *reg)[0] == 3
+    Stub.forge_note = False
+    Stub.entity = {**Stub.entity, "log_index": 9}  # no such leaf
+    assert run(capsys, "verify", KP.did, *reg)[0] == 3
+    Stub.entity = {**Stub.entity, "log_index": None}
+    assert "did not report a log index" in run(capsys, "verify", KP.did, *reg)[1]
+    Stub.entity = {**Stub.entity, "log_index": 3}
     assert "VERIFIED" in run(capsys, "verify", KP.did, *reg)[1]
     f = tmp_path / "decl.json"
     f.write_text(json.dumps(decl))
@@ -293,3 +324,25 @@ def test_rotate_the_registry_refuses_raises_and_returns_nothing(url):
     with pytest.raises(client.RegistryError) as e:
         client.rotate(SEED, registry=url)
     assert e.value.status == 422
+
+
+def test_verify_note_rejects_a_wrong_key_origin_or_body():
+    body = f"{ORIGIN}\n5\n{base64.b64encode(b'r' * 32).decode()}\n"
+    keyid = core.sha256(ORIGIN.encode() + b"\n\x01" + LOG_KEY.public)[:4]
+    note = f"{body}\n\u2014 {ORIGIN} {base64.b64encode(keyid + LOG_KEY.private.sign(body.encode())).decode()}\n"
+    assert core.verify_note(note, ORIGIN, LOG_KEY.public)
+    assert not core.verify_note(note, ORIGIN, KP.public)
+    assert not core.verify_note(note, "other/log", LOG_KEY.public)
+    assert not core.verify_note(note.replace("\n5\n", "\n6\n"), ORIGIN, LOG_KEY.public)
+
+
+def test_chain_check_verifies_redaction_signatures():
+    e1 = core.sign_object({"spec": core.SPEC, "type": "RecordEntry", "eid": KP.did, "seq": 1, "prev": None, "kind": "arc_opened", "payload": {}, "created": core.now()}, KP)
+    h = core.canonical_hash(e1).hex()
+    red = core.sign_object({"spec": core.SPEC, "type": "Redaction", "eid": KP.did, "seq": 1, "entry_sha256": h, "created": core.now()}, KP)
+    ph = {"seq": 1, "prev": None, "redacted": True, "hash": h, "redaction": red}
+    assert cli._chain_checks([ph], KP.did)[-1]["ok"]
+    forged = core.sign_object({k: v for k, v in red.items() if k != "proof"}, core.KeyPair(b"\x05" * 32))
+    assert not cli._chain_checks([{**ph, "redaction": forged}], KP.did)[-1]["ok"]
+    assert not cli._chain_checks([{**ph, "redaction": {**red, "seq": 2}}], KP.did)[-1]["ok"]
+    assert not cli._chain_checks([{**ph, "hash": "zz"}], KP.did)[-1]["ok"]

{openentity-0.3.0 → openentity-0.4.0}/tests/test_core.py

@@ -155,7 +155,7 @@ class _Stub(BaseHTTPRequestHandler):
             return self._send(200, {"accepted": 1})
         doc, decl = body["document"], body["declaration"]
         stamp = self.headers["x-oe-stamp"]
-        _Stub.seen = {"stamp": stamp, "doc": doc, "decl": decl}
+        _Stub.seen = {"stamp": stamp, "doc": doc, "decl": decl, "client": body.get("client")}
         assert core.check_stamp(stamp, 8, doc["eid"]) is None
         assert core.verify_object(doc)[0] and core.verify_object(decl)[0]
         assert decl["text_sha256"] == core.DECLARATION_SHA256 and doc["eid"] == decl["eid"]
@@ -168,13 +168,16 @@ def test_adopt_and_cli(tmp_path, monkeypatch, capsys):
     url = f"http://127.0.0.1:{srv.server_port}"
     try:
         from openentity import adopt
-        res = adopt("Tester", registry=url, seed=SEED)
+        res = adopt("Tester", registry=url, seed=SEED, client="adk")
+        assert _Stub.seen["client"] == "adk"  # the unsigned label travels beside the signed objects
+        with pytest.raises(ValueError):
+            adopt("Tester", registry=url, seed=SEED, client="nope")
         assert res["eid"] == res["did"] == core.KeyPair(SEED).did
         assert res["record_pushed"] and _Stub.seen["entry"]["eid"] == res["eid"]
         monkeypatch.setenv("OPENENTITY_HOME", str(tmp_path))
         assert cli.main(["adopt", "--name", "T2", "--agree", "--registry", url, "--json"]) == 0
         out = json.loads(capsys.readouterr().out)
-        assert "seed_hex" not in out and Path(out["key_file"]).exists()
+        assert "seed_hex" not in out and Path(out["key_file"]).exists() and _Stub.seen["client"] == "cli"
         assert cli.main(["adopt", "--name", "T3", "--registry", url]) == 1  # no --agree, nothing signed
     finally:
         srv.shutdown()
@@ -183,7 +186,7 @@ def test_adopt_and_cli(tmp_path, monkeypatch, capsys):
 def test_cli_version(capsys):
     with pytest.raises(SystemExit) as e:
         cli.main(["--version"])
-    assert e.value.code == 0 and "0.3.0" in capsys.readouterr().out
+    assert e.value.code == 0 and "0.4.0" in capsys.readouterr().out
 
 
 # ---- shared vectors, checked with the independent verifier's own logic ----

openentity-0.4.0/tests/test_identity.py

@@ -0,0 +1,47 @@
+import os
+import stat
+
+import pytest
+
+from openentity import identity
+from openentity.identity import Identity
+
+
+@pytest.fixture(autouse=True)
+def home(tmp_path, monkeypatch):
+    monkeypatch.setenv("OPENENTITY_HOME", str(tmp_path))
+    monkeypatch.setenv("OPENENTITY_KEYCHAIN", "off")
+    return tmp_path
+
+
+def test_file_fallback_is_0600_and_stable():
+    a = Identity.load_or_create()
+    f = identity._file()
+    assert a.source == "file" and stat.S_IMODE(f.stat().st_mode) == 0o600 and stat.S_IMODE(f.parent.stat().st_mode) == 0o700
+    b = Identity.load_or_create()
+    assert (b.did, b.source) == (a.did, "file") and b.seed == a.seed
+
+
+def test_keychain_wins_and_holds_the_only_copy(monkeypatch):
+    store = {}
+
+    def run(argv, stdin=None):
+        if argv[0] == "security" and argv[1] == "find-generic-password":
+            return store.get("k")
+        if argv[0] == "security":
+            store["k"] = argv[-1]
+            return ""
+        return None
+
+    monkeypatch.delenv("OPENENTITY_KEYCHAIN")
+    monkeypatch.setattr(identity, "_run", run)
+    monkeypatch.setattr(identity.sys, "platform", "darwin")
+    a = Identity.load_or_create()
+    assert a.source == "keychain" and store["k"] == a.seed.hex() and not identity._file().exists()
+    assert Identity.load_or_create().did == a.did
+
+
+def test_keychain_failure_falls_back_to_file(monkeypatch):
+    monkeypatch.delenv("OPENENTITY_KEYCHAIN")
+    monkeypatch.setattr(identity, "_run", lambda argv, stdin=None: None)  # no `security`, no `secret-tool`
+    assert Identity.load_or_create().source == "file"

openentity-0.4.0/tests/test_issuer.py

@@ -0,0 +1,46 @@
+"""Issuer helpers: a did:web issuer signs, anyone verifies against the published did.json."""
+from datetime import datetime, timedelta, timezone
+
+import pytest
+
+from openentity import core, issuer
+
+KP = core.KeyPair(bytes(range(1, 33)))  # published throwaway seed from test-vectors
+SUBJECT = core.KeyPair(bytes(range(33, 65))).did
+DID = "did:web:issuer.example"
+NOW = datetime(2026, 10, 27, 12, 0, tzinfo=timezone.utc)
+
+
+def resolver(did):
+    assert did == DID
+    return {"ed25519": [core.public_from_did_key("did:key:" + issuer.did_document(DID, KP.public)["verificationMethod"][0]["publicKeyMultibase"])]}
+
+
+def test_attestation_verifies_against_did_json_and_expires_on_ttl():
+    a = issuer.attestation(KP, SUBJECT, "trust_tier", {"tier": 2, "platform": "x"}, issuer=DID, ttl=timedelta(days=30), now=NOW)
+    assert (a["issuer"], a["created"], a["expires"]) == (DID, "2026-10-27T12:00:00Z", "2026-11-26T12:00:00Z")
+    assert a["proof"]["verificationMethod"] == f"{DID}#key-1"
+    assert core.verify_object(a, resolver) == (True, DID)
+    assert not core.verify_object({**a, "claim": {"tier": 4, "platform": "x"}}, resolver)[0]
+
+
+def test_did_key_issuer_needs_no_key_id_and_ttl_is_capped():
+    a = issuer.attestation(KP, SUBJECT, "stage", {"stage": "agent", "profile": "p"}, evidence={"kind": "t"}, confidence=0.5, now=NOW)
+    assert a["issuer"] == KP.did and core.verify_object(a) == (True, KP.did)
+    for ttl in (timedelta(0), timedelta(days=366)):
+        with pytest.raises(ValueError):
+            issuer.attestation(KP, SUBJECT, "stage", {}, ttl=ttl)
+
+
+def test_revocation_names_the_attestation_hash():
+    a = issuer.attestation(KP, SUBJECT, "custom:x:y", {}, issuer=DID, now=NOW)
+    r = issuer.revocation(KP, a, issuer=DID, reason="superseded", now=NOW)
+    assert r["attestation_sha256"] == core.canonical_hash(a).hex() == issuer.revocation(KP, r["attestation_sha256"], issuer=DID, now=NOW)["attestation_sha256"]
+    assert core.verify_object(r, resolver) == (True, DID)
+
+
+def test_well_known_files_agree_on_the_key():
+    d, o = issuer.did_document(DID, KP.public), issuer.openentity_json(DID, KP.public, "Issuer", "An issuer.", extensions={"openentity:observer": {}})
+    assert d["id"] == o["eid"] == DID
+    assert d["verificationMethod"][0]["publicKeyMultibase"] == o["keys"][0]["publicKeyMultibase"]
+    assert d["assertionMethod"] == [o["keys"][0]["id"]]

openentity-0.4.0/tests/test_trust.py

@@ -0,0 +1,106 @@
+"""trust(): built from registry reads, every signature checked locally, fail closed."""
+from datetime import datetime, timedelta, timezone
+
+import pytest
+
+from openentity import core, issuer, report
+from openentity.report import CLAWGRC, MOLTBOTDEN, POSTURE, SMA, TIER, VIOLATION, trust
+
+SUBJECT = core.KeyPair(b"\1" * 32).did
+KEYS = {d: core.KeyPair(bytes([i]) * 32) for i, d in enumerate([MOLTBOTDEN, CLAWGRC, SMA[0], "did:web:evil.example"], 10)}
+NOW = datetime.now(timezone.utc)
+
+
+def att(did, ct, claim, **kw):
+    return issuer.attestation(KEYS[did], SUBJECT, ct, claim, issuer=did, now=kw.pop("now", NOW - timedelta(hours=1)), **kw)
+
+
+def row(a, rev=None, **kw):
+    return {"sha256": core.canonical_hash(a).hex(), "attestation": a, "revocation": rev, "revoked_at": rev and rev["created"], **kw}
+
+
+class Registry:
+    """A fake registry plus the issuers' did.json files."""
+    def __init__(self, rows, **entity):
+        self.rows, self.entity, self.calls = rows, {"eid": SUBJECT, "level": "L2", "withdrawn": False, **entity}, []
+
+    def __call__(self, url, body=None, headers=None):
+        self.calls.append(url)
+        if url.endswith("/did.json"):
+            host = url.split("/")[2]
+            return issuer.did_document(f"did:web:{host}", KEYS[f"did:web:{host}"].public)
+        return {"attestations": self.rows} if url.endswith("/attestations") else self.entity
+
+
+@pytest.fixture(autouse=True)
+def fresh():
+    report._cache.clear()
+
+
+def full():
+    tier_old = att(MOLTBOTDEN, TIER, {"tier": 1, "platform": "moltbotden"}, ttl=timedelta(days=60), now=NOW - timedelta(days=2))
+    tier_new = att(MOLTBOTDEN, TIER, {"tier": 3, "platform": "moltbotden"})
+    grc = att(CLAWGRC, TIER, {"tier": 2, "platform": "clawgrc"})
+    posture = att(SMA[0], POSTURE, {"score_band": "A", "checks_passed": [], "scanner_version": "1", "evidence_hash": "0" * 64})
+    viol = att(CLAWGRC, VIOLATION, {"policy": "p", "severity": "high", "evidence_hash": "0" * 64, "observed_at": "2026-10-01T00:00:00Z"})
+    old_viol = att(CLAWGRC, VIOLATION, {"policy": "q", "severity": "low", "evidence_hash": "0" * 64, "observed_at": "2026-09-01T00:00:00Z"})
+    rev = issuer.revocation(KEYS[CLAWGRC], old_viol, issuer=CLAWGRC, reason="dispute upheld", now=NOW)
+    return [row(a) for a in (tier_old, tier_new, grc, posture, viol)] + [row(old_viol, rev)], viol, old_viol
+
+
+def test_report_from_registry_reads_only():
+    rows, viol, old = full()
+    reg = Registry(rows)
+    r = trust(SUBJECT, fetch=reg)
+    assert r.ok and r.level == "L2" and not r.withdrawn
+    assert r.trust_tier == {MOLTBOTDEN: 3, CLAWGRC: 2}  # newest per issuer
+    assert r.security_posture["score_band"] == "A"
+    assert [(v["severity"], v["policy"]) for v in r.violations] == [("high", "p")]  # the revoked strike is not active
+    assert [(x["sha256"], x["reason"]) for x in r.revocations] == [(core.canonical_hash(old).hex(), "dispute upheld")]
+    assert all(u.startswith(("https://openentity.org/v1/", "https://moltbotden.com", "https://api.clawgrc.com", "https://securemyagent.ai")) for u in reg.calls)
+
+
+def test_cache_holds_five_minutes():
+    reg = Registry(full()[0])
+    trust(SUBJECT, fetch=reg)
+    n = len(reg.calls)
+    assert trust(SUBJECT, fetch=reg) is trust(SUBJECT, fetch=reg) and len(reg.calls) == n
+    report._cache[("https://openentity.org", SUBJECT)] = (report.time.monotonic() - 301, None)
+    assert trust(SUBJECT, fetch=reg).ok and len(reg.calls) > n
+
+
+def test_fails_closed():
+    good = att(MOLTBOTDEN, TIER, {"tier": 4, "platform": "moltbotden"})
+    forged = {**good, "claim": {"tier": 4, "platform": "evil"}}
+    other_key = issuer.attestation(KEYS["did:web:evil.example"], SUBJECT, TIER, {"tier": 4, "platform": "x"}, issuer=MOLTBOTDEN, now=NOW)
+    viol = att(CLAWGRC, VIOLATION, {"policy": "p", "severity": "critical", "evidence_hash": "0" * 64, "observed_at": "2026-10-01T00:00:00Z"})
+    fake_rev = issuer.revocation(KEYS[MOLTBOTDEN], viol, issuer=CLAWGRC, now=NOW)  # signed by a key that is not the issuer's
+    cases = {
+        "forged claim": [{**row(good), "attestation": forged}],
+        "signed by another key": [row(other_key)],
+        "hidden strike (bad revocation)": [row(viol, fake_rev)],
+        "revocation not carried": [{**row(viol), "revoked_at": "2026-10-02T00:00:00Z"}],
+        "wrong subject": [row(issuer.attestation(KEYS[MOLTBOTDEN], SUBJECT[:-1] + "x", TIER, {"tier": 4}, issuer=MOLTBOTDEN, now=NOW))],
+    }
+    for name, rows in cases.items():
+        r = trust(SUBJECT, fetch=Registry(rows))
+        assert not r.ok and r.error and r.trust_tier == {} and r.level is None, name
+        report._cache.clear()
+
+    def down(*a, **k):
+        raise OSError("registry down")
+    assert not trust(SUBJECT, fetch=down).ok
+    assert not trust("not-a-did", fetch=Registry([])).ok
+    assert not trust(SUBJECT, fetch=Registry([], eid="did:key:other")).ok  # registry answered for someone else
+
+
+def test_expired_and_unlisted_issuers_are_ignored_and_not_fetched():
+    expired = att(MOLTBOTDEN, TIER, {"tier": 4, "platform": "m"}, ttl=timedelta(days=1), now=NOW - timedelta(days=3))
+    stranger = att("did:web:evil.example", TIER, {"tier": 4, "platform": "x"})
+    reg = Registry([row(expired), row(stranger)])
+    r = trust(SUBJECT, fetch=reg)
+    assert r.ok and r.trust_tier == {} and not any("evil.example" in u for u in reg.calls)
+
+
+def test_withdrawn_is_reported():
+    assert trust(SUBJECT, fetch=Registry([], withdrawn=True)).withdrawn

{openentity-0.3.0 → openentity-0.4.0}/tests/test_verifier.py

@@ -15,6 +15,9 @@ ROOT = Path(__file__).resolve().parents[3]
 spec = importlib.util.spec_from_file_location("iv", ROOT / "scripts/independent_verifier.py")
 iv = importlib.util.module_from_spec(spec)
 spec.loader.exec_module(iv)
+spec = importlib.util.spec_from_file_location("rc", ROOT / "scripts/rebuild_check.py")
+rc = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(rc)
 ORIGIN = "openentity.org/log"
 
 
@@ -110,3 +113,59 @@ def test_vector_format(tmp_path):
     assert iv.check_vectors(str(tmp_path)) == 0
     (tmp_path / "v.json").write_text(json.dumps({**vec, "sha256": "0" * 64}))
     assert iv.check_vectors(str(tmp_path)) == 1
+
+
+def _bucket(tmp_path, n=5, tamper=False):
+    kps = [core.KeyPair(bytes([i + 1]) * 32) for i in range(n)]
+    leaves = [core.log_leaf("Declaration", k.did, "ab" * 32, "2026-10-25T00:00:00Z") for k in kps]
+    hs = [core.leaf_hash(core.canonicalize(lf).encode()) for lf in leaves]
+    root = core.merkle_root(hs)
+    (tmp_path / "snapshots").mkdir(); (tmp_path / "tile/0/000.p").mkdir(parents=True); (tmp_path / "tile/entries/000.p").mkdir(parents=True)
+    rows = [json.dumps({"index": i, "leaf": lf, "leaf_hash": hs[i].hex()}) for i, lf in enumerate(leaves)]
+    cp = json.dumps({"checkpoint": {"tree_size": n, "root_hash": root.hex()}})
+    (tmp_path / "snapshots/2026-10-25.jsonl").write_text("\n".join(rows + [cp]) + "\n")
+    (tmp_path / f"tile/0/000.p/{n}").write_bytes(b"".join(hs))
+    ent = b"".join(len(b).to_bytes(2, "big") + b for b in (core.canonicalize(lf).encode() for lf in leaves))
+    (tmp_path / f"tile/entries/000.p/{n}").write_bytes(ent[:-1] + b"x" if tamper else ent)
+    return n, root
+
+
+def test_rebuild_matches_checkpoint(tmp_path):
+    n, root = _bucket(tmp_path)
+    ok, lines = rc.rebuild(tmp_path, (n, root))
+    assert ok, lines
+    assert rc.tile_path(1234067) == "x001/x234/067"
+
+
+def test_rebuild_catches_wrong_root_missing_leaf_and_bad_tile(tmp_path):
+    n, root = _bucket(tmp_path)
+    assert not rc.rebuild(tmp_path, (n, b"\0" * 32))[0]
+    assert not rc.rebuild(tmp_path, (n + 1, root))[0]
+    t = tmp_path / "t"; t.mkdir()
+    n, root = _bucket(t, tamper=True)
+    assert not rc.rebuild(t, (n, root))[0]
+
+
+def test_rebuild_checks_objects_against_leaves(tmp_path):
+    n, root = _bucket(tmp_path)
+    obj = {"type": "Declaration", "eid": "did:key:z1", "n": 1}
+    sha = core.canonical_hash(obj).hex()
+    leaf = core.log_leaf("Declaration", "did:key:z1", sha, "2026-10-25T00:00:00Z")
+    # replace leaf 0 of the bucket with one that commits to obj
+    snap = tmp_path / "snapshots/2026-10-25.jsonl"; rows = snap.read_text().splitlines()
+    leaves = [json.loads(r)["leaf"] for r in rows[:-1]]; leaves[0] = leaf
+    hs = [core.leaf_hash(core.canonicalize(lf).encode()) for lf in leaves]; root = core.merkle_root(hs)
+    snap.write_text("\n".join([json.dumps({"index": i, "leaf": lf, "leaf_hash": hs[i].hex()}) for i, lf in enumerate(leaves)]
+                              + [json.dumps({"checkpoint": {"tree_size": n, "root_hash": root.hex()}})]) + "\n")
+    (tmp_path / "tile/0/000.p" / str(n)).write_bytes(b"".join(hs))
+    (tmp_path / "tile/entries/000.p" / str(n)).write_bytes(b"".join(len(b).to_bytes(2, "big") + b for b in (core.canonicalize(lf).encode() for lf in leaves)))
+    (tmp_path / "objects").mkdir()
+    line = {"idx": 0, "type": "Declaration", "eid": "did:key:z1", "object_sha256": sha, "object": obj}
+    (tmp_path / "objects/2026-10-25.jsonl").write_text(json.dumps(line) + "\n")
+    ok, lines = rc.rebuild(tmp_path, (n, root))
+    assert ok and any("objects: 1 of" in x for x in lines), lines
+    (tmp_path / "objects/2026-10-25.jsonl").write_text(json.dumps({**line, "object": {**obj, "n": 2}}) + "\n")
+    assert not rc.rebuild(tmp_path, (n, root))[0]
+    red = {"seq": 2, "redacted": True, "hash": sha, "redaction": {}}
+    (tmp_path / "objects/2026-10-25.jsonl").write_text(json.dumps({**line, "object": red}) + "\n")
+    assert rc.rebuild(tmp_path, (n, root))[0]

{openentity-0.3.0 → openentity-0.4.0}/uv.lock

@@ -189,7 +189,7 @@ wheels = [
 
 [[package]]
 name = "openentity"
-version = "0.3.0"
+version = "0.4.0"
 source = { editable = "." }
 dependencies = [
     { name = "cryptography" },

openentity-0.3.0/openentity/__init__.py

@@ -1,4 +0,0 @@
-from .client import adopt, dispute, find, present, record, rotate, withdraw  # noqa: F401
-from .core import *  # noqa: F401,F403
-
-__version__ = "0.3.0"