Owning Vulnerability Remediation¶
"Owning" a finding means you are accountable for it reaching one of exactly three end states:
- Fixed and verified — a re-scan or re-test proves it's gone.
- Not applicable / false positive — with evidence.
- Formally accepted or excepted — with an approver, compensating controls and an expiry date (Exception Management).
"We patched it, probably" is not an end state. Neither is a finding that sits at Open for 200 days because nobody knew whose it was.
Contents¶
- The lifecycle
- Finding sources and how they differ
- Intake and normalisation
- Ownership mapping
- Triage: is it real, and does it apply?
- Prioritisation
- Remediation SLAs
- Choosing the remediation
- Verification
- Closure and evidence
- Penetration test findings
- Pulling findings programmatically
- Enriching with KEV and EPSS
- Metrics that matter
- Common failure modes
The lifecycle¶
┌────────┐ ┌───────────┐ ┌────────┐ ┌────────────┐ ┌───────────┐ ┌────────┐ ┌───────┐
│ Detect │ → │ Normalise │ → │ Triage │ → │ Prioritise │ → │ Remediate │ → │ Verify │ → │ Close │
└────────┘ └───────────┘ └────────┘ └────────────┘ └───────────┘ └────────┘ └───────┘
│ │ │
├─→ False positive (evidence) ──┤ │
└─→ Exception request ──────────┘ │
▲ │
└──── Reopened (regression) ┘
Status model (use the same states everywhere — tickets, dashboards, exception register):
| Status | Meaning | Who moves it |
|---|---|---|
New |
Ingested, not yet looked at | Automation |
Triaged |
Validated, owner assigned, priority set | Remediation owner |
In Progress |
Fix being developed/scheduled | Asset owner / engineer |
Pending Verification |
Fix deployed, waiting for re-scan/re-test | Engineer |
Closed – Remediated |
Verified gone | Automation (preferably) or owner with evidence |
Closed – False Positive |
Proven not vulnerable | Owner, peer-reviewed |
Closed – Not Applicable |
Asset decommissioned, out of scope | Owner |
Risk Accepted / Excepted |
Formal exception approved and time-boxed | Approver |
Reopened |
Was closed, detected again | Automation |
Finding sources and how they differ¶
| Source | What it finds | Strengths | Watch out for |
|---|---|---|---|
| Microsoft Defender for Cloud (Defender for Servers / Containers / CSPM, powered by Microsoft Defender Vulnerability Management, MDVM) | OS and software CVEs on Azure VMs and Arc machines (agent-based via Defender for Endpoint or agentless disk scanning), container images in registries and running in AKS, misconfigurations, security baseline deviations | Native to Azure; covers Arc machines; container image scanning included in Defender for Containers / Defender CSPM; findings now also surface in the Defender portal under Exposure Management | Built-in Qualys scanner in Defender for Cloud was retired in favour of MDVM; agentless scans run on a cadence (not real time); premium MDVM features need Defender for Servers Plan 2 |
| Qualys VMDR | Network and agent-based OS/app vulns, policy compliance, web apps (WAS) | Mature detection logic, Qualys Detection Score (QDS), TruRisk, strong policy compliance module | QIDs ≠ CVEs (one QID may map to many CVEs); unauthenticated scans produce version-banner false positives |
| Tenable Vulnerability Management / Nessus / Security Center | Network and agent-based vulns, compliance audits | Huge plugin coverage, Vulnerability Priority Rating (VPR), audit files for CIS | Plugin IDs ≠ CVEs; paranoid-mode plugins; credentialed vs uncredentialed differences |
| Penetration tests | Exploitable chains, logic flaws, misconfigurations, weak credentials, exposures scanners miss | Proven exploitability, business context | Point-in-time; report formats vary; findings often aren't CVEs; needs re-test to close |
| Container/SCA scanners in CI (Trivy, Grype, Dependabot) | Image and dependency CVEs before deployment | Shift-left | Different vulnerability DBs give different answers; see Pipeline Scanning |
Two scanners pointed at the same server will disagree. Pick one system of record per asset class (e.g. MDVM for Azure/Arc servers, Qualys for network-only appliances, Defender for Containers for images) and use others as corroboration, not as additional backlogs.
Intake and normalisation¶
Normalise every finding into a common record before triage:
finding_id: VM-2026-004512 # your ID, stable across re-scans
source: mdvm # mdvm | qualys | tenable | pentest | trivy
source_ref: "CVE-2026-12345" # QID / plugin ID / pentest ref
cve: ["CVE-2026-12345"]
title: "OpenSSH regreSSHion-style RCE in sshd"
asset_id: "/subscriptions/.../machines/web-dc1-03"
asset_hostname: web-dc1-03
asset_owner: [email protected]
environment: prod
exposure: internet
criticality: tier1
component: openssh-server
installed: "1:9.6p1-3ubuntu13.4"
fixed_in: "1:9.6p1-3ubuntu13.5"
fix_available: true
cvss_base: 8.1
cvss_version: "3.1"
epss: 0.42
kev: false
first_seen: 2026-11-04
last_seen: 2026-11-11
status: New
priority: null
due_date: null
ticket: null
Deduplication keys: (asset_id, cve, component) for software vulns; (asset_id, source_ref) for non-CVE findings. When MDVM and Qualys both report the same CVE on the same host, keep one record and attach both source references.
Grouping for work: engineers fix packages and images, not CVEs. A single openssl update may close 14 CVEs across 300 servers. Create remediation tickets per (component, fixed_in, patch_group) or per image, and link the underlying findings to them. One ticket per CVE per host is how backlogs reach 40,000 items.
Ownership mapping¶
The finding's owner is the asset owner, not the security team. The remediation owner (you) is accountable for driving it to closure.
Build the mapping from authoritative data, not spreadsheets:
- Azure tags (
owner,env,criticality) on VMs, Arc machines, AKS clusters, App Services, registries. - CMDB for anything not in Azure.
- Image → repository →
CODEOWNERSfor container findings. - Fallback queue for unmapped assets — and a weekly task to empty it by fixing the tagging gap.
RACI for a typical OS-level finding:
| Activity | Remediation owner | Asset owner | App platform engineer | Security / CISO office | Change manager |
|---|---|---|---|---|---|
| Triage & priority | A/R | C | C | C | — |
| Schedule fix | R | A | C | I | C |
| Apply fix | R | A | R (app layer) | — | I |
| Verify | A/R | I | I | I | — |
| Exception request | R | A (business risk) | C | C (approver) | — |
Triage: is it real, and does it apply?¶
Triage answers four questions, quickly:
1. Is the detection accurate?¶
- Backported fixes. RHEL, Debian and Ubuntu patch security issues without bumping the upstream version.
openssh 8.7p1on RHEL 9 may be fully patched for a CVE that upstream fixed in 9.3. Check the distro's CVE tracker: - Red Hat:
https://access.redhat.com/security/cve/CVE-YYYY-NNNNN - Ubuntu:
https://ubuntu.com/security/CVE-YYYY-NNNNN - Debian:
https://security-tracker.debian.org/tracker/CVE-YYYY-NNNNN - Unauthenticated banner checks. A web server banner says "Apache/2.4.37" → scanner flags every CVE since. Credentialed/agent scans are far more accurate.
- Stale package metadata / leftover files. Old kernels still installed but not running, old JARs in a backup directory.
# RHEL family: is this CVE fixed in the installed packages?
dnf updateinfo info --cve CVE-2026-12345
rpm -q --changelog openssh-server | grep -i CVE-2026-12345
# Ubuntu/Debian
apt changelog openssh-server 2>/dev/null | grep -i CVE-2026-12345
dpkg -l openssh-server
# Which kernel is *running* vs installed
uname -r; rpm -q kernel # or: dpkg -l 'linux-image-*' | grep ^ii
# Windows: is a KB installed?
Get-HotFix -Id KB5046617
# Cumulative updates supersede — check the build number instead
(Get-ItemProperty 'HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion').UBR
[System.Environment]::OSVersion.Version
2. Is the vulnerable code reachable?¶
- Is the vulnerable service running and listening? (
ss -tlnp,Get-NetTCPConnection -State Listen) - Is the vulnerable feature enabled? (e.g. a module not loaded, a protocol disabled)
- Is the library actually loaded by a running process, or just present on disk?
Reachability lowers priority; it rarely justifies closing as false positive. A component not in use should usually be removed, which is a fix.
3. Is a fix available?¶
fix_available: false changes the path: mitigation + exception, or vendor escalation. Don't let no-fix findings rot in the main queue; route them to an exception with a review date tied to vendor advisories.
4. Who owns it?¶
If the triage can't name an owner in under a minute, fix the ownership data.
False-positive evidence standard: command output, distro advisory link, vendor statement, or a reproducible test. Peer-review every false-positive closure; it's the easiest status to abuse.
Prioritisation¶
CVSS alone is a poor priority signal: a large share of published CVEs score High or Critical, while only a small fraction are ever exploited. Combine threat, exposure, and impact:
| Signal | Question it answers | Source |
|---|---|---|
| CISA KEV | Is this being exploited in the wild right now? | cisa.gov/known-exploited-vulnerabilities-catalog (JSON feed) |
| EPSS (v4, March 2025) | What's the probability of exploitation activity in the next 30 days? | api.first.org/data/v1/epss |
| CVSS (3.1 / 4.0 base + your environmental adjustments) | How bad would it be technically? | NVD, vendor |
| Vendor scores (MDVM exposure score, Qualys TruRisk/QDS, Tenable VPR) | The vendor's blend of the above | Scanner |
| Exposure | Is the asset reachable from the internet / untrusted networks? | Your tags, NSGs, external attack surface scans |
| Asset criticality | What's the blast radius? Tier-0 identity, data stores, payment, PII | CMDB / tags |
| Compensating controls | WAF rule, EDR prevention, network isolation in place? | Your controls |
A practical priority matrix¶
P1 (Emergency) KEV listed AND (internet-exposed OR tier0/tier1)
OR active exploitation observed in your environment
OR pentest finding with demonstrated critical impact
P2 (High) KEV listed (internal)
OR EPSS >= 0.10 AND CVSS >= 7.0
OR CVSS >= 9.0 AND internet-exposed
P3 (Medium) CVSS >= 7.0 with fix available
OR EPSS >= 0.01 AND CVSS >= 4.0
P4 (Low) Everything else with a fix available
P5 (Track) No fix available → mitigation + exception path
Thresholds are starting points. Tune them against your backlog: if P1+P2 is more than what the team can clear in a week, the thresholds are too loose to drive behaviour.
SSVC as an alternative¶
CISA's Stakeholder-Specific Vulnerability Categorization (SSVC) replaces a score with a decision tree over Exploitation (none/PoC/active), Automatable (yes/no), Technical Impact (partial/total) and Mission & Well-being impact, producing Track, Track*, Attend, or Act. It's easier to explain to stakeholders than a weighted score, and it maps neatly onto P1–P4.
Remediation SLAs¶
Measured from first detection (not from triage — otherwise slow triage hides in the numbers):
| Priority | Internet-facing / tier 0–1 | Internal / tier 2–3 |
|---|---|---|
| P1 | 72 hours (or KEV due date, whichever is sooner) | 7 days |
| P2 | 7 days | 14 days |
| P3 | 30 days | 60 days |
| P4 | 90 days | Next regular patch cycle, max 180 days |
| P5 | Mitigation within P-equivalent SLA; exception reviewed every 30–90 days | same |
Align these with any external obligations: PCI DSS (critical/high security patches within one month of release for in-scope systems), your cyber insurance terms, customer contracts, and — if you work with US federal systems — CISA BOD 22-01 due dates for KEV entries.
Escalation path when an SLA is at risk:
| Time to breach | Action |
|---|---|
| 50% of SLA elapsed, no plan | Nudge asset owner |
| 75% elapsed | Escalate to owner's manager; offer help |
| Breached | Must have an approved exception or appear in the leadership risk report |
Choosing the remediation¶
In order of preference:
- Remove the vulnerable component (unused package, feature, old JDK, sample app).
- Update to the fixed version (patch, cumulative update, package update, image rebuild).
- Reconfigure (disable vulnerable protocol/cipher/feature, tighten permissions).
- Replace (EOL software → supported version; see Patch and Upgrade Management).
- Mitigate (WAF rule, NSG restriction, private endpoint, EDR rule) → temporary, plus an exception.
Where the fix lands decides who does the work:
| Finding layer | Typical fix | Guide |
|---|---|---|
| OS packages on VMs / Arc servers | AUM schedule or one-time update | Hybrid Server Operations, Patch and Upgrade Management |
| OS configuration | Baseline change via GPO/DSC/Ansible | Configuration Management |
| Container base image / app dependencies / runtime | Rebuild, bump deps, redeploy | Container and Application Remediation |
| Network exposure | NSG, private endpoint, firewall change | Network Changes and Runbooks |
Emergency (P1) playbook¶
- Confirm exposure and affected asset list within the first hour (Resource Graph, scanner,
kubectl get pods -A -o jsonpathfor images). - Apply immediate mitigation if a patch can't go out in hours (block port, disable feature, WAF virtual patch).
- Raise an emergency change; notify stakeholders (template in Patch and Upgrade Management).
- Patch canaries → verify service health → patch the rest.
- Trigger on-demand re-assessment / re-scan.
- Hunt for prior exploitation (EDR, logs) — patching doesn't evict an attacker who's already in.
- Post-incident: why was the exposure there, and how do we detect it faster next time?
Verification¶
A finding is closed by evidence, not by a ticket comment.
| Source | How to verify |
|---|---|
| Azure Update Manager | Trigger on-demand assessment (az vm assess-patches / Check for updates) and confirm the KB/package is no longer pending |
| Defender for Cloud / MDVM | Agent-based results refresh quickly; agentless scanning runs on a periodic cycle (allow up to a day or so). Check the recommendation's affected resources list |
| Qualys | Launch a targeted re-scan or wait for the cloud agent's next upload; status moves to Fixed |
| Tenable | Re-scan; state moves to Fixed; watch for Reopened |
| Container images | Rebuild → push → registry re-scan; confirm running pods use the new digest |
| Pentest | Formal re-test by the tester, or documented reproduction attempt by you with the tester's steps |
Verification gotchas:
- Pending reboot — Windows LCUs and Linux kernels aren't effective until reboot. Many scanners still flag them (correctly).
- Running vs installed — old library still loaded in a long-running process (
needrestart -b,lsof | grep DEL). - Image fixed, pods not restarted — the registry is clean but the cluster is still running the old digest.
- Golden image not updated — autoscaling brings back the vulnerable version tomorrow.
Closure and evidence¶
Store with the finding (or in the ticket):
- Remediation action and change ID
- Before/after evidence (scanner status, command output, screenshot of re-test)
- Date verified and by whom/what
- Linked exception if partial
Auditors will sample closed items. If closure evidence lives only in someone's memory, that's a finding against the program.
Penetration test findings¶
Pentest findings need extra handling because they don't come from a feed:
- Import the report into the same tracker. One record per finding, with the tester's ID (e.g.
PT-2026Q4-07). - Map to assets. Testers list URLs/IPs; translate to resource IDs and owners.
- Re-rate in your context. The tester's severity is a starting point; you know about compensating controls they couldn't see — but document the reasoning if you downgrade.
- Split compound findings. "Weak TLS configuration on 14 hosts" becomes per-owner work items.
- Look for the systemic cause. Default credentials on one appliance usually means no onboarding checklist for appliances. Fix the process too.
- Agree the re-test window with the testing firm up front (often included within 30–90 days).
- Close only after re-test. If the re-test isn't contracted, run the tester's reproduction steps yourself and attach output.
Common pentest finding types and their usual owners:
| Finding | Usual fix | Owner |
|---|---|---|
| Exposed management interfaces (RDP/SSH/WinRM to internet) | NSG/firewall, Bastion, JIT | Network + server owner |
| Outdated TLS/ciphers | Baseline config change | Server owner via config mgmt |
| Missing security headers | App/web server config, Front Door/App Gateway rules | App team |
| Default/weak credentials | Rotate, LAPS, vault | Asset owner |
| Secrets in code/config | Rotate + move to Key Vault | App team (see container guide) |
| SMB signing not required / LLMNR/NBT-NS enabled | GPO | Windows platform |
| Kerberoastable service accounts | gMSA, long random passwords | Identity team |
Pulling findings programmatically¶
Defender for Cloud via Azure Resource Graph¶
securityresources
| where type == "microsoft.security/assessments/subassessments"
| extend status = tostring(properties.status.code),
severity = tostring(properties.status.severity),
cve = tostring(properties.id),
title = tostring(properties.displayName),
resourceId = tostring(properties.resourceDetails.id)
| where status == "Unhealthy"
| project resourceId, cve, title, severity, timeGenerated = todatetime(properties.timeGenerated),
additional = properties.additionalData
| order by severity asc
Filter to a specific recommendation (servers vs containers vs SQL) by the parent assessment key, which you can read from the recommendation's URL in the portal. Use continuous export to stream assessments and sub-assessments into Log Analytics or Event Hubs for history and alerting (see Pipeline Scanning and Monitoring).
az graph query -q "@query.kql" --first 1000 -o json > defender-findings.json
Tenable (pyTenable)¶
from tenable.io import TenableIO
tio = TenableIO(access_key=AK, secret_key=SK)
for v in tio.exports.vulns(severity=["critical", "high"], state=["open", "reopened"]):
print(v["asset"]["hostname"], v["plugin"]["id"],
",".join(v["plugin"].get("cve", [])), v["severity"], v["state"])
Qualys (API v2 host detection)¶
curl -s -u "$QUALYS_USER:$QUALYS_PASS" -H "X-Requested-With: curl" \
"https://qualysapi.qg1.apps.qualys.ca/api/2.0/fo/asset/host/vm/detection/?action=list&status=New,Active,Re-Opened&severities=4,5&show_results=0" \
-o qualys-detections.xml
(Use your platform's API URL — Qualys runs regional pods.)
Write it once¶
Whatever you build — a scheduled script, a Logic App, a small Rust CLI — it should do the same thing for every source: pull → normalise to the common schema → dedupe → enrich → upsert into the tracker → emit metrics.
Enriching with KEV and EPSS¶
#!/usr/bin/env bash
# enrich.sh — add KEV and EPSS to a newline-separated list of CVEs
set -euo pipefail
CVES_FILE="${1:?usage: enrich.sh cves.txt}"
curl -fsSL https://www.cisa.gov/sites/default/files/feeds/known_exploited_vulnerabilities.json \
| jq -r '.vulnerabilities[] | [.cveID, .dueDate, .knownRansomwareCampaignUse] | @tsv' > /tmp/kev.tsv
printf "cve\tkev\tkev_due\transomware\tepss\tpercentile\n"
# EPSS API accepts comma-separated batches
split -l 100 "$CVES_FILE" /tmp/cvebatch.
for b in /tmp/cvebatch.*; do
ids=$(paste -sd, "$b")
curl -fsSL "https://api.first.org/data/v1/epss?cve=${ids}" \
| jq -r '.data[] | [.cve, .epss, .percentile] | @tsv'
done | while IFS=$'\t' read -r cve epss pct; do
kev=$(awk -v c="$cve" '$1==c {print "yes\t"$2"\t"$3}' /tmp/kev.tsv)
[[ -z "$kev" ]] && kev=$'no\t-\t-'
printf "%s\t%s\t%s\t%s\n" "$cve" "$kev" "$epss" "$pct"
done
rm -f /tmp/cvebatch.*
Run it daily — both feeds change daily, and a CVE added to KEV should automatically bump its priority and due date.
Metrics that matter¶
| Metric | Definition | Why |
|---|---|---|
| SLA adherence | % of findings closed within SLA, by priority | The primary health indicator |
| MTTR | Median days from first detection to verified closure, by priority | Track trend, not absolute |
| Open findings by age bucket | 0–30, 31–60, 61–90, 90+ days | Exposes the long tail |
| KEV exposure | Count of open KEV findings and days since KEV listing | The one leadership should see first |
| Reopen rate | % of closed findings that reappear within 90 days | Regression / golden image / drift indicator |
| Coverage | % of inventory assets scanned (authenticated) in the last 7 days | Unscanned = unknown risk |
| Exception volume and age | Count of active exceptions, % expired | Exceptions creeping up = program debt |
| False-positive rate per source | % of triaged findings closed as FP | Tune scanners, pick system of record |
Report by owner team. A single global number lets every team assume it's someone else's problem.
Common failure modes¶
- Ticket per CVE per host. Group by fix.
- SLA clock starts at triage. Start it at detection.
- Security team "owns" remediation. Security owns the program; asset owners own the fix; you own driving it.
- Closing on deploy, not on verify. Require scanner confirmation.
- Scanner disagreement paralysis. Declare a system of record per asset class.
- Ignoring the image pipeline. Patching running containers is pointless; fix the image (see Container and Application Remediation).
- No route for "no fix available." Route to mitigation + time-boxed exception.
- Exceptions with no expiry. Every exception expires. See Exception Management.
References¶
- CISA Known Exploited Vulnerabilities Catalog — cisa.gov/known-exploited-vulnerabilities-catalog
- FIRST EPSS — first.org/epss
- FIRST CVSS v4.0 specification — first.org/cvss
- CISA SSVC — cisa.gov/ssvc
- Microsoft Defender for Cloud — vulnerability assessment with Defender Vulnerability Management (Microsoft Learn)
- Qualys VMDR API documentation
- Tenable Vulnerability Management API / pyTenable