mirror of
https://github.com/lukaszraczylo/gohoarder.git
synced 2026-07-16 05:33:59 +00:00
feat: comprehensive audit + Tier 3 wiring (security/correctness/features)
Multi-agent audit + fix pass covering bugs, security, dead config wiring,
and missing features. All quality gates green: build/vet/test -race/govulncheck/
golangci-lint. Frontend tests 47/47.
SECURITY & CORRECTNESS
- Scanner pipeline fail-closed: cache.go scan timeout now 503 (was goto servePkg);
scanner.go all-scanners-fail saves ScanStatusError; CheckVulnerabilities blocks
on missing/error result instead of allowing.
- Scanner argv corrections: govulncheck source-mode + go.mod discovery;
npm-audit generates lockfile via npm install --package-lock-only --ignore-scripts;
pip-audit per-extension dispatch (wheel direct / sdist extract+pyproject).
- GHSA version-range filtering implemented (was always-include); url.QueryEscape
on package name.
- pypi SSRF closed via host allowlist on original_url; url.QueryEscape on
rewriteURL output.
- Path traversal: cache temp file uses os.CreateTemp; smb keyToPath sanitized;
filesystem keyToPath returns error + filepath.Abs prefix-verify.
- Goroutine leaks plugged: cache.cleanupWorker stop channel; auth.ValidationCache
Stop() with sync.Once; ws.unregister buffered with non-blocking send.
- WebSocket double-close panic fixed via sync.Once Client.closeSend().
- Race conditions: gormstore.registryCache sync.RWMutex (was concurrent map
panic); auth.LastUsedAt no longer mutated under RLock; analytics strict
lock-ordering invariant (statsMu before downloadsMu).
- Auth validator fails CLOSED on transport/unknown-status errors (was returning
true,err 'allow cache fallback').
- Credential cache hash full SHA256 (was 8-byte truncate; eliminates 2^32
collision risk).
- filesystem.fs.used incremented after successful rename (no quota inflation
race).
- gormstore aggregation events deleted in same tx as insert (no double-counting).
- gormstore.SavePackage uses Updates(map) so zero-value security flags
(RequiresAuth=false) can be cleared.
- partition_manager validates partition name regex before DROP TABLE.
- vcs/git: version regex validation rejects --option-injection; checkout uses
--detach -- separator; removed TrimPrefix(repo,'v') that corrupted vault/
vitess/vim-go.
- WebSocket CheckOrigin allowlist (was return true; CSWSH closed); same-origin
default + ServerConfig.AllowedOrigins.
- fiber CVE GO-2026-4543 patched (v2.52.10 -> v2.52.12).
FUNCTIONAL FEATURES
- API key DB persistence: APIKeyModel + migration 202604280002, full CRUD,
async LastUsedAt updates with WaitGroup-tracked goroutines drained on Close.
- Admin bootstrap via GOHOARDER_BOOTSTRAP_ADMIN_KEY env var; idempotent
(skipped when non-revoked admin already exists).
- Auth middleware factory in pkg/app: RequireAuth, RequireRole, RequirePermission,
OptionalAuth. Mounted on proxy + read APIs when Auth.Enabled=true.
DELETE /api/packages/* requires admin role. /health public for k8s probes.
- NFS storage backend: pkg/storage/nfs wraps filesystem with /proc/mounts
detection (Linux), post-write fsync, read-after-write health probe.
- WebSocket real-time pipeline: pkg/events Broadcaster interface; cache + scanner
managers emit EventPackageCached / EventPackageDownloaded / EventScanComplete;
app.go runs 30s EventStatsUpdate ticker. Frontend has full WS client (reconnect
with exponential backoff 1s->30s, 25s heartbeat, subscriber pattern), Pinia
realtime store, Dashboard live indicator + activity feed + reactive stats
override.
- TLS termination: fiber.ListenTLS when Server.TLS.Enabled.
- Pre-warming: Prewarming.Enabled flag wired (was hardcoded false); Interval,
MaxConcurrent, TopPackages plumbed.
- NetworkConfig wired (timeouts, retry, rate-limit, circuit-breaker).
- AuthConfig.BcryptCost wired.
- Security.Scanners.Static.MaxPackageSize plumbed to cache.io.LimitReader.
- Handlers.{Go,NPM,PyPI}.Enabled gates route mounting.
- Graceful shutdown: authManager.Close drains async writes.
LINT/HYGIENE
- 80 golangci-lint issues resolved: errcheck (Close/Write/RemoveAll wrapped),
gofmt, gosec G104/G306, govet shadow renames + fieldalignment reorders,
staticcheck ST1000 pkg comments + QF1003 tagged switches + QF1008 embedded
field selectors + QF1001 De Morgan's law.
BEHAVIOR CHANGES
- Scanner now fail-closed: deployments without scanner binaries
(trivy/govulncheck/npm-audit/pip-audit/grype) BLOCK packages instead of
serving unscanned. Add binaries or plan a future allow-on-scan-error flag.
- WS origin defaults to same-origin; cross-origin dashboards must set
server.allowed_origins.
- Validator no longer fails open; private packages won't serve from cache when
validation can't be performed.
- download_events retention dropped from 24h to ~5min (deleted in agg tx).
Migration 202604280001 purges pre-upgrade events.
- DELETE /api/packages/* requires admin role when auth enabled.
NEW PACKAGES
- pkg/events - Broadcaster interface
- pkg/storage/nfs - NFS-aware filesystem wrapper
DEFERRED (out of scope this pass)
- Static scanner implementation (config defines AllowedLicenses/MaxPackageSize/
BlockSuspicious but pkg/scanner/static/ does not exist).
- AuthConfig.AuditLog wiring (no audit log infra yet).
- CacheConfig.TTLOverrides passthrough (would touch cache.Config beyond
integrator scope).
This commit is contained in:
+198
-11
@@ -1,3 +1,5 @@
|
||||
// Package ghsa implements a vulnerability scanner backed by the GitHub
|
||||
// Security Advisory Database.
|
||||
package ghsa
|
||||
|
||||
import (
|
||||
@@ -6,6 +8,8 @@ import (
|
||||
"fmt"
|
||||
"io"
|
||||
"net/http"
|
||||
"net/url"
|
||||
"strconv"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
@@ -105,7 +109,7 @@ func (s *Scanner) Health(ctx context.Context) error {
|
||||
if err != nil {
|
||||
return fmt.Errorf("github advisory database not accessible: %w", err)
|
||||
}
|
||||
defer resp.Body.Close() // #nosec G104 -- Cleanup, error not critical
|
||||
defer func() { _ = resp.Body.Close() }() // #nosec G104 -- Cleanup, error not critical
|
||||
|
||||
// Accept any 2xx or 403 (rate limit) as healthy
|
||||
// Rate limits are expected without a GitHub token and shouldn't fail health checks
|
||||
@@ -136,9 +140,13 @@ func (s *Scanner) mapRegistryToEcosystem(registry string) string {
|
||||
|
||||
// queryAdvisories queries GitHub Advisory Database for a package
|
||||
func (s *Scanner) queryAdvisories(ctx context.Context, ecosystem, packageName string) ([]GHSAAdvisory, error) {
|
||||
url := fmt.Sprintf("https://api.github.com/advisories?ecosystem=%s&affects=%s&per_page=100", ecosystem, packageName)
|
||||
endpoint := fmt.Sprintf(
|
||||
"https://api.github.com/advisories?ecosystem=%s&affects=%s&per_page=100",
|
||||
url.QueryEscape(ecosystem),
|
||||
url.QueryEscape(packageName),
|
||||
)
|
||||
|
||||
req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
|
||||
req, err := http.NewRequestWithContext(ctx, "GET", endpoint, nil)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to create request: %w", err)
|
||||
}
|
||||
@@ -152,7 +160,7 @@ func (s *Scanner) queryAdvisories(ctx context.Context, ecosystem, packageName st
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to query advisories: %w", err)
|
||||
}
|
||||
defer resp.Body.Close() // #nosec G104 -- Cleanup, error not critical
|
||||
defer func() { _ = resp.Body.Close() }() // #nosec G104 -- Cleanup, error not critical
|
||||
|
||||
if resp.StatusCode != http.StatusOK {
|
||||
body, _ := io.ReadAll(resp.Body)
|
||||
@@ -167,15 +175,194 @@ func (s *Scanner) queryAdvisories(ctx context.Context, ecosystem, packageName st
|
||||
return advisories, nil
|
||||
}
|
||||
|
||||
// filterAffectedAdvisories filters advisories that affect the given version
|
||||
// filterAffectedAdvisories filters advisories that affect the given version.
|
||||
// Each advisory may have multiple GHSAVulnerability entries; if any of them
|
||||
// applies to our installed version (per its vulnerable_version_range), the
|
||||
// advisory is considered affecting.
|
||||
//
|
||||
// Fail-closed: if the version or any range cannot be parsed, the advisory is
|
||||
// included. We err on the side of reporting a possible vulnerability rather
|
||||
// than silently dropping it.
|
||||
func (s *Scanner) filterAffectedAdvisories(advisories []GHSAAdvisory, version string) []GHSAAdvisory {
|
||||
// Check if this version is affected
|
||||
// GitHub API already filters by package, but we need to check version ranges
|
||||
// For now, we'll include all advisories that match the package
|
||||
// A more sophisticated implementation would parse version ranges
|
||||
affected := append([]GHSAAdvisory(nil), advisories...)
|
||||
if version == "" {
|
||||
// Without a target version, conservatively include everything.
|
||||
return append([]GHSAAdvisory(nil), advisories...)
|
||||
}
|
||||
|
||||
return affected
|
||||
out := make([]GHSAAdvisory, 0, len(advisories))
|
||||
for _, adv := range advisories {
|
||||
if advisoryAffectsVersion(adv, version) {
|
||||
out = append(out, adv)
|
||||
}
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
// advisoryAffectsVersion reports whether the given installed version falls
|
||||
// within any of the advisory's vulnerable version ranges.
|
||||
func advisoryAffectsVersion(adv GHSAAdvisory, version string) bool {
|
||||
// If the advisory carries no per-vuln range info, conservatively include.
|
||||
if len(adv.Vulnerabilities) == 0 {
|
||||
return true
|
||||
}
|
||||
|
||||
for _, v := range adv.Vulnerabilities {
|
||||
rangeExpr := strings.TrimSpace(v.VulnerableVersions)
|
||||
if rangeExpr == "" {
|
||||
// No range — assume affected.
|
||||
return true
|
||||
}
|
||||
matched, ok := versionInRange(version, rangeExpr)
|
||||
if !ok {
|
||||
// Parse error → fail-closed: include.
|
||||
log.Debug().
|
||||
Str("ghsa_id", adv.GHSAID).
|
||||
Str("range", rangeExpr).
|
||||
Str("version", version).
|
||||
Msg("Could not parse GHSA vulnerable_version_range, including advisory")
|
||||
return true
|
||||
}
|
||||
if matched {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// versionInRange reports whether version satisfies expr. Returns (matched, ok)
|
||||
// where ok=false signals a parse error. Supported forms (comma separated AND):
|
||||
//
|
||||
// "= X"
|
||||
// "< X"
|
||||
// "<= X"
|
||||
// "> X"
|
||||
// ">= X"
|
||||
// ">= X, < Y"
|
||||
//
|
||||
// All clauses must be satisfied for the range to match.
|
||||
func versionInRange(version, expr string) (bool, bool) {
|
||||
clauses := strings.Split(expr, ",")
|
||||
for _, c := range clauses {
|
||||
c = strings.TrimSpace(c)
|
||||
if c == "" {
|
||||
continue
|
||||
}
|
||||
op, bound, ok := splitOpAndVersion(c)
|
||||
if !ok {
|
||||
return false, false
|
||||
}
|
||||
cmp, ok := compareVersions(version, bound)
|
||||
if !ok {
|
||||
return false, false
|
||||
}
|
||||
switch op {
|
||||
case "=", "==":
|
||||
if cmp != 0 {
|
||||
return false, true
|
||||
}
|
||||
case "<":
|
||||
if cmp >= 0 {
|
||||
return false, true
|
||||
}
|
||||
case "<=":
|
||||
if cmp > 0 {
|
||||
return false, true
|
||||
}
|
||||
case ">":
|
||||
if cmp <= 0 {
|
||||
return false, true
|
||||
}
|
||||
case ">=":
|
||||
if cmp < 0 {
|
||||
return false, true
|
||||
}
|
||||
default:
|
||||
return false, false
|
||||
}
|
||||
}
|
||||
return true, true
|
||||
}
|
||||
|
||||
// splitOpAndVersion parses "<op> <version>" pairs (e.g. ">= 1.2.3").
|
||||
func splitOpAndVersion(clause string) (op, ver string, ok bool) {
|
||||
clause = strings.TrimSpace(clause)
|
||||
// Longer operators first to avoid prefix shadowing.
|
||||
for _, candidate := range []string{">=", "<=", "==", "=", ">", "<"} {
|
||||
if strings.HasPrefix(clause, candidate) {
|
||||
rest := strings.TrimSpace(strings.TrimPrefix(clause, candidate))
|
||||
if rest == "" {
|
||||
return "", "", false
|
||||
}
|
||||
return candidate, rest, true
|
||||
}
|
||||
}
|
||||
return "", "", false
|
||||
}
|
||||
|
||||
// compareVersions compares two dot-separated version strings.
|
||||
// Returns (cmp, ok). Numeric segments are compared numerically.
|
||||
// A pre-release suffix (anything after '-' or '+') is treated as lower-priority
|
||||
// than the same version without one, matching common semver intuition for
|
||||
// the cases we expect from the GitHub Advisory Database.
|
||||
func compareVersions(a, b string) (int, bool) {
|
||||
aBase, aPre := splitPreRelease(a)
|
||||
bBase, bPre := splitPreRelease(b)
|
||||
|
||||
aParts := strings.Split(aBase, ".")
|
||||
bParts := strings.Split(bBase, ".")
|
||||
|
||||
n := len(aParts)
|
||||
if len(bParts) > n {
|
||||
n = len(bParts)
|
||||
}
|
||||
for i := 0; i < n; i++ {
|
||||
var av, bv int
|
||||
var err error
|
||||
if i < len(aParts) {
|
||||
av, err = strconv.Atoi(aParts[i])
|
||||
if err != nil {
|
||||
return 0, false
|
||||
}
|
||||
}
|
||||
if i < len(bParts) {
|
||||
bv, err = strconv.Atoi(bParts[i])
|
||||
if err != nil {
|
||||
return 0, false
|
||||
}
|
||||
}
|
||||
if av != bv {
|
||||
if av < bv {
|
||||
return -1, true
|
||||
}
|
||||
return 1, true
|
||||
}
|
||||
}
|
||||
|
||||
// Bases equal; compare pre-release. No pre-release > has pre-release.
|
||||
switch {
|
||||
case aPre == "" && bPre == "":
|
||||
return 0, true
|
||||
case aPre == "" && bPre != "":
|
||||
return 1, true
|
||||
case aPre != "" && bPre == "":
|
||||
return -1, true
|
||||
default:
|
||||
return strings.Compare(aPre, bPre), true
|
||||
}
|
||||
}
|
||||
|
||||
// splitPreRelease separates "1.2.3-rc1" into ("1.2.3", "rc1"). Build metadata
|
||||
// after '+' is stripped (per semver).
|
||||
func splitPreRelease(v string) (base, pre string) {
|
||||
v = strings.TrimSpace(v)
|
||||
v = strings.TrimPrefix(v, "v")
|
||||
if i := strings.Index(v, "+"); i >= 0 {
|
||||
v = v[:i]
|
||||
}
|
||||
if i := strings.Index(v, "-"); i >= 0 {
|
||||
return v[:i], v[i+1:]
|
||||
}
|
||||
return v, ""
|
||||
}
|
||||
|
||||
// emptyResult returns an empty scan result
|
||||
|
||||
@@ -0,0 +1,160 @@
|
||||
package ghsa
|
||||
|
||||
import (
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestVersionInRange(t *testing.T) {
|
||||
// matched: whether the version satisfies the range expression.
|
||||
// ok: whether the parser/comparator could evaluate the inputs.
|
||||
cases := []struct {
|
||||
name string
|
||||
version string
|
||||
expr string
|
||||
matched bool
|
||||
ok bool
|
||||
}{
|
||||
{"single LT match", "1.2.3", "< 2.0.0", true, true},
|
||||
{"single LT no match", "2.5.0", "< 2.0.0", false, true},
|
||||
{"single GTE match", "2.5.0", ">= 2.0.0", true, true},
|
||||
{"single GTE no match", "1.0.0", ">= 2.0.0", false, true},
|
||||
{"range hit", "1.5.0", ">= 1.0.0, < 2.0.0", true, true},
|
||||
{"range below", "0.9.0", ">= 1.0.0, < 2.0.0", false, true},
|
||||
{"range above", "2.0.0", ">= 1.0.0, < 2.0.0", false, true},
|
||||
{"range upper bound exclusive", "2.0.0", ">= 1.0.0, < 2.0.0", false, true},
|
||||
{"range lower bound inclusive", "1.0.0", ">= 1.0.0, < 2.0.0", true, true},
|
||||
{"equality match", "1.2.3", "= 1.2.3", true, true},
|
||||
{"equality miss", "1.2.4", "= 1.2.3", false, true},
|
||||
{"with v prefix on bound", "1.2.3", ">= v1.0.0", true, true},
|
||||
{"shorter version coerces", "1.0", ">= 1.0.0", true, true},
|
||||
{"pre-release lower than release", "1.0.0-rc1", ">= 1.0.0", false, true},
|
||||
{"pre-release greater than older", "1.0.0-rc1", ">= 0.9.0", true, true},
|
||||
{"malformed operator", "1.0.0", "~ 1.0.0", false, false},
|
||||
{"malformed version", "abc", ">= 1.0.0", false, false},
|
||||
{"empty bound after op", "1.0.0", ">=", false, false},
|
||||
}
|
||||
|
||||
for _, tc := range cases {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
matched, ok := versionInRange(tc.version, tc.expr)
|
||||
if matched != tc.matched || ok != tc.ok {
|
||||
t.Fatalf("versionInRange(%q, %q) = (%v, %v), want (%v, %v)",
|
||||
tc.version, tc.expr, matched, ok, tc.matched, tc.ok)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestAdvisoryAffectsVersion(t *testing.T) {
|
||||
cases := []struct {
|
||||
name string
|
||||
version string
|
||||
adv GHSAAdvisory
|
||||
want bool
|
||||
}{
|
||||
{
|
||||
name: "advisory with no vulnerabilities is conservatively included",
|
||||
adv: GHSAAdvisory{GHSAID: "GHSA-xxxx", Vulnerabilities: nil},
|
||||
version: "1.0.0",
|
||||
want: true,
|
||||
},
|
||||
{
|
||||
name: "matching range marks advisory as affecting",
|
||||
adv: GHSAAdvisory{
|
||||
GHSAID: "GHSA-aaaa",
|
||||
Vulnerabilities: []GHSAVulnerability{
|
||||
{VulnerableVersions: ">= 1.0.0, < 2.0.0"},
|
||||
},
|
||||
},
|
||||
version: "1.5.0",
|
||||
want: true,
|
||||
},
|
||||
{
|
||||
name: "non-matching range excludes advisory",
|
||||
adv: GHSAAdvisory{
|
||||
GHSAID: "GHSA-bbbb",
|
||||
Vulnerabilities: []GHSAVulnerability{
|
||||
{VulnerableVersions: ">= 2.0.0"},
|
||||
},
|
||||
},
|
||||
version: "1.0.0",
|
||||
want: false,
|
||||
},
|
||||
{
|
||||
name: "any matching range across multiple vulns is affecting",
|
||||
adv: GHSAAdvisory{
|
||||
GHSAID: "GHSA-cccc",
|
||||
Vulnerabilities: []GHSAVulnerability{
|
||||
{VulnerableVersions: "< 0.5.0"},
|
||||
{VulnerableVersions: ">= 1.0.0, < 1.2.0"},
|
||||
},
|
||||
},
|
||||
version: "1.1.0",
|
||||
want: true,
|
||||
},
|
||||
{
|
||||
name: "empty range falls back to affecting (fail-closed)",
|
||||
adv: GHSAAdvisory{
|
||||
GHSAID: "GHSA-dddd",
|
||||
Vulnerabilities: []GHSAVulnerability{{VulnerableVersions: ""}},
|
||||
},
|
||||
version: "1.0.0",
|
||||
want: true,
|
||||
},
|
||||
{
|
||||
name: "unparseable range falls back to affecting (fail-closed)",
|
||||
adv: GHSAAdvisory{
|
||||
GHSAID: "GHSA-eeee",
|
||||
Vulnerabilities: []GHSAVulnerability{{VulnerableVersions: "~> 1.0"}},
|
||||
},
|
||||
version: "1.0.0",
|
||||
want: true,
|
||||
},
|
||||
}
|
||||
|
||||
for _, tc := range cases {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
got := advisoryAffectsVersion(tc.adv, tc.version)
|
||||
if got != tc.want {
|
||||
t.Fatalf("advisoryAffectsVersion(%q) = %v, want %v",
|
||||
tc.version, got, tc.want)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestFilterAffectedAdvisoriesEmptyVersion(t *testing.T) {
|
||||
// Without a target version we can't compare ranges, so all advisories
|
||||
// are conservatively included.
|
||||
s := &Scanner{}
|
||||
in := []GHSAAdvisory{
|
||||
{GHSAID: "A", Vulnerabilities: []GHSAVulnerability{{VulnerableVersions: ">= 2.0.0"}}},
|
||||
{GHSAID: "B"},
|
||||
}
|
||||
out := s.filterAffectedAdvisories(in, "")
|
||||
if len(out) != len(in) {
|
||||
t.Fatalf("expected all advisories with empty version, got %d/%d", len(out), len(in))
|
||||
}
|
||||
}
|
||||
|
||||
func TestFilterAffectedAdvisoriesFiltersByRange(t *testing.T) {
|
||||
s := &Scanner{}
|
||||
in := []GHSAAdvisory{
|
||||
{ // matches
|
||||
GHSAID: "MATCH",
|
||||
Vulnerabilities: []GHSAVulnerability{
|
||||
{VulnerableVersions: ">= 1.0.0, < 2.0.0"},
|
||||
},
|
||||
},
|
||||
{ // does not match
|
||||
GHSAID: "MISS",
|
||||
Vulnerabilities: []GHSAVulnerability{
|
||||
{VulnerableVersions: ">= 3.0.0"},
|
||||
},
|
||||
},
|
||||
}
|
||||
out := s.filterAffectedAdvisories(in, "1.5.0")
|
||||
if len(out) != 1 || out[0].GHSAID != "MATCH" {
|
||||
t.Fatalf("expected only MATCH, got %+v", out)
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user