Exception Management¶
An exception is a time-boxed, approved decision not to meet a control yet, with a named owner, a reason, compensating controls, and a plan to resolve it. The process exists so that unfixable or not-yet-fixable risk is visible and decided by the right person — not silently tolerated by whoever happened to be on the ticket.
A healthy exception register is small, current, and shrinking. An unhealthy one is a list of things everyone has agreed to forget.
Contents¶
- Vocabulary
- When an exception is (and isn't) appropriate
- The exception record
- Lifecycle
- Approval matrix
- Compensating controls
- The register as code
- Tying scanner suppressions to the register
- Azure Policy exemptions
- Review cadence and driving to resolution
- Reporting
- Anti-patterns
- Templates
Vocabulary¶
Use these terms consistently; mixing them is how risk gets lost.
| Term | Meaning | Expires? |
|---|---|---|
| False positive | The finding is wrong — the asset isn't vulnerable. Not an exception. Close with evidence. | n/a |
| Not applicable | Control doesn't apply (e.g. asset decommissioned, feature absent). Not an exception. | n/a |
| Deferral / remediation extension | Fix is planned but will miss the SLA; new due date agreed. | Yes — short (≤ 90 days) |
| Risk exception | Control can't be met for a period; compensating controls reduce the risk; a resolution plan exists. | Yes — typically 30–365 days |
| Risk acceptance | Business formally accepts residual risk with no plan to fix (e.g. legacy system being retired). | Yes — still re-reviewed at least annually |
| Compensating control | An alternative control that addresses the intent of the original requirement to a comparable degree. | Lives as long as the exception |
| Mitigation | Anything that reduces likelihood or impact; may or may not be strong enough to count as compensating. | — |
When an exception is (and isn't) appropriate¶
Appropriate:
- No vendor fix exists yet; mitigations are in place.
- The fix requires an application upgrade that's scheduled but can't land within SLA.
- A hardening setting breaks a supported business application; vendor fix is on their roadmap.
- An EOL system is being decommissioned within a defined window; ESU or isolation covers the gap.
- An appliance or vendor-managed system you can't patch yourself.
Not appropriate:
- "We're busy." That's a deferral at most, and it should be escalated, not approved by default.
- Avoiding a reboot indefinitely.
- A finding nobody has triaged — triage first.
- A known false positive — close it as FP with evidence instead.
- Permanent. Nothing is permanent; long-lived acceptances still get re-reviewed.
The exception record¶
Required fields — reject requests missing any of them:
| Field | Description |
|---|---|
id |
Stable identifier, e.g. EXC-2026-0042 |
title |
One line, specific |
type |
deferral | exception | acceptance |
scope |
Exactly which assets, findings, controls (resource IDs, CVEs, policy definition IDs, CIS rule IDs) |
requirement |
The control or policy not being met (e.g. "Remediate P2 within 14 days", "CIS 2.3.9.2 SMB signing") |
reason |
Why it can't be met now — specific and verifiable |
risk |
Likelihood × impact in your risk model, with reasoning |
compensating_controls |
List, each with how it's verified |
resolution_plan |
What ends this exception, with milestones |
requester |
Person |
risk_owner |
Business owner who accepts the residual risk (not the engineer) |
technical_owner |
Who executes the resolution plan |
approver(s) |
Per approval matrix |
created, approved |
Dates |
expires |
Hard date. Required. |
review_frequency |
e.g. 30 / 90 days |
status |
See lifecycle |
linked_findings |
Finding IDs / tickets |
linked_suppressions |
Scanner rule IDs, Azure Policy exemption IDs, .trivyignore entries |
Lifecycle¶
Draft → Submitted → Under Review → Approved → Active → (Review) → Active … → Resolved
│ │ │
└→ Rejected ├→ Expired ───────────┤
└→ Revoked └→ Renewed (new approval, new expiry)
| Status | Meaning | Suppressions in scanners? |
|---|---|---|
| Draft / Submitted / Under Review | Pending decision | No — finding stays visible and its SLA keeps running |
| Approved / Active | In force | Yes, scoped and with matching expiry |
| Expired | Past expires without renewal |
Removed automatically — finding reappears with SLA breached |
| Revoked | Compensating control failed or risk changed (e.g. CVE added to KEV) | Removed |
| Resolved | Underlying issue fixed and verified | Removed |
| Rejected | Not approved | None — remediate within SLA |
Renewal is a new decision, not a date edit. It requires fresh justification, evidence that the compensating controls still work, and the same (or higher) approval level. Cap renewals — e.g. a P2 exception may be renewed at most twice before escalation to the executive risk committee.
Automatic revocation triggers:
- CVE is added to CISA KEV, or EPSS jumps above your P1/P2 threshold.
- Asset exposure changes (internal → internet-facing).
- A compensating control check fails.
- A fix becomes available for a "no fix" exception (vendor releases patch) — convert to remediation with a short SLA.
Approval matrix¶
Approval level scales with residual risk and duration:
| Residual risk | ≤ 30 days | ≤ 90 days | ≤ 180 days | > 180 days |
|---|---|---|---|---|
| Low (P4) | Team lead | Team lead | Engineering manager | Director |
| Medium (P3) | Engineering manager | Engineering manager | Director + Security | Director + CISO delegate |
| High (P2) | Director + Security | Director + CISO delegate | CISO | CISO + business exec |
| Critical (P1 / KEV) | CISO | CISO + business exec | Not permitted without risk committee | Not permitted |
Rules:
- The requester can't approve their own exception.
- Security reviews the compensating controls; the business risk owner accepts the risk. Both are needed above Low.
- Regulatory controls (PCI, SOX, HIPAA scope) may require your compliance function's sign-off regardless of level, and some requirements can't be excepted at all — only met via documented compensating controls the assessor accepts.
Compensating controls¶
A compensating control must address the same threat the original control addresses, to a comparable degree, and be verifiable. PCI DSS's long-standing definition is a useful standard even outside PCI: it must meet the intent and rigor of the original requirement, provide a similar level of defence, be "above and beyond" other requirements, and be commensurate with the additional risk.
Examples that genuinely compensate¶
| Unmet control | Threat | Compensating control | Verification |
|---|---|---|---|
| Unpatched RCE in internal web service, no fix yet | Remote exploitation | NSG/firewall restricts inbound to two known app subnets; WAF virtual-patch rule for the exploit path; EDR in block mode | NSG effective rules export; WAF rule hit logs; EDR policy report — checked weekly |
| Windows Server 2016 after EOL (pending migration) | Unpatched future vulns | ESU enrolled via Arc; isolated VLAN/NSG; no internet egress; admin only via Bastion/PAW | ESU license status; NSG rules; firewall logs |
| SMB signing disabled for legacy scanner appliance | Relay/MITM | Dedicated file share server for scan-to-folder; share accessible only from appliance IP; account restricted to that share | Share ACL & firewall rule review monthly |
| Container image with unfixed base-OS CVE in an unused library | Exploitation of library | Library unreachable (no network listener, not loaded); readOnlyRootFilesystem, non-root, NetworkPolicy deny-all ingress except ingress controller |
Reachability analysis attached; pod security admission audit |
Things that aren't compensating controls¶
- "The server is internal." (Internal networks are where lateral movement happens.)
- "We have antivirus."
- "Nobody knows it's there."
- "It's behind the firewall" — without specifying which rule restricts which path.
- A control that already exists and is required anyway (e.g. "we have MFA" when MFA is mandated for everything) — it doesn't add anything for this specific gap.
Each compensating control needs an automated or scheduled check. If it isn't checked, assume it's gone.
The register as code¶
A spreadsheet works for twenty exceptions and fails at two hundred. A Git repository of YAML files gives you review (merge requests), history (who approved what, when), and automation (expiry checks in CI) for free — and it fits naturally alongside infrastructure code.
Layout¶
risk-exceptions/
├── README.md
├── schema/exception.schema.json
├── exceptions/
│ ├── EXC-2026-0041.yaml
│ ├── EXC-2026-0042.yaml
│ └── ...
├── archive/ # resolved / expired / rejected, kept for audit
└── scripts/
├── validate.py
└── report.py
Record¶
# exceptions/EXC-2026-0042.yaml
id: EXC-2026-0042
title: "OpenSSL CVE-2026-XXXXX on legacy billing appliance — no vendor patch"
type: exception
status: active
scope:
assets:
- "/subscriptions/1111.../resourceGroups/rg-billing/providers/Microsoft.HybridCompute/machines/billing-appl-01"
findings: ["VM-2026-004512"]
cves: ["CVE-2026-XXXXX"]
requirement: "VULN-SLA-P2: remediate within 14 days"
reason: >
Appliance firmware is vendor-controlled. Vendor advisory VA-2026-118 commits
to a fixed firmware in release 7.4, ETA 2027-01-15.
risk:
likelihood: medium
impact: high
rating: high
notes: "EPSS 0.03 at time of request; not in KEV."
compensating_controls:
- id: CC-1
description: "NSG nsg-billing denies all inbound except TCP/443 from snet-billing-app"
verification: "scripts/checks/nsg_rules.sh billing-appl-01 — runs daily in CI"
- id: CC-2
description: "Appliance has no outbound internet; egress via Azure Firewall deny-all"
verification: "Firewall policy rule collection 'billing-egress' review"
resolution_plan:
- milestone: "Vendor firmware 7.4 released"
due: 2027-01-15
- milestone: "Firmware applied in maintenance window"
due: 2027-01-31
requester: "[email protected]"
risk_owner: "[email protected]"
technical_owner: "[email protected]"
approvals:
- name: "[email protected]"
date: 2026-11-08
role: security
- name: "[email protected]"
date: 2026-11-09
role: risk_owner
created: 2026-11-06
approved: 2026-11-09
expires: 2027-02-15
review_frequency_days: 30
last_reviewed: 2026-11-09
renewals: 0
revoke_if:
kev_listed: true
epss_above: 0.10
linked_suppressions:
- system: defender-for-cloud
ref: "disable-rule:CVE-2026-XXXXX:billing-appl-01"
- system: azure-policy
ref: "/subscriptions/1111.../providers/Microsoft.Authorization/policyExemptions/exc-2026-0042"
CI validation¶
#!/usr/bin/env python3
"""validate.py — fail CI on malformed, expired, or overdue-review exceptions."""
import sys, datetime, pathlib, yaml
TODAY = datetime.date.today()
REQUIRED = ["id", "title", "type", "status", "scope", "requirement", "reason",
"risk", "compensating_controls", "resolution_plan", "risk_owner",
"technical_owner", "approvals", "expires", "review_frequency_days",
"last_reviewed"]
MAX_DAYS = {"deferral": 90, "exception": 365, "acceptance": 365}
errors, warnings = [], []
for f in sorted(pathlib.Path("exceptions").glob("*.yaml")):
e = yaml.safe_load(f.read_text())
missing = [k for k in REQUIRED if k not in e]
if missing:
errors.append(f"{f.name}: missing {missing}")
continue
if e["id"] != f.stem:
errors.append(f"{f.name}: id does not match filename")
expires = e["expires"]
approved = e.get("approved")
if approved and (expires - approved).days > MAX_DAYS[e["type"]]:
errors.append(f"{e['id']}: duration exceeds {MAX_DAYS[e['type']]} days for {e['type']}")
if e["status"] == "active" and expires < TODAY:
errors.append(f"{e['id']}: EXPIRED {expires} — renew, resolve, or move to archive/")
elif e["status"] == "active" and (expires - TODAY).days <= 14:
warnings.append(f"{e['id']}: expires in {(expires - TODAY).days} days")
next_review = e["last_reviewed"] + datetime.timedelta(days=e["review_frequency_days"])
if e["status"] == "active" and next_review < TODAY:
errors.append(f"{e['id']}: review overdue since {next_review}")
if e.get("requester") in [a["name"] for a in e["approvals"]]:
errors.append(f"{e['id']}: requester cannot approve own exception")
for w in warnings: print("WARN ", w)
for x in errors: print("ERROR", x)
sys.exit(1 if errors else 0)
Run it on every merge request and on a daily schedule — the scheduled run is what catches expiry without anyone touching the repo.
# .gitlab-ci.yml (excerpt)
validate-exceptions:
image: python:3.13-slim
script:
- pip install --quiet pyyaml
- python scripts/validate.py
rules:
- if: $CI_PIPELINE_SOURCE == "merge_request_event"
- if: $CI_PIPELINE_SOURCE == "schedule"
Protect the exceptions/ path with CODEOWNERS so security must approve merges, and require the risk owner's approval as a second approver.
Tying scanner suppressions to the register¶
Every suppression in a tool must point back to a register entry, and must expire no later than it.
| Tool | Suppression mechanism | Expiry support |
|---|---|---|
| Defender for Cloud (vulnerability findings) | Disable specific findings rules on vulnerability recommendations (by CVE / severity / image / resource) | Rules don't expire by themselves — automate removal from the register |
| Defender for Cloud (recommendations) | Azure Policy exemptions (below) | Yes (expiresOn) |
| Qualys | Ignore vulnerability / VMDR exceptions with comments | Set and track the end date in the exception |
| Tenable | Recast / Accept rules with comments | Yes (expiration date on accept rules) |
| Trivy | .trivyignore.yaml with statement and expired_at |
Yes |
| Grype | .grype.yaml ignore rules with reason |
No — enforce via review |
| Dependabot / Renovate | Dismiss alert with reason / ignoreDeps |
Limited — track in register |
Convention: put the exception ID in every suppression's comment/reason field (EXC-2026-0042). Then a nightly job can list all suppressions across tools and flag any whose ID isn't an active register entry — orphaned suppressions are the most common way exceptions outlive their approval.
Trivy example:
# .trivyignore.yaml
vulnerabilities:
- id: CVE-2026-XXXXX
paths:
- "usr/lib/libexample.so.3"
statement: "EXC-2026-0057 — library not loaded; base image fix pending upstream"
expired_at: 2026-12-31
Azure Policy exemptions¶
Azure Policy has first-class exemptions with categories and expiry, which makes it a good model even if most of your findings come from elsewhere.
| Category | Use when |
|---|---|
Waiver |
Accepting non-compliance (risk exception/acceptance) |
Mitigated |
The intent is met another way (compensating control) |
Terraform¶
resource "azurerm_resource_policy_exemption" "exc_2026_0042" {
name = "exc-2026-0042"
resource_id = data.azurerm_arc_machine.billing_appl_01.id
policy_assignment_id = data.azurerm_management_group_policy_assignment.server_baseline.id
# Exempt only specific policies inside an initiative
policy_definition_reference_ids = ["linuxSshdHardening"]
exemption_category = "Mitigated"
expires_on = "2027-02-15T00:00:00Z"
display_name = "EXC-2026-0042 billing appliance SSH config"
description = "See risk-exceptions/exceptions/EXC-2026-0042.yaml"
metadata = jsonencode({
exceptionId = "EXC-2026-0042"
riskOwner = "[email protected]"
approvedBy = ["[email protected]"]
})
}
Better still: generate exemption resources from the register YAML (a small script or Terraform for_each over decoded YAML files), so the register is the single source of truth and Terraform removes exemptions when entries are archived.
locals {
exceptions = {
for f in fileset("${path.module}/../risk-exceptions/exceptions", "*.yaml") :
trimsuffix(f, ".yaml") => yamldecode(file("${path.module}/../risk-exceptions/exceptions/${f}"))
}
policy_exemptions = {
for id, e in local.exceptions : id => e
if e.status == "active" && try(e.azure_policy, null) != null
}
}
resource "azurerm_resource_policy_exemption" "from_register" {
for_each = local.policy_exemptions
name = lower(each.key)
resource_id = each.value.azure_policy.resource_id
policy_assignment_id = each.value.azure_policy.assignment_id
exemption_category = each.value.type == "acceptance" ? "Waiver" : "Mitigated"
expires_on = "${each.value.expires}T00:00:00Z"
display_name = "${each.key} ${each.value.title}"
}
Listing exemptions¶
policyresources
| where type == "microsoft.authorization/policyexemptions"
| extend expires = todatetime(properties.expiresOn),
category = tostring(properties.exemptionCategory),
excId = tostring(properties.metadata.exceptionId)
| project name, category, expires, excId, scope = tostring(split(id, "/providers/Microsoft.Authorization")[0])
| order by expires asc
Exemptions with no expiresOn or no exceptionId in metadata are orphans — alert on them.
Review cadence and driving to resolution¶
Exceptions don't resolve themselves. Someone has to keep pushing them.
Cadence¶
| Exception risk | Review every | Review asks |
|---|---|---|
| Critical/High | 30 days | Are compensating controls still verified? Did threat intel change (KEV, EPSS, exploit public)? Is the resolution plan on track? |
| Medium | 60–90 days | Same, lighter evidence |
| Low | 90–180 days | Still needed? |
A weekly 30-minute exception stand-up¶
Agenda, in this order:
- Expiring in ≤ 14 days — renew (with fresh approval), resolve, or let expire (and accept the SLA breach visibility).
- Revocation triggers fired — KEV additions, exposure changes, failed control checks.
- Resolution milestones due — is the vendor patch out? Is the migration on schedule?
- New requests — triage completeness before routing to approvers.
Driving with the right owners¶
- Name a person, not a team, as technical owner. Teams don't answer emails; people do.
- Put resolution milestones into the owning team's backlog as real work items with due dates, linked from the exception.
- When a milestone slips, the exception's risk owner gets the escalation — they accepted the risk, they decide whether to fund the fix.
- Make exception counts visible in the same team-level dashboards as vulnerability SLAs. Teams with many long-lived exceptions should be discussed at the same forum as teams with SLA breaches.
Expiry automation¶
- 30, 14, 7 and 1 day before expiry: notify technical and risk owners.
- On expiry: CI flips status, Terraform removes exemption, nightly job removes tool suppressions, findings reappear with SLA breached — and that's intended. The visible breach is the forcing function.
Reporting¶
Monthly report to leadership (one page):
| Section | Content |
|---|---|
| Totals | Active exceptions by risk level; trend vs last 3 months |
| Age | Median age; count > 180 days; count renewed ≥ 2 times |
| Expired/breached | Exceptions that expired without resolution |
| Top risks | The five highest residual-risk exceptions, with risk owner and resolution date |
| Revocations | Exceptions revoked this month and why |
| Resolved | Exceptions closed this month (good news matters) |
Exception data should be queryable alongside vulnerability data — same asset IDs, same owner fields — so a team's risk picture includes both "open findings" and "findings we've agreed to live with for now."
Anti-patterns¶
- No expiry. Every record expires.
- Engineer as risk owner. The person accepting business risk must have authority over the business process.
- Suppress first, approve later. Suppressions only after approval.
- Compensating controls by assertion. If it isn't verified on a schedule, it isn't a control.
- Silent renewal. Renewals require new approval and evidence.
- Blanket scope. "All servers in subscription X" is not a scope; list assets or define a precise filter.
- Spreadsheet in someone's OneDrive. Use a system with history and access control.
- Exceptions for false positives. Close FPs with evidence; don't clutter the register.
Templates¶
Exception request (for ticketing systems that aren't Git)¶
Title:
Type: deferral | exception | acceptance
Scope (assets, findings/CVEs, controls):
Requirement not met:
Why it can't be met now (specific, verifiable):
Risk assessment (likelihood, impact, threat intel e.g. KEV/EPSS):
Compensating controls (each with how it's verified and how often):
Resolution plan (milestones with dates):
Requested duration / expiry date:
Requester:
Technical owner (person):
Risk owner (person with business authority):
Linked tickets / findings:
Review record¶
Exception ID:
Review date:
Reviewer(s):
Compensating controls verified? (evidence links):
Threat changes since last review (KEV/EPSS/public exploit):
Resolution plan status:
Decision: continue | revoke | resolve | escalate
Next review date:
References¶
- PCI DSS v4.0.1, Appendix B (Compensating Controls) and Appendix C (Compensating Controls Worksheet)
- NIST SP 800-37 Rev. 2 (Risk Management Framework) and SP 800-30 Rev. 1 (Risk Assessments)
- Azure Policy exemption structure — Microsoft Learn
- Trivy ignore file documentation — trivy.dev