Skip to Content
Determinate Secure PackagesVulnerabilities and VEX

Vulnerabilities and VEX

At Determinate Systems, we remediate vulnerabilities in the packages that make up Determinate Secure Packages and tell you what we know about them in a form that you and your tools can act on. This page explains how our analysis of each vulnerability reaches you and your tools, how to tell from that analysis whether a package is still affected by it, and how to answer the questions that tend to come up along the way.

Our remediation process has five fundamental steps:

  1. We learn about a vulnerability from public databases, including the National Vulnerability Database (NVD), Open Source Vulnerabilities (OSV), and the GitHub Advisory Database (GHSA), or from an upstream project’s own security advisory.
  2. We fix or analyze the vulnerability in each affected package.
  3. We record the outcome in that package’s metadata as Vulnerability Exploitability eXchange (VEX) data.
  4. FlakeBOM carries that metadata into a Software Bill of Materials (SBOM) for your flake.
  5. You, FlakeAudit, or your vulnerability scanner act on the SBOM.

How we handle vulnerabilities

We resolve a given vulnerability in one of two ways:

  • We update the package to a version that contains the fix.
  • We backport the fix, which means applying one or more patches to the current version of the package.

Which of these options we choose depends on the distribution. Rolling generally takes the update, while long-term support (LTS) distributions favor backports, because an update could bring breaking changes along with the fix. Our package update policy covers this in full, and our SLA covers how quickly we act.

This means that a version number alone can’t tell you whether a package is vulnerable. Take, as an example, three Common Vulnerabilities and Exposures (CVE) entries that affect urllib3 2.7.0 and are fixed upstream in 2.8.0: CVE-2026-97687, CVE-2026-97688, and CVE-2026-97689. Rolling resolves them by updating urllib3 to 2.8.0, whereas 26.05 stays on 2.7.0 and carries backported patches. Neither version is vulnerable to those CVEs, but a scanner that compares version numbers may still flag the patched 2.7.0.

How we triage vulnerabilities

When an advisory lands on a package in any of our distributions, we work through the same four questions in order and stop at the first one that settles it. Our goal is to fix what we can without changing anything else, and to be explicit about what we can’t.

How we triage a vulnerabilityWhen an advisory lands on a package in the Determinate Secure Packages covered package set, we ask three questions in order and stop at the first one that settles it. If the advisory doesn't affect our package, the SBOM marks it not_affected or false_positive. If upstream has a security-only release, we update to it, and the new version usually needs no VEX entry. If we can backport the upstream fix, the SBOM marks it resolved or resolved_with_pedigree. If none of those settle it, we publish what we found, as exploitable or in_triage with an explanation.An advisory landsOn a package in our covered package setDoes it affect our package?Is there a security-only release?Can we backport the upstream fix?We publish what we foundexploitable or in_triage, with anexplanationnot_affected or false_positiveUpdated: usually no VEX entryresolved or resolved_with_pedigreeyesnonoyesnoyes
A basic mapping of our triage process

1. Does it affect our package?

We compare our version against the affected ranges in the upstream advisory, NVD, and other distributions’ security trackers. We also confirm that the advisory is about the same software. Vulnerability databases often identify software by name, so an advisory for one project can land on an unrelated package that happens to share that name, such as a Python library and a command-line tool both called parse. If our version is outside the affected range, or the vulnerable code isn’t in our build, we determine that the package isn’t affected and we stop there.

2. Is there a security-only release?

If upstream has published a release containing the fix, we update to it, but only if everything that release adds beyond our version is a security fix. A single bug fix or new feature rules a release out, however small, because you’re relying on LTS to stay stable. An update like this needs no VEX entry, since the new version is outside the affected range.

3. Can we backport the upstream fix?

If there isn’t a release that qualifies, we apply the fix from the upstream project as a patch on our current version. We name the patch after the vulnerability and credit the original author and commit, so that you can trace exactly what changed. The patched package then has to build, and its tests have to pass in our CI. A patch that doesn’t pass doesn’t get shipped.

4. What if we can’t fix it?

Sometimes upstream has no fix, or the fix is a refactor so large that backporting it would amount to writing our own implementation. We don’t ship improvised fixes in those cases. Instead, we publish what we found: what the bug is, what an attacker needs to exploit it, and why we can’t fix it yet.

We never engage in guesswork. If we can’t determine whether an advisory applies, we say so and name exactly what’s unresolved.

What each outcome looks like in your SBOM

Most conclusions appear in your SBOM as an entry in its CycloneDX v1.5 vulnerabilities array, and the values in the second column are that entry’s analysis.state. The reasons, explanations, and details are in analysis.justification and analysis.detail, and the recommended response is in analysis.response. How to read VEX data walks you through a full vulnerability entry.

Our conclusionWhat you see in your SBOM
The advisory doesn’t apply to this packagefalse_positive
The package isn’t affected, for a specific reasonnot_affected, with the reason why
We updated to a security-only releaseUsually a newer version of the package instead of a vulnerability entry
We backported a fixresolved or resolved_with_pedigree, with the same version of the package
It depends on your environment or configurationin_triage, with an explanation of what it depends on
We can’t determine whether it appliesin_triage, with details about what’s unresolved
It applies and we have no fixexploitable, with an explanation and a recommended response

Triage isn’t a one-time event. We revisit entries as part of our regular work and change the analysis when the facts change, for example when upstream publishes a fix. Our SLA sets how quickly we act, and the CVE remediation dashboard shows how we’re doing against it.

How this information reaches you

We describe vulnerabilities using VEX, a machine-readable format for stating whether a vulnerability affects a piece of software and why. Packages in Determinate Secure Packages carry this analysis in their meta.vulns attribute. FlakeBOM also treats a patch named after a vulnerability identifier as evidence that we’ve addressed the vulnerability.

When you run flakebom in the directory containing your flake, it writes both of these into the vulnerabilities array of a CycloneDX v1.5 SBOM called sbom.cdx.json:

Generate an SBOM
flakebom

What the vulnerabilities array contains

The vulnerabilities array is not a list of every vulnerability we’ve fixed. It mostly covers the issues that a version number can’t explain: backported fixes, issues that don’t apply to our build, and issues that are still open. Fixes that arrive through a version update generally don’t appear, because a scanner can already see the new version. That’s why the array is often shorter than the total number of issues we’ve fixed.

The array also reflects what FlakeBOM can see, which is your flake’s outputs on the current system by default. To include more, see the FlakeBOM docs on specific outputs, other systems, and package discovery.

How to read VEX data

Here’s what an entry looks like for a vulnerability that’s resolved through a backport:

A resolved vulnerability
{ "id": "CVE-2026-97689", "source": { "name": "NVD", "url": "https://nvd.nist.gov/vuln/detail/CVE-2026-97689" }, "analysis": { "state": "resolved", "justification": "code_not_present" }, "affects": [ { "ref": "/nix/store/2999zgp10d7fzxi0vsaaqiif9lpj8x73-python3.13-urllib3-2.7.0.drv", "versions": [ { "range": "vers:nix/2.7.0", "status": "unaffected" } ] } ] }

And here are the id and analysis fields of one that’s still open:

An open vulnerability
{ "id": "CVE-2026-106454", "analysis": { "state": "exploitable", "response": ["update"], "detail": "IMAP wildcardToRegexp compiles unescaped user patterns, so crafted LIST arguments backtrack catastrophically and freeze the reactor. Upstream fixed this in Twisted 26.10.0rc1." } }

These fields generally matter most:

FieldWhat it tells you
idThe vulnerability’s identifier, such as a CVE, GHSA, or Python Packaging Advisory Database (PYSEC) ID.
analysis.stateOur conclusion. The table in the next section covers each value.
analysis.justificationWhy we reached that conclusion. code_not_present, for example, means that the vulnerable code is gone.
analysis.responseWhat needs to happen next. update, for example, means that the remedy is updating to a newer version.
analysis.detailA human-readable explanation.
affects[].refThe exact Nix derivation the entry applies to. A package can have several, one for each variant.
affects[].versions[]The version of that derivation and its status (affected, unaffected, or unknown).

A status applies to the derivation named in ref, not to every build of that version. A status of unaffected on urllib3 2.7.0, for example, describes our patched build and says nothing about an unpatched 2.7.0 from elsewhere.

What each state means

StateWhat it meansWhat to do
resolvedWe’ve fixed it in this derivation.Nothing. You can suppress scanner alerts.
resolved_with_pedigreeWe’ve fixed it and can point to the changes involved.Nothing. You can suppress scanner alerts.
not_affectedIt doesn’t apply to this derivation, for the reason given.Nothing. You can suppress scanner alerts.
false_positiveA vulnerability database matched the advisory to this package by mistake.Nothing. You can suppress scanner alerts.
exploitableIt applies, nothing we know of rules it out, and your pinned version has no fix.Read detail and assess your exposure.
in_triageIt depends on your environment or configuration, or it’s unresolved.Read detail and check whether it applies to you.

Despite the name, in_triage doesn’t necessarily mean that we’re still working on an entry. It’s often our final answer for an issue that only you can settle, such as a flaw that only affects Windows hosts.

FlakeAudit’s flakeaudit.toml writes these states with hyphens (in-triage), whereas the SBOM’s JSON uses underscores (in_triage). FlakeAudit also has an untriaged state of its own for vulnerabilities with no analysis at all, which you won’t find in FlakeBOM’s output.

How to triage vulnerabilities

Triage means deciding what each vulnerability means for your software and what to do about it. We’ve already done part of that work: the VEX data in your SBOM records what we know about each package. What we can’t know is how you deploy or use that package, so the rest of the decision is yours.

Here’s the approach we recommend.

1. Start with what you ship

By default, an SBOM covers your flake’s build-time dependencies as well as its runtime dependencies, which are what ends up in production. To focus on the software that actually runs, generate an SBOM that only includes runtime dependencies:

Generate an SBOM of runtime dependencies
flakebom --runtime-only

This can shrink your list dramatically, and it requires FlakeBOM to realise your flake’s root components. Build tools can still pose a risk to your supply chain, so return to the full SBOM when you’re ready to cover them too.

2. Find what our analysis doesn’t cover

Your SBOM’s VEX data only covers vulnerabilities that we’ve recorded. To catch the rest, query vulnerability databases using flakeaudit scan, which adds any new advisories to your SBOM:

Add advisories from vulnerability databases
flakeaudit scan --source nvd --source osv

Entries that this adds without any analysis are in the untriaged state, and they’re yours to assess.

3. List what’s still open

You can set aside anything marked as resolved or not affected, which leaves the entries that need a decision:

List everything that needs a decision
jq -r ' .vulnerabilities[] | select( .analysis.state == null or .analysis.state == "exploitable" or .analysis.state == "in_triage" ) | "\(.id)\t\(.analysis.state // "untriaged")" ' sbom.cdx.json

4. Assess each one

Read the entry’s detail, if it has one, and follow the link in source to the advisory, which is also where you can find its severity. Then work through these questions:

  • Do you use the vulnerable feature? A flaw in one protocol or module doesn’t matter if you never enable it.
  • Can an attacker reach it? A flaw in a service exposed to the internet differs greatly from one in an internal batch job.
  • What’s the impact if someone exploits it? Consider the data and systems that the affected component can access.
  • Is a fix already available? A newer revision of Determinate Secure Packages may already have one.

5. Act on your decision and record it

Your conclusionWhat to do
A newer revision has a fixUpdate your lock and regenerate your SBOM.
You need a fix that doesn’t exist yetApply your own patch in an overlay, naming it after the vulnerability, or contact us.
It doesn’t affect your deploymentRecord your analysis with a state of not_affected and the reason.
It applies, but you’re accepting the riskAdd an override with a reason, so that the decision is visible in your policy.

Whatever you decide, write down why. A reason recorded next to the decision is what lets the next person, or your auditor, trust it.

6. Keep it enforced

Encode your decisions in a FlakeAudit policy so that CI fails when something new needs your attention. New advisories appear even when your lock doesn’t change, so run your scan on a schedule as well as on every lock update.

Common questions

All of the jq commands below read sbom.cdx.json from the current directory.

Am I affected by this CVE?

Look it up in your SBOM:

Look up a single vulnerability
jq ' .vulnerabilities[] | select(.id == "CVE-2026-97689") ' sbom.cdx.json

If you get an entry back, use its state to decide what to do. If you don’t, see what it means if a vulnerability isn’t listed.

Does the version I’m pinned to include this fix?

Your SBOM answers this for you, because FlakeBOM evaluates your flake using the exact revisions in your flake.lock. Run flakebom in that flake’s directory and look up the vulnerability.

To see the version of a package in your SBOM:

Find a package's version
jq -r ' .components[] | select(.name == "urllib3") | "\(.name) \(.version)" ' sbom.cdx.json

Remember that the version alone doesn’t settle it.

What does it mean if a vulnerability isn’t listed?

It doesn’t prove that you’re safe. A vulnerability can be missing from the array for several reasons:

  • A version update fixed it, so your package is newer than the affected versions.
  • The affected package isn’t in your SBOM, either because your flake doesn’t use it or because FlakeBOM didn’t inspect that output.
  • Nobody has analyzed it yet.

Start by checking whether the package is present and which version it’s at, then compare that against the advisory. To check for advisories that the array doesn’t yet mention, run flakeaudit scan, which queries vulnerability databases and adds what it finds to your SBOM.

Why does my scanner flag something you’ve already fixed?

Most scanners match on version numbers, so they can’t see a backported fix. That’s what VEX is for: your scanner finds issues by version, and the SBOM’s VEX data tells it which ones we’ve handled.

Because FlakeBOM’s output is both an SBOM and a VEX document, tools that process CycloneDX VEX can use it to suppress those alerts automatically. If yours can’t, you can suppress them by hand using the states as your evidence.

Why are there so many exploitable entries?

An SBOM covers everything your flake’s outputs depend on, including build-time components, so even a small flake can produce a long list. exploitable means that an issue applies to the package, that we know of nothing that rules it out, and that your pinned version has no fix. It’s not an assessment of your deployment: whether you’re exposed depends on how you use the package. A flaw in the Internet Message Access Protocol (IMAP) support in Twisted, for example, doesn’t matter that much if you never run an IMAP server. To narrow the list down to what you ship, generate a runtime-only SBOM, then triage what’s left.

We review these entries as part of our regular work and update the analysis as fixes become available, so regenerate your SBOM after updating.

What’s the overall picture for my flake?

Count the entries by state:

Count vulnerabilities by state
jq ' .vulnerabilities | map(.analysis.state) | group_by(.) | map({state: .[0], count: length}) ' sbom.cdx.json

Which vulnerabilities are still open?

List everything that’s exploitable or in_triage:

List open vulnerabilities
jq -r ' .vulnerabilities[] | select( .analysis.state == "exploitable" or .analysis.state == "in_triage" ) | .id ' sbom.cdx.json

Which vulnerabilities affect a specific package?

Match on the derivation paths in affects:

List vulnerabilities for one package
jq -r ' .vulnerabilities[] | select(any(.affects[]; .ref | contains("urllib3"))) | "\(.id)\t\(.analysis.state)" ' sbom.cdx.json

How do I enforce a policy in CI?

Use FlakeAudit, which evaluates an SBOM against a policy and exits non-zero when the SBOM fails, so that you can stop a build or release when it does. You decide how to treat each state and which severities matter:

flakeaudit.toml
[vulnerabilities] severity-floor = "high" [vulnerabilities.state] exploitable = "deny" in-triage = "deny" untriaged = "deny" resolved = "allow" resolved-with-pedigree = "allow" not-affected = "allow" false-positive = "allow"

You can also make exceptions for individual advisories once you’ve assessed them.

How do I record my own analysis?

You have two options, depending on whether your flake uses Determinate Secure Packages.

Set meta.vulns in an overlay

If your flake uses Determinate Secure Packages, set meta.vulns in an overlay, which keeps your analysis alongside the package definition. This overlay records that a vulnerability in OpenSSH doesn’t affect you, because it requires a configuration that you don’t use:

Record your own analysis in an overlay
final: prev: { openssh = prev.openssh.overrideAttrs (old: { meta = old.meta // { vulns = (old.meta.vulns or { }) // { CVE-2026-97690 = { analysis = { justification = prev.lib.vulns.justification.requiresConfiguration "Requires agent forwarding, which we disable on every host."; state = prev.lib.vulns.state.notAffected; }; }; }; }; }); }

The lib.vulns helpers turn these values into CycloneDX, and FlakeBOM includes your entry the next time you generate an SBOM.

Merge a VEX file with --merge-vex

Otherwise, write your analysis as a CycloneDX v1.5 file and pass it to FlakeBOM using --merge-vex:

Merge your own VEX data into your SBOM
flakebom --merge-vex ./path/to/my-analysis.cdx.json

How do I stay up to date?

VEX data is tied to the revision you’re pinned to, and our analysis changes over time. Your SBOM doesn’t change on its own, so update your lock and generate a new SBOM to pick up the latest fixes and analysis:

Update your inputs and regenerate your SBOM
nix flake update flakebom

Running flakebom in CI on every lock update keeps this from going stale.

Where can I see your general remediation work?

The CVE remediation dashboard tracks every CVE in Determinate Secure Packages against its deadline, including how many we’ve fixed within the SLA and how many are open.

Last updated on