From 03561bc677390e241ed45488928d4bdff869477e Mon Sep 17 00:00:00 2001 From: notplants <@notplants> Date: Mon, 16 Nov 2026 17:39:01 +0000 Subject: [PATCH] fix: attribute weekly CVEs to PR image diff --- .claude/skills/recipe-report/SKILL.md | 8 ++++++ .claude/skills/recipe-upgrade/SKILL.md | 27 ++++++++------------ cc-ci-plan/advisory-scan.SPEC.md | 5 ++++ cc-ci-plan/advisory-scan.py | 21 ++++++++++------ cc-ci-plan/test-advisory-scan.py | 35 ++++++++++++++++++++++++++ 5 files changed, 72 insertions(+), 24 deletions(-) diff --git a/.claude/skills/recipe-report/SKILL.md b/.claude/skills/recipe-report/SKILL.md index d0d4242..6e4837c 100644 --- a/.claude/skills/recipe-report/SKILL.md +++ b/.claude/skills/recipe-report/SKILL.md @@ -39,6 +39,14 @@ keeps every weekly edition looking the same regardless of which model writes the - **Security analysis.** Scan the per-recipe `upgrade_notes_md` + the summary (and use your own knowledge of the version bumps) for upgrades that fix **CVEs / security issues**. For each recipe, **count the CVEs** the PR fixes — this drives both the table's `cve` column and the priority sort. + Before crediting a CVE to an open PR, compare that PR's head `compose.yml` with its **merge-base + commit on the target branch**. Run `advisory-scan.py --compose-from + --compose-to ` when an upgrade log lacks that exact scan, or when its listed + image windows disagree with the PR diff. Credit image CVEs only for image version changes in + that diff. A previous release or warm canonical is not the PR baseline: it can include fixes + already present in the target branch. For example, lasuite-docs PR #11 did not change Valkey, + so its 8.1.11→9.1.3 CVE must not be credited to that PR. Record a security-relevant config + fix separately with direct evidence. If the PR diff cannot be verified, use `?` and explain why. - **ADDITIONALLY, and never instead:** each per-recipe log carries an `### Advisory scan (deterministic pre-step)` block (from `cc-ci-plan/advisory-scan.py` — GitHub Security Advisories + vendor security pages + OSV, with severities and fixed-in versions). Treat its diff --git a/.claude/skills/recipe-upgrade/SKILL.md b/.claude/skills/recipe-upgrade/SKILL.md index d7f4e04..3d08585 100644 --- a/.claude/skills/recipe-upgrade/SKILL.md +++ b/.claude/skills/recipe-upgrade/SKILL.md @@ -159,26 +159,21 @@ On cc-ci's `~/.abra/recipes/` (wrap every abra call per the pseudo-TTY b ### 2a. Advisory scan (deterministic; ADDITIVE — run it, never skip it) -Run the deterministic scanner for the exact upgrade window and **paste its markdown block verbatim -into the per-recipe log**: +Run the deterministic scanner against the **exact proposed PR diff** and paste its markdown block +verbatim into the per-recipe log. Use the proposed head's `compose.yml` and the commit it branches +from (the merge base with the target branch), both pinned by commit SHA: ``` -python3 /srv/cc-ci/cc-ci-plan/advisory-scan.py --from --to \ - [--image =:]... +python3 /srv/cc-ci/cc-ci-plan/advisory-scan.py \ + --compose-from \ + --compose-to ``` -**Pass an `--image` for EVERY sidecar you upgraded** (redis, postgres, nginx …), not just the app — -each image is judged by its own versions, and an image you don't name is not counted at all. Repeat -the flag for each one and pass them **all in a single call** (the count is a union across images). -e.g. discourse moving app 3.5.3→2026.7.1 *and* redis 7.4→8.10: - -``` -... --from 3.5.3 --to 2026.7.1 --image redis=7.4:8.10 -``` - -→ 140 CVEs (123 app + 17 redis), where the redis seventeen include a **critical** (CVE-2025-49844) -that is invisible if the sidecar is left out. `` is substring-matched against source repo names, -so make it specific enough to hit exactly one. +Do not substitute the previous published release, warm canonical, or a hand-typed image window for +the PR base. Those answer a different question and can credit a PR for CVEs fixed before its branch +was created. The compose diff includes every changed image, including sidecars. If the PR changes no +image tags, record zero image-version CVEs for this PR; assess any security-relevant configuration +change separately, with its own evidence. **If the scan reports advisories it could NOT judge, re-run it with `--adjudicate`.** That is a second pass: it collects each open case's full evidence (advisory prose, references, affected ranges, every diff --git a/cc-ci-plan/advisory-scan.SPEC.md b/cc-ci-plan/advisory-scan.SPEC.md index 980e90b..577a37a 100644 --- a/cc-ci-plan/advisory-scan.SPEC.md +++ b/cc-ci-plan/advisory-scan.SPEC.md @@ -56,6 +56,11 @@ advisory-scan.py --compose-to [--compose-from ] # windows Exit code is always 0 — this is informational. Failures are *reported*, never raised. +For PR attribution, pin both compose URLs to commits: the PR head and its merge base with the +target branch. A previous release or warm canonical can include image changes already present +before the PR. A compose diff with only sidecar changes has no primary app window; every changed +sidecar is scanned under its own image name. + --- # Pass 1 — deterministic diff --git a/cc-ci-plan/advisory-scan.py b/cc-ci-plan/advisory-scan.py index c69afba..a38e407 100755 --- a/cc-ci-plan/advisory-scan.py +++ b/cc-ci-plan/advisory-scan.py @@ -1336,7 +1336,8 @@ def _default_branch_compose(url: str) -> str | None: return f"{host}/{owner}/{repo}/raw/branch/{br}/{path}" if br else None -def windows_from_compose(to_url: str, from_url: str | None = None) -> tuple[list, str | None]: +def windows_from_compose(to_url: str, from_url: str | None = None, + include_primary: bool = False) -> tuple: """Derive the scan's version windows by DIFFING two compose files. This is the deterministic alternative to a human (or a model) deciding which `--image` args a @@ -1366,7 +1367,8 @@ def windows_from_compose(to_url: str, from_url: str | None = None) -> tuple[list else: others.append((repo.split("/")[-1], prev_tag, tag)) wins = ([app] if app else []) + others - return wins, f"baseline {from_url}" + result = (wins, f"baseline {from_url}") + return (*result, bool(app)) if include_primary else result def main() -> int: @@ -1395,7 +1397,8 @@ def main() -> int: a = ap.parse_args() images = [] if a.compose_to: - wins, note = windows_from_compose(a.compose_to, a.compose_from) + wins, note, app_changed = windows_from_compose(a.compose_to, a.compose_from, + include_primary=True) if not wins: print(f"### Advisory scan — {a.recipe}\n\n**No image versions changed between the two " f"compose files, so this upgrade fixes no CVEs by definition.**\n\n_{note}_") @@ -1403,11 +1406,13 @@ def main() -> int: print(f"_derived from compose diff ({note}):_", file=sys.stderr) for n_, f_, t_ in wins: print(f"_ {n_}: {f_} → {t_}_", file=sys.stderr) - # The `app` service (first entry when present) drives --from/--to; the rest are --image - # windows. Passing every window as --image too is harmless: each is matched by name against - # the advisory sources, and an unmatched name is simply ignored. - a.v_from, a.v_to = a.v_from or wins[0][1], a.v_to or wins[0][2] - images = list(wins[1:]) + # Only an actual app-service change defines the primary window. A sidecar-only PR must + # not be scanned as though its first sidecar were the application image. + if app_changed: + a.v_from, a.v_to = a.v_from or wins[0][1], a.v_to or wins[0][2] + images = list(wins[1:]) + else: + images = list(wins) for spec in a.image: name, _, rng = spec.partition('=') vf, _, vt = rng.partition(':') diff --git a/cc-ci-plan/test-advisory-scan.py b/cc-ci-plan/test-advisory-scan.py index fdf3ed2..3505cb0 100755 --- a/cc-ci-plan/test-advisory-scan.py +++ b/cc-ci-plan/test-advisory-scan.py @@ -746,6 +746,41 @@ volumes: def test_no_change_yields_no_windows(self): self.assertEqual(self._windows(old=self.NEW, new=self.NEW), []) + def test_lasuite_docs_pr_does_not_claim_preexisting_valkey_upgrade(self): + base = """services: + app: + image: lasuite/impress-frontend:v6.0.4 + yhub-valkey: + image: valkey/valkey:9.1.3-alpine + docspec: + image: ghcr.io/docspecio/api:3.0.2 +""" + head = base.replace("ghcr.io/docspecio/api:3.0.2", "ghcr.io/docspec/api:1.21.4") + windows = self._windows(old=base, new=head) + self.assertEqual(windows, [("api", "3.0.2", "1.21.4")]) + self.assertNotIn("valkey", [name for name, _, _ in windows]) + + captured = {} + + def fake_scan(recipe, v_from, v_to, registry, images): + captured.update(from_version=v_from, to_version=v_to, images=images) + return {"recipe": recipe, "from": v_from, "to": v_to, + "count_known": True, "cve_count_fixed": 0, "cves": {}, "sources": [], + "fixed_by_this_upgrade": [], "unclassified": [], "registry_urls": 0, + "sources_failed": [], "sources_benign": [], "windows": {}, + "classified_by": {}} + + with unittest.mock.patch.object(A, "windows_from_compose", + return_value=(windows, "pinned base", False)), \ + unittest.mock.patch.object(A, "scan", fake_scan), \ + unittest.mock.patch.object(sys, "argv", ["advisory-scan.py", "lasuite-docs", + "--compose-from", "base", "--compose-to", "head"]), \ + unittest.mock.patch.object(sys, "stdout", io.StringIO()), \ + unittest.mock.patch.object(sys, "stderr", io.StringIO()): + A.main() + self.assertIsNone(captured["from_version"]) + self.assertEqual(captured["images"], windows) + def test_templated_tags_are_skipped(self): new = self.NEW.replace('ghcr.io/plausible/community-edition:v3.2.1', 'ghost:${IMAGE_VERSION}') self.assertNotIn("ghost", [n for n, _, _ in self._windows(new=new)]) -- 2.54.0