Hash-chained event log

freestream/events.py

@@ -0,0 +1,90 @@
+"""Hash-chained, append-only session event log (see docs/SPEC-EVENTS.md).
+
+Every session produces a verifiable artifact: each entry records the hash
+of the previous entry, so any later tampering is detectable by
+`freestream-log --verify` or `EventLog(path).verify()`.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from pathlib import Path
+
+GENESIS_HASH = "0" * 64
+
+
+def canonical(obj) -> str:
+    return json.dumps(obj, sort_keys=True, separators=(",", ":"))
+
+
+def _hash_entry(seq: int, ts: float, etype: str, payload: dict, prev: str) -> str:
+    material = canonical({"seq": seq, "ts": ts, "type": etype,
+                          "payload": payload, "prev": prev})
+    return hashlib.sha256(material.encode("utf-8")).hexdigest()
+
+
+class EventLog:
+    """Append-only JSONL log with SHA-256 hash chaining."""
+
+    def __init__(self, path: str | Path):
+        self.path = Path(path)
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        self._seq = 0
+        self._prev = GENESIS_HASH
+        if self.path.exists():
+            self._load()
+
+    def _load(self) -> None:
+        ok, first_bad = self.verify()
+        if not ok:
+            raise ValueError(f"event log {self.path} fails hash-chain verification "
+                             f"at seq {first_bad}; refusing to append")
+        with self.path.open("r", encoding="utf-8") as f:
+            last = None
+            for line in f:
+                line = line.strip()
+                if line:
+                    last = json.loads(line)
+        if last:
+            self._seq = last["seq"]
+            self._prev = last["hash"]
+
+    def append(self, etype: str, **payload) -> dict:
+        import time
+        entry = {
+            "seq": self._seq + 1,
+            "ts": time.time(),
+            "type": etype,
+            "payload": payload,
+            "prev": self._prev,
+        }
+        entry["hash"] = _hash_entry(entry["seq"], entry["ts"], etype, payload, self._prev)
+        with self.path.open("a", encoding="utf-8") as f:
+            f.write(json.dumps(entry, sort_keys=True) + "\n")
+        self._seq += 1
+        self._prev = entry["hash"]
+        return entry
+
+    def verify(self) -> tuple[bool, int | None]:
+        """Returns (ok, first_bad_seq). ok=True means the whole chain holds."""
+        if not self.path.exists():
+            return True, None
+        prev = GENESIS_HASH
+        with self.path.open("r", encoding="utf-8") as f:
+            for line in f:
+                line = line.strip()
+                if not line:
+                    continue
+                e = json.loads(line)
+                expected = _hash_entry(e["seq"], e["ts"], e["type"], e["payload"], e["prev"])
+                if e["prev"] != prev or e["hash"] != expected:
+                    return False, e["seq"]
+                prev = e["hash"]
+        return True, None
+
+    def events(self) -> list[dict]:
+        if not self.path.exists():
+            return []
+        with self.path.open("r", encoding="utf-8") as f:
+            return [json.loads(line) for line in f if line.strip()]