Como usar o Trivy para escanear código e dependências além de imagens

1. Introdução ao Trivy e seu ecossistema de varreduras

O Trivy (TRIVulnerabilitY) é uma ferramenta open-source de segurança desenvolvida pela Aqua Security, projetada para detectar vulnerabilidades em containers, código-fonte, dependências e infraestrutura como código. Originalmente conhecido por escanear imagens Docker, o Trivy evoluiu para um scanner multifuncional que cobre todo o ciclo de vida do desenvolvimento de software.

A principal diferença entre o escaneamento de imagens e o escaneamento de código-fonte está no alvo: enquanto imagens são binários empacotados com sistemas operacionais e bibliotecas, o escaneamento de código analisa arquivos de manifesto, configurações e o próprio código-fonte. Isso permite detectar vulnerabilidades antes mesmo da construção da imagem.

Instalação básica do Trivy:

# Linux (via script oficial)
curl -sfL https://raw.githubusercontent.com/aquasecurity/trivy/main/contrib/install.sh | sh

# macOS (via Homebrew)
brew install trivy

# Docker
docker pull aquasec/trivy:latest

2. Escaneamento de dependências em linguagens de programação

O Trivy suporta dezenas de linguagens de programação, analisando arquivos de manifesto para identificar dependências vulneráveis. Ele verifica contra bancos de dados como NVD, GHSA e bancos específicos de cada ecossistema.

Linguagens suportadas: Node.js (package.json, package-lock.json), Python (requirements.txt, Pipfile.lock), Java (pom.xml, build.gradle), Go (go.mod, go.sum), Ruby (Gemfile.lock), Rust (Cargo.lock), entre outras.

Exemplo prático: escaneando um projeto Node.js

# Estrutura do projeto
meu-projeto/
├── package.json
├── package-lock.json
└── src/
    └── index.js

# Escaneando dependências
trivy fs ./meu-projeto --scanners vuln

# Saída simplificada:
# Total: 3 vulnerabilities
# CRITICAL: 1 (CVE-2024-1234 em lodash@4.17.20)
# HIGH: 2 (CVE-2024-5678 em axios@0.21.1)

Exemplo prático: escaneando um projeto Python

# Estrutura do projeto
app-python/
├── requirements.txt
├── Pipfile
└── app.py

# Escaneando dependências Python
trivy fs ./app-python --scanners vuln

# Resultado:
# CRITICAL: CVE-2023-45803 em urllib3@1.26.5
# HIGH: CVE-2024-22195 em Jinja2@3.0.3

3. Análise de código-fonte e configurações

Além de dependências, o Trivy analisa arquivos de infraestrutura como código (IaC) e detecta segredos expostos. Isso é crucial para prevenir configurações inseguras em ambientes de produção.

Varredura de IaC:

# Escaneando arquivos Terraform
trivy fs ./terraform/ --scanners misconfig

# Escaneando manifests Kubernetes
trivy fs ./k8s-manifests/ --scanners misconfig

# Escaneando Dockerfiles
trivy fs ./Dockerfile --scanners misconfig

Detecção de segredos:

# Escaneando repositório em busca de chaves expostas
trivy fs ./repositorio/ --scanners secret

# Usando filtros de severidade
trivy fs ./repositorio/ --scanners secret --severity CRITICAL,HIGH

# Exemplo de saída:
# CRITICAL: AWS Access Key ID exposto em config.json:23
# HIGH: GitHub Token exposto em .env:5

4. Escaneamento de sistemas de arquivos e diretórios completos

O comando trivy fs é a ferramenta principal para escanear diretórios locais, incluindo projetos complexos e monorepos. Ele analisa recursivamente todos os arquivos relevantes.

Escaneando um monorepo:

# Estrutura do monorepo
monorepo/
├── frontend/
│   ├── package.json
│   └── src/
├── backend/
│   ├── pom.xml
│   └── src/
├── infra/
│   ├── main.tf
│   └── k8s.yaml
└── .env

# Escaneamento completo
trivy fs ./monorepo --scanners vuln,misconfig,secret

# Escaneamento específico por tipo
trivy fs ./monorepo --scanners vuln --severity CRITICAL

Integração com Git:

# Escaneando branch específica
trivy repo https://github.com/usuario/repositorio.git --branch main

# Escaneando tag específica
trivy repo https://github.com/usuario/repositorio.git --tag v1.0.0

# Escaneando commit específico
trivy repo https://github.com/usuario/repositorio.git --commit 1a2b3c4d

5. Integração com pipelines CI/CD e automação

O Trivy se integra facilmente com ferramentas de CI/CD, permitindo bloquear builds que contenham vulnerabilidades críticas.

GitHub Actions:

name: Security Scan
on: [push, pull_request]

jobs:
  trivy-scan:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Run Trivy
        uses: aquasecurity/trivy-action@master
        with:
          scan-type: 'fs'
          scan-ref: '.'
          format: 'sarif'
          output: 'trivy-results.sarif'
          exit-code: '1'
          severity: 'CRITICAL,HIGH'

GitLab CI:

trivy-scan:
  stage: test
  script:
    - trivy fs . --scanners vuln --severity CRITICAL --exit-code 1
  artifacts:
    reports:
      sast: trivy-results.sarif

Geração de relatórios:

# Relatório JSON
trivy fs ./projeto --format json --output resultado.json

# Relatório SARIF (para integração com GitHub)
trivy fs ./projeto --format sarif --output resultado.sarif

# Relatório HTML (via plugin)
trivy fs ./projeto --format html --output relatorio.html

6. Boas práticas e personalização de regras

Para ambientes de produção, é essencial personalizar o Trivy para reduzir ruído e focar em riscos reais.

Arquivo .trivyignore:

# Ignorar vulnerabilidades específicas por ID
CVE-2024-1234
CVE-2023-5678

# Ignorar por caminho
./testes/
./docs/

# Ignorar por severidade
# (não recomendado para produção)

Configuração avançada:

# Usando arquivo de configuração YAML
trivy fs ./projeto --config trivy.yaml

# Conteúdo do trivy.yaml:
severity: CRITICAL,HIGH
scanners:
  - vuln
  - misconfig
  - secret
ignorefile: .trivyignore
cache:
  dir: /tmp/trivy-cache

Cache offline para ambientes restritos:

# Baixar banco de dados para uso offline
trivy image --download-db-only --cache-dir /opt/trivy-db

# Escanear usando cache local
trivy fs ./projeto --cache-dir /opt/trivy-db

7. Comparação com outras ferramentas e limitações

Ferramenta Foco Principal Suporte a IaC Detecção de Segredos Custo
Trivy Multi-linguagem Sim Sim Gratuito
Snyk JavaScript/Java Limitado Sim Freemium
Grype Containers Não Não Gratuito
Dependency-Check Java/.NET Não Não Gratuito

Limitações conhecidas do Trivy:

  • Dependências transitivas complexas podem gerar falsos positivos
  • Linguagens exóticas (ex: Elixir, Haskell) têm suporte limitado
  • Não analisa código personalizado para vulnerabilidades lógicas
  • Performance pode ser impactada em monorepos muito grandes

Quando combinar com outras ferramentas:

# Usar Trivy para dependências + SonarQube para código customizado
# Usar Trivy para IaC + Checkov para políticas específicas
# Usar Trivy para segredos + GitLeaks para detecção avançada

8. Casos de uso avançados e próximos passos

Geração de SBOM (Software Bill of Materials):

# Gerar SBOM no formato CycloneDX
trivy fs ./projeto --format cyclonedx --output sbom.json

# Gerar SBOM no formato SPDX
trivy fs ./projeto --format spdx-json --output sbom.spdx.json

# Analisar SBOM existente
trivy sbom sbom.json

Integração com sistemas de tickets:

# Script para criar issues no GitHub automaticamente
trivy fs ./projeto --format json | \
  jq -c '.Results[] | select(.Severity == "CRITICAL")' | \
  while read -r vuln; do
    gh issue create --title "Vulnerabilidade: $vuln" --body "$vuln"
  done

Roteiro para implementação contínua:

  1. Escaneamento local durante desenvolvimento (trivy fs)
  2. Escaneamento em commits via pre-commit hooks
  3. Escaneamento em PRs via GitHub Actions/GitLab CI
  4. Escaneamento noturno completo do repositório
  5. Geração de SBOM para cada release
  6. Monitoramento contínuo de novos CVEs

O Trivy se consolidou como uma ferramenta essencial no ecossistema DevSecOps, oferecendo varreduras abrangentes que vão muito além de imagens de containers. Sua capacidade de analisar código-fonte, dependências, IaC e segredos em um único comando o torna indispensável para equipes que buscam segurança contínua sem complexidade excessiva.

Referências