Building 70 Projects ranging from beginner to advanced so anyone can — learn from, build upon, use as a reference, or even copy directly. Owned by my cybersecurity company đŸ‘‡
Go aicertificationcloud-engineeringcybercybersecuritycybersecurity-analystcybersecurity-certificationcybersecurity-certificationscybersecurity-educationcybersecurity-jobscybersecurity-portfoliocybersecurity-projectscybersecurity-toolsgrchackinglearningpentestingproject-repositoryprojetcspython
feat(monitor/collectors/cve): 2h CVE collector (NVD pull + EPSS enrichment per tick)
CarterPerez-dev5ad1ff8e1432
diff --git a/PROJECTS/advanced/monitor-the-situation-dashboard/backend/internal/collectors/cve/collector.go b/PROJECTS/advanced/monitor-the-situation-dashboard/backend/internal/collectors/cve/collector.gonew file mode 100644index 00000000..b90b2eb0--- /dev/null+++ b/PROJECTS/advanced/monitor-the-situation-dashboard/backend/internal/collectors/cve/collector.go@@ -0,0 +1,146 @@+// ©AngelaMos | 2026+// collector.go++package cve++import (+ "context"+ "encoding/json"+ "log/slog"+ "time"++ "github.com/carterperez-dev/monitor-the-situation/backend/internal/events"+)++const (+ Name = "cve"+ defaultCVEInterval = 2 * time.Hour+ defaultCVEWindow = 2 * time.Hour+)++type NVDFetcher interface {+ Fetch(ctx context.Context, start, end time.Time) (NVDResponse, error)+}++type EPSSFetcher interface {+ LookupBatch(ctx context.Context, cveIDs []string) (map[string]EPSSScore, error)+}++type Repository interface {+ Upsert(ctx context.Context, row Row) error+ UpdateEPSS(ctx context.Context, cveID string, score, percentile float64) error+}++type Emitter interface {+ Emit(ev events.Event)+}++type StateRecorder interface {+ RecordSuccess(ctx context.Context, name string, eventCount int64) error+ RecordError(ctx context.Context, name, errMsg string) error+}++type CollectorConfig struct {+ Interval time.Duration+ Window time.Duration+ NVD NVDFetcher+ EPSS EPSSFetcher+ Repo Repository+ Emitter Emitter+ State StateRecorder+ Logger *slog.Logger+}++type Collector struct {+ cfg CollectorConfig+ logger *slog.Logger+}++func NewCollector(cfg CollectorConfig) *Collector {+ if cfg.Interval <= 0 {+ cfg.Interval = defaultCVEInterval+ }+ if cfg.Window <= 0 {+ cfg.Window = defaultCVEWindow+ }+ if cfg.Logger == nil {+ cfg.Logger = slog.Default()+ }+ return &Collector{cfg: cfg, logger: cfg.Logger}+}++func (c *Collector) Name() string { return Name }++func (c *Collector) Run(ctx context.Context) error {+ ticker := time.NewTicker(c.cfg.Interval)+ defer ticker.Stop()++ c.tick(ctx)++ for {+ select {+ case <-ctx.Done():+ return ctx.Err()+ case <-ticker.C:+ c.tick(ctx)+ }+ }+}++func (c *Collector) tick(ctx context.Context) {+ end := time.Now().UTC()+ start := end.Add(-c.cfg.Window)++ resp, err := c.cfg.NVD.Fetch(ctx, start, end)+ if err != nil {+ c.logger.Warn("nvd fetch", "err", err)+ _ = c.cfg.State.RecordError(ctx, Name, err.Error())+ return+ }++ ids := make([]string, 0, len(resp.Vulnerabilities))+ rows := make([]Row, 0, len(resp.Vulnerabilities))+ for _, v := range resp.Vulnerabilities {+ score, severity := v.PrimarySeverity()+ raw, _ := json.Marshal(v)+ row := Row{+ CveID: v.CVE.ID,+ Published: v.CVE.Published.Time,+ LastModified: v.CVE.LastModified.Time,+ Severity: severity,+ CVSS: score,+ Payload: raw,+ }+ rows = append(rows, row)+ ids = append(ids, v.CVE.ID)+ }++ scores, err := c.cfg.EPSS.LookupBatch(ctx, ids)+ if err != nil {+ c.logger.Warn("epss lookup", "err", err)+ }++ emitted := int64(0)+ for _, row := range rows {+ if err := c.cfg.Repo.Upsert(ctx, row); err != nil {+ c.logger.Warn("upsert cve", "id", row.CveID, "err", err)+ continue+ }+ if s, ok := scores[row.CveID]; ok {+ if err := c.cfg.Repo.UpdateEPSS(ctx, row.CveID, s.Score, s.Percentile); err != nil {+ c.logger.Warn("update epss", "id", row.CveID, "err", err)+ }+ row.EPSSScore = &s.Score+ row.EPSSPercentile = &s.Percentile+ }+ body, _ := json.Marshal(row)+ c.cfg.Emitter.Emit(events.Event{+ Topic: events.TopicCVENew,+ Timestamp: end,+ Source: Name,+ Payload: json.RawMessage(body),+ })+ emitted+++ }+ _ = c.cfg.State.RecordSuccess(ctx, Name, emitted)+}diff --git a/PROJECTS/advanced/monitor-the-situation-dashboard/backend/internal/collectors/cve/collector_test.go b/PROJECTS/advanced/monitor-the-situation-dashboard/backend/internal/collectors/cve/collector_test.gonew file mode 100644index 00000000..d7eea8e1--- /dev/null+++ b/PROJECTS/advanced/monitor-the-situation-dashboard/backend/internal/collectors/cve/collector_test.go@@ -0,0 +1,172 @@+// ©AngelaMos | 2026+// collector_test.go++package cve_test++import (+ "context"+ "encoding/json"+ "sync"+ "testing"+ "time"++ "github.com/stretchr/testify/require"++ "github.com/carterperez-dev/monitor-the-situation/backend/internal/collectors/cve"+ "github.com/carterperez-dev/monitor-the-situation/backend/internal/events"+)++type stubNVD struct {+ resp cve.NVDResponse+ err error+}++func (s *stubNVD) Fetch(context.Context, time.Time, time.Time) (cve.NVDResponse, error) {+ return s.resp, s.err+}++type stubEPSS struct {+ scores map[string]cve.EPSSScore+ err error+}++func (s *stubEPSS) LookupBatch(context.Context, []string) (map[string]cve.EPSSScore, error) {+ return s.scores, s.err+}++type stubCVERepo struct {+ mu sync.Mutex+ upserts map[string]cve.Row+ patches map[string][2]float64+}++func newStubCVERepo() *stubCVERepo {+ return &stubCVERepo{+ upserts: map[string]cve.Row{},+ patches: map[string][2]float64{},+ }+}++func (r *stubCVERepo) Upsert(_ context.Context, row cve.Row) error {+ r.mu.Lock()+ defer r.mu.Unlock()+ r.upserts[row.CveID] = row+ return nil+}++func (r *stubCVERepo) UpdateEPSS(_ context.Context, id string, score, pct float64) error {+ r.mu.Lock()+ defer r.mu.Unlock()+ r.patches[id] = [2]float64{score, pct}+ return nil+}++func (r *stubCVERepo) Upserts() int {+ r.mu.Lock()+ defer r.mu.Unlock()+ return len(r.upserts)+}++func (r *stubCVERepo) Patches() int {+ r.mu.Lock()+ defer r.mu.Unlock()+ return len(r.patches)+}++type stubCVEEmitter struct {+ mu sync.Mutex+ events []events.Event+}++func (e *stubCVEEmitter) Emit(ev events.Event) {+ e.mu.Lock()+ defer e.mu.Unlock()+ e.events = append(e.events, ev)+}++func (e *stubCVEEmitter) Events() []events.Event {+ e.mu.Lock()+ defer e.mu.Unlock()+ out := make([]events.Event, len(e.events))+ copy(out, e.events)+ return out+}++type stubCVEState struct{}++func (stubCVEState) RecordSuccess(context.Context, string, int64) error { return nil }+func (stubCVEState) RecordError(context.Context, string, string) error { return nil }++func TestCVECollector_FetchesEnrichesAndEmits(t *testing.T) {+ now := time.Now().UTC()+ nvd := &stubNVD{resp: cve.NVDResponse{+ Vulnerabilities: []cve.NVDVulnRoot{+ {CVE: cve.NVDCVE{+ ID: "CVE-2026-0001", Published: cve.NVDTime{Time: now.Add(-time.Hour)},+ LastModified: cve.NVDTime{Time: now},+ Metrics: cve.NVDMetrics{CVSSv31: []cve.NVDMetricEntry{+ {CVSSData: cve.NVDCVSSData{BaseScore: 9.8, BaseSeverity: "CRITICAL"}},+ }},+ }},+ {CVE: cve.NVDCVE{+ ID: "CVE-2026-0002", Published: cve.NVDTime{Time: now.Add(-time.Hour)},+ LastModified: cve.NVDTime{Time: now},+ }},+ },+ }}+ epss := &stubEPSS{scores: map[string]cve.EPSSScore{+ "CVE-2026-0001": {CveID: "CVE-2026-0001", Score: 0.9, Percentile: 0.99},+ "CVE-2026-0002": {CveID: "CVE-2026-0002", Score: 0.1, Percentile: 0.5},+ }}+ repo := newStubCVERepo()+ emt := &stubCVEEmitter{}++ c := cve.NewCollector(cve.CollectorConfig{+ Interval: 30 * time.Millisecond,+ NVD: nvd,+ EPSS: epss,+ Repo: repo,+ Emitter: emt,+ State: stubCVEState{},+ })++ ctx, cancel := context.WithTimeout(context.Background(), 50*time.Millisecond)+ defer cancel()+ _ = c.Run(ctx)++ require.GreaterOrEqual(t, repo.Upserts(), 2)+ require.GreaterOrEqual(t, repo.Patches(), 2)++ evs := emt.Events()+ require.GreaterOrEqual(t, len(evs), 2)+ for _, ev := range evs {+ require.Equal(t, events.TopicCVENew, ev.Topic)+ require.Equal(t, cve.Name, ev.Source)+ raw, ok := ev.Payload.(json.RawMessage)+ require.True(t, ok)+ require.Contains(t, string(raw), "CVE-2026-")+ }+}++func TestCVECollector_NVDFetchErrorRecordsState(t *testing.T) {+ nvd := &stubNVD{err: context.DeadlineExceeded}+ repo := newStubCVERepo()+ emt := &stubCVEEmitter{}++ c := cve.NewCollector(cve.CollectorConfig{+ Interval: 20 * time.Millisecond,+ NVD: nvd,+ EPSS: &stubEPSS{},+ Repo: repo,+ Emitter: emt,+ State: stubCVEState{},+ })++ ctx, cancel := context.WithTimeout(context.Background(), 30*time.Millisecond)+ defer cancel()+ _ = c.Run(ctx)++ require.Zero(t, repo.Upserts())+ require.Zero(t, repo.Patches())+ require.Zero(t, len(emt.Events()))+}