Back to glossary

OWASP Dependency-Check

OWASP Dependency-Check is an open source SCA tool that guesses each dependency's CPE identifier from its metadata and reports the NVD CVEs mapped to it.

Also known as ODC, OWASP DependencyCheck, dependency-check-maven

OWASP Dependency-Check (ODC, also written dependency-check) is an open source software composition analysis tool that infers a Common Platform Enumeration (CPE) identifier for each dependency from its metadata, then reports the CVEs that the National Vulnerability Database (NVD) maps to that CPE. Its results are only as good as that guess and the NVD's CPE data.

As of November 2026, the current release is 13.0.0, published on August 3, 2026. It ships as a CLI, Maven and Gradle plugins, an Ant task, and a Docker image. Underneath, it is mainly two different engines writing to one report: a CPE matcher for JAR, .NET, and other binary and manifest files, and a passthrough to npm, Yarn, pnpm, and bundler-audit advisory data for lockfiles. Neither engine looks at what the code inside a package does.

Our position: ODC is a reasonable free baseline for inventorying known CVEs in JVM builds, and the wrong tool to rely on against supply chain attacks. Its CPE engine now has a structural blind spot. Since April 2026, NIST adds CPE data only to CVEs that meet its priority criteria, and ODC's maintainers say plainly that the tool cannot match a CVE without it. Its lockfile path learns about malware only after GitHub publishes an advisory, which in the chalk compromise came almost four hours after the malicious version went live.

How does OWASP Dependency-Check work?

#

OWASP Dependency-Check works by collecting evidence about each file, guessing which NVD product that file is, and then listing the CVEs filed against that product. The project's own description of its internals is short and worth reading in full.

File type analyzers do the collecting. The JAR analyzer reads META-INF/MANIFEST.MF, any embedded pom.xml, and the Java package names inside the archive. Every value it extracts goes into one of three evidence buckets (vendor, product, or version) and gets a confidence rating of HIGHEST, HIGH, MEDIUM, or LOW.

The CPE analyzer turns that evidence into an identifier. It queries a local Apache Lucene index of the vendor and product names that appear in NVD CPE data. It starts with only the HIGHEST-confidence evidence, adds the next tier on each pass, and stops at the first tier that produces a verified match. The resulting CPE inherits the confidence of the weakest evidence used to find it.

The CVE side is a join. Each NVD record lists the CPEs it applies to as cpeMatch criteria, and ODC keeps a full local copy of those records in an H2 database:

JSON
"cve": {
  "id": "CVE-2008-3909",
  "cpeMatch": [
    {
      "vulnerable": true,
      "criteria": "cpe:2.3:a:django_project:django:0.91:*:*:*:*:*:*:*",
      "matchCriteriaId": "B1CE5394-8883-47DB-9214-CCDD05811179"
    }
  ]
}

If the guessed CPE and the dependency's version satisfy a CVE's criteria, the CVE lands in the report. ODC has pulled this data from the NVD API 2.0 since version 9.0.0 in November 2023. ODC's defaults pace NVD requests at 5 per 30 seconds without an API key and 50 with one, which is why the project calls updates without a key "extremely slow." ODC does not identify artifacts by looking up their hashes in a list of vulnerable files. Its Maven Central and repository-manager analyzers use a JAR's hash only to fetch a more reliable pom.xml as better evidence.

Lockfiles take a second path that skips the CPE guess. The Node Audit analyzer rewrites package-lock.json into the payload npm 6 used to send, then POSTs it to the registry's legacy audit endpoint with a hard-coded npm/6.1.0 node/v10.5.0 linux x64 User-Agent. The Yarn and pnpm analyzers shell out to those tools' audit commands, and the Ruby analyzer wraps bundle-audit. These paths match exact package names and versions against advisory data, mostly from the GitHub Advisory Database. A third, smaller path, the RetireJS analyzer, fingerprints bundled JavaScript files against the RetireJS vulnerability repository.

Path 1: CPE engine

*.jar *.war *.dll package.json go.mod ...

  1. Analyzers extract vendor, product, version evidence, each rated HIGHEST to LOW
  2. CPE analyzer searches a Lucene index of NVD vendor/product names, HIGHEST tier first
    āœ— Wrong guess: false positive. 947 shipped suppression rules exist to undo these.
  3. Local H2 copy of the NVD returns CVEs whose cpeMatch covers that CPE and version
    āœ— CVE not enriched: silent miss. 42,353 CVEs were "Not Scheduled" for enrichment as of August 2026.

Path 2: audit passthrough

package-lock.json yarn.lock pnpm-lock.yaml Gemfile.lock

  1. Lockfile rewritten as an npm 6 audit payload, or handed to yarn/pnpm audit or bundle-audit
  2. POST to registry.npmjs.org/-/npm/v1/security/audits as npm/6.1.0
  3. Advisories matched by exact name and version, including malware advisories
    āœ— No advisory yet: nothing reported. chalk@5.6.1 was live 3 h 58 min before its advisory.
One report: HTML, JSON, XML, SARIF, ...
Figure 1. OWASP Dependency-Check's two detection paths and where each one fails.

In text form, the figure shows two pipelines feeding one report. The CPE engine handles JAR, WAR, .NET assemblies, package.json, and the experimental Python, Go, and Ruby gemspec analyzers. It runs four steps: analyzers extract vendor, product, and version evidence with confidence ratings; the CPE analyzer searches a Lucene index of NVD vendor and product names, from HIGHEST confidence down; the local H2 copy of the NVD returns CVEs whose cpeMatch criteria cover that CPE and version; the result goes to the report. It fails in two places: a wrong CPE guess produces a false positive, and a CVE that NIST never enriched with CPE data produces a silent miss. The audit passthrough handles package-lock.json, npm-shrinkwrap.json, yarn.lock, pnpm-lock.yaml, and Gemfile.lock. It converts the lockfile into an audit request, sends it to the npm registry or runs the ecosystem's audit tool, receives advisories matched by exact name and version, and writes them to the same report. It fails in one place: nothing is reported until someone has published an advisory.

Where the CPE guess goes wrong

#

A CPE guess fails when a dependency's name collides with an unrelated product's name. The clearest example lives in ODC's own base suppression file. Redis client libraries contain the word "redis," so ODC can guess cpe:/a:redis:redis, which is the Redis server, and attach every server CVE to a client library. The maintainers ship this rule to undo that guess:

HTML, XML
<suppress base="true">
    <notes><![CDATA[
        FP per #4321, #7444, #7740, 8016
        Redis client packages within various languages are not the same as the redis server
        NOTE: the additional colon in the CPE is required to not match on prefix with cpe:/a:redis:redis.js etc
        ]]></notes>
    <packageUrl regex="true">^pkg:(pypi|nuget|generic|npm|composer)/.*[rR]edis.*@.*$</packageUrl>
    <cpe>cpe:/a:redis:redis:</cpe>
</suppress>

Rules like this one are the hidden cost of CPE matching. We counted the rules ODC distributes on November 8, 2026. The bundled base file holds 627 suppression rules. The hosted file, which ODC downloads again whenever its cached copy is more than two hours old, holds 320 more. That is 947 maintainer-written corrections to the guesser, before a single user writes one for their own project.

Users add their own rules the same way. Each CPE and CVE in the HTML report has a suppress button that generates the XML for a rule, and rules can select files by SHA-1, package URL, Maven coordinates, or file path. Give every local rule an until date so it expires and forces a second look, because a suppression without an expiry outlives the reason it was written.

False negatives are quieter. When a JAR carries little metadata, such as a shaded "uber-jar" without its original POMs, the analyzers collect few evidence items and the CPE search can come back empty. The report then shows that dependency with no CPE and no CVEs, which reads exactly like a clean result. ODC's report guide says an evidence count of 0 to 5 may mean there was not enough information to identify a CPE. The ODC docs warn that scanning JVM artifacts with the CLI without access to Maven Central "may result in significant numbers of false positives and negatives." The Maven and Gradle plugins avoid most of this, because they pass resolved coordinates instead of making ODC infer them from the archive.

One default deserves a warning of its own. The Maven plugin's failBuildOnCVSS defaults to 11. CVSS scores top out at 10, so an unconfigured plugin produces a report and never fails a build.

Why does OWASP Dependency-Check miss new CVEs?

#

OWASP Dependency-Check misses CVEs that the NVD has not enriched with CPE data, because a CVE with no cpeMatch criteria gives the CPE analyzer nothing to join on. Until 2024, a missing CPE usually meant the NVD had not reached a record yet. Since April 2026, for any CVE outside NIST's priority criteria, it can mean the NVD never will.

In April 2026, NIST officially stopped enriching most CVEs. The NVD now enriches CVEs in the CISA Known Exploited Vulnerabilities catalog, CVEs in software the federal government uses, and CVEs in software designated critical under Executive Order 14028. Everything else is labeled "Not Scheduled." NIST attributed the change to a 263% increase in CVE submissions between 2020 and 2025. NVD dashboard figures published alongside NIST's proposed AI-enabled NVD overhaul show the scale. As of August 17, 2026, the NVD listed 42,353 CVEs as "Not Scheduled," against 3,049 awaiting or undergoing enrichment. In August 2026 alone, it enriched 2,246 of the 6,092 new CVEs it received.

The effect on ODC is already on its issue tracker. On October 13, 2026, a user reported in issue #8840 that dependency-check-maven 13.0.0 flagged a vulnerable log4j-core in a test project but missed CVE-2026-89425 in jackson-core 3.x. The NVD record for that CVE had no CPE data. The issue was closed as not planned the same day, and ODC collaborator chadlwilson explained why:

"ODC can only match NVD CVEs that are enriched with CPE information from NVD." (chadlwilson, ODC collaborator, October 13, 2026)

A follow-up feature request, issue #8845, asks ODC to match on fields that CNAs supply directly, such as a package name. It is open with no decision. In that thread, chadlwilson noted that for those CNA-supplied fields, "there are zero standards for these values," so matching on them would trade missed CVEs for new false positives.

The NVD dependency has also become an operational one. In February 2025, a change in NVD API data broke downloads in older releases, and the project told every user to upgrade to 12.1.0 or later. ODC's optional OSS Index analyzer can add advisories the NVD lacks, but it has required an API token since September 2025, and since version 12.1.6 ODC disables it automatically when no credentials are set. A pipeline that ran fine in 2024 can now be quietly scanning against less data than it used to.

Does OWASP Dependency-Check detect malicious packages?

#

OWASP Dependency-Check detects a malicious package only after someone has published an advisory for it, and only through its lockfile audit path. The CPE engine cannot represent malware at all. A malicious package usually gets a GitHub malware advisory with no CVE ID, so there is nothing in the NVD for a CPE to join on.

We replayed ODC's npm request against the live registry on November 8, 2026, using the endpoint and User-Agent its source code sends and a payload in the shape its NpmPayloadBuilder produces. The payload listed four dependencies: event-stream@3.3.6, its dependency flatmap-stream@0.1.1, chalk@5.6.1, and lodash@4.17.15:

Bash
$ curl -s -X POST https://registry.npmjs.org/-/npm/v1/security/audits \
    -H 'Content-Type: application/json' \
    -H 'User-Agent: npm/6.1.0 node/v10.5.0 linux x64' \
    -H 'npm-in-ci: false' -H "npm-session: $(openssl rand -hex 8)" \
    --data @payload.json \
  | jq '.advisories["1107375"] | {module_name, title, severity, vulnerable_versions, cves, github_advisory_id, created}'
{
  "module_name": "chalk",
  "title": "Malware in chalk",
  "severity": "critical",
  "vulnerable_versions": "=5.6.1",
  "cves": [],
  "github_advisory_id": "GHSA-2v46-p5h4-248w",
  "created": "2025-09-08T17:11:19.000Z"
}

The full response contained nine advisory entries: four critical, three high, and two moderate. All four critical entries flag malicious code, in chalk and in the 2018 event-stream compromise, and none of the four carries a CVE ID. The five lodash entries are ordinary vulnerabilities with CVE IDs. So ODC does report known malware on npm, which is easy to miss if you only read about its CPE engine. When --failOnCVSS is set, ODC's CLI maps an unscored "critical" advisory to a CVSS-equivalent 10.0, so a known-malicious version does fail the build.

The problem is when "known" happens. In the Qix maintainer compromise, the registry records chalk@5.6.1 as published at 13:13:05 UTC on September 8, 2025. The clean chalk@5.6.2 followed at 14:47:54. The audit API's own created field dates the chalk malware advisory to 17:11:19 UTC. For 3 hours and 58 minutes, an ODC scan of a lockfile pinning the malicious version would have passed. Our npm audit entry shows the same gap stretching to days for other packages in that campaign.

Position in the pipeline compounds the timing. ODC runs as a build step, after npm ci or mvn verify has already downloaded every dependency. On npm before v12, that install step also executed every dependency's lifecycle scripts, which is where almost every npm worm and credential stealer since late 2025 has run. npm v12 made dependency install scripts opt-in in July 2026, which narrows the exposure but does not move ODC's scan earlier. ODC is a report on what a build already pulled in. It is not a gate in front of the install.

ODC analyzes what a package's metadata claims, not what its code does. Catching a malicious version before an advisory exists requires inspecting the published artifact itself, and blocking it requires sitting in the install path. Socket does both. Its analysis reads the package's published files and raises alerts such as Install scripts, Network access, Obfuscated code, and AI-detected potential malware. Socket Firewall runs as an HTTP proxy between the package manager and the registry (for example, sfw npm install) and refuses to download packages Socket has confirmed as malicious, including transitive ones.

OWASP Dependency-Check vs. other dependency scanners

#

OWASP Dependency-Check is one of three ways to decide whether a dependency is dangerous, and the three fail differently:

ApproachHow it identifies a packageVulnerability dataTypical failureFlags malicious versions?
CPE matching (ODC's JAR and .NET engine)Guesses an NVD vendor and product from file metadataNVD CVEs that NIST enriched with CPE dataName collisions cause false positives; unenriched CVEs are silently missedNo
Package-identifier matching (ODC's lockfile path, npm audit, OSV-Scanner)Exact ecosystem, name, and version from a lockfile or manifestGitHub Advisory Database and OSV recordsKnows only what has been disclosed; says nothing about reachabilityOnly after an advisory is published
Package content analysis (Socket)Exact ecosystem, name, and version, then the package's published filesStatic and behavioral analysis of the code, such as install scripts, network access, and obfuscationFlags risky but legitimate behavior that a person has to reviewYes, including versions with no advisory yet

Verdict: use ODC when you need a free, self-hosted CVE inventory for Maven or Gradle builds and you are willing to maintain suppressions. For anything with a lockfile, exact name-and-version matching against GitHub advisories or OSV data gives the same coverage with far fewer false positives, and ODC's own lockfile path already works that way. Neither replaces package content analysis for supply chain attacks, and that analysis belongs before install, not after the build.

Running OWASP Dependency-Check without the usual failure modes

#

If ODC is staying in your pipeline, five settings decide whether its report means anything:

  • NVD access. Pass an NVD API key through nvdApiKeyEnvironmentVariable in CI, and cache ODC's data directory between runs. Teams with many builds should point --nvdDatafeed at a shared mirror instead of having every runner hit the NVD API.
  • Build failure. Set failBuildOnCVSS (or --failOnCVSS on the CLI) explicitly. The default never fails.
  • Suppressions. Keep the suppression file in version control, require a note on every rule, and give each one an until date. ODC 12.0.0 added a flag that fails the build when a suppression rule matches nothing, which catches rules that have outlived their dependency.
  • Scan inputs. Prefer the Maven or Gradle plugin over pointing the CLI at a directory of JARs, so ODC works from resolved coordinates rather than guesses.
  • Triage. Treat ODC's severity column as an input, not a priority order. Most of what it reports will not be reachable from your code, and reachability analysis is a better filter than a CVSS threshold.

None of these settings fixes the underlying data. ODC's JVM coverage now tracks the share of the CVE stream that NIST still enriches with CPE data, and that share is shrinking. NIST has started work on a CPE 3.0 specification, but as of August 2026 its project page said no specification text existed yet. The project that taught a generation of Java teams to scan their dependencies now depends on a join key its upstream has stopped maintaining for much of the new CVE stream. Until ODC can match on package identifiers rather than CPEs, its silence on a dependency is not evidence that the dependency is safe.