Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
package vulnerability
import (
"context"
"encoding/json"
"fmt"
"net/http"
"net/http/httptest"
"net/url"
"strings"
"sync/atomic"
"testing"
"time"
"github.com/getarcaneapp/arcane/types/v2/features"
"github.com/getarcaneapp/arcane/types/v2/scheduler"
"github.com/getarcaneapp/arcane/types/v2/user"
"github.com/getarcaneapp/arcane/types/v2/vulnerability"
"github.com/libtnb/sqlite"
"github.com/moby/moby/client"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"go.getarcane.app/kit/pkg"
"gorm.io/gorm"
"github.com/getarcaneapp/arcane/backend/v2/internal/activity"
"github.com/getarcaneapp/arcane/backend/v2/internal/common"
"github.com/getarcaneapp/arcane/backend/v2/internal/config"
"github.com/getarcaneapp/arcane/backend/v2/internal/database"
"github.com/getarcaneapp/arcane/backend/v2/internal/docker"
"github.com/getarcaneapp/arcane/backend/v2/internal/event"
"github.com/getarcaneapp/arcane/backend/v2/internal/kv"
"github.com/getarcaneapp/arcane/backend/v2/internal/notification"
"github.com/getarcaneapp/arcane/backend/v2/internal/settings"
"github.com/getarcaneapp/arcane/backend/v2/internal/vulnerability/children/query"
activitylib "github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane/activity"
"github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane/vuln"
"github.com/getarcaneapp/arcane/backend/v2/pkg/pagination"
"github.com/getarcaneapp/arcane/backend/v2/pkg/scheduler/flow/flowtest"
)
func setupVulnerabilityScanTestDB(t *testing.T) (*database.DB, *settings.SettingsService) {
t.Helper()
dsn := fmt.Sprintf("file:vulnerability-scan-test-%d?mode=memory&cache=shared", time.Now().UnixNano())
gdb, err := gorm.Open(sqlite.Open(dsn), &gorm.Config{})
require.NoError(t, err)
require.NoError(t, gdb.AutoMigrate(&VulnerabilityScanRecord{}, &VulnerabilityIgnore{}, &VulnerabilityScanItem{}, &settings.SettingVariable{}))
db := &database.DB{DB: gdb}
settingsService, err := settings.NewSettingsService(t.Context(), db, &config.Config{})
require.NoError(t, err)
t.Cleanup(func() { require.NoError(t, settingsService.Stop(context.WithoutCancel(t.Context()))) })
return db, settingsService
}
func TestSaveScanResult_FixableCountsOSPackagesOnly(t *testing.T) {
ctx := t.Context()
db, settingsSvc := setupVulnerabilityScanTestDB(t)
svc := newTestService(t, db, settingsSvc, http.DefaultClient)
result := &vulnerability.ScanResult{
ImageID: "sha256:img-fixable",
ImageName: "nginx:latest",
Status: vulnerability.ScanStatusCompleted,
ScanTime: time.Now(),
Vulnerabilities: []vulnerability.Vulnerability{
{
VulnerabilityID: "CVE-1",
Class: vulnerability.TrivyClassOSPackages,
FixedVersion: "1.2.3",
},
{VulnerabilityID: "CVE-2", Class: vulnerability.TrivyClassOSPackages},
{
VulnerabilityID: "CVE-3",
Class: vulnerability.TrivyClassLangPackages,
FixedVersion: "2.0.0",
},
},
}
require.NoError(t, svc.store.SaveResult(ctx, result))
var record VulnerabilityScanRecord
require.NoError(t, db.First(&record, "id = ?", "sha256:img-fixable").Error)
require.NotNil(t, record.FixableCount)
require.Equal(t, 1, *record.FixableCount)
}
func TestVulnerabilityService_ListVulnerabilities_NoScanReturnsNotFound(t *testing.T) {
db, settingsSvc := setupVulnerabilityScanTestDB(t)
svc := newTestService(t, db, settingsSvc, http.DefaultClient)
_, _, err := svc.query.ListVulnerabilities(t.Context(), "sha256:unknown", pagination.QueryParams{Limit: 20})
require.ErrorIs(t, err, common.ErrVulnerabilityScanNotFound)
}
func TestVulnerabilityService_DeleteScanResultsByImageIDs(t *testing.T) {
ctx := t.Context()
db, settingsSvc := setupVulnerabilityScanTestDB(t)
svc := newTestService(t, db, settingsSvc, http.DefaultClient)
records := []VulnerabilityScanRecord{
{
ID: "sha256:img1",
ImageName: "nginx:latest",
Status: ScanStatusCompleted,
ScanTime: time.Now(),
},
{
ID: "sha256:img2",
ImageName: "redis:7",
Status: ScanStatusCompleted,
ScanTime: time.Now(),
},
{
ID: "sha256:img3",
ImageName: "postgres:16",
Status: ScanStatusCompleted,
ScanTime: time.Now(),
},
}
for i := range records {
require.NoError(t, db.Create(&records[i]).Error)
}
require.NoError(t, svc.DeleteScanResultsByImageIDs(ctx, []string{"sha256:img1", "sha256:img3"}))
var remaining []VulnerabilityScanRecord
require.NoError(t, db.Find(&remaining).Error)
require.Len(t, remaining, 1)
require.Equal(t, "sha256:img2", remaining[0].ID)
}
func TestVulnerabilityService_DeleteScanResultsByImageIDs_EmptyInput(t *testing.T) {
ctx := t.Context()
db, settingsSvc := setupVulnerabilityScanTestDB(t)
svc := newTestService(t, db, settingsSvc, http.DefaultClient)
require.NoError(t, svc.DeleteScanResultsByImageIDs(ctx, nil))
require.NoError(t, svc.DeleteScanResultsByImageIDs(ctx, []string{}))
}
func TestVulnerabilityService_ListAllVulnerabilities_FiltersIgnoredInline(t *testing.T) {
ctx := t.Context()
db, settingsSvc := setupVulnerabilityScanTestDB(t)
svc := newTestService(t, db, settingsSvc, http.DefaultClient)
vulns := []vulnerability.Vulnerability{
{
VulnerabilityID: "CVE-2026-0001",
PkgName: "openssl",
InstalledVersion: "1.0.0",
Severity: vulnerability.SeverityHigh,
},
}
rawVulns, err := json.Marshal(vulns)
require.NoError(t, err)
scan := VulnerabilityScanRecord{
ID: "sha256:list-all-1",
ImageName: "nginx:latest",
Status: ScanStatusCompleted,
ScanTime: time.Now(),
HighCount: 1,
TotalCount: 1,
Vulnerabilities: database.StringSlice{string(rawVulns)},
}
require.NoError(t, db.Create(&scan).Error)
svc.BackfillScanItems(ctx)
ignore := VulnerabilityIgnore{
EnvironmentID: "env-1",
ImageID: scan.ID,
VulnerabilityID: "CVE-2026-0001",
PkgName: "openssl",
InstalledVersion: "1.0.0",
Reason: new("accepted risk"),
CreatedBy: "tester",
}
require.NoError(t, db.Create(&ignore).Error)
items, page, err := svc.query.ListAllVulnerabilities(ctx, "env-1", pagination.QueryParams{
Limit: 20,
})
require.NoError(t, err)
require.Empty(t, items)
require.Equal(t, int64(0), page.TotalItems)
require.Equal(t, int64(0), page.GrandTotalItems)
}
func TestVulnerabilityService_ListAllVulnerabilityImageOptions_SeverityFilter(t *testing.T) {
ctx := t.Context()
db, settingsSvc := setupVulnerabilityScanTestDB(t)
svc := newTestService(t, db, settingsSvc, http.DefaultClient)
now := time.Now()
records := []VulnerabilityScanRecord{
{
ID: "sha256:critical-a",
ImageName: "zeta:latest",
Status: ScanStatusCompleted,
ScanTime: now,
CriticalCount: 2,
TotalCount: 2,
},
{
ID: "sha256:high-a",
ImageName: "alpha:latest",
Status: ScanStatusCompleted,
ScanTime: now,
HighCount: 4,
TotalCount: 4,
},
{
ID: "sha256:critical-b",
Status: ScanStatusCompleted,
ScanTime: now,
CriticalCount: 1,
TotalCount: 1,
},
{
ID: "sha256:critical-c",
ImageName: "zeta:latest",
Status: ScanStatusCompleted,
ScanTime: now,
CriticalCount: 1,
TotalCount: 1,
},
{
ID: "sha256:failed",
ImageName: "failed:latest",
Status: ScanStatusFailed,
ScanTime: now,
CriticalCount: 9,
TotalCount: 9,
},
{
ID: "sha256:zero",
ImageName: "zero:latest",
Status: ScanStatusCompleted,
ScanTime: now,
CriticalCount: 1,
},
}
for i := range records {
require.NoError(t, db.Create(&records[i]).Error)
}
items, err := svc.query.ListAllVulnerabilityImageOptions(ctx, "critical")
require.NoError(t, err)
require.Equal(t, []string{"sha256:critical-b", "zeta:latest"}, items)
}
func TestVulnerabilityService_ListAllVulnerabilityImageOptions_InvalidSeverityAndNoFilter(t *testing.T) {
ctx := t.Context()
db, settingsSvc := setupVulnerabilityScanTestDB(t)
svc := newTestService(t, db, settingsSvc, http.DefaultClient)
now := time.Now()
records := []VulnerabilityScanRecord{
{
ID: "sha256:one",
ImageName: "beta:latest",
Status: ScanStatusCompleted,
ScanTime: now,
HighCount: 1,
TotalCount: 1,
},
{
ID: "sha256:two",
Status: ScanStatusCompleted,
ScanTime: now,
MediumCount: 2,
TotalCount: 2,
},
{
ID: "sha256:three",
ImageName: "alpha:latest",
Status: ScanStatusCompleted,
ScanTime: now,
LowCount: 1,
TotalCount: 1,
},
}
for i := range records {
require.NoError(t, db.Create(&records[i]).Error)
}
invalid, err := svc.query.ListAllVulnerabilityImageOptions(ctx, "not-a-severity")
require.NoError(t, err)
require.Empty(t, invalid)
all, err := svc.query.ListAllVulnerabilityImageOptions(ctx, "")
require.NoError(t, err)
require.Equal(t, []string{"alpha:latest", "beta:latest", "sha256:two"}, all)
}
// TestVulnerabilityService_ActionableCountExcludingIgnored verifies the
// indexed-sum fast path and the blob-decode path for images with ignore rows
// produce the same count the old full-decode implementation did.
func TestVulnerabilityService_ActionableCountExcludingIgnored(t *testing.T) {
ctx := t.Context()
db, settingsSvc := setupVulnerabilityScanTestDB(t)
svc := newTestService(t, db, settingsSvc, http.DefaultClient)
now := time.Now()
vulnsA := []vulnerability.Vulnerability{
{
VulnerabilityID: "CVE-A1",
PkgName: "openssl",
InstalledVersion: "1.0.0",
Severity: vulnerability.SeverityCritical,
},
{
VulnerabilityID: "CVE-A2",
PkgName: "zlib",
InstalledVersion: "1.2.0",
Severity: vulnerability.SeverityCritical,
},
{
VulnerabilityID: "CVE-A3",
PkgName: "curl",
InstalledVersion: "8.0.0",
Severity: vulnerability.SeverityHigh,
},
{
VulnerabilityID: "CVE-A4",
PkgName: "bash",
InstalledVersion: "5.0.0",
Severity: vulnerability.SeverityMedium,
},
}
rawVulnsA, err := json.Marshal(vulnsA)
require.NoError(t, err)
vulnsB := []vulnerability.Vulnerability{
{
VulnerabilityID: "CVE-B1",
PkgName: "openssl",
InstalledVersion: "1.1.0",
Severity: vulnerability.SeverityCritical,
},
{
VulnerabilityID: "CVE-B2",
PkgName: "glibc",
InstalledVersion: "2.38",
Severity: vulnerability.SeverityHigh,
},
{
VulnerabilityID: "CVE-B3",
PkgName: "less",
InstalledVersion: "600",
Severity: vulnerability.SeverityMedium,
},
}
rawVulnsB, err := json.Marshal(vulnsB)
require.NoError(t, err)
records := []VulnerabilityScanRecord{
{
ID: "sha256:img-a",
ImageName: "nginx:latest",
Status: ScanStatusCompleted,
ScanTime: now,
CriticalCount: 2,
HighCount: 1,
MediumCount: 1,
TotalCount: 4,
Vulnerabilities: database.StringSlice{
string(
rawVulnsA,
),
},
},
{
ID: "sha256:img-b",
ImageName: "redis:7",
Status: ScanStatusCompleted,
ScanTime: now,
CriticalCount: 1,
HighCount: 1,
MediumCount: 1,
TotalCount: 3,
Vulnerabilities: database.StringSlice{
string(
rawVulnsB,
),
},
},
{
ID: "sha256:img-failed",
ImageName: "failed:latest",
Status: ScanStatusFailed,
ScanTime: now,
CriticalCount: 9,
HighCount: 9,
TotalCount: 18,
},
}
for i := range records {
require.NoError(t, db.Create(&records[i]).Error)
}
svc.BackfillScanItems(ctx)
// No ignores: pure indexed sum, no blob decode.
count, err := svc.ActionableCountExcludingIgnored(ctx)
require.NoError(t, err)
require.Equal(t, 5, count)
ignores := []VulnerabilityIgnore{
// Critical on img-b: removes one from the count.
{
ID: "ig-1",
EnvironmentID: "env-1",
ImageID: "sha256:img-b",
VulnerabilityID: "CVE-B1",
PkgName: "openssl",
InstalledVersion: "1.1.0",
CreatedBy: "tester",
},
// Medium on img-b: never counted, must not subtract anything.
{
ID: "ig-2",
EnvironmentID: "env-1",
ImageID: "sha256:img-b",
VulnerabilityID: "CVE-B3",
PkgName: "less",
InstalledVersion: "600",
CreatedBy: "tester",
},
// Stale ignore for a CVE no longer in img-b's blob: no effect.
{
ID: "ig-3",
EnvironmentID: "env-1",
ImageID: "sha256:img-b",
VulnerabilityID: "CVE-GONE",
PkgName: "old",
InstalledVersion: "0.1",
CreatedBy: "tester",
},
}
for i := range ignores {
require.NoError(t, db.Create(&ignores[i]).Error)
}
// img-a (3 via indexed sum) + img-b (high CVE-B2 only, via blob decode).
count, err = svc.ActionableCountExcludingIgnored(ctx)
require.NoError(t, err)
require.Equal(t, 4, count)
}
// TestVulnerabilityService_ListAllVulnerabilities_PagesAndCountsWithInlineFilters
// verifies the batched decode path preserves the old in-memory pipeline's
// pagination semantics: TotalItems reflects the search/filter matches,
// GrandTotalItems reflects every non-ignored CVE, and the page is sliced
// from the sorted matches.
func TestVulnerabilityService_ListAllVulnerabilities_PagesAndCountsWithInlineFilters(t *testing.T) {
ctx := t.Context()
db, settingsSvc := setupVulnerabilityScanTestDB(t)
svc := newTestService(t, db, settingsSvc, http.DefaultClient)
vulnsA := []vulnerability.Vulnerability{
{
VulnerabilityID: "CVE-A1",
PkgName: "openssl",
InstalledVersion: "1.0.0",
Severity: vulnerability.SeverityCritical,
},
{
VulnerabilityID: "CVE-A2",
PkgName: "zlib",
InstalledVersion: "1.2.0",
Severity: vulnerability.SeverityLow,
},
}
rawVulnsA, err := json.Marshal(vulnsA)
require.NoError(t, err)
vulnsB := []vulnerability.Vulnerability{
{
VulnerabilityID: "CVE-B1",
PkgName: "glibc",
InstalledVersion: "2.38",
Severity: vulnerability.SeverityHigh,
},
{
VulnerabilityID: "CVE-B2",
PkgName: "less",
InstalledVersion: "600",
Severity: vulnerability.SeverityMedium,
},
}
rawVulnsB, err := json.Marshal(vulnsB)
require.NoError(t, err)
now := time.Now()
records := []VulnerabilityScanRecord{
{
ID: "sha256:img-a",
ImageName: "nginx:latest",
Status: ScanStatusCompleted,
ScanTime: now,
CriticalCount: 1,
LowCount: 1,
TotalCount: 2,
Vulnerabilities: database.StringSlice{string(rawVulnsA)},
},
{
ID: "sha256:img-b",
ImageName: "redis:7",
Status: ScanStatusCompleted,
ScanTime: now,
HighCount: 1,
MediumCount: 1,
TotalCount: 2,
Vulnerabilities: database.StringSlice{string(rawVulnsB)},
},
}
for i := range records {
require.NoError(t, db.Create(&records[i]).Error)
}
svc.BackfillScanItems(ctx)
// Ignore the medium CVE on img-b: it must vanish from GrandTotalItems.
require.NoError(t, db.Create(&VulnerabilityIgnore{
ID: "ig-1",
EnvironmentID: "env-1",
ImageID: "sha256:img-b",
VulnerabilityID: "CVE-B2",
PkgName: "less",
InstalledVersion: "600",
CreatedBy: "tester",
}).Error)
// Severity filter critical,high with page size 1, sorted by severity desc:
// matches are CVE-A1 (critical) and CVE-B1 (high); the first page holds
// the critical one.
items, page, err := svc.query.ListAllVulnerabilities(ctx, "env-1", pagination.QueryParams{
Limit: 1,
Sort: "severity",
Order: pagination.SortDesc,
Filters: map[string]string{"severity": "critical,high"},
})
require.NoError(t, err)
require.Len(t, items, 1)
require.Equal(t, "CVE-A1", items[0].VulnerabilityID)
require.EqualValues(t, 2, page.TotalItems)
require.EqualValues(t, 3, page.GrandTotalItems)
// Search matches per-CVE fields decoded from the blobs.
items, page, err = svc.query.ListAllVulnerabilities(ctx, "env-1", pagination.QueryParams{
Limit: 20,
Search: "glibc",
})
require.NoError(t, err)
require.Len(t, items, 1)
require.Equal(t, "CVE-B1", items[0].VulnerabilityID)
require.EqualValues(t, 1, page.TotalItems)
require.EqualValues(t, 3, page.GrandTotalItems)
}
func riskTestService(t *testing.T, httpClient *http.Client) (*VulnerabilityService, *settings.SettingsService, *database.DB) {
t.Helper()
settingsSvc, db := featureSettings(t)
sqlDB, err := db.DB.DB()
require.NoError(t, err)
sqlDB.SetMaxOpenConns(1)
require.NoError(t, db.AutoMigrate(&VulnerabilityThreatIntel{}, &query.VulnerabilityRiskSnapshot{}, &kv.KVEntry{}))
svc := newTestService(t, db, settingsSvc, httpClient)
return svc, settingsSvc, db
}
func seedRiskScans(t *testing.T, svc *VulnerabilityService) {
t.Helper()
scans := []*vulnerability.ScanResult{
{
ImageID: "sha256:web",
ImageName: "web:latest",
Status: vulnerability.ScanStatusCompleted,
ScanTime: time.Now(),
Vulnerabilities: []vulnerability.Vulnerability{
{
VulnerabilityID: "CVE-2024-0001",
PkgName: "openssl",
InstalledVersion: "3.0.0",
FixedVersion: "3.0.1",
Severity: vulnerability.SeverityHigh,
CVSS: &vulnerability.CVSSInfo{V3Score: 7.5},
},
{
VulnerabilityID: "CVE-2024-0002",
PkgName: "curl",
InstalledVersion: "8.0.0",
Severity: vulnerability.SeverityMedium,
CVSS: &vulnerability.CVSSInfo{V3Score: 5.3},
},
{
VulnerabilityID: "CVE-2024-0003",
PkgName: "zlib",
InstalledVersion: "1.2.0",
Severity: vulnerability.SeverityCritical,
CVSS: &vulnerability.CVSSInfo{V3Score: 9.8},
},
},
},
{
ImageID: "sha256:db",
ImageName: "db:16",
Status: vulnerability.ScanStatusCompleted,
ScanTime: time.Now(),
Vulnerabilities: []vulnerability.Vulnerability{
{
VulnerabilityID: "CVE-2024-0002",
PkgName: "curl",
InstalledVersion: "8.0.0",
FixedVersion: "8.1.0",
Severity: vulnerability.SeverityMedium,
CVSS: &vulnerability.CVSSInfo{V3Score: 5.3},
},
{
VulnerabilityID: "GHSA-xxxx",
PkgName: "lodash",
InstalledVersion: "4.0.0",
Severity: vulnerability.SeverityLow,
},
},
},
{
ImageID: "sha256:clean",
ImageName: "clean:1",
Status: vulnerability.ScanStatusCompleted,
ScanTime: time.Now(),
},
{
ImageID: "sha256:broken",
ImageName: "broken:1",
Status: vulnerability.ScanStatusFailed,
ScanTime: time.Now(),
Error: "scanner exploded",
},
}
for _, scan := range scans {
require.NoError(t, svc.store.SaveResult(t.Context(), scan))
}
}
func TestVulnerabilityService_GetRiskOverview(t *testing.T) {
svc, _, db := riskTestService(t, nil)
seedRiskScans(t, svc)
require.NoError(t, db.Create(&VulnerabilityThreatIntel{
CVEID: "CVE-2024-0002",
KnownExploited: true,
KEVRansomware: true,
KEVDueDate: "2024-06-01",
}).Error)
require.NoError(t, db.Create(&VulnerabilityIgnore{
ID: "ignore-1",
EnvironmentID: "0",
ImageID: "sha256:web",
VulnerabilityID: "CVE-2024-0003",
PkgName: "zlib",
InstalledVersion: "1.2.0",
}).Error)
overview, err := svc.query.GetRiskOverview(t.Context(), "0")
require.NoError(t, err)
require.Equal(t, 4, overview.Summary.Total, "ignored finding is excluded")
require.Zero(t, overview.Summary.Critical)
require.Equal(t, 4, overview.Drivers.Findings)
require.Equal(t, 2, overview.Drivers.Fixable)
require.Equal(t, 1, overview.Drivers.KnownExploited)
require.Equal(t, 1, overview.Drivers.OverdueKnownExploited, "KEV due date has passed")
require.Equal(t, vulnerability.RiskExposureBreakdown{Unknown: 4}, overview.Exposure, "no daemon means unknown exposure")
require.Equal(t, 3, overview.Drivers.ImagesScanned, "the failed scan is not a scanned image")
require.Equal(t, 3, overview.Drivers.ScoredImages, "the clean image is scored at zero")
require.True(t, overview.ThreatIntel.Enabled)
require.True(t, overview.ThreatIntel.Stale)
// The highlighted fix is the highest-priority fixable occurrence: the KEV in db:16, not the unfixable copy in web.
require.NotNil(t, overview.ScoreDriver)
require.Equal(
t,
vulnerability.RiskScoreDriver{
VulnerabilityID: "CVE-2024-0002",
ImageName: "db:16",
PkgName: "curl",
FixedVersion: "8.1.0",
Exposure: vulnerability.ImageExposureUnknown,
KnownExploited: true,
Risk: 10,
},
*overview.ScoreDriver,
)
require.Len(t, overview.RiskiestFindings, 3, "findings are deduplicated by CVE")
kev := overview.RiskiestFindings[0]
require.Equal(t, "CVE-2024-0002", kev.VulnerabilityID)
require.True(t, kev.KnownExploited)
require.True(t, kev.Ransomware)
require.Equal(t, 2, kev.ImagesAffected)
require.Equal(t, "8.1.0", kev.FixedVersion)
require.InDelta(t, 5.3, kev.CVSS, 0.001, "CVSS comes from the stored cvss_score column")
require.InDelta(t, 10, kev.Risk, 0.001, "known exploited takes the maximum priority")
require.Equal(t, "CVE-2024-0001", overview.RiskiestFindings[1].VulnerabilityID)
require.InDelta(t, 5.3, overview.RiskiestFindings[1].Risk, 0.001, "no threat data discounts the priority")
require.Equal(t, "GHSA-xxxx", overview.RiskiestFindings[2].VulnerabilityID)
require.Len(t, overview.PrevalentFindings, 3)
require.Equal(t, "CVE-2024-0002", overview.PrevalentFindings[0].VulnerabilityID, "the only CVE in two images leads by prevalence")
// The images average to 36 with clean at zero, but db's running KEV keeps the environment at the High floor.
require.Equal(t, 70, overview.RiskScore)
require.Equal(t, vulnerability.RiskBandHigh, overview.RiskBand)
require.Equal(t, vulnerability.ScoreStatusComplete, overview.ScoreStatus, "unknown usage and missing threat data do not withhold the score")
require.Len(t, overview.RiskiestImages, 2)
require.Equal(t, "db:16", overview.RiskiestImages[0].ImageName)
require.Equal(t, 70, overview.RiskiestImages[0].RiskScore)
require.Equal(t, vulnerability.ScoreStatusComplete, overview.RiskiestImages[0].ScoreStatus)
require.Equal(t, "web:latest", overview.RiskiestImages[1].ImageName)
require.Equal(t, 37, overview.RiskiestImages[1].RiskScore, "the unfixable CVE-2024-0002 in web does not enter its score")
require.Len(t, overview.Trend, 1)
require.Nil(t, overview.Delta7d)
}
func TestVulnerabilityService_GetRiskOverview_ImageScoreMatchesInsights(t *testing.T) {
svc, _, db := riskTestService(t, nil)
seedRiskScans(t, svc)
require.NoError(t, db.Create(&VulnerabilityThreatIntel{CVEID: "CVE-2024-0001", EPSSScore: new(0.25)}).Error)
overview, err := svc.query.GetRiskOverview(t.Context(), "0")
require.NoError(t, err)
scan, err := svc.query.GetScanResult(t.Context(), "0", "sha256:web")
require.NoError(t, err)
require.NotNil(t, scan.Insights)
var ranked *vulnerability.RiskImage
for i := range overview.RiskiestImages {
if overview.RiskiestImages[i].ImageID == "sha256:web" {
ranked = &overview.RiskiestImages[i]
}
}
require.NotNil(t, ranked)
require.Equal(t, scan.Insights.RiskScore, ranked.RiskScore)
require.Equal(t, scan.Insights.ScoreStatus, ranked.ScoreStatus)
}
func TestVulnerabilityService_RecordRiskSnapshot(t *testing.T) {
svc, _, db := riskTestService(t, nil)
seedRiskScans(t, svc)
now := time.Now().UTC()
require.NoError(t, db.Create(&[]query.VulnerabilityRiskSnapshot{
{
SnapshotDate: now.AddDate(0, 0, -500).Format(time.DateOnly),
ScoringVersion: vuln.ScoringVersion,
RiskScore: 10,
RiskBand: "low",
},
{
SnapshotDate: now.AddDate(0, 0, -7).Format(time.DateOnly),
ScoringVersion: vuln.ScoringVersion,
RiskScore: 60,
RiskBand: "medium",
KnownExploitedCount: 3,
},
{
SnapshotDate: now.AddDate(0, 0, -3).Format(time.DateOnly),
ScoringVersion: 1,
RiskScore: 95,
RiskBand: "critical",
},
}).Error)
require.NoError(t, svc.RecordRiskSnapshot(t.Context()))
require.NoError(t, svc.RecordRiskSnapshot(t.Context()))
var snapshots []query.VulnerabilityRiskSnapshot
require.NoError(t, db.Order("snapshot_date").Find(&snapshots).Error)
require.Len(t, snapshots, 3, "old snapshot pruned and same-day runs upserted")
today := snapshots[2]
require.Equal(t, now.Format(time.DateOnly), today.SnapshotDate)
require.Equal(t, vuln.ScoringVersion, today.ScoringVersion)
require.Equal(t, 5, today.FindingsCount)
require.Equal(t, 3, today.ScoredImages)
overview, err := svc.query.GetRiskOverview(t.Context(), "0")
require.NoError(t, err)
require.Len(t, overview.Trend, 2, "the older scoring version stays out of the trend")
require.Equal(t, now.Format(time.DateOnly), overview.Trend[1].Date)
require.NotNil(t, overview.Delta7d)
require.Equal(t, overview.RiskScore-60, *overview.Delta7d)
require.NotNil(t, overview.Drivers7dAgo)
require.Equal(t, 3, overview.Drivers7dAgo.KnownExploited)
}
// seedBulkIgnoreFixture stores nginx with 45 findings (more than one page) and redis with three findings covering every filter dimension.
type roundTripFunc func(*http.Request) (*http.Response, error)
func (f roundTripFunc) RoundTrip(r *http.Request) (*http.Response, error) {
return f(r)
}
func TestVulnerabilityService_SyncThreatIntel(t *testing.T) {
var kevRequests, epssRequests atomic.Int32
requestedGHSA := atomic.Bool{}
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
switch r.URL.Path {
case "/sites/default/files/feeds/known_exploited_vulnerabilities.json":
kevRequests.Add(1)
_, err := w.Write([]byte(`{"vulnerabilities":[{"cveID":"CVE-2024-0001","dateAdded":"2024-01-02","dueDate":"2024-01-23","knownRansomwareCampaignUse":"Known"}]}`))
if !assert.NoError(t, err) {
return
}
case "/data/v1/epss":
epssRequests.Add(1)
ids := strings.Split(r.URL.Query().Get("cve"), ",")
if !assert.LessOrEqual(t, len(ids), 100) {
return
}
data := make([]map[string]string, 0, len(ids))
for _, id := range ids {
if strings.HasPrefix(id, "GHSA") {
requestedGHSA.Store(true)
}
if strings.HasSuffix(id, "9") {
continue
}
data = append(data, map[string]string{"cve": id, "epss": "0.25", "percentile": "0.9"})
}
raw, err := json.Marshal(map[string]any{"data": data})
if !assert.NoError(t, err) {
return
}
_, err = w.Write(raw)
if !assert.NoError(t, err) {
return
}
default:
w.WriteHeader(http.StatusNotFound)
}
}))
t.Cleanup(srv.Close)
srvURL, err := url.Parse(srv.URL)
require.NoError(t, err)
httpClient := &http.Client{Transport: roundTripFunc(func(r *http.Request) (*http.Response, error) {
r = r.Clone(r.Context())
r.URL.Scheme, r.URL.Host = srvURL.Scheme, srvURL.Host
return srv.Client().Transport.RoundTrip(r)
})}
svc, settingsSvc, db := riskTestService(t, httpClient)
vulns := make([]vulnerability.Vulnerability, 0, 151)
for i := range 150 {
vulns = append(vulns, vulnerability.Vulnerability{
VulnerabilityID: fmt.Sprintf("CVE-2024-%04d", i),
PkgName: "pkg",
Severity: vulnerability.SeverityMedium,
})
}
vulns = append(vulns, vulnerability.Vulnerability{
VulnerabilityID: "GHSA-abcd",
PkgName: "pkg",
Severity: vulnerability.SeverityLow,
})
require.NoError(
t,
svc.store.SaveResult(
t.Context(),
&vulnerability.ScanResult{
ImageID: "sha256:big",
ImageName: "big:1",
Status: vulnerability.ScanStatusCompleted,
ScanTime: time.Now(),
Vulnerabilities: vulns,
},
),
)
require.NoError(t, db.Create(&VulnerabilityThreatIntel{
CVEID: "CVE-2019-DELISTED",
KnownExploited: true,
KEVDueDate: "2020-01-01",
}).Error)
require.NoError(t, svc.SyncThreatIntel(t.Context(), false))
require.EqualValues(t, 1, kevRequests.Load())
require.GreaterOrEqual(t, epssRequests.Load(), int32(2))
require.False(t, requestedGHSA.Load())
var kev VulnerabilityThreatIntel
require.NoError(t, db.First(&kev, "cve_id = ?", "CVE-2024-0001").Error)
require.True(t, kev.KnownExploited, "EPSS upsert keeps KEV columns")
require.True(t, kev.KEVRansomware)
require.NotNil(t, kev.EPSSScore)
require.InDelta(t, 0.25, *kev.EPSSScore, 0.0001)
var missing VulnerabilityThreatIntel
require.NoError(t, db.First(&missing, "cve_id = ?", "CVE-2024-0009").Error)
require.Nil(t, missing.EPSSScore)
require.NotNil(t, missing.EPSSCheckedAt, "CVEs missing from EPSS are marked checked")
var delisted int64
require.NoError(t, db.Model(&VulnerabilityThreatIntel{}).Where("cve_id = ?", "CVE-2019-DELISTED").Count(&delisted).Error)
require.Zero(t, delisted, "delisted KEV entries without findings are pruned")
require.NoError(t, svc.SyncThreatIntel(t.Context(), false))
require.EqualValues(t, 1, kevRequests.Load(), "recent sync is skipped unless forced")
require.NoError(t, settingsSvc.SetBoolSetting(t.Context(), "vulnerabilityThreatIntelEnabled", false))
require.NoError(t, svc.SyncThreatIntel(t.Context(), true))
require.EqualValues(t, 1, kevRequests.Load(), "disabled intel makes no requests")
}
func seedBulkIgnoreFixture(t *testing.T, db *database.DB, svc *VulnerabilityService) {
t.Helper()
nginx := make([]vulnerability.Vulnerability, 0, 45)
for i := range 45 {
severity := kit.Ternary(i%3 == 0, vulnerability.SeverityHigh, vulnerability.SeverityLow)
fixed := kit.Ternary(i%2 == 0, "2.0.0", "")
nginx = append(
nginx,
vulnerability.Vulnerability{
VulnerabilityID: fmt.Sprintf(
"CVE-N-%03d",
i,
),
PkgName: "libnginx",
InstalledVersion: "1.0.0",
FixedVersion: fixed,
Severity: severity,
Title: "nginx finding",
},
)
}
redis := []vulnerability.Vulnerability{
{
VulnerabilityID: "CVE-R-1",
PkgName: "openssl",
InstalledVersion: "3.0.0",
FixedVersion: "3.0.1",
Severity: vulnerability.SeverityCritical,
Title: "openssl overflow",
},
{
VulnerabilityID: "CVE-R-2",
PkgName: "zlib",
InstalledVersion: "1.2.0",
Severity: vulnerability.SeverityMedium,
Title: "zlib bug",
},
{
VulnerabilityID: "CVE-R-3",
PkgName: "curl",
InstalledVersion: "8.0.0",
FixedVersion: "8.0.1",
Severity: vulnerability.SeverityHigh,
Title: "curl issue",
},
}
for _, image := range []struct {
id, name string
vulns []vulnerability.Vulnerability
critical int
high int
}{
{"sha256:nginx", "nginx:latest", nginx, 0, 15},
{"sha256:redis", "redis:7", redis, 1, 1},
} {
raw, err := json.Marshal(image.vulns)
require.NoError(t, err)
require.NoError(t, db.Create(&VulnerabilityScanRecord{
ID: image.id, ImageName: image.name, Status: ScanStatusCompleted, ScanTime: time.Now(),
CriticalCount: image.critical, HighCount: image.high, TotalCount: len(image.vulns),
Vulnerabilities: database.StringSlice{string(raw)},
}).Error)
}
svc.BackfillScanItems(t.Context())
}
func activeCount(t *testing.T, svc *VulnerabilityService, envID string) int64 {
t.Helper()
_, page, err := svc.query.ListAllVulnerabilities(t.Context(), envID, pagination.QueryParams{Start: 0, Limit: 20})
require.NoError(t, err)
return page.TotalItems
}
func TestBulkIgnoreVulnerabilities_AllMatchingHonorsFilters(t *testing.T) {
ctx := t.Context()
for _, tc := range []struct {
name string
filters vulnerability.BulkVulnerabilityFilters
expected int
}{
{name: "no filters covers every page", expected: 48},
{
name: "severity",
filters: vulnerability.BulkVulnerabilityFilters{Severity: "critical,medium"},
expected: 2,
},
{
name: "image name",
filters: vulnerability.BulkVulnerabilityFilters{ImageName: "redis"},
expected: 3,
},
{
name: "fix available",
filters: vulnerability.BulkVulnerabilityFilters{FixAvailable: true},
expected: 25,
},
{
name: "search",
filters: vulnerability.BulkVulnerabilityFilters{Search: "openssl"},
expected: 1,
},
{
name: "combined",
filters: vulnerability.BulkVulnerabilityFilters{
Severity: "high",
ImageName: "nginx",
FixAvailable: true,
Search: "nginx finding",
},
expected: 8,
},
} {
t.Run(tc.name, func(t *testing.T) {
db, settingsSvc := setupVulnerabilityScanTestDB(t)
svc := newTestService(t, db, settingsSvc, http.DefaultClient)
seedBulkIgnoreFixture(t, db, svc)
before, err := svc.ActionableCountExcludingIgnored(ctx)
require.NoError(t, err)
require.Equal(t, 17, before)
affected, err := svc.ignores.BulkIgnoreVulnerabilities(ctx, "env-1", &tc.filters, "bob")
require.NoError(t, err)
require.Equal(t, tc.expected, affected)
require.EqualValues(t, 48-tc.expected, activeCount(t, svc, "env-1"))
require.EqualValues(t, 48, activeCount(t, svc, "env-2"), "other environments keep their own view")
var actionableIgnored int64
require.NoError(t, db.Model(&VulnerabilityIgnore{}).
Joins("JOIN vulnerability_scan_items ON vulnerability_scan_items.image_id = vulnerability_ignores.image_id "+
"AND vulnerability_scan_items.vulnerability_id = vulnerability_ignores.vulnerability_id AND "+
"vulnerability_scan_items.pkg_name = vulnerability_ignores.pkg_name AND "+
"vulnerability_scan_items.installed_version = vulnerability_ignores.installed_version",
).
Where("vulnerability_scan_items.severity IN ?", []string{"CRITICAL", "HIGH"}).
Count(&actionableIgnored).Error)
after, err := svc.ActionableCountExcludingIgnored(ctx)
require.NoError(t, err)
require.Equal(t, before-int(actionableIgnored), after)
// Repeating the request finds nothing left to ignore.
affected, err = svc.ignores.BulkIgnoreVulnerabilities(ctx, "env-1", &tc.filters, "bob")
require.NoError(t, err)
require.Zero(t, affected)
restored, err := svc.ignores.BulkUnignoreVulnerabilities(ctx, "env-1", &tc.filters)
require.NoError(t, err)
require.Equal(t, tc.expected, restored)
require.EqualValues(t, 48, activeCount(t, svc, "env-1"))
after, err = svc.ActionableCountExcludingIgnored(ctx)
require.NoError(t, err)
require.Equal(t, before, after)
})
}
}
func featureSettings(t *testing.T) (*settings.SettingsService, *database.DB) {
t.Helper()
gdb, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{})
require.NoError(t, err)
require.NoError(t, gdb.AutoMigrate(&settings.SettingVariable{}, &VulnerabilityScanRecord{}, &VulnerabilityScanItem{}, &VulnerabilityReportRecord{}, &VulnerabilityIgnore{}))
db := &database.DB{DB: gdb}
svc, err := settings.NewSettingsService(t.Context(), db, &config.Config{})
if err == nil {
t.Cleanup(func() { require.NoError(t, svc.Stop(context.WithoutCancel(t.Context()))) })
}
require.NoError(t, err)
return svc, db
}
func TestVulnerabilityFeatureDisabledRejectsScansAndRetainsReports(t *testing.T) {
settingsSvc, db := featureSettings(t)
svc := newTestService(t, db, settingsSvc, http.DefaultClient)
require.NoError(t, db.Create(&VulnerabilityScanRecord{
ID: "test-image",
ImageName: "test:latest",
Status: ScanStatusCompleted,
ScanTime: time.Now(),
}).Error)
require.NoError(t, db.Create(&VulnerabilityReportRecord{ImageID: "test-image", Data: "stored report"}).Error)
require.NoError(t, settingsSvc.SetBoolSetting(t.Context(), features.VulnerabilityManagementSettingKey, false))
_, err := svc.ScanImage(t.Context(), "0", "test-image", user.Actor{})
require.ErrorIs(t, err, common.ErrFeatureDisabled)
_, err = svc.scan.Targets(t.Context())
require.ErrorIs(t, err, common.ErrFeatureDisabled)
summaries, err := svc.GetScanSummariesByImageIDs(t.Context(), []string{"test-image"})
require.NoError(t, err)
require.Empty(t, summaries)
count, err := svc.ActionableCountExcludingIgnored(t.Context())
require.NoError(t, err)
require.Zero(t, count)
require.NoError(t, settingsSvc.SetBoolSetting(t.Context(), features.VulnerabilityManagementSettingKey, true))
summaries, err = svc.GetScanSummariesByImageIDs(t.Context(), []string{"test-image"})
require.NoError(t, err)
require.Contains(t, summaries, "test-image")
var report VulnerabilityReportRecord
require.NoError(t, db.First(&report, "image_id = ?", "test-image").Error)
require.Equal(t, "stored report", report.Data)
}
// newTestService wires a VulnerabilityService and its children over db.
func newTestService(t *testing.T, db *database.DB, settingsService *settings.SettingsService, httpClient *http.Client) *VulnerabilityService {
t.Helper()
dockerClient, err := client.New(client.WithHost("unix:///nonexistent/arcane-vulnerability-test.sock"), client.WithAPIVersion("1.41"))
require.NoError(t, err)
t.Cleanup(func() { require.NoError(t, dockerClient.Close()) })
cfg := &config.Config{}
return NewVulnerabilityService(
db,
cfg,
docker.NewDockerClientService(t.Context(), nil, nil, nil).WithClient(dockerClient),
event.NewEventService(db, cfg, nil),
settingsService,
notification.NewNotificationService(db, cfg, nil, nil, nil),
activity.NewActivityService(db, settingsService),
nil,
kv.NewKVService(db),
httpClient,
)
}
func TestScanWorkflowSkipsWhenFeatureDisabled(t *testing.T) {
settingsSvc, db := featureSettings(t)
require.NoError(t, db.AutoMigrate(&activity.Activity{}, &activity.ActivityMessage{}))
harness := flowtest.New(t, activity.NewActivityService(db, nil))
svc := newTestService(t, db, settingsSvc, http.DefaultClient)
require.NoError(t, svc.RegisterWorkflows(harness.Engine))
harness.Start(t)
flowtest.AssertDefinitions(t, harness)
require.NoError(t, settingsSvc.SetBoolSetting(t.Context(), features.VulnerabilityManagementSettingKey, false))
outcome, err := harness.Engine.Run(t.Context(), svc.ScanWorkflow(), nil, activitylib.StartRequest{}, nil)
require.NoError(t, err)
require.Equal(t, scheduler.Skipped, outcome.Status)
require.Len(t, outcome.Steps, 3)
}