Back to glossary

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

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 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). The original format capped each year at 9,999 IDs. The CVE ID syntax change 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.

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: "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. 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 for more than 40 JavaScript projects in May 2025, and the ENISA CVE Root began supervising European CNAs in November 2025.

The CNA rules, 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:

Bash
$ 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"}}]}
FieldCVE record, CNA containerCVE record, CISA ADP containernpm advisory (GHSA-2p57-rm9w-gvfp)
Package identityvendor and product "n/a"CPE vendor fedorindutny, product ipnpm 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 releaseAffected, per the prose onlyOutside the range, so "unknown"Affected
Weakness"n/a"CWE-918CWE-918
SeveritynoneCVSS 3.1 base 8.1CVSS 3.1 base 8.1
CVE ID presentyesyesno

Three things stand out. The authoritative CNA container has no machine-readable product or version at all. CISA's enrichment added a CWE and a CVSS 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. 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. The NVD now enriches CVEs in CISA's Known Exploited Vulnerabilities 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. 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 and 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.

SourceKeyed byPackage and fixed versionCovers malwareBest used for
CVE recordCVE IDRarely; 0.71% of 2025 records name a registry packageOnly hijacked legitimate packagesNaming a bug across vendors, advisories, and compliance reports
NVDCVE IDCPE strings, now for a minority of new CVEsNoCVSS and CPE for prioritized and federal software
GitHub Advisory DatabaseGHSA ID, aliases CVEYes, per ecosystemYes, as malware advisoriesWhat npm audit and most open source tooling consume
OSVEcosystem ID, aliases CVE and GHSAYes, as version eventsYes, MAL- recordsMachine 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 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 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 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.

On July 18, 2025, an attacker used a phished npm token in the eslint-config-prettier 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 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. "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.

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.

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 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. 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 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. In March 2026, GCVE launched a 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.