Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
4 changes: 4 additions & 0 deletions CHANGELOG.md
Original file line number Diff line number Diff line change
Expand Up @@ -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
Expand Down
22 changes: 22 additions & 0 deletions backend/internal/api/handlers.go
Original file line number Diff line number Diff line change
Expand Up @@ -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.
Expand Down
76 changes: 76 additions & 0 deletions backend/internal/api/handlers_test.go
Original file line number Diff line number Diff line change
Expand Up @@ -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{
Expand Down
1 change: 1 addition & 0 deletions backend/internal/api/server.go
Original file line number Diff line number Diff line change
Expand Up @@ -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) {
Expand Down
8 changes: 8 additions & 0 deletions backend/internal/model/types.go
Original file line number Diff line number Diff line change
Expand Up @@ -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"`
Expand Down
80 changes: 48 additions & 32 deletions backend/internal/store/cve.go
Original file line number Diff line number Diff line change
Expand Up @@ -80,15 +80,23 @@ 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,
)
if err != nil {
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
Expand Down Expand Up @@ -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.
Expand Down Expand Up @@ -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
}
Expand All @@ -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)
}
Expand Down
102 changes: 102 additions & 0 deletions backend/internal/store/cve_test.go
Original file line number Diff line number Diff line change
Expand Up @@ -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))
}
})
}
Loading