Vulnerabilità
CVE scanner: come funziona la scansione CVE e perché registrare la build batte scansionarla
Uno scanner CVE ricava quali componenti open source ci sono nel Suo software e confronta ciascuno con le vulnerabilità pubblicate. È valido solo quanto quel primo passaggio. Un componente che lo scanner non identifica non potrà mai corrispondere a una CVE, e i più pericolosi sono spesso proprio quelli che non riesce a vedere.
Aggiornato il
Come funziona uno scanner CVE
Ogni scanner CVE, gratuito o commerciale, fa le stesse tre cose. Le differenze tra gli strumenti stanno in quanto bene fanno ciascuna.
- Identificare i componenti. Lo scanner ricava che cosa c'è all'interno del target ed elenca ogni componente con un nome e una versione.
- Associarli ai dati sulle vulnerabilità. Ogni componente viene cercato in uno o più database di vulnerabilità per trovare le CVE e gli altri advisory che ne riguardano la versione.
- Produrre il report. I risultati escono con una gravità, di solito un punteggio CVSS, e una versione corretta quando esiste. Nella CI, una soglia può far fallire il job.
Passaggio 1: tre modi per identificare i componenti
| Metodo | Che cosa legge lo scanner | Dove è in difficoltà |
|---|---|---|
| Manifest e lockfile | package-lock.json, poetry.lock, Cargo.lock, go.sum e file simili nel repository |
Tutto ciò che non è dichiarato in quei file, e i repository che non includono alcun lockfile |
| Metadati dei pacchetti installati | Il database dei pacchetti di un'immagine container o di un host, come i record che mantengono apt o apk |
Il software copiato, scaricato con curl o compilato dai sorgenti, che non lascia alcun record di pacchetto |
| Impronte dei binari | Stringhe di versione, hash dei file e metadati incorporati nei file compilati | Il codice compilato che contiene pochi metadati, come la maggior parte dei binari Rust, dove lo scanner deve indovinare che cosa vi è entrato |
La maggior parte degli scanner di vulnerabilità open source combina i primi due. L'analisi dei binari è più comune negli strumenti pensati per firmware e prodotti embedded.
Passaggio 2: associare i componenti ai dati CVE
Le fonti principali sono il National Vulnerability Database (NVD), OSV, il GitHub Advisory Database e i feed di sicurezza delle distribuzioni Linux e dei vendor. Il modo in cui un componente viene associato dipende dalla fonte:
-
Tramite CPE. I record dell'NVD indicano quali prodotti riguarda una CVE sotto forma di nomi
CPE, come
cpe:2.3:a:tukaani:xz. Lo scanner deve trasformare il nome di ogni pacchetto in un CPE ipotetico, e il vendor e il prodotto del dizionario non corrispondono sempre al nome del pacchetto nel suo ecosistema. -
Tramite package URL o nome nell'ecosistema. OSV e il GitHub Advisory Database indicano il pacchetto
interessato con il suo ecosistema e il suo nome, per esempio
jinja2su PyPI, insieme agli intervalli di versioni interessati. Un package URL comepkg:pypi/[email protected]corrisponde direttamente a questi record, senza ipotesi.
Passaggio 3: il report
Una prima scansione di un progetto reale restituisce spesso centinaia di risultati. La sola gravità è un pessimo criterio per ordinarli: i dati sullo sfruttamento del catalogo KEV della CISA e l'EPSS di solito dicono di più. Come leggere i risultati di una scansione SCA illustra l'ordine da seguire, e come ridurre il rumore delle vulnerabilità spiega che cosa fare quando l'elenco è troppo lungo per intervenire.
Dove sbaglia la scansione CVE
I quattro problemi seguenti sono limiti della scansione in sé, non di un singolo prodotto. Cambiare scanner cambia i dettagli, non lo schema.
1. Componenti che lo scanner non identifica mai
Uno scanner legge file. Tutto ciò che una build scarica senza che alcun file lo dichiari gli è invisibile. Queste dipendenze nascoste sono comuni:
-
Script di installazione. npm esegue gli script
preinstallepostinstall, e questi possono scaricare qualsiasi cosa. È la strada usata dal worm Shai-Hulud. -
Script di build. Alcuni script di build Rust scaricano librerie in fase di build, e nulla in
Cargo.locklo registra. - Immagini base e i loro layer. In una build di container, l'immagine base e i suoi pacchetti del sistema operativo sono separati dal manifest della Sua applicazione. Una scansione del repository non li vede affatto.
- La pipeline stessa. Le GitHub Actions eseguite da un workflow e gli strumenti che installa fanno parte della build, non di un lockfile.
Un componente mai identificato non produce alcun risultato, quindi un report pulito può semplicemente significare che lo scanner non ha guardato dove si trovava il problema. CRACI ha trovato pacchetti vulnerabili che Snyk e Aikido non avevano segnalato, perché quei componenti non erano mai stati in ciò che avevano scansionato.
2. Rumore nelle corrispondenze
La corrispondenza tramite CPE fallisce in entrambe le direzioni. Un nome ambiguo colpisce il prodotto sbagliato e crea un falso positivo che qualcuno deve analizzare. Un CPE mancante o errato non corrisponde a nulla, e la CVE viene persa senza che nessuno se ne accorga. Anche l'NVD è rimasto indietro: dal 15 aprile 2026 arricchisce le CVE in base alla priorità ed etichetta le altre "Lowest Priority - not scheduled for immediate enrichment", quindi molte nuove CVE arrivano a uno scanner basato su CPE in ritardo o senza i dati di cui ha bisogno. La corrispondenza tramite package URL evita le ipotesi, ma solo per i componenti che sono stati identificati.
3. Scansionare qualcosa di diverso da ciò che è stato distribuito
La scansione e la release spesso non sono la stessa cosa. Una scansione di una pull request legge il repository; la
build di release risolve le versioni quando viene eseguita. Senza un lockfile, un intervallo di versioni può risolversi
diversamente una settimana dopo. Un tag di immagine mutabile come node:22 punta a un'immagine diversa nel
tempo. Anche con lo stesso commit, le build non sono riproducibili per impostazione predefinita: i package manager
possono risolvere e installare in un ordine diverso, e gli step di build possono includere elementi casuali. L'unica
registrazione affidabile di ciò che è stato distribuito è quella effettuata mentre la build di release era in
esecuzione. Veda perché la sicurezza della supply chain va nella Sua CI.
4. Una scansione è un'istantanea
Una scansione da riga di comando Le dice che cosa era vulnerabile nel momento in cui è stata eseguita. Ogni giorno vengono pubblicate nuove CVE per versioni che ha già distribuito. Gli strumenti ospitati ricontrollano i manifest attuali di un repository man mano che compaiono gli advisory, il che Le dice com'è oggi il Suo branch principale. Non Le dice che le release dalla 2.1 alla 2.4, distribuite tra gennaio e aprile, contenevano un pacchetto che a giugno ha ricevuto una CVE critica, dopo che Lei lo aveva già aggiornato sul main.
L'alternativa: registrare la build, poi continuare a confrontare
CRACI è un registratore, non uno scanner. È un runner GitHub Actions: Lei cambia runs-on in
craci e, mentre ogni job è in esecuzione, CRACI vede i pacchetti e i file che scarica da registry di
pacchetti, sorgenti Git e registry di container, compresi i pacchetti ripristinati dalle cache CI. Invece di ricostruire
a posteriori che cosa è entrato in una build, registra ciò che la build ha scaricato.
- Registra le dipendenze nascoste che gli strumenti basati sui lockfile non vedono. I download effettuati da hook di installazione e script di build, e l'immagine base con i suoi layer del sistema operativo, sono nella registrazione perché CRACI vede il traffico. La SBOM di ogni job riporta anche uno stato di completezza, così un job il cui traffico CRACI non ha potuto vedere del tutto viene segnalato invece di sembrare completo.
- Nessun falso positivo nell'elenco dei componenti. Ogni componente di una SBOM CRACI è stato effettivamente scaricato nella build. È un'affermazione sulla SBOM, non sui risultati delle vulnerabilità: una CVE associata può comunque non riguardare il Suo prodotto, ed è a questo che serve VEX.
- Corrispondenza tramite package URL. Ogni pacchetto registrato è identificato dal suo package URL, e ogni risultato mostra gli advisory applicabili (CVE, GHSA e altri ID) con la gravità, oltre ai pacchetti che introducono quello vulnerabile.
- Rivalutazione continua. CRACI continua a rivalutare le SBOM monitorate man mano che vengono pubblicate nuove vulnerabilità, quindi una CVE pubblicata mesi dopo una release compare su quella release senza che nessuno esegua una scansione.
- Cronologia delle build. Ogni build passata e la sua SBOM vengono conservate per il Suo periodo di conservazione, così può vedere quali build contenevano una dipendenza vulnerabile, diretta o transitiva, e per quanto tempo è stato esposto.
- Policy gate. Una build può essere bloccata in base ai risultati, compresa qualsiasi build che contiene una CVE specifica, così una vulnerabilità che ha corretto non ricompare in una build successiva.
I team di sicurezza esaminano i risultati e li inoltrano ai team responsabili della correzione. Per il workflow completo, consulti monitoraggio delle vulnerabilità e correzione delle CVE.
Scanner CVE e registratore della build a confronto
| Scanner CVE | Registratore della build (CRACI) | |
|---|---|---|
| Come trova i componenti | Legge manifest, lockfile, database dei pacchetti o binari | Registra ciò che ogni job di build ha scaricato |
| Dipendenze nascoste | Perse, a meno che non lascino traccia nei file che legge | Registrate, con uno stato di completezza per ciò che non ha potuto vedere |
| Che cosa descrive | Qualsiasi cosa gli sia stata indicata, nel momento in cui è stato eseguito | La build CI che ha prodotto la release |
| Corrispondenza | CPE, package URL o nome nell'ecosistema, a seconda dello strumento | Package URL |
| Nuove CVE dopo la release | Trovate quando si scansiona di nuovo, o monitorando il repository attuale | Rivalutazione continua delle SBOM di ciò che è stato distribuito |
| Quali release erano interessate | Richiede risultati passati conservati e ancora accurati | Cronologia delle build, entro il Suo periodo di conservazione |
| Immagini non compilate da Lei, host, IaC | Sì, a seconda dello strumento | No |
| Analisi di raggiungibilità | Alcuni strumenti commerciali | No |
Scanner CVE gratuiti
Quattro scanner di vulnerabilità open source coprono la maggior parte delle esigenze, tutti gratuiti con licenza Apache-2.0:
- Trivy, di Aqua Security, scansiona immagini, filesystem, repository, immagini VM e Kubernetes, usando gli advisory dei vendor, il GitHub Advisory Database e l'NVD. Trova anche configurazioni IaC errate, secret e licenze. CRACI vs Trivy.
-
Grype, di Anchore, scansiona immagini, filesystem e SBOM rispetto al proprio database, scaricato in
locale, e può far fallire le build con
--fail-on. CRACI vs Syft e Grype. - OSV-Scanner, di Google, è il client ufficiale del database OSV.dev e legge lockfile, immagini container e SBOM.
- OWASP Dependency-Check identifica i componenti tramite CPE e li confronta con l'NVD, il che si adatta meglio ai progetti Java e .NET.
Li esegue Lei stesso, quindi monitoraggio, analisi e cronologia sono a Suo carico. Condividono anche i limiti visti sopra: ciascuno legge file, quindi ciascuno perde ciò che i file non dichiarano. Per le opzioni commerciali, consulti i migliori strumenti SCA a confronto e, per capire perché i generatori di SBOM gratuiti non concordano sullo stesso repository, che cosa perdono i generatori di SBOM open source.
Quando uno scanner resta lo strumento giusto
La registrazione funziona solo per le build eseguite su CRACI. Mantenga uno scanner per:
- Immagini che non ha compilato Lei. Le immagini di terze parti scaricate in un cluster non hanno una Sua build da registrare. Veda scansione dei container.
- Host, cluster e immagini VM in esecuzione. Che cosa è installato oggi su un server è una domanda per uno scanner.
- Infrastructure as code e configurazioni errate. CRACI non verifica Terraform, manifest Kubernetes o configurazioni.
- Feedback prima di qualsiasi build. Una scansione nell'editor o su una pull request avvisa uno sviluppatore di un pacchetto vulnerabile prima che venga integrato.
CRACI inoltre non offre analisi di raggiungibilità e non scansiona il Suo codice. Per il software che compila in GitHub Actions, però, registrare la build risponde alla domanda sulle CVE con meno lacune di qualsiasi scansione di file.
Scansione CVE: domande frequenti
Che cos'è uno scanner CVE?
Uno scanner CVE è uno strumento che identifica i componenti di un software, come i pacchetti open source in un repository o in un'immagine container, e confronta ciascuno con le vulnerabilità pubblicate da fonti come l'NVD, OSV e il GitHub Advisory Database. Riporta le CVE che trova, di solito con una gravità e una versione corretta.
Come funziona la scansione CVE?
Lo scanner legge manifest e lockfile, il database dei pacchetti di un'immagine o i binari compilati per elencare componenti e versioni. Poi associa ciascuno ai record delle vulnerabilità, tramite CPE per i dati dell'NVD o tramite nome del pacchetto ed ecosistema per gli advisory di OSV e GitHub, e riporta le corrispondenze con la gravità.
Qual è il miglior scanner CVE gratuito?
Trivy, Grype, OSV-Scanner e OWASP Dependency-Check sono gratuiti e open source. Trivy copre il maggior numero di target, compresi IaC e secret; OSV-Scanner usa OSV.dev; Dependency-Check effettua la corrispondenza tramite CPE con l'NVD ed è adatto a Java e .NET. Tutti leggono file, quindi tutti perdono le dipendenze che nessun file dichiara.
Perché gli scanner CVE perdono delle vulnerabilità?
Di solito perché non hanno mai identificato il componente. Il codice scaricato da script di installazione o di build, i layer delle immagini base e gli strumenti installati da una pipeline non sono nei file che uno scanner legge. La corrispondenza tramite CPE può anche perdere una CVE quando il nome non corrisponde o quando l'NVD non ha ancora aggiunto i prodotti interessati.
Uno scanner delle dipendenze è la stessa cosa di uno scanner CVE?
In gran parte sì. Uno scanner delle dipendenze verifica le vulnerabilità note nei pacchetti da cui dipende un progetto, cioè una scansione CVE delle dipendenze. Uno scanner CVE può coprire anche i pacchetti del sistema operativo in immagini e host, e molti scanner delle dipendenze verificano anche le licenze.
Con quale frequenza eseguire una scansione CVE?
A ogni pull request, per impedire l'ingresso di nuovi rischi, e in modo continuo dopo la release, perché vengono pubblicate nuove CVE per versioni già distribuite. Il controllo continuo serve solo se ha conservato una registrazione accurata di ciò che conteneva ogni release.
CRACI è uno scanner CVE?
No. CRACI è un registratore. Esegue i Suoi job GitHub Actions, registra i pacchetti che ogni job ha effettivamente scaricato e continua a rivalutare quelle SBOM man mano che vengono pubblicate nuove vulnerabilità. La cronologia delle build mostra quali build contenevano una dipendenza vulnerabile. Non scansiona immagini che non ha compilato Lei, host o IaC.
Veda le CVE che il Suo scanner non poteva vedere
Esegua un workflow GitHub Actions su CRACI e confronti la SBOM registrata e i risultati con ciò che ha riportato il Suo scanner.
Prenota una demo