# Common Vulnerabilities and Exposures (CVE)

> CVE (Common Vulnerabilities and Exposures) is the global naming system for disclosed software vulnerabilities: one ID and one public record per flaw.

Also known as: CVE ID, CVE record, CVE number, CVE identifier

Source: https://socket.dev/glossary/common-vulnerabilities-and-exposures-cve

Last updated: 2026-10-29

Common Vulnerabilities and Exposures (CVE) is the global naming system for publicly disclosed software vulnerabilities. A CVE Numbering Authority gives each flaw one ID, such as CVE-2024-29415, and publishes a structured record about it, so scanners, advisories, and patches can refer to the same bug. CVE names vulnerabilities. It does not score, rank, or detect them.

That distinction is where most teams go wrong. A CVE is a join key, not a security control. The CNA rules require a record to contain only an affected product, a prose description, and one public reference. Severity scores and product matching usually come from someone else, and since April 2026 the [National Vulnerability Database](https://socket.dev/glossary/national-vulnerability-database-nvd) no longer adds them for most CVEs.

The record is also rarely package-native. We parsed all 43,648 published CVE records with a 2025 ID: only 309, or 0.71%, identify the affected package by a registry identifier such as an npm or PyPI package URL. And by rule, purpose-built malware cannot get a CVE at all. Our position: use CVE to talk about known bugs in code you otherwise trust, and never treat "no matching CVE" as evidence that a package is safe.

## What is a CVE?

A CVE is three things that share one name: an identifier, a record, and the program that issues both.

The identifier is `CVE-`, a year, and a sequence number of four or more digits. The year marks when the flaw was disclosed or the ID was reserved, not when the bug was written ([CNA Rule 4.2.21](https://www.cve.org/Resources/Roles/Cnas/CNA_Rules_v4.2.0.pdf)). The original format capped each year at 9,999 IDs. The [CVE ID syntax change](https://www.cve.org/Resources/Media/Archives/OldWebsite/cve/identifiers/syntaxchange.html) took effect on January 1, 2014, and the first IDs with longer sequence numbers were issued on January 13, 2015. The cap mattered: 48,185 CVEs were published in 2025, a 20.6% increase over 2024, according to [Jerry Gamblin's analysis of the year](https://socket.dev/blog/cve-volume-surges-past-48k-in-2025).

The record is a JSON document in the CVE Record Format, introduced as CVE JSON 5.0 in 2022. A CNA can reserve an ID before disclosure, and the public record then appears with a state of `PUBLISHED`, or `REJECTED` if the ID is withdrawn. A record holds one `cna` container written by the authority that assigned the ID, plus optional `adp` containers that Authorized Data Publishers such as CISA append later.

The program is the CVE Program, operated by MITRE and sponsored by the U.S. Cybersecurity and Infrastructure Security Agency (CISA). Its value has never been the database itself. Adam Shostack, who helped create CVE, said during [the 2025 MITRE contract crisis](https://socket.dev/blog/cisa-extends-mitre-contract): "The value of CVE is not as a database, but as a stable way to cross-reference between databases and other tools."

## What does CVE stand for?

CVE stands for Common Vulnerabilities and Exposures. The name comes from a January 1999 MITRE paper by David Mann and Steve Christey, "Towards a Common Enumeration of Vulnerabilities." CVE launched that year with 321 records, according to the program's [25th anniversary report](https://www.cve.org/Resources/Media/Cve25YearsAnniversaryReport.pdf). Before CVE, each vendor and scanner named the same bug differently, so nobody could tell whether two advisories described one flaw or two.

Today "a CVE" is shorthand for the ID itself, as in "we patched three CVEs." The expansion matters less than the job: one stable name per vulnerability.

## Who assigns CVE IDs?

CVE Numbering Authorities (CNAs) assign CVE IDs, each within a defined scope such as its own products or an open source foundation's projects. MITRE was the only CNA in 1999. Since October 2016, CNAs publish their own records, and the program counted 411 CNAs in 40 countries in October 2024.

The hierarchy has three levels. CNAs report to a Root, and Roots report to a Top-Level Root, a role MITRE and CISA hold. MITRE also acts as the CNA of last resort for anything no other CNA covers. Open source has its own CNAs: GitHub assigns IDs for advisories that maintainers publish on GitHub, the [OpenJS Foundation became a CNA](https://socket.dev/blog/openjs-foundation-is-now-a-cna) for more than 40 JavaScript projects in May 2025, and the [ENISA CVE Root](https://socket.dev/blog/enisa-becomes-a-cve-root) began supervising European CNAs in November 2025.

The [CNA rules](https://www.cve.org/Resources/Roles/Cnas/CNA_Rules_v4.2.0.pdf), at version 4.2.0 as of August 25, 2026, govern what a CNA must do. A CNA should assign one CVE per independently fixable vulnerability (Rule 4.2.11). A published record must name at least one affected product, contain a prose description, and cite one public reference (Rules 5.1.3, 5.1.9, 5.1.10). Nothing in that list requires a package name, an ecosystem, or a fixed version.

## Inside a real CVE record

The fastest way to understand CVE data is to read a real record next to the advisory a package manager actually uses. CVE-2024-29415 is a server-side request forgery bug in `ip`, an npm package for parsing IP addresses. Its `isPublic()` function treats addresses like `127.1` as globally routable, which is an incomplete fix for CVE-2023-42282. As of October 29, 2026, the latest `ip` release is still 2.0.1, published February 19, 2024.

This excerpt is the record as stored in the CVE Program's `cvelistV5` repository, trimmed to the fields that matter:

```json
{
  "cveMetadata": { "cveId": "CVE-2024-29415", "assignerShortName": "mitre",
                   "datePublished": "2024-05-27T20:04:14.756Z" },
  "containers": {
    "cna": {
      "descriptions": [{ "value": "The ip package through 2.0.1 for Node.js might allow SSRF ..." }],
      "affected": [{ "vendor": "n/a", "product": "n/a",
                     "versions": [{ "version": "n/a", "status": "affected" }] }],
      "problemTypes": [{ "descriptions": [{ "type": "text", "description": "n/a" }] }]
    },
    "adp": [{
      "title": "CISA ADP Vulnrichment",
      "affected": [{ "vendor": "fedorindutny", "product": "ip",
                     "cpes": ["cpe:2.3:a:fedorindutny:ip:*:*:*:*:*:node.js:*:*"],
                     "defaultStatus": "unknown",
                     "versions": [{ "version": "0", "lessThan": "2.0.1",
                                    "versionType": "custom", "status": "affected" }] }],
      "metrics": [{ "cvssV3_1": { "baseScore": 8.1, "baseSeverity": "HIGH" } }]
    }]
  }
}
```

Now ask the npm registry about the same bug. `npm audit` posts your dependency versions to the registry's bulk advisory endpoint:

```sh
$ curl -s -X POST -H 'content-type: application/json' \
    https://registry.npmjs.org/-/npm/v1/security/advisories/bulk \
    -d '{"ip":["2.0.1"]}'
{"ip":[{"id":1101851,
  "url":"https://github.com/advisories/GHSA-2p57-rm9w-gvfp",
  "title":"ip SSRF improper categorization in isPublic",
  "severity":"high","vulnerable_versions":"<=2.0.1",
  "cwe":["CWE-918"],
  "cvss":{"score":8.1,"vectorString":"CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H"}}]}
```

> CVE-2024-29415 in the npm package ip as described by three records. The CVE record's CNA container lists vendor, product, and version as n/a. The CISA ADP container lists CPE vendor fedorindutny, range 0 to less than 2.0.1, so version 2.0.1 evaluates as unknown. The npm advisory GHSA-2p57-rm9w-gvfp lists package ip, range less than or equal to 2.0.1, so 2.0.1 is affected, and it carries no CVE ID.

| Field | CVE record, CNA container | CVE record, CISA ADP container | npm advisory (GHSA-2p57-rm9w-gvfp) |
| --- | --- | --- | --- |
| Package identity | vendor and product "n/a" | CPE vendor fedorindutny, product ip | npm package ip |
| Affected versions | "n/a"; prose says "through 2.0.1" | 0 to less than 2.0.1 | \<=2.0.1 |
| Status of 2.0.1, the latest release | Affected, per the prose only | Outside the range, so "unknown" | Affected |
| Weakness | "n/a" | CWE-918 | CWE-918 |
| Severity | none | CVSS 3.1 base 8.1 | CVSS 3.1 base 8.1 |
| CVE ID present | yes | yes | no |

Three things stand out. The authoritative CNA container has no machine-readable product or version at all. CISA's enrichment added a [CWE](https://socket.dev/glossary/common-weakness-enumeration-cwe) and a [CVSS](https://socket.dev/glossary/common-vulnerability-scoring-system) score, but its structured range excludes 2.0.1, so a tool that evaluates the range as the schema defines it returns "unknown" for 2.0.1, the latest release. The npm advisory gets the package and range right, and its response does not contain the CVE ID at all.

The ip record is not an outlier. In our snapshot of `cvelistV5` taken October 29, 2026, 43,648 records with a 2025 ID were published. Only 309 of them identify the affected package with a registry-native identifier for npm, PyPI, Maven, Go, Cargo, Composer, NuGet, or RubyGems. Only 55 do it for npm. GitHub's CNA published 3,004 of those records, and 2,995 of them write versions as operator strings such as `"version": "< 0.62.0"`. The schema treats an entry with only `version` and `status` as one exact version, so a strict evaluator matches that string against no real release.

You can reproduce both halves. Run `npm audit` in a project that depends on `ip@2.0.1`, then read `cves/2024/29xxx/CVE-2024-29415.json` in the [cvelistV5 repository](https://github.com/CVEProject/cvelistV5). The CVE ID tells you two people are talking about the same bug. The ecosystem advisory tells you whether you have it.

## How CVE, NVD, GHSA, and OSV fit together

The CVE ID is the hub. The data that makes a vulnerability actionable lives in databases keyed to it or alongside it.

The pipeline starts when a CNA publishes to the CVE List. The NVD ingests new records within about an hour, then its analysts add a CVSS score, CWE, and Common Platform Enumeration (CPE) product matches. That second step stopped scaling. In April 2026, [NIST stopped routinely enriching most CVEs](https://socket.dev/blog/nist-officially-stops-enriching-most-cves). The NVD now enriches CVEs in CISA's [Known Exploited Vulnerabilities](https://socket.dev/glossary/cisa-kev) catalog, software the federal government uses, and software designated critical under Executive Order 14028. Everything else is labeled "Not Scheduled," and NIST no longer computes its own CVSS score when the CNA supplied one.

The numbers show the shift. As of August 17, 2026, the NVD had received 53,115 new CVEs that year and enriched 30,531, with 42,353 CVEs marked "Not Scheduled," according to our coverage of [NIST's proposed AI overhaul of the NVD](https://socket.dev/blog/nist-nvd-ai-automation). Only 57.6% of 2025 CVEs carried CPE identifiers, the field scanners use to match a CVE to installed software.

Open source ecosystems route around this. The [GitHub Advisory Database](https://socket.dev/glossary/github-advisory-database) and [OSV](https://socket.dev/glossary/osv) key advisories to an ecosystem and package name, carry affected ranges and fixed versions, and cross-reference CVE IDs as aliases when one exists.

| Source | Keyed by | Package and fixed version | Covers malware | Best used for |
| --- | --- | --- | --- | --- |
| CVE record | CVE ID | Rarely; 0.71% of 2025 records name a registry package | Only hijacked legitimate packages | Naming a bug across vendors, advisories, and compliance reports |
| NVD | CVE ID | CPE strings, now for a minority of new CVEs | No | CVSS and CPE for prioritized and federal software |
| GitHub Advisory Database | GHSA ID, aliases CVE | Yes, per ecosystem | Yes, as malware advisories | What npm audit and most open source tooling consume |
| OSV | Ecosystem ID, aliases CVE and GHSA | Yes, as version events | Yes, MAL- records | Machine matching across ecosystems |

Verdict: use the CVE ID as the shared name in tickets, reports, and vendor conversations. Match open source dependencies against GHSA or OSV data, which describe packages the way your lockfile does. Treat NVD enrichment as optional context that may never arrive.

## Does malware get a CVE?

Purpose-built malware does not get a CVE, because the CNA rules forbid it. Rule 4.1.7 says: "General purpose deliberately malicious code MUST NOT be determined to be a Vulnerability." A typosquat or a package written to steal credentials is never a CVE. As of October 29, 2026, the [OpenSSF malicious packages dataset](https://ossf.github.io/malicious-packages/stats/) holds more than 239,000 such reports, about 222,000 of them on npm, each tracked as an OSV `MAL-` record. A scanner that only matches CVE IDs reports every one of these [malicious packages](https://socket.dev/glossary/malicious-package) as clean.

Rule 4.1.8 carves out one exception. Products "modified to become malicious," including backdoors and "similar supply chain compromises," may receive a CVE. The [xz Utils backdoor](https://socket.dev/blog/how-to-use-socket-to-find-out-if-you-were-affected-by-the-backdoored-xz-package) became CVE-2024-3094 on March 29, 2024. Hijacked npm packages have received them too, and in both cases below the CVE arrived after the damage window had closed.

> Timelines of two npm compromises. eslint-config-prettier: malicious versions published July 18, 2025 from 15:51 to 16:13 UTC, 10.1.8, not listed as affected, at 18:40 UTC, CVE-2025-54313 published July 19, added to CISA KEV January 22, 2026. debug: malicious 4.4.2 published September 8, 2025 at 13:12 UTC and removed by npm the same day, CVE ID reserved September 9, CVE-2025-59144 published September 15 at 19:10 UTC.

On July 18, 2025, an attacker used a phished npm token in [the eslint-config-prettier compromise](https://socket.dev/blog/npm-phishing-campaign-leads-to-prettier-tooling-packages-compromise). Four malicious versions of `eslint-config-prettier` went up between 15:51 and 16:13 UTC, and installing them ran an `install.js` that launched a Windows DLL. Version 10.1.8, which the CVE does not list as affected, followed at 18:40 UTC. CVE-2025-54313 was published on July 19, and CISA added it to the KEV catalog on January 22, 2026, 188 days after the attack.

On September 8, 2025, [the chalk and debug compromise](https://socket.dev/blog/npm-author-qix-compromised-in-major-supply-chain-attack) put malicious `debug@4.4.2` on npm at 13:12 UTC, with a payload that redirected cryptocurrency transactions in browsers. npm removed that version over the course of the day. The CVE ID was reserved on September 9, and GitHub's CNA published CVE-2025-59144 for debug, and sibling CVEs for packages such as `color` and `color-string`, on September 15. That was a week after npm had pulled the malicious version. The debug CVE record lists our write-up of the attack as a reference.

A CVE for a compromise is useful for audit and cleanup. It cannot protect the builds that ran while the malicious version was live, because it does not exist yet. That is why Socket keeps malware and vulnerabilities in separate [alert types](https://socket.dev/alerts). "Critical CVE" through "Low CVE" alerts mean a package version matches a published vulnerability. "Known malware" marks versions confirmed as malicious, and "AI-detected potential malware" comes from scanning the code in the package itself. A signal derived from the package's own code does not wait for anyone to write an advisory.

## Why CVE counts and CVSS scores mislead triage

A CVE ID says a bug exists somewhere. It does not say whether your application can reach it.

Volume makes that gap expensive. The 2025 CVEs averaged a CVSS score of 6.60, and nearly 19,000 were rated high or critical. Scores also disagree by source. Of 1,567 CVEs scored by both the NVD and GitHub, the NVD came in higher 885 times and GitHub 682 times, with gaps as large as 6.9 points, according to [Jerry Gamblin's Consensus Engine data](https://socket.dev/blog/nist-officially-stops-enriching-most-cves).

Inflated scores have real costs for maintainers. CVE-2023-42282, the earlier `ip` bug, was filed as a 9.8 critical. Maintainer Fedor Indutny started getting messages from users whose `npm audit` flagged it, disputed the rating, and archived the repository. GitHub then lowered its advisory to low severity, and Indutny restored the repository about a week later, as we reported in [the node-ip CVE dispute](https://socket.dev/blog/node-ip-maintainer-restores-github-repo-after-archiving-due-to-overblown-cve-rating).

[Reachability analysis](https://socket.dev/glossary/reachability-analysis) attacks the triage problem directly. It traces whether any path leads from your code to the vulnerable function. Socket's precomputed reachability marks about 60% of CVEs as unreachable from the dependency graph alone, and [Tier 1 Reachability](https://socket.dev/blog/introducing-tier-1-reachability) filters about 80% by also analyzing application code. Reachability has limits. It over-approximates, marking a CVE reachable or unknown when in doubt, so it narrows the queue without proving safety. It also does nothing for malware, which runs at install or import time whether or not your code calls it.

## The CVE Program is a single point of failure

In April 2025, the CVE Program came within hours of losing its operator. MITRE's contract was about to expire when CISA announced an [11-month extension to March 2026](https://socket.dev/blog/cisa-extends-mitre-contract). CVE board members formed a CVE Foundation, and ENISA launched the European Vulnerability Database the same week.

The cliff passed quietly. In March 2026, [CSO Online reported](https://www.csoonline.com/article/4142600/cve-program-funding-secured-easing-fears-of-repeat-crisis.html) that CISA had moved CVE funding to a protected line in its budget, while the contract's terms remained undisclosed. Funding solved the outage risk. It did not solve the data model.

Pressure keeps arriving at the edges. In February 2026, the OpenClaw project published more than 200 GitHub Security Advisories in about three weeks. MITRE's Top-Level Root pushed back on a request to claim the 170 that lacked CVE IDs in one batch, and the request was withdrawn, as we covered in [the OpenClaw advisory surge](https://socket.dev/blog/openclaw-advisory-surge-highlights-gaps-between-ghsa-and-cve-tracking). In March 2026, [GCVE launched a decentralized publishing ecosystem](https://socket.dev/blog/gcve-launches-decentralized-publishing-ecosystem) that maps every existing CVE into its own format, so CVE-2023-40224 becomes GCVE-0-2023-40224.

The open problem is not a shortage of IDs. The record attached to the ID was never designed around packages. The CVE Record Format already has `packageURL` and `collectionURL` fields, and fewer than 1% of 2025 records use them for an open source registry. Until CNAs publish the package, the range, and the fix in a form a package manager can evaluate, the CVE ID will remain what Shostack said it was for, a stable cross-reference, attached to data you still have to get somewhere else.
