#!/usr/bin/env python3 """Export the CVE proof corpus into certkit format. Reads the internal specification manifest and its Farkas certificates, and emits one self-contained JSONL record per vulnerability class. Each record carries the safety relation, the shipped guard, the declared domain, and the multipliers that prove the guard implies safety. Two things make this corpus worth publishing rather than a toy: 1. The relations are the *real* ones. `openssl_heartbeat` is the CVE-2014-0160 length relation, not a paraphrase of it. Six classes across six ecosystems. 2. Every record is independently checkable. The multipliers are the proof, and `verify.py` re-checks all of them with `certkit` -- which imports nothing from the tool that produced them. A corpus you cannot verify is a claim; this one is an artifact. Field mapping from the internal manifest to the published schema: domain_full -> domain constraints bounding the attacker's input guard -> guard what the shipped fix checks in_bounds -> safety the memory-safety relation that must hold The obligation model is identical in both: one obligation per safety conjunct, refuting `domain AND guard AND NOT safety[i]`. Run from this directory: python export.py --repo-root ../../.. """ from __future__ import annotations import argparse import hashlib import json import sys from pathlib import Path from typing import Any SCHEMA = "cve-proof-corpus/v1" # Public identifiers for each class. These are facts about the upstream CVEs, not # anything derived from the internal pipeline. CVE_METADATA = { "openssl_heartbeat": { "cve": "CVE-2014-0160", "common_name": "Heartbleed", "project": "OpenSSL", "cwe": "CWE-125", "weakness": "out-of-bounds read", "relation": "the heartbeat payload length must fit inside the record it arrived in", }, "libxml2_len_overflow": { "cve": "CVE-2015-8317", "common_name": "libxml2 length overflow", "project": "libxml2", "cwe": "CWE-125", "weakness": "out-of-bounds read", "relation": "a declared length must not exceed the remaining input", }, "zlib_inflate_extra": { "cve": "CVE-2022-37434", "common_name": "zlib inflate extra-field overflow", "project": "zlib", "cwe": "CWE-787", "weakness": "out-of-bounds write", "relation": "the extra-field copy must fit the destination state buffer", }, "libpng_rfc1123": { "cve": "CVE-2015-7981", "common_name": "libpng time formatting overflow", "project": "libpng", "cwe": "CWE-125", "weakness": "out-of-bounds read", "relation": "the formatted output must fit the fixed destination buffer", }, "sudo_set_cmnd": { "cve": "CVE-2021-3156", "common_name": "Baron Samedit", "project": "sudo", "cwe": "CWE-787", "weakness": "heap out-of-bounds write", "relation": "the concatenated argument length must fit the allocated buffer", }, "curl_ntlm_type3": { "cve": "CVE-2019-3822", "common_name": "curl NTLM type-3 overflow", "project": "curl", "cwe": "CWE-787", "weakness": "stack out-of-bounds write", "relation": "the NTLM response length plus header must fit the output buffer", }, } def fingerprint(body: dict[str, Any]) -> str: payload = json.dumps(body, sort_keys=True, separators=(",", ":")) return hashlib.sha256(payload.encode("utf-8")).hexdigest() def build_record(name: str, spec: dict[str, Any], certs: dict[str, Any] | None) -> dict[str, Any]: """Assemble one published record from the internal manifest entry.""" meta = CVE_METADATA.get(name, {}) body: dict[str, Any] = { "schema": "certkit/spec/v1", "name": name, "domain": spec["domain_full"], "guard": spec["guard"], "safety": spec["in_bounds"], } body["fingerprint"] = fingerprint(dict(body)) # Map the internal certificate's per-obligation multipliers onto certkit's # obligation list, which is ordered by safety conjunct. obligations: list[dict[str, Any]] = [] if certs: by_index = {} for ob in certs.get("obligations", []): idx = ob.get("in_bounds_atom_index") if idx is not None: by_index[int(idx)] = ob.get("farkas", {}) for i in range(len(body["safety"])): obligations.append({"multipliers": by_index.get(i, {})}) certificate = { "schema": "certkit/farkas/v1", "spec_fingerprint": body["fingerprint"], "obligations": obligations, } return { "schema": SCHEMA, "id": name, "cve": meta.get("cve"), "common_name": meta.get("common_name"), "project": meta.get("project"), "cwe": meta.get("cwe"), "weakness": meta.get("weakness"), "relation_in_words": meta.get("relation"), "variables": spec["vars"], "spec": body, "certificate": certificate, "n_safety_conjuncts": len(body["safety"]), "n_domain_atoms": len(body["domain"]), "n_guard_atoms": len(body["guard"]), "has_certificate": bool(obligations) and all(o["multipliers"] for o in obligations), } def main(argv: Any = None) -> int: ap = argparse.ArgumentParser(description="Export the CVE proof corpus.") ap.add_argument("--repo-root", type=Path, required=True) ap.add_argument( "--out", type=Path, default=Path(__file__).resolve().parent / "cve-proof-corpus.jsonl", ) args = ap.parse_args(argv) manifest_path = args.repo_root / "verifier" / "spec_manifest.json" cert_dir = args.repo_root / "artifacts" / "certs" if not manifest_path.is_file(): print(f"error: manifest not found at {manifest_path}", file=sys.stderr) return 2 manifest = json.loads(manifest_path.read_text(encoding="utf-8")) classes = manifest["classes"] records = [] for name in sorted(classes): cert_file = cert_dir / f"{name}.certs.json" certs = json.loads(cert_file.read_text(encoding="utf-8")) if cert_file.is_file() else None records.append(build_record(name, classes[name], certs)) with args.out.open("w", encoding="utf-8") as fh: for rec in records: fh.write(json.dumps(rec, sort_keys=True) + "\n") with_cert = sum(1 for r in records if r["has_certificate"]) print(f"wrote {len(records)} records to {args.out}") print(f" {with_cert} of {len(records)} carry a complete certificate") return 0 if __name__ == "__main__": raise SystemExit(main())