cr0hn/dockerscanO Scanner de Segurança Docker Mais Abrangente
<div align="center">
<img src="https://assets.kitploit.com/production/public/readmes/1309/3345979faae1cdabbe2912dfcaf46221df5cb53697630a8e8dcc5eebf814e949.png" alt="DockerScan Logo" width="200">
# DockerScan v2.0
### *O Scanner de Segurança Docker Mais Abrangente*
[](LICENSE)
[](https://golang.org/)
[](https://github.com/cr0hn/dockerscan/releases)
[](https://github.com/cr0hn/dockerscan/actions/workflows/dockerscan.yml)
[](https://github.com/cr0hn/dockerscan)
[](https://goreportcard.com/report/github.com/cr0hn/dockerscan)
[](https://github.com/cr0hn/dockerscan/releases)
**Por [Daniel Garcia (cr0hn)](https://cr0hn.com)** | [GitHub](https://github.com/cr0hn/dockerscan) | [Site](https://cr0hn.com)
---
[Funcionalidades](#-features) •
[Instalação](#-installation) •
[Início Rápido](#-quick-start) •
[Documentação](#-documentation) •
[Casos de Uso](#-use-cases) •
[O que há de novo](#-whats-new-in-v20) •
[Contribuir](#-contributing)
</div>
---
## 📑 Tabela de Conteúdo
- [Visão Geral](#-overview)
- [Funcionalidades](#-features)
- [O que há de novo no v2.0](#-whats-new-in-v20)
- [Instalação](#-installation)
- [Início Rápido](#-quick-start)
- [Uso](#-usage)
- [Autenticação em Registro Privado](#-private-registry-authentication)
- [Scanners de Segurança](#-security-scanners)
- [Formatos de Saída](#-output-formats)
- [Casos de Uso](#-use-cases)
- [Comparação](#-comparison-with-other-tools)
- [Arquitetura](#-architecture)
- [Contribuir](#-contributing)
- [Referências](#-references)
- [Licença](#-license)
- [Autor](#-author)
---
## 🎯 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?
1. **Desempenho** - Go fornece escaneamento 10x mais rápido com goroutines
2. **Ameaças Modernas** - Incorpora padrões de ataque de 2024-2025
3. **Pronto para Empresas** - Saída SARIF, códigos de saída, distribuição de binário único
4. **Extensibilidade** - Arquitetura de plugins limpa para scanners personalizados
5. **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
# Get login credentials from AWS
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
# Login with Azure CLI
az acr login --name myregistry
# Scan ACR image
dockerscan myregistry.azurecr.io/myapp:v1.0
# Or use service principal credentials
export DOCKER_USERNAME=<service-principal-id>
export DOCKER_PASSWORD=<service-principal-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/
---
[Read more](https://github.com/cr0hn/dockerscan)