Mirror GitHub commit 954b20931bd23bf971072a5ec79424ac03b09d6b (committed 2026-09-12T11:35:28+03:00), pushed 2026-09-12T08:35:36Z

MIRROR_PROVENANCE.md

@@ -2,7 +2,7 @@
 
 This is not part of the archived repository -- it is written fresh on every push and carries no `.sha256` seal, deliberately. Every *other* file in this mirror is a byte-exact `git archive` of one GitHub commit, sealed at that commit; this file is the one exception, so that the file describing the copy never has to also be true about the copy's own past.
 
-- **Source commit:** [`8f96bd001f6099c87a59b08dda2ed3bd95956832`](https://github.com/soulinpsyabstract/eilatsecure/commit/8f96bd001f6099c87a59b08dda2ed3bd95956832)
-- **Committed upstream:** 2026-09-05T11:10:12+03:00
-- **Pushed to this mirror:** 2026-09-05T08:11:41Z
-- **Method:** `git archive` of that exact commit, uploaded as one atomic commit via `upload_folder(delete_patterns=["*"])`.
+- **Source commit:** [`954b20931bd23bf971072a5ec79424ac03b09d6b`](https://github.com/soulinpsyabstract/eilatsecure/commit/954b20931bd23bf971072a5ec79424ac03b09d6b)
+- **Committed upstream:** 2026-09-12T11:35:28+03:00
+- **Pushed to this mirror:** 2026-09-12T08:35:36Z
+- **Method:** `git archive` of that exact commit, uploaded as one atomic commit via `scripts/hf_mirror_push.py`, which refuses to run on a dirty tree.

hackathon-techex/.gitignore

@@ -0,0 +1,7 @@
+__pycache__/
+*.pyc
+*.egg-info/
+.pytest_cache/
+build/
+dist/
+scan_history.jsonl

hackathon-techex/README.md

@@ -0,0 +1,52 @@
+# hackathon-techex — Verifiable Scan History
+
+New work for the [TechEx Amsterdam Hackathon](https://lablab.ai/ai-hackathons/techex-amsterdam-hackathon)
+(cybersecurity track, online build 16–19 Oct 2026), built on top of the
+existing live EilatSecure scanner — **does not modify** `scan.js` or
+`scan_own_domains.py` at the repo root, only consumes what they already
+produce.
+
+Full concept and track status:
+[docs/BUILD_PLAN.md](docs/BUILD_PLAN.md)
+
+## The gap
+
+A scan today is a one-off JSON blob: nothing proves it wasn't edited after
+the fact, and comparing two scans of the same site means reading two files
+by hand. Both are real gaps in a product that's already live.
+
+## Quickstart (no network calls, no changes to the live scanner)
+
+```bash
+cd hackathon-techex
+pip install -e ".[dev]"
+python run_demo.py     # example data, shaped exactly like the real scanner's output
+pytest -q              # 17 tests
+```
+
+```python
+from sipa_scan_ledger import ScanLedger, ScanRecord, Finding, diff_scans
+
+ledger = ScanLedger("scan_history.jsonl")
+ledger.append(ScanRecord("example.com", "2026-10-16T08:00:00Z",
+                          [Finding("high", "No forced HTTPS redirect")]))
+```
+
+## Structure
+
+| Module | What it does | Status |
+| --- | --- | --- |
+| `sipa_scan_ledger/record.py` | Fixed schema wrapping the scanner's existing finding format | built, tested |
+| `sipa_scan_ledger/chain.py` + `verify.py` | Hash-chained history + tamper check | built, tested |
+| `sipa_scan_ledger/diff.py` | What changed between two scans of the same target | built, tested |
+| `sipa_scan_ledger/adapter.py` | Converts `scan_own_domains.py`'s real report shape into ledger entries | built, tested |
+
+## What's still open (see the plan for skill-matched slots)
+
+- Wire the adapter into a real scheduled run of `scan_own_domains.py`
+- A diff view on the EilatSecure landing page, not just terminal output
+- Demo video + lablab.ai submission
+
+Team: solo on this hackathon (the only other teammate on the team page
+opted out of TechEx Amsterdam specifically) — the tracks above are scoped
+for anyone who joins, not written assuming they will.

hackathon-techex/README.md.TAG

@@ -0,0 +1,5 @@
+FILE=README.md
+SHA256=d1c02d3a67a6e9affe2766d3ef920c1922b81bc8049f69dafe22bb7c02891ec6
+SIZE=2134
+DEVICE=SERVER
+TS=2026-09-12__10-54-40

hackathon-techex/README.md.sha256

@@ -0,0 +1 @@
+d1c02d3a67a6e9affe2766d3ef920c1922b81bc8049f69dafe22bb7c02891ec6  README.md

hackathon-techex/docs/BUILD_PLAN.md

@@ -0,0 +1,2 @@
+Full concept, what's built, and skill-matched open tracks:
+https://claude.ai/code/artifact/dcb20301-1541-474b-89b4-9923d5269c9a

hackathon-techex/pyproject.toml

@@ -0,0 +1,20 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "sipa-scan-ledger"
+version = "0.1.0"
+description = "Verifiable, diffable scan history for EilatSecure - TechEx Amsterdam Hackathon entry"
+requires-python = ">=3.10"
+license = { text = "Apache-2.0" }
+dependencies = []
+
+[project.optional-dependencies]
+dev = ["pytest>=7"]
+
+[tool.setuptools]
+packages = ["sipa_scan_ledger"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

hackathon-techex/run_demo.py

@@ -0,0 +1,70 @@
+"""End-to-end demo: two example self-scan reports (the exact shape
+scan_own_domains.py's main() already produces), fed through the ledger and
+diffed. Example data, clearly marked as such - not a live scan.
+
+    python run_demo.py
+"""
+from __future__ import annotations
+
+import os
+import tempfile
+
+from sipa_scan_ledger.adapter import records_from_self_scan_report
+from sipa_scan_ledger.chain import ScanLedger
+from sipa_scan_ledger.diff import diff_scans
+from sipa_scan_ledger.verify import verify
+
+# EXAMPLE reports, shaped exactly like scan_own_domains.py's real output -
+# not a live scan result.
+REPORT_DAY_1 = {
+    "ran_at": "2026-10-16T08:00:00+00:00",
+    "targets": {
+        "sipa-os.org": [],
+        "focus.sipa-os.org": [
+            {"severity": "medium", "title": "Missing Content-Security-Policy"},
+            {"severity": "low", "title": "Missing Referrer-Policy"},
+        ],
+    },
+}
+
+REPORT_DAY_8 = {
+    "ran_at": "2026-10-23T08:00:00+00:00",
+    "targets": {
+        "sipa-os.org": [
+            {"severity": "high", "title": "TLS cert expires in 6 days"},
+        ],
+        "focus.sipa-os.org": [
+            {"severity": "low", "title": "Missing Referrer-Policy"},
+        ],
+    },
+}
+
+
+def main() -> None:
+    log_path = os.path.join(tempfile.mkdtemp(), "scan_history.jsonl")
+    ledger = ScanLedger(log_path)
+
+    ledger.append_many(records_from_self_scan_report(REPORT_DAY_1))
+    ledger.append_many(records_from_self_scan_report(REPORT_DAY_8))
+
+    print("== sipa-os.org: 8 days apart ==")
+    history = ledger.history_for("sipa-os.org")
+    d = diff_scans(history[0], history[1])
+    print(f"  new findings:      {d.new_findings}")
+    print(f"  resolved findings: {d.resolved_findings}")
+    print(f"  got_worse={d.got_worse()}  (a cert expiring soon showed up between scans)")
+
+    print("\n== focus.sipa-os.org: 8 days apart ==")
+    history = ledger.history_for("focus.sipa-os.org")
+    d = diff_scans(history[0], history[1])
+    print(f"  new findings:      {d.new_findings}")
+    print(f"  resolved findings: {d.resolved_findings}")
+    print(f"  improved={d.improved()}  (the CSP finding got fixed between scans)")
+
+    res = verify(log_path)
+    print(f"\nscan history: {res.count} entries - {'OK' if res.ok else 'FAIL: ' + str(res.problems)}")
+    print(f"log file: {log_path}")
+
+
+if __name__ == "__main__":
+    main()

hackathon-techex/sipa_scan_ledger/__init__.py

@@ -0,0 +1,26 @@
+"""sipa_scan_ledger: verifiable, diffable history for EilatSecure's passive
+scans. Built for TechEx Amsterdam Hackathon (cybersecurity track) as new
+work on top of the existing, live EilatSecure scanner - it does not modify
+scan.js or scan_own_domains.py, only consumes what they already produce.
+
+Today a scan is a one-off JSON blob: no proof it wasn't edited after the
+fact, and no way to see what changed since the last scan of the same target
+without diffing two files by hand. This adds both, without touching the
+scanner itself.
+"""
+from .record import ScanRecord, Finding
+from .chain import ScanLedger
+from .verify import verify, VerifyResult
+from .diff import diff_scans, ScanDiff
+from .adapter import records_from_self_scan_report
+
+__all__ = [
+    "ScanRecord",
+    "Finding",
+    "ScanLedger",
+    "verify",
+    "VerifyResult",
+    "diff_scans",
+    "ScanDiff",
+    "records_from_self_scan_report",
+]

hackathon-techex/sipa_scan_ledger/adapter.py

@@ -0,0 +1,26 @@
+"""Bridges this module to the existing, unmodified scan_own_domains.py.
+
+That script's main() builds and prints exactly this shape:
+
+    {"ran_at": "<iso8601>", "targets": {"<host>": [{"severity", "title", ...}, ...], ...}}
+
+(see scan_own_domains.py's own main(), read directly from the repo before
+writing this - not guessed). This adapter turns that report dict into one
+ScanRecord per host. It does not import or call scan_own_domains.py itself,
+so this track can be built and tested without touching the existing script.
+"""
+from __future__ import annotations
+
+from .record import Finding, ScanRecord
+
+
+def records_from_self_scan_report(report: dict) -> list[ScanRecord]:
+    ran_at = report["ran_at"]
+    records = []
+    for host, findings in report.get("targets", {}).items():
+        records.append(ScanRecord(
+            target=host,
+            scanned_at=ran_at,
+            findings=[Finding.from_dict(f) for f in findings],
+        ))
+    return records

hackathon-techex/sipa_scan_ledger/chain.py

@@ -0,0 +1,74 @@
+"""Append-only, hash-chained history of scans. A business owner - or an
+auditor, or a customer deciding whether to trust the report - can verify
+this file was not edited after the fact, without trusting whoever ran the
+scan."""
+from __future__ import annotations
+
+import hashlib
+import json
+import time
+from pathlib import Path
+
+from .record import ScanRecord
+
+GENESIS = "0" * 64
+_PAYLOAD_KEYS = ("seq", "ts", "target", "scanned_at", "findings")
+
+
+def _canonical(obj) -> bytes:
+    return json.dumps(obj, sort_keys=True, separators=(",", ":"), ensure_ascii=False).encode("utf-8")
+
+
+def compute_hash(prev_hash: str, payload: dict) -> str:
+    h = hashlib.sha256()
+    h.update(prev_hash.encode("ascii"))
+    h.update(_canonical({k: payload.get(k) for k in _PAYLOAD_KEYS}))
+    return h.hexdigest()
+
+
+class ScanLedger:
+    def __init__(self, path: str | Path):
+        self.path = Path(path)
+        self._last_hash = GENESIS
+        self._seq = 0
+        if self.path.exists():
+            self._replay()
+
+    def _replay(self) -> None:
+        for line in self.path.read_text(encoding="utf-8").splitlines():
+            line = line.strip()
+            if not line:
+                continue
+            rec = json.loads(line)
+            self._last_hash = rec["hash"]
+            self._seq = rec["seq"] + 1
+
+    def append(self, record: ScanRecord) -> dict:
+        payload = {
+            "seq": self._seq,
+            "ts": time.time(),
+            "target": record.target,
+            "scanned_at": record.scanned_at,
+            "findings": [f.to_dict() for f in record.findings],
+        }
+        entry_hash = compute_hash(self._last_hash, payload)
+        entry = {**payload, "prev_hash": self._last_hash, "hash": entry_hash}
+        with self.path.open("a", encoding="utf-8") as f:
+            f.write(json.dumps(entry, ensure_ascii=False) + "\n")
+        self._last_hash = entry_hash
+        self._seq += 1
+        return entry
+
+    def append_many(self, records: list[ScanRecord]) -> list[dict]:
+        return [self.append(r) for r in records]
+
+    def entries(self) -> list[dict]:
+        if not self.path.exists():
+            return []
+        return [json.loads(l) for l in self.path.read_text(encoding="utf-8").splitlines() if l.strip()]
+
+    def history_for(self, target: str) -> list[ScanRecord]:
+        """All scans of one target, in chain order - what diff_scans() compares."""
+        return [
+            ScanRecord.from_dict(e) for e in self.entries() if e["target"] == target
+        ]

hackathon-techex/sipa_scan_ledger/diff.py

@@ -0,0 +1,38 @@
+"""What changed between two scans of the same target. Matches findings by
+title (the same check reported twice, same wording, from the same fixed
+check list scan_own_domains.py / scan.js run) - a human reading this doesn't
+re-read two full reports side by side, they read what's different."""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from .record import ScanRecord
+
+
+@dataclass
+class ScanDiff:
+    target: str
+    new_findings: list[dict] = field(default_factory=list)       # appeared since last scan
+    resolved_findings: list[dict] = field(default_factory=list)  # gone since last scan
+    unchanged_findings: list[dict] = field(default_factory=list)
+
+    def got_worse(self) -> bool:
+        return len(self.new_findings) > 0
+
+    def improved(self) -> bool:
+        return len(self.resolved_findings) > 0 and not self.new_findings
+
+
+def diff_scans(before: ScanRecord, after: ScanRecord) -> ScanDiff:
+    if before.target != after.target:
+        raise ValueError(f"diffing scans of different targets: {before.target!r} vs {after.target!r}")
+
+    before_titles = {f.title: f for f in before.findings}
+    after_titles = {f.title: f for f in after.findings}
+
+    new = [after_titles[t].to_dict() for t in after_titles.keys() - before_titles.keys()]
+    resolved = [before_titles[t].to_dict() for t in before_titles.keys() - after_titles.keys()]
+    unchanged = [after_titles[t].to_dict() for t in after_titles.keys() & before_titles.keys()]
+
+    return ScanDiff(target=after.target, new_findings=new, resolved_findings=resolved,
+                     unchanged_findings=unchanged)

hackathon-techex/sipa_scan_ledger/record.py

@@ -0,0 +1,61 @@
+"""The fixed schema a scan turns into. Matches the real shape
+`scan_own_domains.py` and `functions/api/scan.js` already produce -
+`{severity, title}` findings per target - this module doesn't invent a new
+finding format, it wraps the existing one so it can be chained and diffed.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+@dataclass(frozen=True)
+class Finding:
+    severity: str   # "critical" | "high" | "medium" | "low" - as scan_own_domains.py emits
+    title: str
+    detail: str = ""
+
+    @classmethod
+    def from_dict(cls, d: dict) -> "Finding":
+        return cls(severity=d["severity"], title=d["title"], detail=d.get("detail", ""))
+
+    def to_dict(self) -> dict:
+        d = {"severity": self.severity, "title": self.title}
+        if self.detail:
+            d["detail"] = self.detail
+        return d
+
+
+_SEVERITY_ORDER = {"critical": 3, "high": 2, "medium": 1, "low": 0}
+
+
+@dataclass
+class ScanRecord:
+    target: str
+    scanned_at: str          # ISO 8601, as produced by scan_own_domains.py / scan.js
+    findings: list[Finding] = field(default_factory=list)
+
+    def worst_severity(self) -> str | None:
+        if not self.findings:
+            return None
+        return max(self.findings, key=lambda f: _SEVERITY_ORDER.get(f.severity, -1)).severity
+
+    def severity_counts(self) -> dict:
+        counts = {"critical": 0, "high": 0, "medium": 0, "low": 0}
+        for f in self.findings:
+            counts[f.severity] = counts.get(f.severity, 0) + 1
+        return counts
+
+    def to_dict(self) -> dict:
+        return {
+            "target": self.target,
+            "scanned_at": self.scanned_at,
+            "findings": [f.to_dict() for f in self.findings],
+        }
+
+    @classmethod
+    def from_dict(cls, d: dict) -> "ScanRecord":
+        return cls(
+            target=d["target"],
+            scanned_at=d["scanned_at"],
+            findings=[Finding.from_dict(f) for f in d.get("findings", [])],
+        )

hackathon-techex/sipa_scan_ledger/verify.py

@@ -0,0 +1,56 @@
+"""Recompute the hash chain from scratch. Run it against a ledger file you
+did not produce and it still tells you whether the record is intact."""
+from __future__ import annotations
+
+import json
+import sys
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from .chain import GENESIS, _PAYLOAD_KEYS, compute_hash
+
+
+@dataclass
+class VerifyResult:
+    ok: bool
+    count: int
+    problems: list[str] = field(default_factory=list)
+
+
+def verify(path: str | Path) -> VerifyResult:
+    path = Path(path)
+    if not path.exists():
+        return VerifyResult(False, 0, [f"no such log: {path}"])
+    problems: list[str] = []
+    entries = [json.loads(l) for l in path.read_text(encoding="utf-8").splitlines() if l.strip()]
+    prev = GENESIS
+    for i, e in enumerate(entries):
+        if e.get("seq") != i:
+            problems.append(f"entry {i}: seq is {e.get('seq')}, expected {i}")
+        if e.get("prev_hash") != prev:
+            problems.append(f"entry {i}: chain broken")
+        expected = compute_hash(e.get("prev_hash", ""), {k: e.get(k) for k in _PAYLOAD_KEYS})
+        if e.get("hash") != expected:
+            problems.append(f"entry {i}: hash mismatch (altered)")
+        prev = e.get("hash", "")
+    return VerifyResult(ok=not problems, count=len(entries), problems=problems)
+
+
+def main(argv: list[str] | None = None) -> int:
+    argv = list(sys.argv[1:] if argv is None else argv)
+    if not argv:
+        print("usage: python -m sipa_scan_ledger.verify <ledger.jsonl>")
+        return 2
+    res = verify(argv[0])
+    print(f"entries: {res.count}")
+    if res.ok:
+        print("OK - chain intact, nothing altered")
+        return 0
+    print("FAIL:")
+    for p in res.problems:
+        print(f"  - {p}")
+    return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

hackathon-techex/tests/test_adapter.py

@@ -0,0 +1,35 @@
+from sipa_scan_ledger.adapter import records_from_self_scan_report
+
+# Shape copied from scan_own_domains.py's own main(): report = {"ran_at": ..., "targets": {host: findings}}
+SAMPLE_REPORT = {
+    "ran_at": "2026-10-16T08:00:00+00:00",
+    "targets": {
+        "sipa-os.org": [],
+        "focus.sipa-os.org": [
+            {"severity": "medium", "title": "Missing Content-Security-Policy"},
+        ],
+        "shell.sipa-os.org": [
+            {"severity": "critical", "title": "Unreachable over HTTPS", "detail": "timed out"},
+        ],
+    },
+}
+
+
+def test_one_record_per_target():
+    records = records_from_self_scan_report(SAMPLE_REPORT)
+    assert len(records) == 3
+    targets = {r.target for r in records}
+    assert targets == {"sipa-os.org", "focus.sipa-os.org", "shell.sipa-os.org"}
+
+
+def test_scanned_at_taken_from_ran_at():
+    records = records_from_self_scan_report(SAMPLE_REPORT)
+    assert all(r.scanned_at == "2026-10-16T08:00:00+00:00" for r in records)
+
+
+def test_findings_preserved():
+    records = records_from_self_scan_report(SAMPLE_REPORT)
+    by_target = {r.target: r for r in records}
+    assert by_target["shell.sipa-os.org"].findings[0].severity == "critical"
+    assert by_target["shell.sipa-os.org"].findings[0].detail == "timed out"
+    assert by_target["sipa-os.org"].findings == []

hackathon-techex/tests/test_chain.py

@@ -0,0 +1,33 @@
+from sipa_scan_ledger.chain import GENESIS, ScanLedger
+from sipa_scan_ledger.record import Finding, ScanRecord
+
+
+def test_chain_links(tmp_path):
+    log = ScanLedger(tmp_path / "l.jsonl")
+    e1 = log.append(ScanRecord("a.com", "t1", [Finding("low", "x")]))
+    e2 = log.append(ScanRecord("b.com", "t2", []))
+    assert e1["prev_hash"] == GENESIS
+    assert e2["prev_hash"] == e1["hash"]
+
+
+def test_reopen_continues_sequence(tmp_path):
+    p = tmp_path / "l.jsonl"
+    log = ScanLedger(p)
+    log.append(ScanRecord("a.com", "t1", []))
+    last = log.append(ScanRecord("a.com", "t2", []))
+
+    reopened = ScanLedger(p)
+    nxt = reopened.append(ScanRecord("a.com", "t3", []))
+    assert nxt["seq"] == 2
+    assert nxt["prev_hash"] == last["hash"]
+
+
+def test_history_for_filters_by_target(tmp_path):
+    log = ScanLedger(tmp_path / "l.jsonl")
+    log.append(ScanRecord("a.com", "t1", [Finding("low", "x")]))
+    log.append(ScanRecord("b.com", "t1", [Finding("high", "y")]))
+    log.append(ScanRecord("a.com", "t2", []))
+
+    history = log.history_for("a.com")
+    assert len(history) == 2
+    assert [r.scanned_at for r in history] == ["t1", "t2"]

hackathon-techex/tests/test_diff.py

@@ -0,0 +1,37 @@
+import pytest
+
+from sipa_scan_ledger.diff import diff_scans
+from sipa_scan_ledger.record import Finding, ScanRecord
+
+
+def test_new_finding_detected():
+    before = ScanRecord("a.com", "t1", [Finding("low", "Missing HSTS")])
+    after = ScanRecord("a.com", "t2", [Finding("low", "Missing HSTS"), Finding("high", "No forced HTTPS redirect")])
+    d = diff_scans(before, after)
+    assert len(d.new_findings) == 1
+    assert d.new_findings[0]["title"] == "No forced HTTPS redirect"
+    assert d.got_worse()
+
+
+def test_resolved_finding_detected():
+    before = ScanRecord("a.com", "t1", [Finding("high", "No forced HTTPS redirect")])
+    after = ScanRecord("a.com", "t2", [])
+    d = diff_scans(before, after)
+    assert len(d.resolved_findings) == 1
+    assert d.improved()
+    assert not d.got_worse()
+
+
+def test_unchanged_findings_tracked():
+    before = ScanRecord("a.com", "t1", [Finding("low", "Missing HSTS")])
+    after = ScanRecord("a.com", "t2", [Finding("low", "Missing HSTS")])
+    d = diff_scans(before, after)
+    assert len(d.unchanged_findings) == 1
+    assert not d.new_findings and not d.resolved_findings
+
+
+def test_different_targets_raises():
+    before = ScanRecord("a.com", "t1", [])
+    after = ScanRecord("b.com", "t2", [])
+    with pytest.raises(ValueError):
+        diff_scans(before, after)

hackathon-techex/tests/test_record.py

@@ -0,0 +1,27 @@
+from sipa_scan_ledger.record import Finding, ScanRecord
+
+
+def test_roundtrip():
+    r = ScanRecord("example.com", "2026-10-16T00:00:00Z",
+                    [Finding("high", "No forced HTTPS redirect")])
+    d = r.to_dict()
+    back = ScanRecord.from_dict(d)
+    assert back == r
+
+
+def test_worst_severity():
+    r = ScanRecord("x", "t", [Finding("low", "a"), Finding("critical", "b"), Finding("medium", "c")])
+    assert r.worst_severity() == "critical"
+
+
+def test_worst_severity_none_when_clean():
+    r = ScanRecord("x", "t", [])
+    assert r.worst_severity() is None
+
+
+def test_severity_counts():
+    r = ScanRecord("x", "t", [Finding("low", "a"), Finding("low", "b"), Finding("high", "c")])
+    counts = r.severity_counts()
+    assert counts["low"] == 2
+    assert counts["high"] == 1
+    assert counts["critical"] == 0

hackathon-techex/tests/test_verify.py

@@ -0,0 +1,38 @@
+import json
+
+from sipa_scan_ledger.chain import ScanLedger
+from sipa_scan_ledger.record import Finding, ScanRecord
+from sipa_scan_ledger.verify import verify
+
+
+def _populate(path):
+    log = ScanLedger(path)
+    log.append(ScanRecord("a.com", "t1", [Finding("high", "No forced HTTPS redirect")]))
+    log.append(ScanRecord("a.com", "t2", []))
+    return log
+
+
+def test_clean_ledger_verifies(tmp_path):
+    p = tmp_path / "l.jsonl"
+    _populate(p)
+    res = verify(p)
+    assert res.ok
+    assert res.count == 2
+
+
+def test_missing_file(tmp_path):
+    res = verify(tmp_path / "nope.jsonl")
+    assert not res.ok
+
+
+def test_altered_entry_is_caught(tmp_path):
+    p = tmp_path / "l.jsonl"
+    _populate(p)
+    lines = p.read_text().splitlines()
+    tampered = json.loads(lines[0])
+    tampered["findings"] = []  # quietly erase the finding
+    lines[0] = json.dumps(tampered)
+    p.write_text("\n".join(lines) + "\n")
+    res = verify(p)
+    assert not res.ok
+    assert any("altered" in x for x in res.problems)

scripts/hf_mirror_push.py

@@ -0,0 +1,112 @@
+#!/usr/bin/env python3
+"""hf_mirror_push -- same convention as sipa-os-governance/scripts/hf_mirror_push.py,
+adapted for this repo (no dataset-specific citation checkers here to run against
+the archived tree; eilatsecure has none).
+
+It:
+  1. Refuses to run if `git status --porcelain` is not empty.
+  2. Resolves HEAD to a single sha and archives *that exact commit's tree*
+     via `git archive`, not the working directory.
+  3. Writes that sha (plus UTC push time) into MIRROR_PROVENANCE.md -- a
+     file that does NOT come out of the archive and carries no .sha256 of
+     its own, so the seal never has to be true about the mirror's own past.
+  4. Uploads the archived tree plus that one added file as ONE atomic
+     commit via upload_folder, with delete_patterns=["*"] so a file
+     deleted upstream also disappears from the mirror.
+
+Requires HF_TOKEN in the environment and huggingface_hub installed.
+"""
+import os
+import subprocess
+import sys
+import tarfile
+import tempfile
+from datetime import datetime, timezone
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+HF_REPO_ID = "SoulInPsyAbstract/eilatsecure"
+
+
+def run(cmd: list[str], **kw) -> str:
+    return subprocess.run(cmd, cwd=REPO_ROOT, capture_output=True, text=True, check=True, **kw).stdout.strip()
+
+
+def refuse_if_dirty() -> None:
+    status = run(["git", "status", "--porcelain"])
+    if status:
+        print("[hf_mirror_push] REFUSED: working tree is dirty, not pushing a mixed-moment mirror.")
+        print(status)
+        sys.exit(1)
+
+
+def current_sha() -> str:
+    return run(["git", "rev-parse", "HEAD"])
+
+
+def commit_timestamp(sha: str) -> str:
+    return run(["git", "show", "-s", "--format=%cI", sha])
+
+
+def archive_commit_to(sha: str, dest: Path) -> None:
+    dest.mkdir(parents=True, exist_ok=True)
+    archive_path = dest.parent / f"{sha}.tar"
+    with open(archive_path, "wb") as f:
+        subprocess.run(["git", "archive", "--format=tar", sha], cwd=REPO_ROOT, stdout=f, check=True)
+    with tarfile.open(archive_path) as tar:
+        tar.extractall(dest, filter="data")
+    archive_path.unlink()
+
+
+def write_provenance_file(tree: Path, sha: str, commit_ts: str) -> str:
+    pushed_at = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+    content = (
+        "# Mirror provenance\n\n"
+        "This is not part of the archived repository -- it is written fresh on every "
+        "push and carries no `.sha256` seal, deliberately. Every *other* file in this "
+        "mirror is a byte-exact `git archive` of one GitHub commit, sealed at that "
+        "commit; this file is the one exception, so that the file describing the copy "
+        "never has to also be true about the copy's own past.\n\n"
+        f"- **Source commit:** [`{sha}`](https://github.com/soulinpsyabstract/eilatsecure/commit/{sha})\n"
+        f"- **Committed upstream:** {commit_ts}\n"
+        f"- **Pushed to this mirror:** {pushed_at}\n"
+        "- **Method:** `git archive` of that exact commit, uploaded as one atomic "
+        "commit via `scripts/hf_mirror_push.py`, which refuses to run on a dirty tree.\n"
+    )
+    (tree / "MIRROR_PROVENANCE.md").write_text(content)
+    return f"Mirror GitHub commit {sha} (committed {commit_ts}), pushed {pushed_at}"
+
+
+def main() -> int:
+    refuse_if_dirty()
+    sha = current_sha()
+    commit_ts = commit_timestamp(sha)
+    print(f"[hf_mirror_push] pushing commit {sha} ({commit_ts})")
+
+    with tempfile.TemporaryDirectory() as tmp:
+        tree = Path(tmp) / "tree"
+        archive_commit_to(sha, tree)
+
+        commit_msg = write_provenance_file(tree, sha, commit_ts)
+
+        from huggingface_hub import HfApi
+
+        token = os.environ.get("HF_TOKEN") or os.environ.get("HF_TOKEN_GRAND")
+        if not token:
+            print("[hf_mirror_push] REFUSED: no HF_TOKEN in environment.")
+            return 1
+
+        api = HfApi(token=token)
+        api.upload_folder(
+            folder_path=str(tree),
+            repo_id=HF_REPO_ID,
+            repo_type="dataset",
+            commit_message=commit_msg,
+            delete_patterns=["*"],
+        )
+    print(f"[hf_mirror_push] DONE: mirror now projects commit {sha}, single atomic push.")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())