Vulnerabilidades
Scanner de CVE: como funciona a análise de CVE e porque registar o build é melhor do que analisá-lo
Um scanner de CVE determina que componentes open source estão no seu software e verifica cada um face às vulnerabilidades publicadas. Só é tão bom quanto esse primeiro passo. Um componente que o scanner nunca identifica nunca pode corresponder a uma CVE, e os mais perigosos são muitas vezes precisamente os que ele não consegue ver.
Atualizado a
Como funciona um scanner de CVE
Todos os scanners de CVE, gratuitos ou comerciais, fazem as mesmas três coisas. As diferenças entre ferramentas estão na qualidade com que fazem cada uma.
- Identificar os componentes. O scanner determina o que está dentro do alvo e lista cada componente com um nome e uma versão.
- Cruzá-los com dados de vulnerabilidades. Cada componente é procurado numa ou em várias bases de dados de vulnerabilidades para encontrar as CVE e outros avisos de segurança que abrangem a sua versão.
- Reportar. As conclusões saem com uma gravidade, normalmente uma pontuação CVSS, e uma versão corrigida, quando existe. Na CI, um limiar pode fazer falhar o job.
Passo 1: três formas de identificar componentes
| Método | O que o scanner lê | Onde tem dificuldades |
|---|---|---|
| Manifestos e lockfiles | package-lock.json, poetry.lock, Cargo.lock, go.sum e ficheiros semelhantes no repositório |
Tudo o que não está declarado nesses ficheiros, e repositórios que não fazem commit de nenhum lockfile |
| Metadados de pacotes instalados | A base de dados de pacotes de uma imagem de contentor ou de um host, como os registos que o apt ou o apk mantêm |
Software copiado, descarregado com curl ou compilado a partir do código-fonte, que não deixa registo de pacote |
| Impressões digitais de binários | Strings de versão, hashes de ficheiros e metadados incorporados em ficheiros compilados | Código compilado com poucos metadados, como a maioria dos binários Rust, em que o scanner tem de adivinhar o que entrou |
A maioria dos scanners de vulnerabilidades open source combina os dois primeiros. A análise de binários é mais comum em ferramentas criadas para firmware e produtos embebidos.
Passo 2: cruzar componentes com dados de CVE
As principais fontes são a National Vulnerability Database (NVD), a OSV, a GitHub Advisory Database e os feeds de segurança das distribuições Linux e dos fornecedores. A forma como um componente é cruzado depende da fonte:
-
Por CPE. Os registos da NVD indicam os produtos que uma CVE afeta como nomes CPE, como
cpe:2.3:a:tukaani:xz. O scanner tem de transformar cada nome de pacote numa estimativa de CPE, e o fornecedor e o produto no dicionário nem sempre correspondem ao nome do pacote no seu ecossistema. -
Por package URL ou nome no ecossistema. A OSV e a GitHub Advisory Database identificam o pacote afetado pelo
seu ecossistema e nome, por exemplo
jinja2no PyPI, com os intervalos de versões afetados. Um package URL comopkg:pypi/[email protected]corresponde a estes registos diretamente, sem estimativas.
Passo 3: o relatório
Uma primeira análise de um projeto real devolve muitas vezes centenas de conclusões. A gravidade, por si só, é uma má forma de as ordenar: os dados de exploração do catálogo KEV da CISA e do EPSS costumam dizer-lhe mais. Como ler os resultados de uma análise SCA explica a ordem, e como reduzir o ruído de vulnerabilidades aborda o que fazer quando a lista é demasiado longa para agir.
Onde a análise de CVE falha
As quatro falhas abaixo são limites da própria análise, não de um produto em particular. Mudar de scanner altera os pormenores, não o padrão.
1. Componentes que o scanner nunca identifica
Um scanner lê ficheiros. Tudo o que um build obtém sem que nenhum ficheiro o declare é-lhe invisível. Estas dependências ocultas são comuns:
-
Scripts de instalação. O npm executa scripts
preinstallepostinstall, e estes podem descarregar qualquer coisa. Foi esse o caminho que o worm Shai-Hulud usou. -
Scripts de build. Alguns scripts de build de Rust descarregam bibliotecas durante o build, e nada no
Cargo.locko regista. - Imagens base e as suas camadas. Num build de contentor, a imagem base e os pacotes do sistema operativo estão separados do manifesto da sua aplicação. Uma análise do repositório não os vê de todo.
- O próprio pipeline. As GitHub Actions que um workflow executa e as ferramentas que instala fazem parte do build, não de qualquer lockfile.
Um componente que nunca é identificado não produz nenhuma conclusão, pelo que um relatório limpo pode significar apenas que o scanner não procurou onde estava o problema. O CRACI encontrou pacotes vulneráveis que o Snyk e o Aikido não reportaram, porque os componentes nunca estiveram naquilo que analisaram.
2. Ruído na correspondência
A correspondência por CPE falha nos dois sentidos. Um nome ambíguo atinge o produto errado e cria um falso positivo que alguém tem de triar. Um CPE em falta ou errado não corresponde a nada, e a CVE passa despercebida sem aviso. A NVD também tem estado atrasada: desde 15 de abril de 2026, enriquece as CVE por prioridade e etiqueta as restantes como "Lowest Priority - not scheduled for immediate enrichment", pelo que muitas CVE novas chegam a um scanner baseado em CPE tarde ou sem os dados de que precisa. A correspondência por package URL evita as estimativas, mas apenas para os componentes que foram identificados à partida.
3. Analisar algo diferente do que foi lançado
A análise e a versão lançada muitas vezes não são a mesma coisa. Uma análise de pull request lê o repositório; o build da release
resolve as versões quando é executado. Sem um lockfile, um intervalo de versões pode ser resolvido de outra forma uma semana depois. Uma
tag de imagem mutável como node:22 aponta para uma imagem diferente ao longo do tempo. Mesmo com o mesmo commit, os builds
não são reprodutíveis por predefinição: os gestores de pacotes podem resolver e instalar por outra ordem, e os passos de build podem
incluir aleatoriedade. O único registo fiável do que foi lançado é o que é feito enquanto o build da release é executado. Consulte
porque é que a segurança da cadeia de abastecimento pertence à sua CI.
4. Uma análise é um instantâneo
Uma análise na linha de comandos diz-lhe o que estava vulnerável no momento em que foi executada. Todos os dias são publicadas novas CVE para versões que já lançou. As ferramentas alojadas voltam a verificar os manifestos atuais de um repositório à medida que surgem avisos, o que lhe diz como está hoje o seu branch principal. Não lhe diz que as versões 2.1 a 2.4, lançadas entre janeiro e abril, continham um pacote que recebeu uma CVE crítica em junho, depois de já o ter atualizado no main.
A alternativa: registar o build e continuar a cruzar
O CRACI é um registador, não um scanner. É um runner de GitHub Actions: altera runs-on para
craci e, à medida que cada job é executado, o CRACI vê os pacotes e ficheiros que ele traz de registos de pacotes, fontes
Git e registos de contentores, incluindo pacotes restaurados de caches de CI. Em vez de deduzir depois o que
entrou num build, regista o que o build obteve.
- Regista as dependências ocultas que escapam às ferramentas baseadas em lockfiles. As descargas feitas por hooks de instalação e scripts de build, bem como a imagem base e as camadas do seu sistema operativo, estão no registo porque o CRACI vê o tráfego. A SBOM de cada job tem também um estado de completude, pelo que um job cujo tráfego o CRACI não conseguiu ver totalmente é assinalado em vez de parecer completo.
- Sem falsos positivos na lista de componentes. Cada componente de uma SBOM do CRACI entrou efetivamente no build. Esta é uma afirmação sobre a SBOM, não sobre as conclusões de vulnerabilidades: uma CVE correspondente pode mesmo assim não afetar o seu produto, e é para isso que serve o VEX.
- Correspondência por package URL. Cada pacote registado é identificado pelo seu package URL, e cada conclusão mostra os avisos de segurança aplicáveis (CVE, GHSA e outros IDs) com a gravidade, além dos pacotes que trazem o pacote vulnerável.
- Reavaliação contínua. O CRACI reavalia continuamente as SBOM monitorizadas à medida que são publicadas novas vulnerabilidades, pelo que uma CVE publicada meses depois de uma release aparece associada a essa release sem que ninguém execute uma análise.
- Histórico de builds. Cada build anterior e a respetiva SBOM são guardados durante o seu período de retenção, para que possa ver que builds continham uma dependência vulnerável, direta ou transitiva, e durante quanto tempo esteve afetado.
- Policy gates. Um build pode ser bloqueado com base em conclusões, incluindo qualquer build que contenha uma CVE específica, para que uma vulnerabilidade que corrigiu não volte num build posterior.
As equipas de segurança fazem a triagem das conclusões e enviam-nas às equipas responsáveis pela correção. Para o fluxo completo, consulte acompanhamento de vulnerabilidades e correção de CVE.
Scanner de CVE vs registador de builds
| Scanner de CVE | Registador de builds (CRACI) | |
|---|---|---|
| Como encontra os componentes | Lê manifestos, lockfiles, bases de dados de pacotes ou binários | Regista o que cada job de build obteve |
| Dependências ocultas | Escapam-lhe, a menos que deixem registo nos ficheiros que lê | Registadas, com um estado de completude para o que não conseguiu ver |
| O que descreve | Aquilo para que foi apontado, no momento em que foi executado | O build de CI que produziu a release |
| Correspondência | CPE, package URL ou nome no ecossistema, consoante a ferramenta | Package URL |
| Novas CVE após o lançamento | Encontradas quando volta a analisar, ou monitorizando o repositório atual | Reavaliação contínua das SBOM do que foi lançado |
| Que releases foram afetadas | Exige resultados anteriores que tenham sido guardados e continuem exatos | Histórico de builds, dentro do seu período de retenção |
| Imagens que não construiu, hosts, IaC | Sim, consoante a ferramenta | Não |
| Análise de alcançabilidade | Algumas ferramentas comerciais | Não |
Scanners de CVE gratuitos
Quatro scanners de vulnerabilidades open source cobrem a maioria das necessidades, todos gratuitos sob Apache-2.0:
- O Trivy, da Aqua Security, analisa imagens, sistemas de ficheiros, repositórios, imagens de VM e Kubernetes, com base em avisos de segurança dos fornecedores, na GitHub Advisory Database e na NVD. Encontra também configurações incorretas de IaC, segredos e licenças. CRACI vs Trivy.
-
O Grype, da Anchore, analisa imagens, sistemas de ficheiros e SBOM face à sua própria base de dados, descarregada
localmente, e pode fazer falhar builds com
--fail-on. CRACI vs Syft e Grype. - O OSV-Scanner, da Google, é o cliente oficial da base de dados OSV.dev e lê lockfiles, imagens de contentores e SBOM.
- O OWASP Dependency-Check identifica componentes por CPE e cruza-os com a NVD, o que se adequa melhor a projetos Java e .NET.
É a sua equipa que os executa, pelo que a monitorização, a triagem e o histórico ficam a seu cargo. Partilham também os limites acima: cada um lê ficheiros, pelo que a cada um escapa o que os ficheiros não declaram. Para opções comerciais, consulte as melhores ferramentas SCA comparadas e, para saber porque é que os geradores de SBOM gratuitos divergem no mesmo repositório, o que escapa aos geradores de SBOM open source.
Quando um scanner continua a ser a ferramenta certa
O registo só funciona para builds executados no CRACI. Mantenha um scanner para:
- Imagens que não construiu. As imagens de terceiros trazidas para um cluster não têm um build seu para registar. Consulte análise de contentores.
- Hosts, clusters e imagens de VM em execução. O que está hoje instalado num servidor é uma questão para um scanner.
- Infraestrutura como código e configurações incorretas. O CRACI não verifica Terraform, manifestos Kubernetes nem configurações.
- Feedback antes de qualquer build. Uma análise no editor ou num pull request avisa um programador sobre um pacote vulnerável antes de ser integrado.
O CRACI também não oferece análise de alcançabilidade nem analisa o seu próprio código. Para o software que constrói em GitHub Actions, porém, registar o build responde à questão das CVE com menos lacunas do que qualquer análise de ficheiros.
Análise de CVE: perguntas frequentes
O que é um scanner de CVE?
Um scanner de CVE é uma ferramenta que identifica os componentes de um software, como pacotes open source num repositório ou numa imagem de contentor, e verifica cada um face às vulnerabilidades publicadas em fontes como a NVD, a OSV e a GitHub Advisory Database. Reporta as CVE que encontra, normalmente com uma gravidade e uma versão corrigida.
Como funciona a análise de CVE?
O scanner lê manifestos e lockfiles, a base de dados de pacotes de uma imagem ou binários compilados para listar componentes e versões. Depois cruza cada um com registos de vulnerabilidades, por CPE no caso dos dados da NVD ou por nome de pacote e ecossistema no caso dos avisos da OSV e do GitHub, e reporta as correspondências com a gravidade.
Qual é o melhor scanner de CVE gratuito?
O Trivy, o Grype, o OSV-Scanner e o OWASP Dependency-Check são gratuitos e open source. O Trivy cobre mais alvos, incluindo IaC e segredos; o OSV-Scanner usa o OSV.dev; o Dependency-Check faz a correspondência por CPE face à NVD e adequa-se a Java e .NET. Todos leem ficheiros, pelo que a todos escapam as dependências que nenhum ficheiro declara.
Porque é que os scanners de CVE deixam escapar vulnerabilidades?
Normalmente porque nunca identificaram o componente. O código descarregado por scripts de instalação ou de build, as camadas da imagem base e as ferramentas que um pipeline instala não estão nos ficheiros que um scanner lê. A correspondência por CPE pode também falhar uma CVE quando o nome não corresponde ou quando a NVD ainda não acrescentou os produtos afetados.
Um scanner de dependências é o mesmo que um scanner de CVE?
Em grande parte. Um scanner de dependências verifica os pacotes de que um projeto depende quanto a vulnerabilidades conhecidas, o que é uma análise de CVE das dependências. Um scanner de CVE pode também abranger pacotes do sistema operativo em imagens e hosts, e muitos scanners de dependências verificam também licenças.
Com que frequência deve executar uma análise de CVE?
Em cada pull request, para impedir a entrada de novos riscos, e continuamente após o lançamento, porque são publicadas novas CVE para versões que já lançou. A verificação contínua só ajuda se tiver guardado um registo exato do que cada release continha.
O CRACI é um scanner de CVE?
Não. O CRACI é um registador. Executa os seus jobs de GitHub Actions, regista os pacotes que cada job efetivamente obteve e continua a reavaliar essas SBOM à medida que são publicadas novas vulnerabilidades. O histórico de builds mostra que builds continham uma dependência vulnerável. Não analisa imagens que não construiu, hosts nem IaC.
Veja as CVE que o seu scanner não conseguiu ver
Execute um workflow de GitHub Actions no CRACI e compare a SBOM registada e as conclusões com o que o seu scanner reportou.
Marcar demo