snapshot 2026-04-21T16:53:01Z

README.md

@@ -50,4 +50,4 @@ print(len(entries), "entries")
 
 Run by [@da03](https://github.com/da03).
 
-Last auto-generated: 2026-04-21T16:42:57Z
+Last auto-generated: 2026-04-21T16:53:00Z

verify.py

@@ -1,38 +1,48 @@
 #!/usr/bin/env python3
 """
-verify.py - standalone chain verifier for append.page
+verify.py - standalone chain + body verifier for append.page
 
-Usage:
-    python verify.py path/to/page.jsonl
-    curl -sS https://append.page/p/<slug>/raw | python verify.py /dev/stdin
-    python verify.py path/to/page.jsonl --with-bodies path/to/bodies.json
+Common usage (one URL, full check):
+    python verify.py https://append.page/p/<slug>
+
+Other modes:
+    python verify.py path/to/page.jsonl                       # chain only, offline
+    curl -sS https://append.page/p/<slug>/raw | \\
+        python verify.py /dev/stdin                           # chain only, offline
+    python verify.py path/to/page.jsonl \\
+        --with-bodies path/to/bodies.json                     # chain + bodies, offline
 
 Exit codes:
-    0  chain is intact
-    1  chain is broken (failure details on stderr)
-    2  usage error
+    0  chain (and optionally bodies) intact
+    1  verification failed (details on stderr)
+    2  usage error / network failure
 
 What it checks:
     1. Each entry's `hash` matches SHA-256(JCS-canonical(entry_minus_hash)).
     2. Each entry's `prev_hash` matches the previous entry's `hash`.
-    3. The first entry's `prev_hash` matches SHA-256("genesis|<slug>|<page_created_at>").
-       (The genesis seed only depends on the slug + page creation timestamp; we
-       derive `page_created_at` from a "?genesis_at=<ISO8601>" hint on the URL
-       or from the first entry's metadata if available; otherwise the genesis
-       check is skipped with a note.)
-    4. With --with-bodies: each revealed (body, salt) pair hashes to the on-chain
-       body_commitment for its entry.
-
-Dependencies: stdlib only (json, hashlib, sys, argparse) + the `jcs` PyPI
-package for RFC 8785 canonicalization. Install with: pip install jcs
-(falls back to a sort_keys + compact-separators approach if jcs is missing,
-which is byte-equivalent for our entry shape since we use only string/integer
-values, no floats and no special escaping).
+    3. seq increments by 1 from 0; page slug is constant across the chain.
+    4. The first entry's `prev_hash` matches the genesis seed
+       SHA-256("genesis|<slug>|<page_created_at>"). Pass --genesis-at <ISO>
+       to enforce this; without it the genesis check is skipped with a note.
+    5. URL mode + bodies mode: each non-erased entry's body+salt satisfies
+       SHA-256(salt || body) == entry.body_commitment. Erased entries skip
+       this check (the body is gone). The API still returns salt for
+       erased entries, so anyone who archived a body privately before
+       erasure can re-verify it offline by passing --with-bodies on a
+       JSON file they assemble themselves.
+
+Dependencies: stdlib only (json, hashlib, sys, argparse, urllib) + the
+`jcs` PyPI package for RFC 8785 canonicalization. Install with:
+    pip install jcs
+(falls back to sort_keys + compact-separators, which is byte-equivalent
+for our entry shape since we use only string and integer values).
 """
 import argparse
 import hashlib
 import json
 import sys
+import urllib.error
+import urllib.request
 from typing import Optional
 
 try:
@@ -132,29 +142,109 @@ def verify_chain(
     return True, f"verified {len(entries)} entries, chain intact, head: {expected_prev_hash}"
 
 
+def _http_get_jsonl(url: str) -> list[dict]:
+    """Download a JSONL endpoint and parse one object per non-empty line."""
+    with urllib.request.urlopen(url, timeout=30) as resp:
+        text = resp.read().decode("utf-8")
+    return [json.loads(line) for line in text.splitlines() if line.strip()]
+
+
+def _http_post_json(url: str, payload: dict) -> dict:
+    req = urllib.request.Request(
+        url,
+        data=json.dumps(payload).encode("utf-8"),
+        headers={"content-type": "application/json"},
+        method="POST",
+    )
+    with urllib.request.urlopen(req, timeout=30) as resp:
+        return json.loads(resp.read().decode("utf-8"))
+
+
+def fetch_url(base_url: str) -> tuple[list[dict], dict[str, dict]]:
+    """
+    Fetch the chain (one HTTP call) plus all bodies+salts (one bulk POST per
+    200-id batch). Returns (entries, bodies_by_id) where bodies_by_id maps
+    entry id -> {body, salt}. Erased entries are omitted from bodies_by_id
+    (no body to verify against); the chain check still applies to them.
+    The API does still return salt for erased entries — useful if you
+    have a private archive of the body and want to recheck offline.
+    """
+    base_url = base_url.rstrip("/")
+    raw_url = base_url + "/raw"
+    bodies_url = base_url + "/bodies"
+
+    entries = _http_get_jsonl(raw_url)
+    if not entries:
+        return entries, {}
+
+    ids = [e["id"] for e in entries]
+    bodies_by_id: dict[str, dict] = {}
+    for batch_start in range(0, len(ids), 200):
+        batch = ids[batch_start : batch_start + 200]
+        resp = _http_post_json(bodies_url, {"ids": batch})
+        for item in resp.get("entries", []):
+            entry = item.get("entry", {})
+            entry_id = entry.get("id")
+            if not entry_id:
+                continue
+            if item.get("erased"):
+                continue
+            body = item.get("body")
+            salt = item.get("salt")
+            if body is None or salt is None:
+                continue
+            bodies_by_id[entry_id] = {"body": body, "salt": salt}
+    return entries, bodies_by_id
+
+
 def main() -> int:
-    ap = argparse.ArgumentParser(description="Verify an append.page chain (JSONL).")
-    ap.add_argument("jsonl", help="path to a .jsonl file (or /dev/stdin)")
+    ap = argparse.ArgumentParser(
+        description="Verify an append.page chain (and optionally bodies)."
+    )
+    ap.add_argument(
+        "source",
+        help=(
+            "either an append.page URL like https://append.page/p/<slug> "
+            "(fetches chain + bodies + salts and verifies everything), or a "
+            "path to a .jsonl file (chain-only unless --with-bodies given)"
+        ),
+    )
     ap.add_argument(
         "--with-bodies",
         metavar="PATH",
-        help="JSON file mapping entry_id -> {body, salt} (salt as hex)",
+        help=(
+            "JSON file mapping entry_id -> {body, salt} (salt as hex). "
+            "Ignored when SOURCE is a URL — bodies are fetched live in "
+            "that case."
+        ),
     )
     ap.add_argument(
         "--genesis-at",
         metavar="ISO8601",
-        help="page creation timestamp; if supplied, also verifies entry[0].prev_hash "
-        "== SHA-256(\"genesis|<slug>|<ts>\")",
+        help=(
+            "page creation timestamp; if supplied, also verifies "
+            'entry[0].prev_hash == SHA-256("genesis|<slug>|<ts>")'
+        ),
     )
     args = ap.parse_args()
 
-    with open(args.jsonl, "r", encoding="utf-8") as f:
-        entries = [json.loads(line) for line in f if line.strip()]
+    is_url = args.source.startswith("http://") or args.source.startswith(
+        "https://"
+    )
 
-    bodies_by_id = None
-    if args.with_bodies:
-        with open(args.with_bodies, "r", encoding="utf-8") as f:
-            bodies_by_id = json.load(f)
+    bodies_by_id: Optional[dict[str, dict]] = None
+    if is_url:
+        try:
+            entries, bodies_by_id = fetch_url(args.source)
+        except urllib.error.URLError as e:
+            print(f"FAIL: could not fetch {args.source}: {e}", file=sys.stderr)
+            return 2
+    else:
+        with open(args.source, "r", encoding="utf-8") as f:
+            entries = [json.loads(line) for line in f if line.strip()]
+        if args.with_bodies:
+            with open(args.with_bodies, "r", encoding="utf-8") as f:
+                bodies_by_id = json.load(f)
 
     ok, msg = verify_chain(entries, bodies_by_id)
     if not ok:
@@ -172,7 +262,15 @@ def main() -> int:
             )
             return 1
 
-    print(f"OK: {msg}")
+    body_note = ""
+    if bodies_by_id is not None:
+        verified = sum(1 for _ in bodies_by_id)
+        skipped = len(entries) - verified
+        body_note = (
+            f"; verified {verified} bodies (commitment matches),"
+            f" skipped {skipped} (erased or no body)"
+        )
+    print(f"OK: {msg}{body_note}")
     return 0