DockerScan v2.0

O Scanner de Segurança Docker Mais Abrangente

Por Daniel Garcia (cr0hn) | GitHub | Site

Funcionalidades • Instalação • Início Rápido • Documentação • Casos de Uso • O que há de novo • Contribuir

📑 Tabela de Conteúdo

Visão Geral
Funcionalidades
O que há de novo no v2.0
Instalação
Início Rápido
Uso
- Autenticação em Registro Privado
Scanners de Segurança
Formatos de Saída
Casos de Uso
Comparação
Arquitetura
Contribuir
Referências
Licença
Autor

🎯 Visão Geral

DockerScan v2.0 é um scanner de segurança de próxima geração para contêineres e imagens Docker, totalmente reescrito em Go. Ele combina múltiplas técnicas de escaneamento de segurança baseadas nas pesquisas mais recentes de 2024-2025, padrões da indústria (CIS Benchmark, NIST SP 800-190) e padrões reais de ataques descobertos em ambientes de produção.

Por que DockerScan v2.0?

✅ Mais Abrangente: Combina 5+ técnicas de escaneamento de segurança em uma ferramenta
✅ Pesquisas Recentes: Baseado em ataques à cadeia de suprimentos e CVEs de 2024-2025
✅ Pronto para Produção: Saída SARIF para CI/CD, códigos de saída para automação
✅ Extremamente Rápido: Escrito em Go com escaneamento concorrente
✅ Extensível: Arquitetura de plugins para scanners personalizados
✅ Gratuito e Open Source: Licença BSD-3

🌟 Funcionalidades

🛡️ Módulos de Escaneamento de Segurança

1. CIS Docker Benchmark v1.7.0

Verificação completa de conformidade com mais de 80 controles automatizados:

✅ Segurança de configuração do host (13 verificações)
✅ Endurecimento do daemon Docker (18 verificações)
✅ Permissões de arquivos e diretórios (9 verificações)
✅ Melhores práticas de imagem de contêiner (13 verificações)
✅ Validação de segurança em tempo de execução (31+ verificações)
✅ Conformidade com operações de segurança

2. Detecção de Ataques à Cadeia de Suprimentos 🆕

Baseado em campanhas reais de ataque de 2024:

✅ Detecção de Contêiner Sem Imagem - Identifica contêineres maliciosos sem camadas reais (4M+ encontrados no Docker Hub)
✅ Detecção de Mineradores de Criptomoedas - Detecta malware de mineração (120K+ pulls de imagens maliciosas detectados)
✅ Detecção de Bibliotecas com Backdoor - Captura dependências comprometidas (incidentes xz-utils, liblzma)
✅ Verificação de Assinatura de Imagem - Valida assinaturas usando Notary/Cosign
✅ Detecção de Conteúdo de Phishing - Escaneia documentação em busca de engenharia social
✅ Destinos de Rede Maliciosos - Identifica servidores C2, pools de mineração, nós Tor

3. Detecção Avançada de Segredos 🔑

Mais de 40 padrões de segredos, incluindo APIs modernas (atualização 2024):

✅ Provedores de Nuvem: AWS, GCP, Azure credenciais
✅ Controle de Versão: Tokens do GitHub, GitLab, Bitbucket
✅ APIs de IA/ML: Chaves OpenAI, Anthropic, Hugging Face
✅ Pagamento: Chaves Stripe, PayPal, Square
✅ Comunicação: Chaves Slack, SendGrid, Twilio, Mailchimp
✅ Autenticação: Tokens JWT, Tokens OAuth
✅ Cripto: Chaves privadas (RSA, SSH, PGP, EC, DSA), certificados
✅ Bancos de Dados: Strings de conexão PostgreSQL, MySQL, MongoDB
✅ Docker: Tokens de autenticação de registro
✅ Análise de Entropia: Cálculo de entropia de Shannon para segredos desconhecidos (limiar >4.5)

4. Escaneamento de CVE e Vulnerabilidades 🚨

Detecção crítica de CVEs 2024-2025:

✅ CVE-2024-21626 - Fuga de contêiner runc (CVSS 8.6)
✅ CVE-2024-23651 - RCE por envenenamento de cache BuildKit (CVSS 9.1)
✅ CVE-2024-23652 - Condição de corrida BuildKit (CVSS 7.5)
✅ CVE-2024-23653 - Escalonamento de privilégio BuildKit
✅ CVE-2024-8695/8696 - Docker Desktop RCE (CVSS 8.8)
✅ CVE-2025-9074 - Vulnerabilidade de acesso local no Docker Desktop
✅ Detecção de imagens base no fim da vida útil
✅ Escaneamento de pacotes vulneráveis conhecidos

5. Análise de Segurança em Tempo de Execução ⚙️

Verificações de endurecimento em tempo de execução de contêiner:

✅ Auditoria de Capacidades Linux - Detecta capacidades perigosas (CAP_SYS_ADMIN, CAP_NET_ADMIN, etc.)
✅ Validação de Perfil Seccomp - Garante que a filtragem de chamadas de sistema está ativada
✅ Verificações AppArmor/SELinux - Verificação de controle de acesso obrigatório
✅ Detecção de Contêiner Privilegiado - Identifica contêineres com acesso total ao host
✅ Isolamento de Namespace - Verificações de namespace PID, IPC, rede, usuário
✅ Indicadores de Fuga de Contêiner - Detecta técnicas comuns de fuga

📊 Relatórios e Integração

JSON - Saída legível por máquina para automação
SARIF - Integração nativa com:
- Guia de Segurança do GitHub
- Azure DevOps
- Extensões VS Code
- Painéis de segurança do GitLab
CLI Bonito - Níveis de severidade codificados por cores com emojis
Códigos de Saída - Amigável para CI/CD (0=limpo, 1=avisos, 2=crítico)

🚀 Desempenho

⚡ 10x Mais Rápido que alternativas em Python
🔄 Escaneamento Concorrente com goroutines Go
💾 Baixo Consumo de Memória (~50-100MB)
📦 Binário Único - Sem dependências

🆕 O que há de novo no v2.0?

DockerScan v2.0 é uma reescrita completa do zero. Aqui está o que mudou do v1.x:

Principais Mudanças

Funcionalidade	v1.x (Python)	v2.0 (Go)
Linguagem	Python 3.5+	Go 1.21+
Desempenho	~500 imagens/hora	~5000 imagens/hora
Uso de Memória	200-500 MB	50-100 MB
Distribuição	pip install + dependências	Binário único
Scanners de Segurança	2 módulos	5 módulos
CIS Benchmark	Parcial	Completo v1.7.0 (80+ verificações)
Cadeia de Suprimentos	❌ Não disponível	✅ Baseado em pesquisa de 2024
Padrões de Segredos	10 padrões	40+ padrões
Detecção de CVE	Básica	CVEs 2024-2025
Segurança em Tempo de Execução	❌ Não disponível	✅ Auditoria completa de capacidades
Saída SARIF	❌ Não disponível	✅ Suporte completo
Integração CI/CD	Manual	Nativa (códigos de saída, SARIF)

O que foi preservado do v1.x

✅ Ferramentas Ofensivas - Capacidades de trojanização de imagens (em breve no v2.1)
✅ Operações de Registro - Operações push, pull, delete (em breve no v2.1)
✅ Escaneamento de Rede - Descoberta de registro Docker (em breve no v2.1)

Novo no v2.0.5 🔐

🔑 Autenticação em Registro Privado - Suporte completo para escanear imagens de registros privados (corrige #24)
🌐 Suporte a Múltiplos Registros - Docker Hub, GHCR, ECR, GCR, ACR, GitLab e registros auto-hospedados
🔐 Múltiplos Métodos de Autenticação - Variáveis de ambiente (CI/CD), flags de linha de comando (teste), arquivo de configuração Docker (transparente)
🎯 Prioridade Inteligente de Autenticação - Flags CLI > Variáveis ENV > Config Docker (seleção automática)
📝 Mensagens de Erro Aprimoradas - Dicas específicas de registro (expiração de token ECR, limites de taxa, certificados)
🧪 Testes Abrangentes - 64 casos de teste, 91.2% de cobertura, testado com registro privado real
📚 Documentação Completa - Exemplos para todos os principais registros em nuvem e métodos de autenticação

Novo no v2.0.4

🗄️ Integração com Banco de Dados de CVE - Banco de dados SQLite local com dados NVD (2.5 anos de CVEs)
🔄 Atualizações Automáticas Diárias - GitHub Action atualiza o banco de dados de CVE todos os dias
⚡ Downloads Paralelos de CVE - 4 workers para builds mais rápidas do banco de dados (nvd2sqlite)
🔁 Retry com Backoff - Retry automático para requisições limitadas por taxa na API NVD
📦 Flag --from-file - Instalar banco de dados de CVE a partir de arquivo local (offline/air-gapped)
🔇 Modo Silencioso (-q) - Suprimir banner para pipelines CI/CD
🧹 Menos Falsos Positivos - Detecção de segredos melhorada com filtragem de entropia

Por que a Reescrita?

Desempenho - Go fornece escaneamento 10x mais rápido com goroutines
Ameaças Modernas - Incorpora padrões de ataque de 2024-2025
Pronto para Empresas - Saída SARIF, códigos de saída, distribuição de binário único
Extensibilidade - Arquitetura de plugins limpa para scanners personalizados
Manutenibilidade - Segurança de tipos, melhor tratamento de erros, mais fácil de contribuir

📦 Instalação

Opção 1: Baixar Binário Pré-compilado (Recomendado)

Binários pré-compilados são construídos e lançados automaticamente via GitHub Actions para cada tag de versão.

Plataformas Suportadas:

Linux: amd64, arm64, 386
macOS: amd64 (Intel), arm64 (Apple Silicon)
Windows: amd64, arm64, 386
FreeBSD: amd64

Linux (amd64)```bash

curl -L https://github.com/cr0hn/dockerscan/releases/latest/download/dockerscan-linux-amd64 -o dockerscan chmod +x dockerscan sudo mv dockerscan /usr/local/bin/

#### Linux (arm64)```bash
curl -L https://github.com/cr0hn/dockerscan/releases/latest/download/dockerscan-linux-arm64 -o dockerscan
chmod +x dockerscan
sudo mv dockerscan /usr/local/bin/

macOS (Intel)```bash

curl -L https://github.com/cr0hn/dockerscan/releases/latest/download/dockerscan-darwin-amd64 -o dockerscan chmod +x dockerscan sudo mv dockerscan /usr/local/bin/

#### macOS (Apple Silicon)```bash
curl -L https://github.com/cr0hn/dockerscan/releases/latest/download/dockerscan-darwin-arm64 -o dockerscan
chmod +x dockerscan
sudo mv dockerscan /usr/local/bin/

Windows (PowerShell)```powershell

Invoke-WebRequest -Uri "https://github.com/cr0hn/dockerscan/releases/latest/download/dockerscan-windows-amd64.exe" -OutFile "dockerscan.exe"

#### Verificar Download (Opcional, mas Recomendado)```bash
# Download checksums
curl -L https://github.com/cr0hn/dockerscan/releases/latest/download/checksums.txt -o checksums.txt

# Verify (Linux/macOS)
sha256sum -c checksums.txt --ignore-missing

Opção 2: Compilar a partir do código-fonte```bash

Clone repository

git clone https://github.com/cr0hn/dockerscan cd dockerscan/dockerscan-v2

Build

make build

Install

sudo make install

Or build manually

go build -o bin/dockerscan ./cmd/dockerscan

### Opção 3: Go Install```bash
go install github.com/cr0hn/dockerscan/v2/cmd/dockerscan@latest

🚀 Início Rápido

Configuração Inicial

Antes de escanear, baixe o banco de dados CVE (atualizado diariamente, ~30MB compactado):```bash

Download latest CVE database from GitHub

dockerscan update-db

> **Dica**: O banco de dados é atualizado diariamente via GitHub Actions. Execute `update-db` periodicamente para obter os dados mais recentes de CVE.

### Escaneamento Básico```bash
# Scan a Docker image
dockerscan nginx:latest

# Scan with specific scanners
dockerscan --scanners cis,secrets ubuntu:22.04

# Scan and save reports
dockerscan alpine:latest --output /tmp/reports

# Quiet mode (suppress banner)
dockerscan -q nginx:latest

Exemplo de Saída```

╔══════════════════════════════════════════════════════════════════════════╗ ║ ██████╗ ██████╗ ██████╗██╗ ██╗███████╗██████╗ ███████╗ ██████╗ █████╗ ███╗ ██╗ ║ ██╔══██╗██╔═══██╗██╔════╝██║ ██╔╝██╔════╝██╔══██╗██╔════╝██╔════╝██╔══██╗████╗ ██║ ║ ██║ ██║██║ ██║██║ █████╔╝ █████╗ ██████╔╝███████╗██║ ███████║██╔██╗ ██║ ║ ██║ ██║██║ ██║██║ ██╔═██╗ ██╔══╝ ██╔══██╗╚════██║██║ ██╔══██║██║╚██╗██║ ║ ██████╔╝╚██████╔╝╚██████╗██║ ██╗███████╗██║ ██║███████║╚██████╗██║ ██║██║ ╚████║ ║ ║ ║ Advanced Docker Security Scanner v2.0.0 ║ ║ ║ ║ Author: Daniel Garcia (cr0hn) ║ ║ Website: https://cr0hn.com ║ ╚══════════════════════════════════════════════════════════════════════════════════════╝

🔍 Scanning image: nginx:latest

═══════════════════════════════════════════════════════════════════ SCAN RESULTS ═══════════════════════════════════════════════════════════════════

📊 Summary: Total Findings: 47 Duration: 2.3s

🔴 By Severity: Critical: 8 High: 15 Medium: 18 Low: 6

📁 By Category: CIS-Benchmark: 12 Secrets: 8 Supply-Chain: 5 Vulnerability: 10 Runtime-Security: 12

📄 JSON report saved to: dockerscan-report.json 📄 SARIF report saved to: dockerscan-report.sarif

---

## 📖 Uso

### Opções da Linha de Comando```bash
dockerscan [COMMAND] [OPTIONS] <IMAGE>

Commands:
  scan        Scan a Docker image (default)
  update-db   Download or update the CVE database
              Options: --from-file <path>  Install from local SQLite file
  version     Show version information
  help        Show help message

Options:
  -h, --help              Show help message
  -v, --version           Show version
  -q, --quiet             Suppress banner output (quiet mode)
  --scanners SCANNERS     Comma-separated list of scanners to run
                          (default: all)
                          Options: cis,secrets,supplychain,vulnerabilities,runtime
  --output DIR            Output directory for reports (default: .)
  --only-critical         Show only critical/high severity findings
  --verbose, -v           Show scan progress (scanner names, findings count, image pull status). Output to stderr.
  --debug                 Show verbose output plus internal errors and technical details. Output to stderr.

Authentication (for private registries):
  --registry-user <username>       Registry username
  --registry-password <password>   Registry password (not recommended, use env vars)
  --registry <url>                 Registry URL (optional, auto-detected from image)
  --docker-config <path>           Path to Docker config file (default: ~/.docker/config.json)

  Environment variables (recommended for CI/CD):
    DOCKER_USERNAME or REGISTRY_USERNAME     Registry username
    DOCKER_PASSWORD or REGISTRY_PASSWORD     Registry password or token
    DOCKER_REGISTRY or REGISTRY             Registry URL (optional)

Exit Codes:
  0   No issues found
  1   HIGH severity issues found
  2   CRITICAL severity found

Exemplos```bash

Scan with all scanners (default)

dockerscan myapp:latest

Only run specific scanners

dockerscan --scanners secrets,supplychain redis:7

Save reports to specific directory

dockerscan --output /var/reports postgres:14

Only show critical issues

dockerscan --only-critical production-app:v1.0

Ver progreso del scan (scanner names, findings count, image pull status)

dockerscan --verbose ubuntu:22.04

Debug detallado (errores internos, detalles técnicos)

dockerscan --debug ubuntu:22.04

Scan private registry images (see Authentication section below)

dockerscan ghcr.io/myorg/private-app:v1.0

### 🔐 Autenticação em Registro Privado

O DockerScan suporta três métodos para autenticar em registros privados:

#### Método 1: Arquivo de Configuração do Docker (Recomendado para Uso Local)

O método mais conveniente - utiliza suas credenciais existentes do Docker:```bash
# First, authenticate with your registry using Docker
docker login ghcr.io
# Username: your-username
# Password: ghp_your-token-here

# Now DockerScan can use these credentials automatically
dockerscan ghcr.io/myorg/private-app:latest

DockerScan lê automaticamente as credenciais de ~/.docker/config.json. Isso funciona com todos os registros nos quais você fez login com docker login.

Os auxiliares de credenciais são totalmente suportados. O DockerScan resolve credenciais nativamente por meio de:

credsStore — auxiliar de credenciais global (por exemplo, osxkeychain no macOS com Docker Desktop, wincred no Windows, pass no Linux)
credHelpers — auxiliares de credenciais por registro (têm precedência sobre credsStore)
Fallback automático — se o binário do auxiliar especificado não estiver instalado, o DockerScan volta para o bloco auths em texto simples em config.json

No macOS com Docker Desktop, isso funciona imediatamente, sem configuração adicional:```json { "credsStore": "osxkeychain" }

DockerScan chamará `docker-credential-osxkeychain` de forma transparente para recuperar tokens, então você nunca precisa passar credenciais explicitamente.

### Método 2: Variáveis de Ambiente (Recomendado para CI/CD)

Melhor para ambientes automatizados e pipelines de CI/CD:```bash
# Set environment variables
export DOCKER_USERNAME=myusername
export DOCKER_PASSWORD=mytoken

# Scan private image
dockerscan ghcr.io/myorg/private-app:latest

# Or use alternative variable names
export REGISTRY_USERNAME=myusername
export REGISTRY_PASSWORD=mytoken
dockerscan myregistry.example.com/app:v1.0

Exemplo de CI/CD (GitHub Actions):```yaml

name: Scan private image env: DOCKER_USERNAME: ${{ secrets.REGISTRY_USERNAME }} DOCKER_PASSWORD: ${{ secrets.REGISTRY_TOKEN }} run: dockerscan ghcr.io/${{ github.repository }}:${{ github.sha }}

#### Método 3: Opções de Linha de Comando (Não Recomendado)

Apenas para testes rápidos (credenciais visíveis na lista de processos):```bash
dockerscan --registry-user myuser --registry-password mytoken ghcr.io/myorg/app:v1

Aviso de Segurança: Este método expõe credenciais no seu histórico do shell e na lista de processos. Use variáveis de ambiente ou configuração do Docker em vez disso.

Exemplos Específicos para Registries

Docker Hub (Repositórios Privados)```bash

Using Docker config

docker login docker.io dockerscan myusername/private-repo:latest

Using environment variables

export DOCKER_USERNAME=myusername export DOCKER_PASSWORD=dckr_pat_XXXXXXXXXXXXX dockerscan myusername/private-repo:latest

#### GitHub Container Registry (GHCR)```bash
# Using Docker config
echo $GITHUB_TOKEN | docker login ghcr.io -u USERNAME --password-stdin
dockerscan ghcr.io/myorg/myapp:v1.0

# Using environment variables
export DOCKER_USERNAME=myusername
export DOCKER_PASSWORD=ghp_XXXXXXXXXXXXXXXXXXXX
dockerscan ghcr.io/myorg/myapp:v1.0

AWS Elastic Container Registry (ECR)```bash

aws ecr get-login-password --region us-east-1 |
docker login --username AWS --password-stdin
123456789012.dkr.ecr.us-east-1.amazonaws.com

Scan ECR image

dockerscan 123456789012.dkr.ecr.us-east-1.amazonaws.com/myapp:latest

Or use environment variables with ECR credentials

export DOCKER_USERNAME=AWS export DOCKER_PASSWORD=$(aws ecr get-login-password --region us-east-1) dockerscan 123456789012.dkr.ecr.us-east-1.amazonaws.com/myapp:latest

#### Google Container Registry (GCR) / Artifact Registry```bash
# Authenticate with gcloud
gcloud auth configure-docker gcr.io

# Scan GCR image
dockerscan gcr.io/my-project/myapp:latest

# For Artifact Registry
gcloud auth configure-docker us-docker.pkg.dev
dockerscan us-docker.pkg.dev/my-project/my-repo/myapp:latest

# Or use service account JSON key
export DOCKER_USERNAME=_json_key
export DOCKER_PASSWORD="$(cat service-account-key.json)"
dockerscan gcr.io/my-project/myapp:latest

Azure Container Registry (ACR)```bash

az acr login --name myregistry

Scan ACR image

dockerscan myregistry.azurecr.io/myapp:v1.0

Or use service principal credentials

export DOCKER_USERNAME= export DOCKER_PASSWORD= dockerscan myregistry.azurecr.io/myapp:v1.0

#### GitLab Container Registry```bash
# Using Docker config
docker login registry.gitlab.com
dockerscan registry.gitlab.com/mygroup/myproject/myapp:latest

# Using environment variables with deploy token
export DOCKER_USERNAME=gitlab+deploy-token-1
export DOCKER_PASSWORD=DEPLOY_TOKEN_HERE
dockerscan registry.gitlab.com/mygroup/myproject/myapp:latest

Registros Auto-hospedados/Privados```bash

Standard authentication

docker login myregistry.example.com:5000 dockerscan myregistry.example.com:5000/myapp:latest

With environment variables

export DOCKER_USERNAME=admin export DOCKER_PASSWORD=secret dockerscan myregistry.example.com:5000/myapp:latest

Insecure registries (not recommended for production)

Add to Docker daemon config: /etc/docker/daemon.json

{

"insecure-registries": ["myregistry.example.com:5000"]

}

### Resolução de Problemas de Autenticação

#### Problemas Comuns

**1. erro "autenticação necessária"**```bash
# Make sure you're logged in
docker login <registry>

# Or set environment variables
export DOCKER_USERNAME=your-username
export DOCKER_PASSWORD=your-token

2. Erro "unauthorized: authentication failed"

Verifique se suas credenciais estão corretas
Verifique se o seu token expirou (especialmente para provedores em nuvem)
Certifique-se de que sua conta tem permissões de pull para a imagem

3. AWS ECR "authorization token has expired"```bash

ECR tokens expire after 12 hours - refresh them

aws ecr get-login-password --region us-east-1 |
docker login --username AWS --password-stdin
123456789012.dkr.ecr.us-east-1.amazonaws.com

**4. Limitação de taxa no Docker Hub**
- Autentique-se para aumentar os limites de taxa (200 pulls/6 horas para contas gratuitas)
- Considere usar uma conta Docker Hub Pro para limites mais altos

**5. Erros de certificado com certificados autoassinados**
- Adicione o certificado CA ao seu repositório de confiança do sistema
- Ou configure o Docker para confiar no registro (consulte a documentação do Docker)

---

## 🔍 Scanners de Segurança

### CIS Docker Benchmark

Verificação automatizada de conformidade com o CIS Docker Benchmark v1.7.0:```bash
dockerscan --scanners cis nginx:latest

Checks include:

O usuário do contêiner não é root
Nenhum pacote desnecessário instalado
Instrução HEALTHCHECK presente
Tags de versão específicas (não :latest)
Portas expostas mínimas
Nenhum contêiner privilegiado
Capacidades Linux restritas
Perfis Seccomp/AppArmor aplicados
Sistema de arquivos raiz somente leitura
E mais de 70 verificações...

Segurança da Cadeia de Suprimentos

Detecte ataques reais à cadeia de suprimentos:```bash dockerscan --scanners supplychain suspicious-image:1.0

Detecta:
- Contêineres sem imagem (ataques apenas de documentação)
- Mineradores de criptomoedas (xmrig, claymore, etc.)
- Bibliotecas com backdoor (caso xz-utils)
- Imagens não assinadas/não verificadas
- Tentativas de phishing em documentações
- Conexões a pools de mineração, servidores C2

### Detecção de Segredos

Encontre segredos codificados:```bash
dockerscan --scanners secrets webapp:prod

Encontra:

Credenciais de nuvem (AWS, GCP, Azure)
Chaves de API (40+ serviços)
Chaves privadas e certificados
Credenciais de banco de dados
Autenticação de registry Docker
Strings de alta entropia (potenciais segredos desconhecidos)

Varredura de Vulnerabilidades

Detecta CVEs conhecidos:```bash dockerscan --scanners vulnerabilities node:16

Verifica:
- CVEs críticas do Docker (2024-2025)
- Vulnerabilidades de escape de contêiner
- Vulnerabilidades de RCE no BuildKit
- Imagens base fora de suporte (fim de vida)
- Pacotes vulneráveis

### Segurança em Tempo de Execução

Auditar configurações de tempo de execução:```bash
dockerscan --scanners runtime running-container

Analisa:

Capacidades do Linux (CAP_SYS_ADMIN, etc.)
Perfis Seccomp
Políticas AppArmor/SELinux
Isolamento de namespace
Uso do modo privilegiado

📁 Formatos de Saída

Saída JSON```json

{ "target": { "image_name": "nginx:latest" }, "start_time": "2024-11-22T10:30:00Z", "findings": [ { "id": "CIS-4.1", "title": "Container should not run as root", "severity": "HIGH", "category": "CIS-Benchmark", "description": "Running containers as root increases attack surface...", "remediation": "Use USER instruction in Dockerfile..." } ], "summary": { "total_findings": 47, "by_severity": { "CRITICAL": 8, "HIGH": 15 } } }

### SARIF Output

Compatível com GitHub Security, Azure DevOps, VS Code:```json
{
  "$schema": "https://raw.githubusercontent.com/oasis-tcs/sarif-spec/master/Schemata/sarif-schema-2.1.0.json",
  "version": "2.1.0",
  "runs": [
    {
      "tool": {
        "driver": {
          "name": "DockerScan",
          "version": "2.0.0"
        }
      },
      "results": [...]
    }
  ]
}

💼 Casos de Uso

1. Integração de Pipeline CI/CD

GitHub Actions:```yaml name: Docker Security Scan

on: [push]

jobs: security-scan: runs-on: ubuntu-latest steps: - uses: actions/checkout@v3

  - name: Build Docker image
    run: docker build -t myapp:${{ github.sha }} .

  - name: Install DockerScan
    run: |
      curl -L https://github.com/cr0hn/dockerscan/releases/latest/download/dockerscan-linux-amd64 -o dockerscan
      chmod +x dockerscan

  - name: Update CVE Database
    run: ./dockerscan update-db

  - name: Run Security Scan
    run: ./dockerscan -q myapp:${{ github.sha }}

  - name: Upload SARIF results
    uses: github/codeql-action/upload-sarif@v2
    with:
      sarif_file: dockerscan-report.sarif

**GitLab CI:**```yaml
docker-security-scan:
  stage: test
  script:
    - docker build -t $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA .
    - wget https://github.com/cr0hn/dockerscan/releases/latest/download/dockerscan-linux-amd64 -O dockerscan
    - chmod +x dockerscan
    - ./dockerscan update-db
    - ./dockerscan -q $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA
  artifacts:
    reports:
      sast: dockerscan-report.sarif

2. Auditorias de Segurança```bash

Comprehensive audit of production images

for image in $(docker images --format "{{.Repository}}:{{.Tag}}"); do echo "Scanning $image..." dockerscan $image --output /audit-reports/ done

Generate summary report

cat /audit-reports/*.json | jq -s ' { total_images: length, total_findings: map(.summary.total_findings) | add, critical_findings: map(.summary.by_severity.CRITICAL // 0) | add } '

### 3. **Validação Pré-implantação**```bash
# Fail deployment if critical issues found
dockerscan production-app:v2.0
exit_code=$?

if [ $exit_code -eq 2 ]; then
  echo "❌ Critical vulnerabilities found. Deployment blocked."
  exit 1
elif [ $exit_code -eq 1 ]; then
  echo "⚠️  High severity issues found. Manual review required."
  # Send notification...
else
  echo "✅ No critical issues. Proceeding with deployment."
fi

4. Relatórios de Conformidade```bash

Generate CIS compliance report

dockerscan --scanners cis --only-critical all-production-images:* > cis-compliance-report.txt

Weekly security scan for compliance

0 0 * * 0 /usr/local/bin/dockerscan --scanners cis,vulnerabilities production-images:latest --output /compliance/weekly/

### 5. **Fluxo de Trabalho do Desenvolvedor**```bash
# Pre-commit hook
#!/bin/bash
# .git/hooks/pre-commit

docker build -t local-test:latest .
dockerscan --only-critical local-test:latest

if [ $? -ne 0 ]; then
  echo "❌ Docker security scan failed. Fix issues before committing."
  exit 1
fi

📊 Comparação com Outras Ferramentas

Funcionalidade	DockerScan v2.0	Trivy	Clair	Snyk	Grype
CIS Benchmark v1.7	✅ Completo (80+ verificações)	❌	❌	Parcial	❌
Supply Chain Detection (2024)	✅ Sim	❌	❌	❌	❌
Secrets Scanning	✅ 40+ padrões	Básico	❌	✅	❌
CVE Database	✅ CVEs 2024-2025	✅	✅	✅	✅
Runtime Security	✅ Completo	❌	❌	❌	❌
SARIF Output	✅	✅	❌	✅	✅
Velocidade (Go)	⚡ Muito Rápido	⚡ Muito Rápido	🐌 Lento	⚡ Rápido	⚡ Muito Rápido
Extensível	✅ Sistema de plugins	Limitado	Limitado	❌	Limitado
Códigos de Saída	✅ Pronto para CI/CD	✅	Parcial	✅	✅
Custo	🆓 Gratuito	🆓 Gratuito	🆓 Gratuito	💰 Níveis pagos	🆓 Gratuito
Modo Offline	✅	✅	❌	❌	✅
Licença	Proprietário com Código Fonte Disponível	Apache-2.0	Apache-2.0	Proprietário	Apache-2.0

Por que escolher o DockerScan?

Mais Abrangente: Única ferramenta que combina CIS + Cadeia de Suprimentos + Segredos + CVE + Runtime
Pesquisa Mais Recente: Baseado em ataques reais de 2024-2025
Configuração Zero: Funciona imediatamente
Amigável para Desenvolvedores: Saída CLI bonita com remediação acionável
Pronto para Empresas: SARIF + códigos de saída + saída JSON

🏗️ Arquitetura

Estrutura do Projeto```

dockerscan/ ├── logo.png # Project logo ├── cmd/ │ ├── dockerscan/ # Main CLI application │ │ └── main.go │ └── nvd2sqlite/ # CVE database builder tool │ └── main.go ├── data/ # CVE database (auto-updated daily) │ ├── latest.db.gz # Compressed SQLite database │ └── metadata.json # Database version info ├── internal/ │ ├── scanner/ # Extensible scanner framework │ │ ├── scanner.go # Scanner interface & registry │ │ ├── cis/ # CIS Benchmark implementation │ │ ├── secrets/ # Secrets detection │ │ ├── supplychain/ # Supply chain attacks │ │ ├── vulnerabilities/ # CVE scanning │ │ └── runtime/ # Runtime security │ ├── report/ # Report generators │ │ ├── json.go # JSON reporter │ │ └── sarif.go # SARIF reporter │ ├── models/ # Data models │ │ └── models.go # Findings, scan results, etc. │ └── config/ # Configuration │ └── config.go # App config & banner └── pkg/docker/ # Docker client wrapper └── client.go

### Base de Dados CVE & Ferramenta nvd2sqlite

O DockerScan utiliza uma base de dados SQLite local para consultas de CVE. A base de dados é **atualizada automaticamente diariamente** através do GitHub Actions e está alojada no repositório, para que tenha sempre acesso aos dados CVE mais recentes.

#### Funcionalidades da Base de Dados

- 🗄️ **Base de dados pré-construída** - Pronta a usar, sem necessidade de configuração manual
- 🔄 **Atualizações diárias** - GitHub Action atualiza a base de dados todos os dias às 00:00 UTC
- 📅 **2,5 anos de dados CVE** - Abrange CVEs desde meados de 2022 até ao presente
- ⚡ **Consultas rápidas** - SQLite com índices otimizados
- 🌐 **Alojado no GitHub** - Descarregado automaticamente com o comando `update-db`

#### Atualizar a Base de Dados```bash
# Download latest database from GitHub (recommended)
dockerscan update-db

# Install from local file (for air-gapped/offline environments)
dockerscan update-db --from-file /path/to/cve-db.sqlite

Nota: Na primeira vez que você executar dockerscan, ele solicitará o download do banco de dados. Depois disso, você pode atualizá-lo periodicamente com update-db.

Construindo o Banco de Dados Manualmente (nvd2sqlite)```bash

Build the tool

make build # Builds both dockerscan and nvd2sqlite

Download CVEs (last 2.5 years by default)

./bin/nvd2sqlite --output data/cve-db.sqlite --verbose

With NVD API key (10x faster - 50 req/30sec vs 5 req/30sec)

NVD_API_KEY=your-key ./bin/nvd2sqlite --output data/cve-db.sqlite --verbose

Custom date range

./bin/nvd2sqlite --output data/cve-db.sqlite
--start-date 2023-01-01
--end-date 2024-12-31

**Recursos do nvd2sqlite:**
- ⚡ **4 workers de download paralelos** para downloads mais rápidos
- 🔄 **Re tentativa automática com backoff exponencial** para limitação de taxa (HTTP 429)
- 📦 **Downloads para diretório temporário**, em seguida, processa sequencialmente
- 🗄️ **Saída SQLite** com tabelas indexadas para consultas rápidas

---

### Extensibilidade

Adicionar um novo scanner é simples:```go
package myscan

import (
    "context"
    "github.com/cr0hn/dockerscan/v2/internal/models"
    "github.com/cr0hn/dockerscan/v2/internal/scanner"
)

type MyScanner struct {
    scanner.BaseScanner
}

func NewMyScanner() *MyScanner {
    return &MyScanner{
        BaseScanner: scanner.NewBaseScanner(
            "my-scanner",
            "Description of my scanner",
            true, // enabled
        ),
    }
}

func (s *MyScanner) Scan(ctx context.Context, target models.ScanTarget) ([]models.Finding, error) {
    var findings []models.Finding

    // Your scanning logic here...

    return findings, nil
}

// Register in main.go:
// registry.Register(myscan.NewMyScanner())

🤝 Contribuindo

Contribuições são bem-vindas! O DockerScan é projetado para ser extensível.

Como Contribuir

Faça um fork do repositório
Crie um branch de funcionalidade (git checkout -b feature/amazing-scanner)
Adicione seu scanner em internal/scanner/
Escreva testes (mantemos mais de 90% de cobertura)
Faça commit das suas alterações (git commit -am 'Add amazing scanner')
Faça push para o branch (git push origin feature/amazing-scanner)
Abra um Pull Request

Desenvolvimento```bash

Clone and setup

git clone https://github.com/cr0hn/dockerscan cd dockerscan/dockerscan-v2

Install dependencies

make deps

Run tests

make test

Run with coverage

make coverage

Build

make build

Format code

make fmt

Lint

make lint

### Adicionando Novos Scanners

Recebemos especialmente:
- Integração com bases de dados de vulnerabilidades (NVD, GitHub Security Advisories)
- Escaneamento de segurança Kubernetes
- Segurança de registros de contêineres
- Análise de segurança do Docker Compose
- Escaneamento de IaC (Dockerfiles)

---

## 📚 Referências

### Padrões e Benchmarks

- [CIS Docker Benchmark v1.7.0](https://www.cisecurity.org/benchmark/docker) - Centro de Segurança na Internet
- [NIST SP 800-190](https://csrc.nist.gov/publications/detail/sp/800-190/final) - Guia de Segurança de Contêineres de Aplicativos
- [OWASP Docker Security Cheat Sheet](https://cheatsheetseries.owasp.org/cheatsheets/Docker_Security_Cheat_Sheet.html) - Folha de Dicas de Segurança Docker OWASP

### Pesquisas e CVEs

- [4M Contêineres Maliciosos Sem Imagem](https://thehackernews.com/2024/04/millions-of-malicious-imageless.html) - The Hacker News, Abril de 2024
- [Ataques à Cadeia de Suprimentos Usando Imagens de Contêineres](https://www.aquasec.com/blog/supply-chain-threats-using-container-images/) - Aqua Security
- [CVE-2024-21626: Escape de Contêiner runc](https://nvd.nist.gov/vuln/detail/CVE-2024-21626) - NIST NVD
- [CVE-2024-23651: RCE no BuildKit](https://nvd.nist.gov/vuln/detail/CVE-2024-23651) - NIST NVD
- [Backdoor do xz-utils (Março de 2024)](https://www.openwall.com/lists/oss-security/2024/03/29/4) - OpenWall

### Ferramentas e Projetos

- [Trivy](https://github.com/aquasecurity/trivy) - Scanner de vulnerabilidades
- [Docker Bench Security](https://github.com/docker/docker-bench-security) - Script de benchmark CIS
- [Cosign](https://github.com/sigstore/cosign) - Assinatura e verificação de contêineres
- [SARIF Specification](https://docs.oasis-open.org/sarif/sarif/v2.1.0/sarif-v2.1.0.html) - Formato de Resultados de Análise Estática

---

## 📄 Licença

Este projeto está licenciado sob a **DockerScan Proprietary Source-Available License**.

### O Que Isso Significa

✅ **Você PODE (Gratuitamente):**
- Usar DockerScan **gratuitamente** para escaneamento de segurança interno
- Usá-lo em seus **pipelines CI/CD** e fluxos de trabalho de segurança
- **Modificar, bifurcar e contribuir** de volta à comunidade
- Usá-lo para fins **educacionais e de pesquisa**
- Usá-lo como **ferramenta em serviços profissionais** (consultoria, auditorias de segurança, testes de penetração)
- **Integrá-lo** em outros produtos onde seja um componente auxiliar

❌ **Você NÃO PODE (sem permissão expressa por escrito ou licença comercial):**
- Oferecer **escaneamento Docker como SaaS comercial**
- **Vender instâncias hospedadas** do DockerScan
- Construir uma **plataforma comercial** baseada principalmente no DockerScan
- Criar um **serviço gerenciado pago** onde o DockerScan seja a oferta principal

### Por que Esta Licença?

Esta licença protege a sustentabilidade do projeto ao:
- ✅ Conceder **liberdade** para usar o software para fins legítimos
- ❌ Prevenir o **aproveitamento parasitário prejudicial** onde empresas lucram ao oferecê-lo como serviço sem contribuir de volta
- 💰 Garantir que o projeto permaneça **sustentável** através de licenciamento comercial para usos concorrentes
- 🔓 Manter o **código-fonte disponível** para transparência e contribuições da comunidade

**Isso NÃO é código aberto** - é **código-fonte disponível** com restrições de uso comercial competitivo.

### Licenciamento Comercial

**Exigido para:**
- Ofertas SaaS ou hospedadas
- Plataformas comerciais usando DockerScan como funcionalidade principal
- Revenda ou redistribuição como produto comercial
- Serviços gerenciados onde DockerScan é a oferta central

**Contato para licenciamento comercial:**

📧 Email: cr0hn [at] cr0hn.com
🌐 Site: https://cr0hn.com
💼 Termos de licenciamento flexíveis disponíveis para empresas e startups

Veja o arquivo [LICENSE](https://github.com/cr0hn/dockerscan/blob/HEAD/LICENSE) para os termos legais completos.

---

## 👤 Autor

<div align="center">

### **Daniel Garcia (cr0hn)**

[![Site](https://img.shields.io/badge/Website-cr0hn.com-blue?style=for-the-badge&logo=google-chrome)](https://cr0hn.com)
[![GitHub](https://img.shields.io/badge/GitHub-cr0hn-black?style=for-the-badge&logo=github)](https://github.com/cr0hn)
[![Twitter](https://img.shields.io/badge/Twitter-@ggdaniel-1DA1F2?style=for-the-badge&logo=twitter)](https://twitter.com/ggdaniel)

**Pesquisador de Segurança | Desenvolvedor Open Source | Especialista em Segurança Docker**

</div>

---

## 🙏 Agradecimentos

Agradecimentos especiais a:
- A comunidade de segurança Docker
- CIS pelo Docker Benchmark
- NIST pelo SP 800-190
- Pesquisadores de segurança que descobriram os ataques à cadeia de suprimentos de 2024
- Todos os colaboradores e usuários do DockerScan

---

## 📞 Suporte

- **Issues**: [GitHub Issues](https://github.com/cr0hn/dockerscan/issues)
- **Discussões**: [Discussões do GitHub](https://github.com/cr0hn/dockerscan/discussions)
- **Segurança**: Relate vulnerabilidades para [email protected]

---

<div align="center">

**⭐ Se você achar o DockerScan útil, por favor, dê uma estrela no repositório! ⭐**

*Tornando a Segurança Docker Acessível para Todos*

[⬆ Voltar ao Topo](#-dockerscan-v20)

</div>

Ler mais

dockerscan v2.1.0

Categorias

dockerscan v2.1.0

DockerScan v2.0

O Scanner de Segurança Docker Mais Abrangente

📑 Tabela de Conteúdo

🎯 Visão Geral

Por que DockerScan v2.0?

🌟 Funcionalidades

🛡️ Módulos de Escaneamento de Segurança

1. CIS Docker Benchmark v1.7.0

2. Detecção de Ataques à Cadeia de Suprimentos 🆕

3. Detecção Avançada de Segredos 🔑

4. Escaneamento de CVE e Vulnerabilidades 🚨

5. Análise de Segurança em Tempo de Execução ⚙️

📊 Relatórios e Integração

🚀 Desempenho

🆕 O que há de novo no v2.0?

Principais Mudanças

O que foi preservado do v1.x

Novo no v2.0.5 🔐

Novo no v2.0.4

Por que a Reescrita?

📦 Instalação

Opção 1: Baixar Binário Pré-compilado (Recomendado)

Linux (amd64)```bash

macOS (Intel)```bash

Windows (PowerShell)```powershell

Opção 2: Compilar a partir do código-fonte```bash

Clone repository

Build

Install

Or build manually

🚀 Início Rápido

Configuração Inicial

Download latest CVE database from GitHub

Exemplo de Saída```

Exemplos```bash

Scan with all scanners (default)

Only run specific scanners

Save reports to specific directory

Only show critical issues

Ver progreso del scan (scanner names, findings count, image pull status)

Debug detallado (errores internos, detalles técnicos)

Scan private registry images (see Authentication section below)

Exemplos Específicos para Registries

Docker Hub (Repositórios Privados)```bash

Using Docker config

Using environment variables

AWS Elastic Container Registry (ECR)```bash

Get login credentials from AWS

Scan ECR image

Or use environment variables with ECR credentials

Azure Container Registry (ACR)```bash

Login with Azure CLI

Scan ACR image

Or use service principal credentials

Registros Auto-hospedados/Privados```bash

Standard authentication

With environment variables

Insecure registries (not recommended for production)

Add to Docker daemon config: /etc/docker/daemon.json

{

"insecure-registries": ["myregistry.example.com:5000"]

}

ECR tokens expire after 12 hours - refresh them

Segurança da Cadeia de Suprimentos

Varredura de Vulnerabilidades

📁 Formatos de Saída

Saída JSON```json

💼 Casos de Uso

1. Integração de Pipeline CI/CD

2. Auditorias de Segurança```bash

Comprehensive audit of production images

Generate summary report

4. Relatórios de Conformidade```bash

Generate CIS compliance report

Weekly security scan for compliance

📊 Comparação com Outras Ferramentas

Por que escolher o DockerScan?

🏗️ Arquitetura

Estrutura do Projeto```