release tarball checksums: debian sid + homebrew + guix, 2026-08-11 harvest

README.md

@@ -0,0 +1,57 @@
+---
+license: cc0-1.0
+pretty_name: Release tarball checksums (Debian, Homebrew, Guix)
+tags:
+- file-hashes
+configs:
+- config_name: data
+  data_files: data/tarballs.parquet
+- config_name: maps
+  data_files: maps/md5.parquet
+---
+
+# Release tarball checksums (Debian, Homebrew, Guix)
+
+Per-artifact checksums of **release archives as shipped** — the
+tarball itself, not its contents. Content-level indexes (Software
+Heritage, distro file digests) unpack archives before hashing, so a
+pristine `hello-2.12.3.tar.gz` matches nothing in them; the three
+package indexes here publish exact hashes of the artifact:
+
+- **debian** — sid `Sources.xz`, all four components: md5 **and**
+  sha256 per source file (orig/debian tarballs, `.dsc`, `.asc`) —
+  each row is a single witness carrying both digests
+- **homebrew** — `formula.json`: sha256 of each formula's stable
+  upstream archive
+- **guix** — `sources.json`, `outputHashMode=flat` entries only
+  (recursive entries are NAR-style directory hashes, not raw bytes):
+  sha256 of raw tarball bytes, with content-addressed mirror URLs
+
+**159,973 rows** (debian 131,303 / guix 20,390 / homebrew 8,280),
+harvested 2026-08-11.
+
+## Layout
+
+- `data/tarballs.parquet` — witness, sha256, md5, name, version,
+  filename, loc; **sorted by sha256**. `loc` is the Debian pool
+  directory, the Homebrew upstream URL, or the Guix content-addressed
+  mirror URL.
+- `maps/md5.parquet` — md5 → sha256 (Debian rows), **sorted by md5**.
+- `tarballs.tsv.gz` — the normalized harvest the parquet is built
+  from.
+
+Both parquet files carry page indexes (zstd, no dictionaries,
+128 KiB pages), so a point lookup over HTTP range reads fetches a few
+tens of KB. This is how [hashdex](https://github.com/davidar/hashdex)
+resolves hashes from the CLI and from a static browser page.
+
+## Rebuild
+
+`release_tarballs.py` in this repo fetches the three indexes (six
+metadata GETs, ~50 MB, no package content) and writes the TSV;
+`tarballs_parquet.py` converts and verifies (sorted keys, page
+indexes present). Sources move — Debian sid continuously, Homebrew
+and Guix per commit — so a rebuild reflects harvest time.
+
+Checksums metadata © the respective projects (Debian archive,
+Homebrew, GNU Guix), generously public; this compilation CC0.

data/tarballs.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:decf7c7be456c25b226388b8d768bcb39850515f8d90418d027c9124d3c13214
+size 15020745

maps/md5.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d9f5b242536ab867757b05ae297fbb6c1adeae73af73d247702a6e238b30432d
+size 7418626

release_tarballs.py

@@ -0,0 +1,222 @@
+#!/usr/bin/env python3
+"""Harvest release-artifact hashes from distro package indexes.
+
+Three sources publish full per-artifact hash indexes — the tarballs
+themselves as shipped, the lifecycle every other hashdex source misses
+(SWH unpacks archives; Fedora FILEDIGESTS covers installed files):
+
+  debian    deb.debian.org sid Sources.xz — md5 AND sha256 per source
+            file (orig/debian tarballs, .dsc, .asc): multi-hash
+            single-witness rows, an edge-minting-compliant crosswalk
+  homebrew  formulae.brew.sh/api/formula.json — sha256 of each
+            formula's stable upstream archive
+  guix      guix.gnu.org/sources.json — SRI sha256 of raw tarball
+            bytes for outputHashMode=flat entries, each carrying a
+            content-addressed mirror URL (a claim URL by construction)
+
+Preimage trap: Guix "recursive" entries (git/svn/hg) are NAR-style
+directory hashes, NOT raw bytes — only flat url entries are ingested.
+
+Ingest is 6 HTTP GETs of index metadata (~50 MB), never content:
+admission-rule clean. Dumps are kept beside the output.
+
+Usage:
+  tools/release_tarballs.py [outdir]     # default ~/.cache/hashdex/tarballs
+  hdx index build tarballs <outdir>/tarballs.tsv.gz
+
+Output TSV columns (one row per file×witness, "-" = absent):
+  witness sha256 md5 name version filename loc
+where loc is the Debian pool directory, the Homebrew upstream URL, or
+the Guix content-addressed mirror URL.
+"""
+import base64
+import gzip
+import json
+import lzma
+import pathlib
+import re
+import sys
+import urllib.request
+
+UA = "hashdex-release-tarballs/0.1 (hash index research; 6 index GETs)"
+
+DEBIAN_BASE = "https://deb.debian.org/debian/dists/sid"
+DEBIAN_COMPONENTS = ["main", "contrib", "non-free", "non-free-firmware"]
+BREW_URL = "https://formulae.brew.sh/api/formula.json"
+GUIX_URL = "https://guix.gnu.org/sources.json"
+
+HEX256 = re.compile(r"[0-9a-f]{64}")
+HEX128 = re.compile(r"[0-9a-f]{32}")
+
+
+def fetch(url, dest):
+    """GET url to dest (skipping if already present), return bytes."""
+    if dest.exists():
+        print(f"  reusing {dest.name} ({dest.stat().st_size:,} bytes)", file=sys.stderr)
+        return dest.read_bytes()
+    req = urllib.request.Request(url, headers={"User-Agent": UA})
+    with urllib.request.urlopen(req, timeout=120) as resp:
+        data = resp.read()
+        # urllib does not decompress; guix.gnu.org serves sources.json
+        # with Content-Encoding: gzip.
+        if resp.headers.get("Content-Encoding") == "gzip" or data[:2] == b"\x1f\x8b":
+            data = gzip.decompress(data)
+    dest.write_bytes(data)
+    print(f"  fetched {dest.name} ({len(data):,} bytes)", file=sys.stderr)
+    return data
+
+
+def field(s, width, what):
+    if "\t" in s or "\n" in s:
+        raise ValueError(f"{what} contains separator: {s!r}")
+    if len(s.encode()) > width:
+        raise ValueError(f"{what} over {width} bytes: {s!r}")
+    return s if s else "-"
+
+
+def debian_rows(sources_xz):
+    """Parse RFC822 stanzas; one row per Checksums-Sha256 file, md5
+    joined from the Files paragraph by filename."""
+    text = lzma.decompress(sources_xz).decode("utf-8", errors="replace")
+    for stanza in text.split("\n\n"):
+        if not stanza.strip():
+            continue
+        fields = {}
+        key = None
+        for line in stanza.split("\n"):
+            if line[:1] in (" ", "\t"):
+                if key:
+                    fields[key] += "\n" + line.strip()
+            else:
+                key, _, val = line.partition(":")
+                fields[key] = val.strip()
+        pkg = fields.get("Package", "")
+        version = fields.get("Version", "")
+        directory = fields.get("Directory", "")
+        if not (pkg and version and directory):
+            continue
+        md5s = {}
+        for line in fields.get("Files", "").split("\n"):
+            parts = line.split()
+            if len(parts) == 3 and HEX128.fullmatch(parts[0]):
+                md5s[parts[2]] = parts[0]
+        for line in fields.get("Checksums-Sha256", "").split("\n"):
+            parts = line.split()
+            if len(parts) != 3 or not HEX256.fullmatch(parts[0]):
+                continue
+            sha256, _, filename = parts
+            yield ("debian", sha256, md5s.get(filename, "-"), pkg, version, filename, directory)
+
+
+def brew_rows(formula_json):
+    for f in json.loads(formula_json):
+        stable = (f.get("urls") or {}).get("stable") or {}
+        sha256 = stable.get("checksum")
+        url = stable.get("url")
+        if not (sha256 and url and HEX256.fullmatch(sha256)):
+            continue
+        version = (f.get("versions") or {}).get("stable") or ""
+        yield ("homebrew", sha256, "-", f["name"], version, "-", url)
+
+
+def guix_rows(sources_json):
+    data = json.loads(sources_json)
+    entries = data["sources"] if isinstance(data, dict) else data
+    dropped = 0
+    for e in entries:
+        if e.get("type") != "url" or e.get("outputHashMode") != "flat":
+            continue  # recursive = NAR directory hash, not raw bytes
+        integrity = e.get("integrity", "")
+        if not integrity.startswith("sha256-"):
+            continue
+        try:
+            digest = base64.b64decode(integrity[len("sha256-") :])
+        except ValueError:
+            continue
+        if len(digest) != 32:
+            continue
+        urls = e.get("urls") or []
+        # Prefer the content-addressed mirrors: URLs that name the hash
+        # are claims about the bytes by construction.
+        loc = next(
+            (u for u in urls if "bordeaux.guix.gnu.org/file/" in u),
+            next((u for u in urls if "tarballs.nixos.org/sha256/" in u), None),
+        )
+        # The content-addressed URLs are .../file/<filename>/sha256/<hash>
+        # — the artifact's name is the segment after /file/, never the
+        # URL basename (that's the hash).
+        filename = next(
+            (u.split("/file/", 1)[1].split("/", 1)[0] for u in urls if "/file/" in u),
+            urls[0].rsplit("/", 1)[-1] if urls else "",
+        )
+        if not (loc and filename):
+            dropped += 1
+            continue
+        yield ("guix", digest.hex(), "-", "-", "-", filename, loc)
+    if dropped:
+        print(
+            f"  note: {dropped} flat entries had no content-addressed mirror URL, dropped",
+            file=sys.stderr,
+        )
+
+
+# Widths mirror the tarballs SourceSpec row layout in src/inverted.rs.
+WIDTHS = {"name": 72, "version": 56, "filename": 128, "loc": 192}
+
+
+def main():
+    outdir = pathlib.Path(
+        sys.argv[1] if len(sys.argv) > 1 else pathlib.Path.home() / ".cache/hashdex/tarballs"
+    )
+    outdir.mkdir(parents=True, exist_ok=True)
+
+    rows = []
+    print("debian sid Sources:", file=sys.stderr)
+    for comp in DEBIAN_COMPONENTS:
+        url = f"{DEBIAN_BASE}/{comp}/source/Sources.xz"
+        try:
+            data = fetch(url, outdir / f"debian-sid-{comp}-Sources.xz")
+        except Exception as e:
+            print(f"  warning: {comp}: {e}", file=sys.stderr)
+            continue
+        rows.extend(debian_rows(data))
+    print("homebrew formula.json:", file=sys.stderr)
+    rows.extend(brew_rows(fetch(BREW_URL, outdir / "brew-formula.json")))
+    print("guix sources.json:", file=sys.stderr)
+    rows.extend(guix_rows(fetch(GUIX_URL, outdir / "guix-sources.json")))
+
+    out = outdir / "tarballs.tsv.gz"
+    seen = set()
+    counts = {}
+    skipped = 0
+    with gzip.open(out, "wt", encoding="utf-8") as fh:
+        for witness, sha256, md5, name, version, filename, loc in rows:
+            try:
+                line = "\t".join(
+                    [
+                        witness,
+                        sha256,
+                        md5,
+                        field(name, WIDTHS["name"], "name"),
+                        field(version, WIDTHS["version"], "version"),
+                        field(filename, WIDTHS["filename"], "filename"),
+                        field(loc, WIDTHS["loc"], "loc"),
+                    ]
+                )
+            except ValueError as e:
+                skipped += 1
+                if skipped <= 10:
+                    print(f"  warning: skipping row: {e}", file=sys.stderr)
+                continue
+            if line in seen:
+                continue
+            seen.add(line)
+            fh.write(line + "\n")
+            counts[witness] = counts.get(witness, 0) + 1
+    per = ", ".join(f"{w} {n:,}" for w, n in sorted(counts.items()))
+    print(f"wrote {out}: {sum(counts.values()):,} rows ({per}), {skipped} skipped", file=sys.stderr)
+    print(out)
+
+
+if __name__ == "__main__":
+    main()

tarballs.tsv.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3387051f4eade696827758929410cf224995c9c4e705f7ebd8d9cfff9bad48ff
+size 12306972

tarballs_parquet.py

@@ -0,0 +1,108 @@
+#!/usr/bin/env python3
+"""Convert the release-tarballs TSV to the published parquet layout.
+
+Parquet is the wire format (HDXI stays a locally-derived index): one
+data table sorted by sha256 with page indexes for ~64 KB point reads,
+plus a small md5→sha256 map (Debian rows carry md5) sorted by md5.
+
+  data/tarballs.parquet   witness sha256 md5 name version filename loc
+  maps/md5.parquet        md5 sha256
+
+Usage:
+  tools/tarballs_parquet.py [tarballs.tsv.gz] [outdir]
+  (defaults: ~/.cache/hashdex/tarballs/tarballs.tsv.gz, sibling parquet/)
+
+Then upload outdir to the HF dataset and point hdx/web at it.
+"""
+import gzip
+import pathlib
+import sys
+
+try:
+    import pyarrow as pa
+    import pyarrow.parquet as pq
+except ImportError:
+    sys.exit("needs pyarrow (pip install pyarrow)")
+
+COLUMNS = ["witness", "sha256", "md5", "name", "version", "filename", "loc"]
+
+# Page size is only enforced per write batch: a large batch writes one
+# giant page regardless of data_page_size. Keep batches small.
+WRITER_OPTS = dict(
+    compression="zstd",
+    compression_level=3,
+    use_dictionary=False,
+    data_page_size=128 * 1024,
+    write_batch_size=256,
+    write_page_index=True,
+)
+
+
+def read_rows(tsv_path):
+    rows = []
+    with gzip.open(tsv_path, "rt", encoding="utf-8") as fh:
+        for line in fh:
+            parts = line.rstrip("\n").split("\t")
+            if len(parts) != len(COLUMNS):
+                sys.exit(f"malformed TSV line: {line!r}")
+            rows.append([None if v == "-" else v for v in parts])
+    return rows
+
+
+def write_sorted(rows, cols, sort_key, path):
+    rows = sorted(rows, key=sort_key)
+    table = pa.table(
+        {c: pa.array([r[i] for r in rows], type=pa.string()) for i, c in enumerate(cols)}
+    )
+    path.parent.mkdir(parents=True, exist_ok=True)
+    pq.write_table(table, path, **WRITER_OPTS)
+    return len(rows)
+
+
+def verify(path, key_col, expect_rows):
+    f = pq.ParquetFile(path)
+    assert f.metadata.num_rows == expect_rows, (path, f.metadata.num_rows, expect_rows)
+    # Page indexes must be physically present — readers rely on them
+    # for point lookups (duckdb's parquet_metadata does not show this).
+    for rg in range(f.metadata.num_row_groups):
+        for col in range(f.metadata.num_columns):
+            assert f.metadata.row_group(rg).column(col).has_offset_index, (path, rg, col)
+    keys = f.read(columns=[key_col]).column(0).to_pylist()
+    assert keys == sorted(keys), f"{path}: {key_col} not sorted"
+    print(
+        f"  {path}: {expect_rows:,} rows, sorted by {key_col}, "
+        f"page-indexed, {path.stat().st_size:,} bytes"
+    )
+
+
+def main():
+    tsv = pathlib.Path(
+        sys.argv[1]
+        if len(sys.argv) > 1
+        else pathlib.Path.home() / ".cache/hashdex/tarballs/tarballs.tsv.gz"
+    )
+    outdir = pathlib.Path(sys.argv[2]) if len(sys.argv) > 2 else tsv.parent / "parquet"
+
+    rows = read_rows(tsv)
+    n = write_sorted(
+        rows,
+        COLUMNS,
+        lambda r: (r[1], r[0], r[3] or "", r[5] or ""),
+        outdir / "data" / "tarballs.parquet",
+    )
+
+    md5_rows = sorted({(r[2], r[1]) for r in rows if r[2]})
+    m = write_sorted(
+        [list(t) for t in md5_rows],
+        ["md5", "sha256"],
+        lambda r: (r[0], r[1]),
+        outdir / "maps" / "md5.parquet",
+    )
+
+    verify(outdir / "data" / "tarballs.parquet", "sha256", n)
+    verify(outdir / "maps" / "md5.parquet", "md5", m)
+    print(outdir)
+
+
+if __name__ == "__main__":
+    main()