# CISA KEV Explained: The Exploited Vulnerabilities List and Your App

URL: https://tuvio.dev/blog/cisa-kev-explained
Published: 2026-11-08
By the Tuvio team

CISA KEV is the Known Exploited Vulnerabilities catalog, a list kept by the US Cybersecurity and Infrastructure Security Agency of vulnerabilities that attackers are actively using against real systems. It's short, it's public, and for anyone deciding which of 15 `npm audit` findings to fix tonight, it's the best first filter there is: if a package in your app has a CVE on this list, that one goes first.

This post covers what the catalog is, what has to be true for a vulnerability to be added, how to check your own dependencies against it in two commands, and what being on the list does and doesn't mean.

## What the CISA KEV catalog is

CISA describes the [catalog](https://www.cisa.gov/known-exploited-vulnerabilities-catalog) as its authoritative source of vulnerabilities that have been exploited in the wild. Each entry is one CVE, with the vendor and product, the date it was added, a one-line description, the required action (almost always "apply updates per vendor instructions"), a due date for US federal agencies, and whether it's known to have been used in ransomware campaigns.

It is small by design. The 2026-11-06 release lists 1,769 entries across all software: operating systems, network appliances, browsers, CMSs, libraries. Compare that with the tens of thousands of CVEs published every year. Most vulnerabilities, including most of the ones `npm audit` prints, never get exploited at scale, and never appear here.

## What gets a vulnerability onto the list

CISA's [KEV page](https://www.cisa.gov/known-exploited-vulnerabilities) sets three conditions, all of which must hold:

1. "The vulnerability has an assigned Common Vulnerabilities and Exposures (CVE) ID."
2. "There is reliable evidence that the vulnerability has been actively exploited in the wild."
3. "There is a clear remediation action for the vulnerability, such as a vendor-provided update."

The second one is the point. Severity scores describe how bad a flaw *could* be. The KEV catalog records that someone *is* using it. A critical-rated bug nobody has weaponised isn't on the list; a medium-rated bug that a ransomware group is exploiting this week is.

The third condition matters too. A vulnerability with no fix available isn't added, because the list exists to tell people what to do, and "there is nothing you can do" isn't an action.

## Who has to act on it, and who should

For US federal civilian agencies, the catalog is a mandate. CISA's Binding Operational Directive 26-04, which the agency says "carries forward the KEV catalog criteria from BOD 22-01", requires agencies to remediate catalog vulnerabilities within prescribed timeframes, either by applying the vendor's update or by removing the product from the network if it can't be updated.

For everyone else, it's advice, but strong advice. CISA's own words: "Organizations should use the KEV catalog as an input to their vulnerability management prioritization framework", and it "strongly recommends all stakeholders include a requirement to immediately address KEV catalog vulnerabilities" in their vulnerability management plan.

For a solo founder with an AI-built app, translate that as: the exploited list is the one set of findings you don't get to schedule for a quiet afternoon.

## Does it include npm packages?

Yes, when they're exploited. Most entries are products you don't run (firewalls, VPN appliances, Windows), but JavaScript ecosystem entries do appear. React's Server Components remote code execution flaw, [CVE-2025-55182](https://react.dev/blog/2025/12/03/critical-security-vulnerability-in-react-server-components), was added on 2025-12-05 and affected Next.js among other frameworks.

So checking isn't a formality. It's a quick filter that, a few times a year, catches something in a stack like yours.

## How to check your npm packages against CISA KEV

`npm audit` doesn't check the catalog, and it reports advisories by GitHub's `GHSA-` id rather than by CVE. Two commands bridge the gap.

First, turn an advisory id into its CVE:

```bash
curl -s https://api.github.com/advisories/GHSA-pxg6-pf52-xh8x | jq -r .cve_id
```

Then search the catalog's JSON feed for that CVE:

```bash
curl -s https://www.cisa.gov/sites/default/files/feeds/known_exploited_vulnerabilities.json \
  | jq -r '.vulnerabilities[] | select(.cveID == "CVE-2025-55182")
           | "\(.cveID) added \(.dateAdded), due \(.dueDate), ransomware: \(.knownRansomwareCampaignUse)"'
```

No output means that CVE isn't on the list. Output means fix it now, before anything else in the audit.

To do it for every finding at once, pull the CVE ids out of the audit report and check them in one pass:

```bash
npm audit --omit=dev --json \
  | jq -r '.vulnerabilities[].via[] | objects | .cve[]?' \
  | sort -u > /tmp/my-cves.txt

curl -s https://www.cisa.gov/sites/default/files/feeds/known_exploited_vulnerabilities.json \
  | jq -r '.vulnerabilities[].cveID' \
  | grep -F -x -f /tmp/my-cves.txt
```

The last command prints only the CVEs that appear in both your audit and the catalog. Empty output is the answer you want. Not every advisory has a CVE id, so the GHSA lookup above is still the way to check a single finding that this misses.

## Reading an entry

A catalog entry looks like this (fields trimmed):

```json
{
  "cveID": "CVE-2025-55182",
  "vendorProject": "Meta",
  "product": "React Server Components",
  "dateAdded": "2025-12-05",
  "requiredAction": "Apply mitigations per vendor instructions...",
  "dueDate": "2025-12-26",
  "knownRansomwareCampaignUse": "Unknown"
}
```

- **dateAdded** is when CISA confirmed exploitation, not when the bug was found. An entry added today may be a vulnerability patched months ago, which tells you attackers are now scanning for anyone who hasn't updated.
- **dueDate** is the federal deadline. You aren't bound by it, but three weeks is a reasonable upper bound for anyone.
- **knownRansomwareCampaignUse** is `Known` or `Unknown`. `Known` means at least one ransomware operation has used it, which is as urgent as a dependency finding gets.

## What being on the list does not mean

**It's not a complete list of dangerous vulnerabilities.** A CVE missing from the catalog may still be exploitable, and may be exploited quietly without CISA having reliable evidence yet. The list is a floor, not a ceiling: fix these first, then keep going by severity and reachability.

**It doesn't say whether your app is affected.** The entry is about a package version. Whether your code reaches the vulnerable path is a separate question, and when you can't answer it in a few minutes, assume it does. Upgrading is cheaper than proving you're safe.

**Severity and exploitation are different measures.** FIRST, which maintains the CVSS scoring system, says in its [user guide](https://www.first.org/cvss/v4.0/user-guide) that base scores measure severity and should not be used alone to assess risk. FIRST also publishes [EPSS](https://www.first.org/epss/), a probability that a CVE will be exploited in the next 30 days, which fills the gap between "critical" and "on the KEV list". The catalog is the yes-or-no version of that question.

**It doesn't cover malicious packages.** A typosquatted or hijacked npm package is a different problem, with no CVE and no catalog entry. Lockfiles, `npm ci` and reading what you install are the defences there.

## A practical order for an npm audit

Putting the catalog where it belongs in the [fixing process](https://tuvio.dev/blog/how-to-fix-npm-vulnerabilities):

1. `npm audit --omit=dev` to see what ships to production.
2. Check the CVEs against the catalog with the commands above. Anything that matches: upgrade that package today, by name, not with [`npm audit fix --force`](https://tuvio.dev/blog/npm-audit-fix-force).
3. Then production findings by severity, reachable ones first.
4. Dev-only tooling when you have time.
5. Commit `package.json` and `package-lock.json` together.

## Checklist

- You know the catalog exists, and that it's about exploitation, not severity.
- Your audit findings have been checked against it, by CVE id.
- Any match is fixed first, as a single targeted upgrade.
- The rest of the audit follows the normal order.
- Your lockfile is committed, so whatever checks your repository has exact versions to check.

Checking by hand works for one audit. Between audits, a free [Tuvio scan](https://tuvio.dev/scan) of your GitHub repository, no account needed, reads the lockfile and reports known vulnerabilities in production dependencies, marking the ones on CISA's catalog and listing them first within their severity. JavaScript is one of 13 ecosystems it covers. The catalog and the vulnerability database behind it are refreshed weekly, never live, so a vulnerability added to the list this morning shows up in the next refresh. [Coverage](https://tuvio.dev/coverage) lists what is checked, and the [vibe coding security checklist](https://tuvio.dev/blog/vibe-coding-security-checklist) puts dependencies next to the other things worth checking before launch.
