diff --git a/CHANGELOG.md b/CHANGELOG.md index 1e3f966..e0aa705 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -11,6 +11,10 @@ an example value. See `deploy/host/README.md`. ## [Unreleased] +### Added + +- `GET /api/cve/findings` lists every image scan that currently has HIGH or CRITICAL CVEs, across all images, with the findings. An optional `?project=` prefix such as `ppg:staging` keeps that project and its subprojects. + ## [0.2.9] - 2026-11-13 ### Added diff --git a/backend/internal/api/handlers.go b/backend/internal/api/handlers.go index ec83638..680c0d0 100644 --- a/backend/internal/api/handlers.go +++ b/backend/internal/api/handlers.go @@ -556,6 +556,28 @@ func cveScansHandler(db *sql.DB) http.HandlerFunc { } } +// cveFindingsHandler returns a handler for GET /api/cve/findings. +// It lists every per-arch image scan that currently has HIGH or CRITICAL +// findings, across all images, each with its project, package and findings. +// The optional ?project= param is a project prefix: "ppg:staging" keeps that +// project and its subprojects. No match returns an empty array. +func cveFindingsHandler(db *sql.DB) http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + scans, err := store.QueryVulnerableScans(db, r.URL.Query().Get("project")) + if err != nil { + slog.Error("api: cve findings", "err", err) + http.Error(w, "internal server error", http.StatusInternalServerError) + return + } + if scans == nil { + scans = []model.ImageCveScan{} + } + + w.Header().Set("Content-Type", "application/json") + _ = json.NewEncoder(w).Encode(scans) + } +} + // cveRescanHandler handles POST /api/cve/rescan: it queues a fresh scan of // every image that currently has HIGH/CRITICAL CVEs and returns // {"queued": N}, the number of images queued. diff --git a/backend/internal/api/handlers_test.go b/backend/internal/api/handlers_test.go index 64dc3f8..c37ae82 100644 --- a/backend/internal/api/handlers_test.go +++ b/backend/internal/api/handlers_test.go @@ -573,6 +573,82 @@ func TestCveScansRoute(t *testing.T) { } } +func TestCveFindingsHandler(t *testing.T) { + db, err := store.Open(":memory:") + if err != nil { + t.Fatalf("store.Open: %v", err) + } + t.Cleanup(func() { db.Close() }) + + h := cveFindingsHandler(db) + get := func(url string) []model.ImageCveScan { + t.Helper() + rec := httptest.NewRecorder() + h(rec, httptest.NewRequest(http.MethodGet, url, nil)) + if rec.Code != http.StatusOK { + t.Fatalf("%s: expected 200, got %d", url, rec.Code) + } + if strings.TrimSpace(rec.Body.String()) == "null" { + t.Fatalf("%s: expected a JSON array, got null", url) + } + var scans []model.ImageCveScan + if err := json.NewDecoder(rec.Body).Decode(&scans); err != nil { + t.Fatalf("decode: %v", err) + } + return scans + } + + if scans := get("/api/cve/findings"); len(scans) != 0 { + t.Fatalf("empty DB: expected no scans, got %d", len(scans)) + } + + for _, project := range []string{"ppg:staging:18:containers", "ppg:devel:18:containers"} { + scan := model.CveScan{ + Repo: "images", + Arch: "x86_64", + ImageRef: "registry.example/percona-postgresql18:latest", + ScannedAt: time.Date(2026, 7, 1, 12, 0, 0, 0, time.UTC), + CriticalCount: 1, + Findings: []model.CveFinding{{ + ID: "CVE-2026-0001", PkgName: "openssl", InstalledVersion: "3.0.1", + FixedVersion: "3.0.2", Severity: "CRITICAL", Title: "test vulnerability", + }}, + } + if err := store.UpsertCveScan(db, project, "percona-postgresql18", scan); err != nil { + t.Fatalf("UpsertCveScan: %v", err) + } + } + + if scans := get("/api/cve/findings"); len(scans) != 2 { + t.Fatalf("no filter: expected 2 scans, got %d", len(scans)) + } + + scans := get("/api/cve/findings?project=ppg:staging") + if len(scans) != 1 { + t.Fatalf("filtered: expected 1 scan, got %d", len(scans)) + } + got := scans[0] + if got.Project != "ppg:staging:18:containers" || got.Package != "percona-postgresql18" || + got.Repo != "images" || got.Arch != "x86_64" || got.CriticalCount != 1 { + t.Fatalf("unexpected scan: %+v", got) + } + if len(got.Findings) != 1 || got.Findings[0].ID != "CVE-2026-0001" { + t.Fatalf("unexpected findings: %+v", got.Findings) + } +} + +func TestCveFindingsRoute(t *testing.T) { + router := setupTestServer(t) + rec := httptest.NewRecorder() + router.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/api/cve/findings", nil)) + if rec.Code != http.StatusOK { + t.Fatalf("route not registered or failing: expected 200, got %d", rec.Code) + } + if ct := rec.Header().Get("Content-Type"); ct != "application/json" { + t.Fatalf("expected JSON, got %q", ct) + } +} + func TestProductsTierValidation(t *testing.T) { router := setupTestServer(t) for _, path := range []string{ diff --git a/backend/internal/api/server.go b/backend/internal/api/server.go index b08a282..8283142 100644 --- a/backend/internal/api/server.go +++ b/backend/internal/api/server.go @@ -96,6 +96,7 @@ func NewRouter(db *sql.DB, h *hub.Hub, fleet *obs.Fleet, ws Statter, telemetryEn r.Get("/api/overview", overviewHandler(db, fleet.Default().Slug, overview)) r.Get("/api/cve/scans", cveScansHandler(db)) + r.Get("/api/cve/findings", cveFindingsHandler(db)) // State-changing actions: signed-in, allowlisted users only. r.Group(func(r chi.Router) { diff --git a/backend/internal/model/types.go b/backend/internal/model/types.go index 5a97651..33b244a 100644 --- a/backend/internal/model/types.go +++ b/backend/internal/model/types.go @@ -77,6 +77,14 @@ type CveScan struct { Findings []CveFinding `json:"findings,omitempty"` } +// ImageCveScan is a CveScan together with the image it belongs to, for +// listings that span more than one image. +type ImageCveScan struct { + Project string `json:"project"` + Package string `json:"package"` + CveScan +} + type CvePeriod struct { Project string `json:"project"` Package string `json:"package"` diff --git a/backend/internal/store/cve.go b/backend/internal/store/cve.go index 7ed320c..0c86c0c 100644 --- a/backend/internal/store/cve.go +++ b/backend/internal/store/cve.go @@ -80,7 +80,7 @@ func UpsertCveScan(db *sql.DB, project, pkg string, scan model.CveScan) error { // QueryCveScans returns all arch scan results for a package. func QueryCveScans(db *sql.DB, project, pkg string) ([]model.CveScan, error) { rows, err := db.Query(` - SELECT repo, arch, image_ref, scanned_at, critical_count, high_count, findings_json, cve_since, clean_since + SELECT project, package, repo, arch, image_ref, scanned_at, critical_count, high_count, findings_json, cve_since, clean_since FROM cve_scans WHERE project = ? AND package = ?`, project, pkg, ) @@ -88,7 +88,15 @@ func QueryCveScans(db *sql.DB, project, pkg string) ([]model.CveScan, error) { return nil, err } defer rows.Close() - return scanCveRows(rows) + rowScans, err := scanImageCveRows(rows) + if err != nil { + return nil, err + } + var scans []model.CveScan + for _, s := range rowScans { + scans = append(scans, s.CveScan) + } + return scans, nil } // AttachCveScans batch-fetches CVE scan results for a slice of packages and @@ -125,32 +133,37 @@ func AttachCveScans(db *sql.DB, packages []*model.Package) error { } defer rows.Close() - for rows.Next() { - var project, pkg string - var scan model.CveScan - var scannedAtStr string - var findingsJSON string - var cveSinceStr, cleanSinceStr sql.NullString - if err := rows.Scan(&project, &pkg, &scan.Repo, &scan.Arch, &scan.ImageRef, - &scannedAtStr, &scan.CriticalCount, &scan.HighCount, &findingsJSON, - &cveSinceStr, &cleanSinceStr); err != nil { - return err - } - var parseErr error - scan.ScannedAt, parseErr = time.Parse(time.RFC3339, scannedAtStr) - if parseErr != nil { - return fmt.Errorf("cve_scans: invalid scanned_at %q: %w", scannedAtStr, parseErr) - } - applyNullableTimestamps(&scan, cveSinceStr, cleanSinceStr) - if findingsJSON != "" && findingsJSON != "[]" { - _ = json.Unmarshal([]byte(findingsJSON), &scan.Findings) - } - k := project + "/" + pkg - if p, ok := index[k]; ok { - p.CveScans = append(p.CveScans, scan) + scans, err := scanImageCveRows(rows) + if err != nil { + return err + } + for _, s := range scans { + if p, ok := index[s.Project+"/"+s.Package]; ok { + p.CveScans = append(p.CveScans, s.CveScan) } } - return rows.Err() + return nil +} + +// QueryVulnerableScans returns every per-arch scan that currently has HIGH or +// CRITICAL findings, with the findings, ordered by project, package, repo, +// arch. A non-empty projectPrefix keeps only that project and its +// subprojects: "ppg:staging" matches "ppg:staging" and "ppg:staging:18", not +// "ppg:staging2". The prefix is compared literally, not as a LIKE pattern. +func QueryVulnerableScans(db *sql.DB, projectPrefix string) ([]model.ImageCveScan, error) { + rows, err := db.Query(` + SELECT project, package, repo, arch, image_ref, scanned_at, critical_count, high_count, findings_json, cve_since, clean_since + FROM cve_scans + WHERE critical_count + high_count > 0 + AND (?1 = '' OR project = ?1 OR substr(project, 1, length(?1) + 1) = ?1 || ':') + ORDER BY project, package, repo, arch`, + projectPrefix, + ) + if err != nil { + return nil, err + } + defer rows.Close() + return scanImageCveRows(rows) } // QueryCvePeriods returns completed CVE episodes for a package, newest first. @@ -229,14 +242,17 @@ func parseRFC3339(s string) (time.Time, error) { return time.Parse(time.RFC3339Nano, s) } -func scanCveRows(rows *sql.Rows) ([]model.CveScan, error) { - var scans []model.CveScan +// scanImageCveRows reads rows of (project, package, repo, arch, image_ref, +// scanned_at, critical_count, high_count, findings_json, cve_since, +// clean_since). +func scanImageCveRows(rows *sql.Rows) ([]model.ImageCveScan, error) { + var scans []model.ImageCveScan for rows.Next() { - var scan model.CveScan + var scan model.ImageCveScan var scannedAtStr, findingsJSON string var cveSinceStr, cleanSinceStr sql.NullString - if err := rows.Scan(&scan.Repo, &scan.Arch, &scan.ImageRef, &scannedAtStr, - &scan.CriticalCount, &scan.HighCount, &findingsJSON, + if err := rows.Scan(&scan.Project, &scan.Package, &scan.Repo, &scan.Arch, &scan.ImageRef, + &scannedAtStr, &scan.CriticalCount, &scan.HighCount, &findingsJSON, &cveSinceStr, &cleanSinceStr); err != nil { return nil, err } @@ -245,7 +261,7 @@ func scanCveRows(rows *sql.Rows) ([]model.CveScan, error) { if parseErr != nil { return nil, fmt.Errorf("cve_scans: invalid scanned_at %q: %w", scannedAtStr, parseErr) } - applyNullableTimestamps(&scan, cveSinceStr, cleanSinceStr) + applyNullableTimestamps(&scan.CveScan, cveSinceStr, cleanSinceStr) if findingsJSON != "" && findingsJSON != "[]" { _ = json.Unmarshal([]byte(findingsJSON), &scan.Findings) } diff --git a/backend/internal/store/cve_test.go b/backend/internal/store/cve_test.go index 067f29a..18af1fe 100644 --- a/backend/internal/store/cve_test.go +++ b/backend/internal/store/cve_test.go @@ -370,3 +370,105 @@ func TestQueryVulnerableImages(t *testing.T) { } } } + +func TestQueryVulnerableScans(t *testing.T) { + db, err := store.Open(":memory:") + if err != nil { + t.Fatal(err) + } + defer db.Close() + + at := time.Date(2026, 7, 1, 12, 0, 0, 0, time.UTC) + vuln := func(arch string) model.CveScan { + return model.CveScan{ + Repo: "images", Arch: arch, ImageRef: "registry.example/img:1", ScannedAt: at, + HighCount: 1, + Findings: []model.CveFinding{{ID: "CVE-2026-0001", PkgName: "openssl", Severity: "HIGH"}}, + } + } + clean := model.CveScan{Repo: "images", Arch: "x86_64", ImageRef: "registry.example/clean:1", ScannedAt: at} + + seed := []struct { + project, pkg string + scan model.CveScan + }{ + {"ppg:staging:18:containers", "pg18", vuln("x86_64")}, + {"ppg:staging:18:containers", "pg18", vuln("aarch64")}, + {"ppg:staging:18:containers", "cleanimg", clean}, + {"ppg:staging", "toplevel", vuln("x86_64")}, + {"ppg:staging2:18:containers", "lookalike", vuln("x86_64")}, + {"ppg:devel:18:containers", "pg18", vuln("x86_64")}, + } + for _, s := range seed { + if err := store.UpsertCveScan(db, s.project, s.pkg, s.scan); err != nil { + t.Fatal(err) + } + } + + keys := func(scans []model.ImageCveScan) []string { + var out []string + for _, s := range scans { + out = append(out, s.Project+"/"+s.Package+"/"+s.Arch) + } + return out + } + equal := func(a, b []string) bool { + if len(a) != len(b) { + return false + } + for i := range a { + if a[i] != b[i] { + return false + } + } + return true + } + + t.Run("no prefix returns every vulnerable scan, clean ones omitted", func(t *testing.T) { + scans, err := store.QueryVulnerableScans(db, "") + if err != nil { + t.Fatal(err) + } + want := []string{ + "ppg:devel:18:containers/pg18/x86_64", + "ppg:staging/toplevel/x86_64", + "ppg:staging2:18:containers/lookalike/x86_64", + "ppg:staging:18:containers/pg18/aarch64", + "ppg:staging:18:containers/pg18/x86_64", + } + if got := keys(scans); !equal(got, want) { + t.Fatalf("got %v, want %v", got, want) + } + if len(scans[0].Findings) != 1 || scans[0].Findings[0].ID != "CVE-2026-0001" { + t.Fatalf("findings not attached: %+v", scans[0]) + } + if scans[0].CveSince == nil { + t.Fatal("expected cve_since on a vulnerable scan") + } + }) + + t.Run("prefix matches the project itself and its subprojects only", func(t *testing.T) { + scans, err := store.QueryVulnerableScans(db, "ppg:staging") + if err != nil { + t.Fatal(err) + } + want := []string{ + "ppg:staging/toplevel/x86_64", + "ppg:staging:18:containers/pg18/aarch64", + "ppg:staging:18:containers/pg18/x86_64", + } + if got := keys(scans); !equal(got, want) { + t.Fatalf("got %v, want %v", got, want) + } + }) + + t.Run("LIKE wildcards in the prefix are literal", func(t *testing.T) { + scans, err := store.QueryVulnerableScans(db, "ppg:%") + if err != nil { + t.Fatal(err) + } + if len(scans) != 0 { + t.Fatalf("expected no match, got %v", keys(scans)) + } + }) +}