138% meer gemelde CVE's per dag in 2026 dan vorig jaar.Nieuw: altijd actieve Fixboxes. Kwetsbare afhankelijkheden, gefixt en geverifieerd.

Kwetsbaarheden

CVE-scanner: hoe CVE-scanning werkt, en waarom de build vastleggen beter is dan hem scannen

Een CVE-scanner zoekt uit welke open-sourcecomponenten in uw software zitten en controleert elk ervan op gepubliceerde kwetsbaarheden. Hij is maar zo goed als die eerste stap. Een component dat de scanner nooit herkent, kan nooit aan een CVE worden gekoppeld, en de gevaarlijkste zijn vaak juist de componenten die hij niet kan zien.

Bijgewerkt op

Hoe een CVE-scanner werkt

Elke CVE-scanner, gratis of commercieel, doet dezelfde drie dingen. De verschillen tussen tools zitten in hoe goed ze elk ervan doen.

  1. De componenten herkennen. De scanner zoekt uit wat er in het doel zit en vermeldt elk component met een naam en een versie.
  2. Ze koppelen aan kwetsbaarheidsgegevens. Elk component wordt opgezocht in een of meer kwetsbaarheidsdatabases om de CVE's en andere advisories te vinden die voor de versie gelden.
  3. Rapporteren. Bevindingen komen naar buiten met een ernst, meestal een CVSS-score, en een versie met de oplossing waar die bestaat. In CI kan een drempel de job laten mislukken.

Stap 1: drie manieren om componenten te herkennen

Methode Wat de scanner leest Waar het moeizaam gaat
Manifesten en lockfiles package-lock.json, poetry.lock, Cargo.lock, go.sum en vergelijkbare bestanden in de repository Alles wat niet in die bestanden is gedeclareerd, en repositories die geen lockfile committen
Metadata van geïnstalleerde pakketten De pakketdatabase van een containerimage of host, zoals de gegevens die apt of apk bijhouden Software die is binnengekopieerd, met curl gedownload of uit broncode gecompileerd, wat geen pakketgegeven achterlaat
Binaire vingerafdrukken Versiestrings, bestandshashes en metadata die in gecompileerde bestanden zijn ingebed Gecompileerde code met weinig metadata, zoals de meeste Rust-binaries, waarbij de scanner moet raden wat erin is gegaan

De meeste open-sourcekwetsbaarheidsscanners combineren de eerste twee. Binaire analyse komt vaker voor in tools die voor firmware en embedded producten zijn gebouwd.

Stap 2: componenten koppelen aan CVE-gegevens

De belangrijkste bronnen zijn de National Vulnerability Database (NVD), OSV, de GitHub Advisory Database en de beveiligingsfeeds van Linux-distributies en leveranciers. Hoe een component wordt gekoppeld, hangt af van de bron:

  • Via CPE. NVD-records vermelden welke producten een CVE raakt als CPE-namen, zoals cpe:2.3:a:tukaani:xz. De scanner moet van elke pakketnaam een CPE-gok maken, en de leverancier en het product in het woordenboek zijn niet altijd hoe het pakket in zijn ecosysteem heet.
  • Via package URL of ecosysteemnaam. OSV en de GitHub Advisory Database noemen het getroffen pakket bij zijn ecosysteem en naam, bijvoorbeeld jinja2 op PyPI, met de getroffen versiebereiken. Een package URL zoals pkg:pypi/[email protected] matcht deze records rechtstreeks, zonder te raden.

Stap 3: het rapport

Een eerste scan van een echt project levert vaak honderden bevindingen op. Ernst alleen is een slechte manier om ze te rangschikken: exploitatiegegevens uit de KEV-catalogus van CISA en EPSS zeggen meestal meer. Hoe u SCA-scanresultaten leest loopt de volgorde door, en hoe u kwetsbaarheidsruis vermindert behandelt wat u doet wanneer de lijst te lang is om op te handelen.

Waar CVE-scanning misgaat

De vier tekortkomingen hieronder zijn grenzen van scannen zelf, niet van één product. Een andere scanner kiezen verandert de details, niet het patroon.

1. Componenten die de scanner nooit herkent

Een scanner leest bestanden. Alles wat een build ophaalt en dat in geen enkel bestand is gedeclareerd, is voor hem onzichtbaar. Deze verborgen afhankelijkheden komen vaak voor:

  • Installatiescripts. npm draait preinstall- en postinstall-scripts, en die kunnen alles downloaden. Dat is de route die de worm Shai-Hulud gebruikte.
  • Buildscripts. Sommige Rust-buildscripts downloaden bibliotheken tijdens de build, en niets in Cargo.lock legt dat vast.
  • Base images en hun lagen. Bij een containerbuild staan de base image en de pakketten van het besturingssysteem los van het manifest van uw applicatie. Een repositoryscan ziet ze helemaal niet.
  • De pipeline zelf. De GitHub Actions die een workflow draait en de tools die hij installeert, zijn onderdeel van de build, niet van een lockfile.

Een component dat nooit wordt herkend, levert geen bevinding op, dus een schoon rapport kan gewoon betekenen dat de scanner niet keek waar het probleem zat. CRACI heeft kwetsbare pakketten gevonden die Snyk en Aikido niet rapporteerden, omdat de componenten nooit in wat zij scanden zaten.

2. Ruis bij het koppelen

CPE-matching faalt in beide richtingen. Een dubbelzinnige naam raakt het verkeerde product en veroorzaakt een fout-positief dat iemand moet triëren. Een ontbrekende of verkeerde CPE matcht niets, en de CVE wordt ongemerkt gemist. De NVD liep ook achter: sinds 15 april 2026 verrijkt hij CVE's op prioriteit en labelt hij de rest als "Lowest Priority - not scheduled for immediate enrichment", dus veel nieuwe CVE's bereiken een CPE-gebaseerde scanner laat of zonder de gegevens die hij nodig heeft. Matching op package URL voorkomt het raden, maar alleen voor componenten die überhaupt zijn herkend.

3. Iets anders scannen dan wat is geleverd

De scan en de release zijn vaak niet hetzelfde. Een pull-requestscan leest de repository; de releasebuild bepaalt versies wanneer hij draait. Zonder lockfile kan een versiebereik een week later anders uitvallen. Een veranderlijke imagetag zoals node:22 wijst na verloop van tijd naar een andere image. Zelfs met dezelfde commit zijn builds standaard niet reproduceerbaar: pakketbeheerders kunnen in een andere volgorde resolven en installeren, en buildstappen kunnen willekeur bevatten. De enige betrouwbare vastlegging van wat is geleverd, is er een die is gemaakt terwijl de releasebuild draaide. Zie waarom softwareketenbeveiliging in uw CI hoort.

4. Een scan is een momentopname

Een scan via de opdrachtregel vertelt u wat kwetsbaar was op het moment dat hij draaide. Er worden elke dag nieuwe CVE's gepubliceerd voor versies die u al hebt geleverd. Gehoste tools controleren de huidige manifesten van een repository opnieuw wanneer er advisories verschijnen, wat u iets vertelt over uw main-branch vandaag. Het vertelt u niet dat releases 2.1 tot en met 2.4, geleverd tussen januari en april, een pakket bevatten dat in juni een kritieke CVE kreeg, nadat u het op main al had bijgewerkt.

Het alternatief: leg de build vast en blijf matchen

CRACI legt vast, het is geen scanner. Het is een GitHub Actions-runner: u wijzigt runs-on in craci, en terwijl elke job draait, ziet CRACI de pakketten en bestanden die hij binnenhaalt uit pakketregistries, Git-bronnen en containerregistries, inclusief pakketten die uit CI-caches worden teruggezet. In plaats van achteraf uit te zoeken wat er in een build is gegaan, legt het vast wat de build heeft opgehaald.

  • Het legt de verborgen afhankelijkheden vast die tools op basis van lockfiles missen. Downloads door installatiehooks en buildscripts, en de base image met de lagen van het besturingssysteem, staan in de vastlegging omdat CRACI het verkeer ziet. De SBOM van elke job heeft ook een volledigheidsstatus, zodat een job waarvan CRACI het verkeer niet volledig kon zien, wordt gemarkeerd in plaats van volledig te lijken.
  • Geen fout-positieven in de componentenlijst. Elk component in een SBOM van CRACI is werkelijk in de build binnengehaald. Dat is een uitspraak over de SBOM, niet over de kwetsbaarheidsbevindingen: een gekoppelde CVE kan uw product alsnog niet raken, en daarvoor is VEX er.
  • Matching op package URL. Elk vastgelegd pakket wordt geïdentificeerd door zijn package URL, en elke bevinding toont de advisories die van toepassing zijn (CVE-, GHSA- en andere ID's) met ernst, plus de pakketten die het kwetsbare pakket binnenhalen.
  • Continue herbeoordeling. CRACI blijft gemonitorde SBOM's opnieuw beoordelen zodra nieuwe kwetsbaarheden worden gepubliceerd, dus een CVE die maanden na een release verschijnt, wordt tegen die release zichtbaar zonder dat iemand een scan draait.
  • Buildhistorie. Elke eerdere build en zijn SBOM worden bewaard gedurende uw bewaartermijn, zodat u kunt zien welke builds een kwetsbare afhankelijkheid bevatten, direct of transitief, en hoe lang u getroffen was.
  • Policy gates. Een build kan op bevindingen worden geblokkeerd, waaronder elke build die een specifieke CVE bevat, zodat een kwetsbaarheid die u hebt opgelost niet in een latere build terugkomt.

Securityteams triëren de bevindingen en sturen ze naar de teams die eigenaar zijn van de oplossing. Voor de volledige workflow, zie kwetsbaarheden volgen en CVE-remediatie.

CVE-scanner vs buildvastlegger

CVE-scanner Buildvastlegger (CRACI)
Hoe het componenten vindt Leest manifesten, lockfiles, pakketdatabases of binaries Legt vast wat elke buildjob heeft opgehaald
Verborgen afhankelijkheden Gemist, tenzij ze een spoor achterlaten in de bestanden die hij leest Vastgelegd, met een volledigheidsstatus voor wat het niet kon zien
Wat het beschrijft Waarop hij ook was gericht, op het moment dat hij draaide De CI-build die de release opleverde
Matching CPE, package URL of ecosysteemnaam, afhankelijk van de tool Package URL
Nieuwe CVE's na de release Gevonden wanneer u opnieuw scant, of door de huidige repository te monitoren Continue herbeoordeling van de SBOM's van wat is geleverd
Welke releases getroffen waren Vereist eerdere resultaten die zijn bewaard en nog kloppen Buildhistorie, binnen uw bewaartermijn
Images die u niet zelf bouwde, hosts, IaC Ja, afhankelijk van de tool Nee
Reachability-analyse Sommige commerciële tools Nee

Gratis CVE-scanners

Vier open-sourcekwetsbaarheidsscanners dekken de meeste behoeften, allemaal gratis onder Apache-2.0:

  • Trivy, van Aqua Security, scant images, bestandssystemen, repositories, VM-images en Kubernetes, met advisories van leveranciers, de GitHub Advisory Database en de NVD. Het vindt ook IaC-misconfiguraties, secrets en licenties. CRACI vs Trivy.
  • Grype, van Anchore, scant images, bestandssystemen en SBOM's tegen een eigen database die lokaal wordt gedownload, en kan builds laten mislukken met --fail-on. CRACI vs Syft en Grype.
  • OSV-Scanner, van Google, is de officiële client voor de OSV.dev-database en leest lockfiles, containerimages en SBOM's.
  • OWASP Dependency-Check herkent componenten via CPE en matcht ze tegen de NVD, wat het best past bij Java- en .NET-projecten.

U draait ze zelf, dus monitoring, triage en historie moet u zelf opbouwen. Ze delen ook de grenzen hierboven: elk leest bestanden, dus elk mist wat de bestanden niet declareren. Voor commerciële opties, zie de beste SCA-tools vergeleken, en voor waarom gratis SBOM-generatoren het over dezelfde repository oneens zijn, wat open-source-SBOM-generatoren missen.

Wanneer een scanner nog steeds de juiste tool is

Vastleggen werkt alleen voor builds die op CRACI draaien. Behoud een scanner voor:

  • Images die u niet zelf hebt gebouwd. Images van derden die in een cluster worden binnengehaald, hebben geen build van u om vast te leggen. Zie containerscanning.
  • Draaiende hosts, clusters en VM-images. Wat er vandaag op een server is geïnstalleerd, is een vraag voor een scanner.
  • Infrastructure as code en misconfiguraties. CRACI controleert geen Terraform, Kubernetes-manifesten of configuratie.
  • Feedback voordat er iets wordt gebouwd. Een scan in de editor of op een pull request waarschuwt een developer voor een kwetsbaar pakket voordat het wordt gemerged.

CRACI biedt ook geen reachability-analyse en scant uw eigen code niet. Voor de software die u in GitHub Actions bouwt, beantwoordt de build vastleggen de CVE-vraag echter met minder gaten dan welke scan van bestanden ook.

CVE-scanning: veelgestelde vragen

Wat is een CVE-scanner?

Een CVE-scanner is een tool die de componenten in software herkent, zoals open-sourcepakketten in een repository of containerimage, en elk ervan controleert op gepubliceerde kwetsbaarheden uit bronnen als de NVD, OSV en de GitHub Advisory Database. Hij rapporteert de CVE's die hij vindt, meestal met een ernst en een versie met de oplossing.

Hoe werkt CVE-scanning?

De scanner leest manifesten en lockfiles, de pakketdatabase van een image of gecompileerde binaries om componenten en versies op te sommen. Daarna koppelt hij elk component aan kwetsbaarheidsrecords, via CPE voor NVD-gegevens of via pakketnaam en ecosysteem voor OSV- en GitHub-advisories, en rapporteert hij de matches met ernst.

Wat is de beste gratis CVE-scanner?

Trivy, Grype, OSV-Scanner en OWASP Dependency-Check zijn gratis en open source. Trivy dekt de meeste doelen, waaronder IaC en secrets; OSV-Scanner gebruikt OSV.dev; Dependency-Check matcht via CPE tegen de NVD en past bij Java en .NET. Allemaal lezen ze bestanden, dus allemaal missen ze afhankelijkheden die geen enkel bestand declareert.

Waarom missen CVE-scanners kwetsbaarheden?

Meestal omdat ze het component nooit hebben herkend. Code die door installatie- of buildscripts wordt gedownload, lagen van base images en tools die een pipeline installeert, staan niet in de bestanden die een scanner leest. CPE-matching kan ook een CVE missen wanneer de naam niet overeenkomt of de NVD de getroffen producten nog niet heeft toegevoegd.

Is een dependency-scanner hetzelfde als een CVE-scanner?

Grotendeels. Een dependency-scanner controleert de pakketten waarvan een project afhangt op bekende kwetsbaarheden, wat een CVE-scan van afhankelijkheden is. Een CVE-scanner kan ook pakketten van het besturingssysteem in images en hosts dekken, en veel dependency-scanners controleren ook licenties.

Hoe vaak moet u een CVE-scan draaien?

Bij elke pull request, om nieuwe risico's tegen te houden, en continu na de release, omdat er nieuwe CVE's worden gepubliceerd voor versies die u al hebt geleverd. Continu controleren helpt alleen als u een nauwkeurige vastlegging hebt bewaard van wat elke release bevatte.

Is CRACI een CVE-scanner?

Nee. CRACI legt vast. Het draait uw GitHub Actions-jobs, legt de pakketten vast die elke job werkelijk heeft opgehaald en blijft die SBOM's opnieuw beoordelen zodra nieuwe kwetsbaarheden worden gepubliceerd. De buildhistorie toont welke builds een kwetsbare afhankelijkheid bevatten. Het scant geen images die u niet zelf hebt gebouwd, hosts of IaC.

Zie de CVE's die uw scanner niet kon zien

Draai één GitHub Actions-workflow op CRACI en vergelijk de vastgelegde SBOM en bevindingen met wat uw scanner rapporteerde.

Demo boeken