# Vulnerability Management

> Use this skill when implementing or operating a vulnerability management program — automated vulnerability scanning, risk-based prioritization (CVSS/EPSS), patch management automation, zero-day response procedures, CVE tracking and monitoring, vulnerability metrics tracking, remediation verification, security advisory monitoring, and threat intelligence integration.

- Skill: `jpeetz/vulnerability-management` (Agent Skill, multi-file: 7 files)
- Install (CLI): `npx get-skill add jpeetz/vulnerability-management`
- Raw SKILL.md: https://api.skillmd.com/api/skills/jpeetz/vulnerability-management/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Security
- License: MIT
- Author: JPeetz (https://skillmd.com/u/jpeetz)
- Updated: 2026-11-18
- Page: https://skillmd.com/skills/jpeetz/vulnerability-management

---


# Vulnerability Management

## Overview

Vulnerability management is a continuous loop, not a quarterly scan:
**discover → prioritize → remediate → verify → measure → improve**. Every step
must produce a durable artifact (a finding with an owner, a ticket, a patch, a
metric) or it did not happen.

The core discipline is triage economics. Scanners produce far more findings than
any team can fix, and most are never exploited. Spend remediation capacity on
the small set that is reachable, exploitable, and material to the business — then
prove the rest was consciously accepted.

## When to Use

- Standing up a vulnerability management program from scratch
- Designing or tuning a scanning strategy (internal, external, agent, DAST/SAST)
- Building a risk-based prioritization model for a noisy scanner backlog
- Automating patch deployment and remediation verification
- Handling an actively exploited vulnerability or zero-day
- Setting up CVE / vendor advisory monitoring and alerting
- Defining vulnerability SLAs, MTTR targets, or executive reporting
- Integrating scanner output with SIEM, SOAR, ticketing, or a vulnerability database
- Preparing audit evidence (PCI-DSS 11.3, SOC 2 CC7, ISO 27001 A.8.8)

## Program Structure

Six named components. If any is missing, the program degrades into "scan and
email a PDF."

| Component | Owner | Output | Cadence |
|---|---|---|---|
| Asset inventory | IT / Platform | Assets with owner, criticality, exposure | Continuous |
| Discovery & scanning | Security engineering | Findings with evidence | Daily–weekly |
| Prioritization | Security + asset owners | Ranked remediation queue | Per scan cycle |
| Remediation | Asset owners | Patches, config changes, controls | Per SLA |
| Verification | Security engineering | Re-scan evidence / closure record | Post-fix |
| Measurement | Program owner | Metrics, trends, exceptions | Monthly / quarterly |

**Inventory first.** Every asset needs a unique ID, an owning team (not an
individual), business criticality (Tier 1 revenue / Tier 2 internal / Tier 3
dev), exposure (internet, partner, internal, air-gapped), data classification,
OS and software versions, and last successful scan. Assets without an owner are
the largest single source of unpatched criticals — route them to a default owner
and escalate.

**Scope and exclusions.** Write down what is out of scope and why: medical
devices under vendor contracts, OT with change-control windows, end-of-life
systems awaiting decommission. Every exclusion needs an owner and an expiry date.

**SLAs.** Baseline thresholds; adjust for regulatory context (PCI-DSS requires
critical patches within 30 days):

| Severity | Internet-facing | Internal Tier 1 | Tier 2/3 |
|---|---|---|---|
| Critical (CVSS ≥ 9.0 or KEV) | 48–72 h | 7 days | 30 days |
| High (7.0–8.9) | 7 days | 30 days | 60 days |
| Medium (4.0–6.9) | 30 days | 90 days | 180 days |
| Low (0.1–3.9) | 90 days | 180 days | Best effort |

Overrides that beat the table: **KEV listing** → Critical regardless of CVSS;
**EPSS ≥ 0.10 with a reachable path** → bump one tier; **public exploit or active
exploitation** → emergency change; **documented compensating control** → may
extend, but only via an approved, time-boxed exception.

**Exceptions.** Each record holds finding ID, justification, compensating
control, risk owner, approval and expiry dates (max 90 days, renewable). Review
monthly; expired exceptions auto-reopen the finding.

## Scanning Strategy

No single scan type covers an environment. Combine them and de-duplicate.

### Authenticated (Credentialed)

Default for servers and workstations: the scanner logs in and reads installed
packages, registry, and configuration. Higher fidelity, fewer false positives
than network scanning.

- Use a least-privilege read-only scan account; store credentials in a secrets
  manager, never in scanner config
- Verify credentials work — a silently failing credentialed scan degrades to
  unauthenticated and quietly loses coverage
- Alert when a host's credentialed scan fails two cycles in a row

### Agent-Based

Preferred for roaming laptops, ephemeral cloud instances, and networks that
block inbound scan traffic.

- Continuous reporting enables near-real-time detection
- Watch agent health: offline agents are invisible assets
- Prevent non-admin users from disabling the agent
- Treat the agent as privileged software — patch and monitor it too

### Unauthenticated / Network

Port and service discovery, banner grabbing, TLS configuration. Use for asset
discovery and to see what an attacker sees. Expect false positives; treat
results as leads, not findings.

### External / Perimeter

Scan from the public internet against owned ranges and domains — this is what
regulators and attackers see.

- Confirm authorization (cloud provider approval, ISP notification, written scope)
- Maintain a live inventory of external IPs and DNS names; shadow-IT domains are
  the most common external exposure
- Weekly minimum, daily for Tier 1 internet-facing assets
- Include certificate expiry and weak-cipher checks

### DAST

Test running applications: OWASP ZAP, Burp, Nuclei. Run in CI against staging and
continuously against production with safe policies.

- Authenticate the scanner — most high-impact bugs live behind auth
- Avoid destructive payloads in production (no DELETE, no mass form submission)
- DAST output needs human confirmation; scanner "critical" often means "reflected
  parameter exists"

### SAST and SCA

- **SAST** (Semgrep, CodeQL, SonarQube): run per pull request; block only on
  high-confidence critical rules, or developers learn to ignore it
- **SCA** (Dependabot, Renovate, Trivy, Grype, OWASP Dependency-Check): required
  per build; emit an SBOM per release
- Feed SAST/SCA results into the same prioritization queue so owners see one
  list, not four dashboards

### Container and Cloud

- Scan images at build time and continuously in the registry; block deploys when
  a patched base image exists
- Scan running workloads for drift from the built image
- Cloud configuration findings (CSPM) belong in the same program — a public
  bucket is a vulnerability in business terms

### Scheduling

Daily for internet-facing and Tier 1; weekly for internal Tier 2; monthly for
Tier 3 and developer endpoints. Scan after major change windows and immediately
after patch deployment for verification. Stagger windows to avoid saturating
links or tripping IDS alarms during business hours.

## CVSS Scoring

CVSS produces a severity score, not a business priority. Know which vector you
are reading.

### Base (Intrinsic, Static)

- **Attack Vector (AV)**: Network / Adjacent / Local / Physical
- **Attack Complexity (AC)**: Low / High
- **Privileges Required (PR)**: None / Low / High
- **User Interaction (UI)**: None / Required
- **Scope (S)**: Unchanged / Changed
- **C/I/A impact**: High / Low / None

v3.1 and v4.0 differ in mechanics (v4.0 adds Attack Requirements and splits
subsequent-system impact) but the decision logic is the same. Prefer the version
the vendor published; do not re-score to make vendors comparable.

Bands: 0.0 None · 0.1–3.9 Low · 4.0–6.9 Medium · 7.0–8.9 High · 9.0–10.0 Critical.

### Temporal (Exploit Maturity)

- **Exploit Code Maturity (E)**: Unproven / PoC / Functional / High
- **Remediation Level (RL)**: Official Fix / Temporary / Workaround / Unavailable
- **Report Confidence (RC)**: Unknown / Reasonable / Confirmed

This is where most programs should spend their energy: a 9.8 with no exploit and
no reachable path matters less than a 6.5 with a working public exploit.

### Environmental (Your Context)

- **Modified base metrics**: is the component present and configured vulnerably?
- **C/I/A requirements (CR/IR/AR)**: how much does this asset matter?

Environmental scoring is manual, so apply it only to Tier 1 assets and to any
finding whose default severity would trigger an emergency change.

### Discipline

- Never average CVSS scores into a risk rating; use the maximum plus counts
- Record the vector string, not just the number — the number is unauditable alone
- Do not let a vendor's 10.0 drive an emergency response without checking
  reachability; do not dismiss a 5.3 that is internet-facing and pre-auth
- Legacy v2 scores still appear in feeds; map them coarsely and flag them rather
  than mixing them into v3/v4 statistics

## EPSS Prioritization

EPSS (FIRST.org) estimates the probability that a vulnerability is exploited in
the wild within 30 days: a score from 0 to 1 plus a percentile rank, derived
from observed exploitation rather than expert judgment.

- EPSS is a **triage input**, not a severity replacement. High EPSS on an
  unreachable asset is still not urgent; low EPSS on an internet-facing pre-auth
  RCE is still urgent, because EPSS is a population average.
- Practical composite: **CVSS ≥ 7.0 AND (EPSS ≥ 0.10 OR KEV)**. This captures
  most real-world exploited vulnerabilities while cutting queue volume sharply.
- Use the **percentile** in reporting ("top 5% of scored CVEs") and the raw score
  for thresholds.
- Refresh daily and re-rank the open backlog at least weekly.
- A brand-new CVE may have no score for hours — treat missing as unknown, not zero.

### Composite Priority Model

```
priority = severity_weight(CVSS band)
         + exposure_weight(internet +3 / partner +2 / internal +1)
         + exploit_weight(KEV +4 / EPSS ≥ 0.5 +3 / EPSS ≥ 0.1 +2 / public PoC +1)
         + criticality_weight(Tier 1 +3 / Tier 2 +1)
         - mitigating_control(compensating control in place -2)
```

Sort descending, apply SLAs by the resulting band, publish the formula so owners
can see why their item ranks where it does, and re-tune weights quarterly against
what actually got exploited in your environment.

**CISA KEV** is the curated list of CVEs with confirmed in-the-wild
exploitation. Small, high-signal, mandatory. Any KEV entry present in your
environment is an emergency. Ingest it as a daily feed diff, not a manual check.

## Patch Management Lifecycle

Patching is a supply-chain operation. Automate the middle stages; never skip the
last.

**1 — Assessment.** Identify affected assets by exact version, not product name.
Confirm the vulnerability is reachable in your configuration (a disabled module
is not exploitable). Read the advisory for prerequisites, regressions, and
required intermediate patches. Note whether a reboot, restart, or schema change
is needed. Record finding, asset, fix version, and window.

**2 — Testing.** Apply to a canary group (1–5% of fleet, one of each OS/role).
Run smoke tests and critical-path suites. Watch error rates, latency, and crashes
for 24–72 h. Check vendor known issues. Document the rollback procedure and
artifact before touching production.

**3 — Deployment.** Wave the rollout: canary → 10% → 50% → 100% with automated
health gates. Respect maintenance windows and freezes — a KEV critical overrides
a freeze with incident-commander approval. Prefer immutable replacement over
in-place patching in cloud; rollback becomes trivial. Where no patch exists,
deploy a compensating control (segmentation, WAF rule, feature disable) and
record it against the finding.

**4 — Verification.** Re-scan the specific asset and confirm the finding is
gone. Confirm the *running* version, not just the installed one — containers and
JVM apps often keep old artifacts. Close only with verification evidence
attached. If verification fails, reopen and escalate: a falsely closed finding
is worse than an open one.

### Automation Patterns

- **Dependabot / Renovate**: automated update PRs; auto-merge patch/minor with
  green CI, require review for majors
- **Ansible / Chef / Intune / Fleet**: scheduled OS patch runs with reboot
  orchestration and canary inventory groups
- **Container rebuild pipeline**: nightly base-image refresh → rebuild → scan →
  deploy; the only sustainable way to keep images patched
- **Idempotent remediation scripts**: safe to re-run, log to stdout, exit
  non-zero on failure so the orchestrator can gate
- Guardrails: rate-limit concurrent reboots, require approval for large
  production waves, always provide a kill switch

## Zero-Day Response Playbook

Triggered by a vulnerability with no vendor patch, credible reports of active
exploitation, and a plausible path to your assets.

**Phase 0 — Triage (first 2 h).** Confirm the report is real (vendor
acknowledgement, reputable research, KEV or CERT advisory) — premature and false
disclosure are common. Identify affected products/versions and whether you run
them. Assign one incident commander and one channel. Determine exposure:
internet-facing count, authenticated-only count, whether the component is enabled.

**Phase 1 — Contain (first 24 h).** Apply the highest-fidelity mitigation
available, in order: disable the vulnerable feature → network block/segmentation
→ WAF or IDS virtual patch → reduce service privilege. Increase logging and hunt
for prior compromise (zero-days are often exploited before disclosure). If
exploitation is confirmed, pivot to incident response: isolate, preserve
evidence, follow the IR plan.

**Phase 2 — Eradicate.** Deploy the vendor patch as soon as it exists, ahead of
normal change control, with an emergency change record. Without a patch, maintain
the control and set a review date. Rotate any credentials or keys that could have
been exposed. Verify with targeted scanning that the control holds.

**Phase 3 — Recover and learn.** Restore operations; remove temporary controls
only after the patch is verified. Write the timeline (detection, decision,
containment, patch). Add a permanent detection rule for the exploitation pattern.
Update the asset inventory with anything found during the hunt. Feed lessons into
scan policy, SLAs, and patch automation.

**Communication.** One authoritative channel; no written speculation. Executive
updates every 24 h while active, even if unchanged. Never publish exploit details
or internal exposure counts. Coordinate disclosure with the vendor.

## CVE Monitoring and Alerting

| Source | Signal | Latency |
|---|---|---|
| NVD | Canonical record, CVSS, CWE, CPE | Hours–days after CVE |
| CVE.org / MITRE | CVE assignment and description | At publication |
| CISA KEV | Confirmed exploitation | Same day |
| FIRST EPSS | Exploitation probability | Daily |
| Vendor advisories (MSRC, Red Hat, Cisco, Oracle, Atlassian, GitHub) | Patch availability, versions | At release |
| GHSA | Open-source package vulns | Often before NVD |
| OSV.dev | Multi-ecosystem package vulns | Near-real-time |
| oss-security, full-disclosure | Early warning, sometimes pre-CVE | Earliest |
| Exploit-DB, Metasploit modules | Weaponization signal | Post-disclosure |

**Pipeline:** ingest on a schedule (daily minimum; hourly for KEV and vendor
feeds) → normalize to a common schema (cve_id, products/CPEs, versions, CVSS
vector, EPSS, KEV flag, published date, references, patch availability) → match
against inventory by product + version range, not keyword → dedupe against
existing findings (update, don't duplicate) → score with the composite model →
notify the owning team with finding, fix, and deadline.

**Alert design.** Alert on match + severity, never on every published CVE.
Suppress products you do not run — the primary source of alert fatigue. Group by
asset owner so one team gets one digest. Include the action: patch version,
workaround, or "not affected". Page on-call for critical/KEV; everything else
goes to a ticket queue. Track alert-to-acknowledgement time.

**Advisory discipline.** Subscribe to vendor advisories for every product in
inventory and maintain that list at onboarding. Review advisories even without a
CVE — some vendors ship fixes silently. Watch end-of-life announcements: EOL
software generates unfixable findings forever and needs migration, not patching.

## Vulnerability Metrics

| Metric | Definition | Target signal |
|---|---|---|
| **MTTR** | Finding creation → verified closure | Down per severity band |
| **Remediation rate** | Closed / opened per period | ≥ 1.0 (backlog shrinking) |
| **Exposure window** | Median days critical/high open on internet-facing assets | Critical ≤ 3 days |
| **SLA compliance** | % closed within SLA | ≥ 90% critical, ≥ 80% high |
| **Backlog aging** | Open findings > 90 days by severity | Decreasing |
| **Scan coverage** | % of inventory scanned last cycle | ≥ 95% |
| **Reopen rate** | Closed findings that reopen | < 5% (higher = false closures) |
| **False positive rate** | Rejected findings / total | < 15% |
| **Risk-weighted backlog** | Sum of open priority scores | Decreasing |
| **KEV exposure** | KEV findings open, and their age | 0, always |

Cadence: **daily** new criticals/KEV, SLA breaches, scan failures; **weekly**
queue by owner, aging outliers, expiring exceptions; **monthly** MTTR trends,
SLA compliance, coverage, reopen rate, top recurring root causes; **quarterly**
posture trend, maturity, investment asks.

Anti-patterns: raw finding counts reward noisy scanners; averaged severity hides
the critical tail; MTTR alone can be gamed by early closure — pair with reopen
rate; "scans run" is activity, not outcome; cross-team MTTR comparison without
normalization is misleading.

## SIEM / SOAR Integration

**SIEM.** Forward findings and asset context so exploitation alerts can be
enriched with "this host has CVE-X open". Correlate EDR/IDS exploitation signals
with open findings to prioritize live incidents. Build detections for exploit
attempts against known-vulnerable services. Retain findings 1 year+ for audit.

**SOAR.** Automate ticket creation → owner routing → SLA timer. Auto-enrich with
CVSS vector, EPSS, KEV, asset criticality, known exploits. Auto-close only on
re-scan verification, never on a "done" comment. Auto-expire exceptions and
reopen findings. Automate containment for confirmed exploitation (isolate host,
disable account, block IOC) with approval gates on destructive actions. Keep
playbooks idempotent so retries don't duplicate tickets.

**Ticketing hygiene.** One ticket per finding-asset pair, not per scan. Include
CVE, asset, fix version, SLA deadline, verification command, rollback plan. Link
to the change record for audit traceability. Use a dedicated queue/component so
metrics are computable.

## Scripts

- `scripts/cve_lookup.py` — NVD lookup with CVSS vector, EPSS score, and KEV
  status; retries on NVD rate limits.
- `scripts/prioritize.py` — rank a JSON/CSV findings export with the composite
  model above and compute SLA due dates and overdue status.

Both are stdlib-only (Python 3.9+) and support `--help`. Pass an NVD API key via
`NVD_API_KEY`, never on the command line.

## Pitfalls

- **Scanner-first program**: buying a tool and calling it a program. Without
  ownership, SLAs, and verification, findings rot in a dashboard.
- **Severity sorting**: a CVSS-sorted queue is dominated by unreachable library
  CVEs while an internet-facing medium with a public exploit waits at the bottom.
- **Unaudited exclusions**: "accepted risk" lists that grow forever. Every
  exception needs an expiry.
- **False closures**: closing because a patch was "deployed" without re-scanning.
  Containers and JVM apps frequently still run the old artifact.
- **Credentialed scan blindness**: a broken scan account drops coverage to near
  zero while dashboards stay green.
- **Ignoring compensating controls**: teams patch what is easy, not what is
  exposed. Segmentation and WAF rules are legitimate when documented.
- **Alert fatigue**: forwarding every new CVE to every team instead of matching
  against inventory first.
- **No asset owner**: unowned assets are where criticals live for years.
- **EPSS as severity**: it is a probability and a population average; it cannot
  see your architecture.
- **Patching without rollback**: an emergency patch that breaks production is an
  outage, not a security win.
- **Activity metrics**: scans run, tickets created, reports sent — none say
  whether exposure went down.
- **Zero-day panic patching**: fleet-wide deployment of an unverified patch
  within an hour, causing a second incident.

## Verification

- [ ] Asset inventory has owner, criticality, and exposure for every asset
- [ ] Scan coverage ≥ 95% of inventory, with failed scans alerted on
- [ ] Credentialed scanning verified working on a sample host
- [ ] External scan covers all owned public ranges and domains
- [ ] SLAs defined per severity and exposure, with KEV override documented
- [ ] Prioritization uses CVSS + EPSS + KEV + asset criticality, formula published
- [ ] Every open critical/high has an owner and an SLA deadline
- [ ] Patch process includes canary, health gates, and rollback artifact
- [ ] Remediation verified by re-scan before ticket closure
- [ ] Exception register reviewed; all entries have expiry dates
- [ ] Zero-day playbook documented with a named incident commander role
- [ ] CVE/KEV/vendor feeds ingested on schedule with dedupe
- [ ] MTTR, SLA compliance, coverage, and reopen rate reported monthly
- [ ] SIEM enrichment and SOAR ticket automation tested end to end
- [ ] Audit evidence (scan reports, closure records, exceptions) retrievable

