138% more reported CVEs per day in 2026 than last year.New: always-on Fixboxes. Vulnerable dependencies, fixed and verified.

Vulnerabilities

CVE scanner: how CVE scanning works, and why recording the build beats scanning it

A CVE scanner works out which open source components are in your software and checks each one against published vulnerabilities. It is only as good as that first step. A component the scanner never identifies can never match a CVE, and the most dangerous ones are often exactly the ones it cannot see.

Updated

How a CVE scanner works

Every CVE scanner, free or commercial, does the same three things. The differences between tools are in how well they do each one.

  1. Identify the components. The scanner works out what is inside the target and lists each component with a name and a version.
  2. Match them to vulnerability data. Each component is looked up in one or more vulnerability databases to find the CVEs and other advisories that cover its version.
  3. Report. Findings come out with a severity, usually a CVSS score, and a fixed version where one exists. In CI, a threshold can fail the job.

Step 1: three ways to identify components

Method What the scanner reads Where it struggles
Manifests and lockfiles package-lock.json, poetry.lock, Cargo.lock, go.sum and similar files in the repository Anything not declared in those files, and repositories that commit no lockfile
Installed package metadata The package database of a container image or host, such as the records apt or apk keep Software copied in, downloaded with curl or compiled from source, which leaves no package record
Binary fingerprints Version strings, file hashes and metadata embedded in compiled files Compiled code that carries little metadata, such as most Rust binaries, where the scanner has to guess what went in

Most open source vulnerability scanners combine the first two. Binary analysis is more common in tools built for firmware and embedded products.

Step 2: matching components to CVE data

The main sources are the National Vulnerability Database (NVD), OSV, the GitHub Advisory Database and the security feeds of Linux distributions and vendors. How a component is matched depends on the source:

  • By CPE. NVD records say which products a CVE affects as CPE names, such as cpe:2.3:a:tukaani:xz. The scanner has to turn each package name into a CPE guess, and the vendor and product in the dictionary are not always what the package is called in its ecosystem.
  • By package URL or ecosystem name. OSV and the GitHub Advisory Database name the affected package by its ecosystem and name, for example jinja2 on PyPI, with the affected version ranges. A package URL such as pkg:pypi/[email protected] matches these records directly, with no guessing.

Step 3: the report

A first scan of a real project often returns hundreds of findings. Severity alone is a poor way to rank them: exploitation data from CISA's KEV catalog and EPSS usually tells you more. How to read SCA scan results walks through the order, and how to reduce vulnerability noise covers what to do when the list is too long to act on.

Where CVE scanning goes wrong

The four failures below are limits of scanning itself, not of any one product. Switching scanners changes the details, not the pattern.

1. Components the scanner never identifies

A scanner reads files. Anything a build fetches that no file declares is invisible to it. These hidden dependencies are common:

  • Install scripts. npm runs preinstall and postinstall scripts, and those can download anything. That is the route the Shai-Hulud worm used.
  • Build scripts. Some Rust build scripts download libraries at build time, and nothing in Cargo.lock records it.
  • Base images and their layers. In a container build, the base image and its operating system packages are separate from your application's manifest. A repository scan does not see them at all.
  • The pipeline itself. The GitHub Actions a workflow runs and the tools it installs are part of the build, not part of any lockfile.

A component that is never identified produces no finding, so a clean report can simply mean the scanner did not look where the problem was. CRACI has found vulnerable packages that Snyk and Aikido did not report, because the components were never in what they scanned.

2. Matching noise

CPE matching fails in both directions. An ambiguous name hits the wrong product and creates a false positive that someone has to triage. A missing or wrong CPE matches nothing, and the CVE is silently missed. The NVD has also been behind: since April 15, 2026 it enriches CVEs by priority and labels the rest "Lowest Priority - not scheduled for immediate enrichment", so many new CVEs reach a CPE-based scanner late or without the data it needs. Package URL matching avoids the guessing, but only for components that were identified in the first place.

3. Scanning something other than what shipped

The scan and the release are often not the same thing. A pull request scan reads the repository; the release build resolves versions when it runs. Without a lockfile, a version range can resolve differently a week later. A mutable image tag such as node:22 points to a different image over time. Even with the same commit, builds are not reproducible by default: package managers can resolve and install in a different order, and build steps can include randomness. The only reliable record of what shipped is one taken while the release build ran. See why supply chain security belongs in your CI.

4. A scan is a snapshot

A command line scan tells you what was vulnerable at the moment it ran. New CVEs are published every day for versions you already shipped. Hosted tools re-check a repository's current manifests as advisories appear, which tells you about your main branch today. It does not tell you that releases 2.1 to 2.4, shipped between January and April, contained a package that got a critical CVE in June, after you had already upgraded it on main.

The alternative: record the build, then keep matching

CRACI is a recorder, not a scanner. It is a GitHub Actions runner: you change runs-on to craci, and as each job runs, CRACI sees the packages and files it pulls in from package registries, Git sources and container registries, including packages restored from CI caches. Instead of working out afterward what went into a build, it records what the build fetched.

  • It records the hidden dependencies that lockfile-based tools miss. Downloads by install hooks and build scripts, and the base image and its operating system layers, are in the record because CRACI sees the traffic. Each job's SBOM also carries a completeness state, so a job whose traffic CRACI could not fully see is flagged instead of looking complete.
  • No false positives in the component list. Every component in a CRACI SBOM was actually pulled into the build. That is a claim about the SBOM, not the vulnerability findings: a matched CVE can still not affect your product, which is what VEX is for.
  • Matching by package URL. Every recorded package is identified by its package URL, and each finding shows the advisories that apply (CVE, GHSA and other IDs) with severity, plus the packages that pull the vulnerable one in.
  • Continuous re-evaluation. CRACI keeps re-evaluating monitored SBOMs as new vulnerabilities are published, so a CVE published months after a release shows up against that release without anyone running a scan.
  • Build history. Every past build and its SBOM is kept for your retention period, so you can see which builds contained a vulnerable dependency, direct or transitive, and for how long you were affected.
  • Policy gates. A build can be blocked on findings, including any build that contains a specific CVE, so a vulnerability you fixed does not come back in a later build.

Security teams triage the findings and send them to the teams that own the fix. For the full workflow, see vulnerability tracking and CVE remediation.

CVE scanner vs build recorder

CVE scanner Build recorder (CRACI)
How it finds components Reads manifests, lockfiles, package databases or binaries Records what each build job fetched
Hidden dependencies Missed unless they leave a record in the files it reads Recorded, with a completeness state for what it could not see
What it describes Whatever it was pointed at, when it ran The CI build that produced the release
Matching CPE, package URL or ecosystem name, depending on the tool Package URL
New CVEs after release Found when you scan again, or by monitoring the current repository Continuous re-evaluation of the SBOMs of what shipped
Which releases were affected Needs past results that were kept and are still accurate Build history, within your retention period
Images you did not build, hosts, IaC Yes, depending on the tool No
Reachability analysis Some commercial tools No

Free CVE scanners

Four open source vulnerability scanners cover most needs, all free under Apache-2.0:

  • Trivy, from Aqua Security, scans images, filesystems, repositories, VM images and Kubernetes, using vendor advisories, the GitHub Advisory Database and the NVD. It also finds IaC misconfigurations, secrets and licenses. CRACI vs Trivy.
  • Grype, from Anchore, scans images, filesystems and SBOMs against its own database, downloaded locally, and can fail builds with --fail-on. CRACI vs Syft and Grype.
  • OSV-Scanner, from Google, is the official client for the OSV.dev database and reads lockfiles, container images and SBOMs.
  • OWASP Dependency-Check identifies components by CPE and matches them against the NVD, which suits Java and .NET projects best.

You run them yourself, so monitoring, triage and history are yours to build. They also share the limits above: each reads files, so each misses what the files do not declare. For commercial options, see the best SCA tools compared, and for why free SBOM generators disagree on the same repository, what open source SBOM generators miss.

When a scanner is still the right tool

Recording only works for builds that run on CRACI. Keep a scanner for:

  • Images you did not build. Third-party images pulled into a cluster have no build of yours to record. See container scanning.
  • Running hosts, clusters and VM images. What is installed on a server today is a question for a scanner.
  • Infrastructure as code and misconfigurations. CRACI does not check Terraform, Kubernetes manifests or configuration.
  • Feedback before anything builds. A scan in the editor or on a pull request warns a developer about a vulnerable package before it is merged.

CRACI also does not offer reachability analysis or scan your own code. For the software you build in GitHub Actions, though, recording the build answers the CVE question with fewer gaps than any scan of files.

CVE scanning: frequently asked questions

What is a CVE scanner?

A CVE scanner is a tool that identifies the components in software, such as open source packages in a repository or container image, and checks each one against published vulnerabilities from sources like the NVD, OSV and the GitHub Advisory Database. It reports the CVEs it finds, usually with a severity and a fixed version.

How does CVE scanning work?

The scanner reads manifests and lockfiles, the package database of an image, or compiled binaries to list components and versions. It then matches each one to vulnerability records, by CPE for NVD data or by package name and ecosystem for OSV and GitHub advisories, and reports the matches with severity.

What is the best free CVE scanner?

Trivy, Grype, OSV-Scanner and OWASP Dependency-Check are free and open source. Trivy covers the most targets, including IaC and secrets; OSV-Scanner uses OSV.dev; Dependency-Check matches by CPE against the NVD and suits Java and .NET. All read files, so all miss dependencies that no file declares.

Why do CVE scanners miss vulnerabilities?

Usually because they never identified the component. Code downloaded by install or build scripts, base image layers and tools a pipeline installs are not in the files a scanner reads. CPE matching can also miss a CVE when the name does not match or the NVD has not added the affected products yet.

Is a dependency scanner the same as a CVE scanner?

Mostly. A dependency scanner checks the packages a project depends on for known vulnerabilities, which is a CVE scan of dependencies. A CVE scanner can also cover operating system packages in images and hosts, and many dependency scanners also check licenses.

How often should you run a CVE scan?

On every pull request, to stop new risks entering, and continuously after release, because new CVEs are published for versions you already shipped. Continuous checking only helps if you kept an accurate record of what each release contained.

Is CRACI a CVE scanner?

No. CRACI is a recorder. It runs your GitHub Actions jobs, records the packages each job actually fetched, and keeps re-evaluating those SBOMs as new vulnerabilities are published. Build history shows which builds contained a vulnerable dependency. It does not scan images you did not build, hosts or IaC.

See the CVEs your scanner could not see

Run one GitHub Actions workflow on CRACI and compare its recorded SBOM and findings with what your scanner reported.

Book a demo