Your SBOM Is Not Your Attack Surface: A CVE Evidence Playbook
A practical workflow for turning SBOM and CVE matches into defensible patch decisions using provenance, reachability, exploit evidence, and deployment checks.
Approximately 14 min read
A scanner reports a critical vulnerability in a library. The security dashboard creates a ticket, the ticket is assigned to an application team, and somebody asks for an emergency change. But the affected library may exist only in a development tool, the shipped application may bundle a patched fork, or the vulnerable function may never be reachable from attacker-controlled input.
The opposite failure is just as serious. A team dismisses a finding because a function is not called in its source tree, while the vulnerable parser actually executes in a worker, plugin, command-line helper, or transitive dependency. The alert was valid; the inventory and runtime evidence were incomplete.
An SBOM answers what components are represented in a product or build. It does not, by itself, answer what an attacker can reach. The useful question is not “How many CVEs did our scanner find?” It is “What evidence connects this advisory to this exact deployed artifact and an actionable risk decision?”
The distinction is already visible in the 2025 joint SBOM guidance published by CISA and international partners: component transparency helps defenders, but inventory data must be used with vulnerability and product context. This article turns that principle into an operational process that can survive an audit, a production incident, or an AI-generated finding.
Seven gates between a CVE and a patch decision
Treat each vulnerability finding as an evidence chain, not a severity label.
| Gate | Question | Strong evidence |
|---|---|---|
| 1. Identity | Did we match the right package and ecosystem? | Package URL, supplier, package manager, advisory alias |
| 2. Version | Is the exact component revision affected? | Resolved version, commit, distro-specific fix record |
| 3. Presence | Is it in an artifact we actually deploy? | SBOM tied to an immutable build digest |
| 4. Reachability | Can execution reach the vulnerable operation? | Call path, entry point, runtime or integration test |
| 5. Preconditions | Can an attacker satisfy the required conditions? | Input control, authentication, configuration, privileges |
| 6. Threat | How urgently might this be used against us? | KEV, EPSS, exposed services, business impact |
| 7. Closure | Did the fix or mitigation reach the running service? | Release digest, regression result, runtime verification |
A failure to prove a gate is not proof of safety. Record unknown, then decide whether the remaining uncertainty is tolerable at that exposure level. This is especially important for high-impact services where a missing call graph is a limitation of the tool, not evidence that the code is unreachable.
Gate 1: package identity is harder than it looks
Start with the package ecosystem, not the component’s display name. A name such as core, json, or http-client can appear in multiple ecosystems; matching by short names or fuzzy text can create false positives. Use a package URL (PURL) or similarly precise ecosystem identifier when available, and retain the original dependency path.
Check whether the finding refers to a direct dependency, transitive dependency, shaded Java library, vendored code, statically linked code, operating-system package, or a container base layer. Each has a different remediation owner. Updating a Maven dependency does nothing to patch a system library embedded in the base image. Updating a base image does not necessarily remove a vulnerable library shaded inside an application JAR.
Keep source SBOM and runtime/deployment SBOM separate. A source manifest tells you what the project declares. A lockfile tells you what the resolver selected for a build context. An image or binary inventory describes a produced artifact. None is interchangeable with the others. Record the build pipeline, architecture, dependency scopes, and artifact digest so that a ticket does not drift from one revision to another.
A useful immutable identity tuple is:
service + environment + image digest + component PURL + resolved version + advisory ID
If one element changes, re-evaluate the finding rather than silently carrying the prior disposition forward.
Gate 2: read the advisory’s affected-range semantics
Version comparison is not universally numeric. The OSV schema models affected packages using ecosystem, version and range information, including introduced, fixed, and last_affected events. Those events represent ranges under the declared range type; they are not generic decimal numbers.
Three common errors cause avoidable tickets:
- Treating
1.10as smaller than1.9because the comparison is lexical. - Assuming upstream version numbers fully describe a Linux distributor’s backported security fixes.
- Ignoring that an advisory can have several affected intervals, branches or ecosystem-specific records.
When a component comes from a Linux distribution, check the vendor’s security tracker and build-release notation. When the package is a fork or vendored copy, determine whether the vulnerable change or fix is present in that exact source revision. A package filename alone may not settle the question.
The decision here is narrow: is the identified build of the identified component in an affected range? Do not yet conclude that the application is exploitable.
Gate 3: prove that the affected code is deployed
A vulnerable library can be present in a repository without being included in the service people run. A test-only dependency might never ship; a packaging step might replace it; an old container layer might be recorded in an inventory even though the runtime uses a different copy.
Ask the build system for the resolved dependency tree, identify the physical packaged location, and connect the output to a signed or otherwise verifiable artifact digest. For containers, compare what the registry serves with what the cluster actually runs. For Java, inspect the effective dependency tree and the final JAR/WAR. For compiled workloads, ask whether vulnerable functions were statically linked or optimized out; absence from a manifest is not enough.
Evidence should contain:
- Immutable artifact identifier and production workload identifier.
- The path by which the dependency entered the artifact.
- The component’s exact resolved version or commit.
- The release and environment in which that artifact is running.
- A timestamp and the method used to collect each observation.
This is where many workflow automations fail: the scanner reports against today’s default branch, while the patch ticket is attached to last week’s production release.
Gate 4: reachability is not exploitability
The most valuable technical distinction is between dependency presence, code reachability, and attacker-controlled exploitability.
A call graph may prove that application code can invoke a vulnerable function. It does not prove that an external actor can reach that code, supply a malicious argument, satisfy a rare option flag, or cross an authorization boundary. GitHub’s reachability-analysis documentation makes the same distinction: a reachable call path is not, by itself, proof of exploitable impact.
For a suspected parser issue, the investigation must ask four separate questions:
Entry point: Is the parser invoked by a public HTTP endpoint, batch job, authenticated admin API, message queue consumer, or local CLI?
Input control: Can a relevant attacker influence the exact bytes or object graph reaching the vulnerable function? A public endpoint does not mean all downstream values are attacker-controlled.
Execution conditions: Is the vulnerable option enabled? Does a guard, feature flag, input-size limit, or different parser path prevent the dangerous branch? Have you checked how the production build configures it?
Security consequence: If the vulnerable condition is met, what boundary is crossed: memory safety, unauthorized file access, privilege escalation, data disclosure, or availability? A crash in an isolated disposable worker and code execution in a privileged service do not imply the same response.
Useful evidence includes a call-path trace, input-propagation analysis, an integration test with harmless boundary inputs, a runtime stack trace from an authorized staging setup, or source-level proof that a security precondition cannot be reached. Avoid turning an inability to reproduce into a finding of “not exploitable.” Reproduction may be blocked by missing fixtures or incomplete instrumentation.
A worked example: same CVE, three different outcomes
Consider a fictional advisory, DEMO-2026-0001, affecting a hypothetical JSON parser pkg:maven/example/[email protected] when a specific unsafe option processes attacker-controlled documents. The package, advisory and version are invented for this example; they are not real vulnerability intelligence.
Service A: internet-facing document upload. The parser is in the deployed JAR. The upload endpoint accepts user documents, passes their contents to the vulnerable parser, and enables the unsafe option. A staging regression demonstrates the vulnerable code path with a harmless marker. This is a high-confidence affected case. Request a patched build, bound the upload path in the interim, and prioritize based on current threat and business impact.
Service B: scheduled internal report generator. The same library is packaged, but the relevant parsing function is invoked only on immutable, locally produced data. Network access and writable input paths have been checked, and reviewers can explain the invariant. This may justify a conditional mitigation or a tightly scoped not affected statement, depending on the advisory’s precise preconditions and the quality of evidence. It still needs a re-check when the job gains a new data source.
Service C: test-only dependency. The vulnerable version exists in a development dependency tree but not in the release artifact. That is a clear production-scope non-exposure finding. It does not imply there is no risk to CI workers, developer laptops, or test pipelines, where the same package may process untrusted fixtures.
All three services can produce the same scanner headline. Only the evidence chain explains what the headline means.
Gate 5: exploit evidence, probability and severity are different
Three signals are often blended into a single dashboard color, even though they answer different questions.
CVE/CVSS: The vulnerability identifier and severity assessment describe the disclosed issue and its technical characteristics. A high base severity is not evidence that the affected component is deployed in your service.
CISA KEV: Presence in the Known Exploited Vulnerabilities catalog is evidence of known exploitation of the vulnerability in the wild. It does not automatically establish that your product contains the vulnerable code, but it should materially raise remediation urgency when exposure is plausible.
FIRST EPSS: The Exploit Prediction Scoring System estimates the probability of exploitation in the wild during the next 30 days. It is a threat-likelihood model, not an asset-level probability of compromise or a replacement for deployment evidence. Record the retrieval date because the model’s scores change.
Add the asset context: internet accessibility, authentication, privilege level, reachable attack path, data sensitivity, compensating controls, availability tolerance and service criticality. Use SSVC’s stakeholder-specific decision methodology to make an action decision explicit rather than pretending a single numeric score can settle every case.
A practical priority rule is: confirmed reachable exposure with known active exploitation receives immediate human attention; clearly absent runtime components may be closed with evidence; unknown exposure on critical assets stays open until proved otherwise or explicitly risk-accepted. The timetable is an organizational decision, not a universal property of a CVE.
Gate 6: write evidence, not just a ticket state
The difference between a reliable system and a dashboard is a structured record that can be re-evaluated when code, data or external conditions change.
A minimal assessment record can look like this:
{
"asset": "upload-api",
"environment": "production",
"artifact_digest": "sha256:<artifact-digest>",
"component": "pkg:maven/example/[email protected]",
"advisory": "DEMO-2026-0001",
"identity": "confirmed",
"affected_version": "confirmed",
"deployed": "confirmed",
"call_path": "confirmed",
"attacker_input": "confirmed",
"preconditions": "confirmed",
"threat_signals_checked_at": "2026-11-19",
"decision": "remediate",
"evidence": [
"release-manifest:upload-api-build-183",
"staging-test:parser-unsafe-option-regression"
],
"owner": "application-security-and-service-team",
"reassess_on": ["new-image-digest", "advisory-update"]
}
Here the digest value, build identifier and test name are placeholders in a hypothetical record. Real evidence references must resolve to immutable artifacts or test outputs, with suitable access restrictions.
Store states explicitly: confirmed, refuted, unknown, and not-applicable are materially different. In particular, unknown must not be converted to refuted because a scanner lacks the language support or an AI assistant cannot find the call path.
The record should answer: who made the determination, which exact release was assessed, what data supported it, what remains uncertain, and which events invalidate the conclusion.
Gate 7: express non-applicability without creating permanent blind spots
VEX (Vulnerability Exploitability eXchange) is designed to convey vulnerability applicability in a product context. It is particularly useful when a component appears in an SBOM but the corresponding vulnerability does not affect the assembled product.
A defensible not_affected assertion needs more than “the team says it is safe.” Record the precise product version, advisory, status, technical justification and supporting evidence. Distinguish such causes as vulnerable code absent, vulnerable code not in an executable path, and impact prevented by a specific environmental condition. Each makes a different claim and can become stale for different reasons.
The CISA SBOM consumption guidance describes VEX as one way to communicate product applicability; it is not a substitute for validating the underlying statement.
Make VEX determinations invalidate on meaningful changes: component upgrade, feature activation, changed traffic path, altered trust boundary, newly disclosed exploit condition, or deployment to a differently configured environment. If the reasoning depends on a WAF rule, the status needs to change when that rule is removed.
The patch is not finished when the pull request merges
Vulnerability programs often measure the speed of creating remediation pull requests. That measures work initiated, not risk removed.
For an actionable finding, close the loop in this order:
- Capture the starting state. Pin the production artifact digest, relevant advisory revision, observed configuration and an authorized reproducer or regression test where possible.
- Choose the narrowest adequate change. It might be a library upgrade, vendor backport, configuration fix, feature disablement, privilege reduction or network constraint. Record why it addresses the vulnerable condition.
- Test both failure and normal behavior. Confirm that the vulnerable path no longer exhibits the unsafe condition, while representative business workflows still work.
- Trace the change into a new artifact. Associate the fix commit, build provenance, software inventory and digest. A passing pipeline on an unrelated branch is irrelevant.
- Verify the running release. Confirm the actual deployed image/binary and effective configuration in the target environment. Blue/green, canary, older replicas and rollback targets can preserve vulnerable copies.
- Reassess the advisory. A clean scanner result is useful corroboration, but check that the root cause and any sibling code paths are addressed. Record the new evidence and closure date.
If a fix is delayed, keep the risk record active with a compensating control, an owner and a checkable deadline. A mitigation is not the same thing as a patched component; dashboards should not silently merge them.
Where AI agents help, and where they should stop
An agent can usefully expand an advisory into affected packages, inspect lockfiles, locate code paths, compare diffs, generate a proposed test, draft a patch and collect release evidence. These are bounded research and engineering tasks.
The risky jump is from “I found a plausible path” to “this is exploitable,” or from “tests pass” to “the running service is safe.” Source inspection is not a production observation. A language model may overlook dynamic dispatch, generated code, reflection, plugins or configuration-only entry points. It may also invent a plausible-looking call path when its retrieval is incomplete.
A safer workflow uses explicit checkpoints:
| Agent may prepare | Human or independently enforced gate must verify |
|---|---|
| Advisory aliases and affected-version hypothesis | Package identity, ecosystem and vendor corrections |
| Dependency path and suspected source-to-sink chain | Runtime route, data control and actual preconditions |
| Candidate regression test and remediation PR | Test validity, security impact and change approval |
| Evidence packet and proposed priority | KEV/EPSS freshness, criticality and policy decision |
| Scan comparison after deployment | Production digest, configuration and root-cause closure |
Avoid granting an exploratory agent authority to silence findings or deploy emergency changes merely because it generated a convincing explanation. Separate retrieval, proposed action and authorization.
For related reading, see RAMGPT’s GitHub AI Scan evaluation guide on why alert generation and verified remediation require different evidence.
A one-week pilot that produces useful measurements
Select a small, mixed set of real services: one internet-facing application, one batch processor, one containerized service with OS packages, and one JVM service with transitive dependencies. Do not start by dumping thousands of alerts into an agent.
Day 1 — inventory and freeze: Record exact production revisions and artifact digests. Export the current dependency data. Check whether each inventory reflects source, build or runtime.
Day 2 — adjudicate a sample: Select findings across known-exploited, high predicted-likelihood and ordinary severity categories. Review package identity and affected-range semantics before analyzing code.
Day 3 — map reachability: Trace each candidate from deployed component to executable call path, input control and exploit conditions. Include explicit unknown states; do not pressure analysts to force definitive answers.
Day 4 — validate dispositions: Have a second reviewer sample confirmed, non-affected and uncertain findings. Re-check any VEX-style non-applicability claims against their exact product artifacts.
Day 5 — follow one fix to production: Carry one approved remediation through regression, build, deployment and runtime readback. Compare the ticket’s closure time with the actual exposure-removal time.
Report precision of confirmed actionable findings, analyst effort per disposition, proportion with runtime provenance, number of unresolved unknowns, re-opened false closures, and time from confirmed exposure to production verification. Do not claim global recall without a known ground-truth corpus. Count findings by root cause, not by the number of dashboards that repeated them.
The operational conclusion
An SBOM is necessary inventory, not an attack-surface oracle. A CVE match is a hypothesis. Static reachability is stronger evidence, but not a proof of exploitability. Active exploitation intelligence raises urgency without resolving local product identity. And a merged patch is not closure until a known-safe artifact and configuration are observed where the service actually runs.
The durable result is an evidence chain attached to the exact released product. Build that chain once, make its uncertainty visible, and let automation maintain it as packages, software and threat intelligence change.
Primary references
- CISA and partners: A Shared Vision of SBOM for Cybersecurity
- OSV vulnerability schema and affected range events
- GitHub: About reachability analysis for Dependabot alerts
- CISA Known Exploited Vulnerabilities Catalog
- FIRST EPSS Frequently Asked Questions
- CERT/CC: SSVC methodology
- CycloneDX VEX capability
- CISA: SBOM consumption recommended practices
Sources and further reading
- cisa.gov · joint guidance a shared vision of software bill of materials for cybersecurity 508c.pdf
- ossf.github.io · osv schema
- docs.github.com · about reachability analysis for dependabot alerts
- first.org · faq
- cisa.gov · known exploited vulnerabilities catalog
- certcc.github.io · howto
- cyclonedx.org · vex
- cisa.gov · SECURING THE SOFTWARE SUPPLY CHAIN RECOMMENDED PRACTICES FOR SOFTWARE BILL OF MATERIALS CONSUMPTION (2).pdf