Andrew Mercer
on this page

Owning Vulnerability Remediation

"Owning" a finding means you are accountable for it reaching one of exactly three end states:

  1. Fixed and verified — a re-scan or re-test proves it's gone.
  2. Not applicable / false positive — with evidence.
  3. 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

  1. The lifecycle
  2. Finding sources and how they differ
  3. Intake and normalisation
  4. Ownership mapping
  5. Triage: is it real, and does it apply?
  6. Prioritisation
  7. Remediation SLAs
  8. Choosing the remediation
  9. Verification
  10. Closure and evidence
  11. Penetration test findings
  12. Pulling findings programmatically
  13. Enriching with KEV and EPSS
  14. Metrics that matter
  15. 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:

  1. Azure tags (owner, env, criticality) on VMs, Arc machines, AKS clusters, App Services, registries.
  2. CMDB for anything not in Azure.
  3. Image → repository → CODEOWNERS for container findings.
  4. 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.7p1 on 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:

  1. Remove the vulnerable component (unused package, feature, old JDK, sample app).
  2. Update to the fixed version (patch, cumulative update, package update, image rebuild).
  3. Reconfigure (disable vulnerable protocol/cipher/feature, tighten permissions).
  4. Replace (EOL software → supported version; see Patch and Upgrade Management).
  5. 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

  1. Confirm exposure and affected asset list within the first hour (Resource Graph, scanner, kubectl get pods -A -o jsonpath for images).
  2. Apply immediate mitigation if a patch can't go out in hours (block port, disable feature, WAF virtual patch).
  3. Raise an emergency change; notify stakeholders (template in Patch and Upgrade Management).
  4. Patch canaries → verify service health → patch the rest.
  5. Trigger on-demand re-assessment / re-scan.
  6. Hunt for prior exploitation (EDR, logs) — patching doesn't evict an attacker who's already in.
  7. 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:

  1. Import the report into the same tracker. One record per finding, with the tester's ID (e.g. PT-2026Q4-07).
  2. Map to assets. Testers list URLs/IPs; translate to resource IDs and owners.
  3. 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.
  4. Split compound findings. "Weak TLS configuration on 14 hosts" becomes per-owner work items.
  5. Look for the systemic cause. Default credentials on one appliance usually means no onboarding checklist for appliances. Fix the process too.
  6. Agree the re-test window with the testing firm up front (often included within 30–90 days).
  7. 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