DockSec

Scanner de segurança Docker com IA que explica vulnerabilidades em linguagem simples

O que é o DockSec?

DockSec é um OWASP Lab Project que preenche a lacuna entre resultados complexos de varredura de segurança e correções acionáveis para desenvolvedores. Ele integra scanners padrão do setor (Trivy, Hadolint, Docker Scout) com IA para fornecer análise de segurança contextualizada.

Em vez de sobrecarregá-lo com uma lista de mais de 200 CVEs, o DockSec:

• Prioriza o que realmente afeta sua configuração específica de contêiner.
• Explica vulnerabilidades em linguagem simples, não apenas em jargão de segurança.
• Sugere correções específicas para seu Dockerfile.
• Gera relatórios de segurança profissionais e interativos para sua equipe.

Tudo é escaneado localmente; a única coisa que sai da sua máquina é o conteúdo do arquivo (com segredos ocultados) enviado ao provedor de IA que você escolher - e com um modelo local ou modo somente varredura, nada sai. Consulte Fluxo de dados e privacidade.

Como Funciona

Fluxo de trabalho do DockSec: da varredura a insights acionáveis

O DockSec segue um pipeline de cinco estágios:

1. Scan: Executa Trivy (vulnerabilidades de imagem e configurações incorretas do Dockerfile), Hadolint e Docker Scout localmente em seu ambiente.
2. Prioritize: Classifica cada descoberta de CVE por severidade combinada com sua probabilidade de exploração EPSS, para que a lista seja ordenada pelo que corrigir primeiro, e não pelo que foi encontrado primeiro.
3. Correlate: Detecta cadeias de exploração onde descobertas separadas se combinam em um único caminho de ataque - um banco de dados com credenciais que um serviço voltado para a internet pode alcançar é uma cadeia, não duas descobertas não relacionadas. Com uma chave de API, uma passagem de IA raciocina sobre a saída completa da varredura para classificar, explicar e estender isso.
4. Recommend: Produz comandos de correção prontos para copiar e executar e alterações concretas no Dockerfile ou no compose, e informa quantas descobertas eles resolvem.
5. Report: Exporta resultados acionáveis como HTML, PDF, JSON, CSV, Markdown, SARIF e CycloneDX SBOM.

Primeiros Passos

1. Pré-requisitos

O DockSec orquestra scanners locais, então precisa de:

Ou deixe o DockSec instalar o Trivy e o Hadolint para você:```bash python -m docksec.setup_external_tools

### 2. Instalar o DockSec```bash
# Full install with AI analysis support (recommended)
pip install "docksec[ai]"

# Or the slim, scan-only core (no LLM dependencies, no API key needed)
pip install docksec

3. Execute sua primeira varredura

Nenhuma chave de API é necessária para varredura local:```bash docksec Dockerfile --scan-only

Todo scan termina com um resumo de resultados: uma tabela de severidade, uma pontuação de segurança de 0 a 100 com uma
classificação, um bloco de ação "Quick take", os relatórios gerados (salvos em
`~/.docksec/results/` por padrão) e um próximo comando sugerido.

### 4. Ativar análise de IA

A análise de IA explica os achados e sugere correções. Escolha um provedor, defina sua chave de API e execute:```bash
# OpenAI (default provider)
export OPENAI_API_KEY="sk-..."
docksec Dockerfile

# Anthropic Claude
export ANTHROPIC_API_KEY="sk-ant-..."
docksec Dockerfile --ai-only --provider anthropic --model claude-sonnet-5

# Google Gemini
export GOOGLE_API_KEY="..."
docksec Dockerfile --ai-only --provider google

# Ollama (fully local, no API key, data never leaves your machine)
docksec Dockerfile --ai-only --provider ollama --model llama3.1

Cada provedor tem um modelo padrão sensato (OpenAI: gpt-4o, Anthropic: claude-haiku-4-5, Google: gemini-1.5-pro, Ollama: llama3.1), então --model é opcional. Para evitar repetir flags, defina variáveis de ambiente (ou coloque-as em um arquivo .env no diretório a partir do qual você executa - o DockSec o carrega automaticamente):```bash export LLM_PROVIDER=anthropic export LLM_MODEL=claude-sonnet-5 docksec Dockerfile

Antes de que qualquer conteúdo seja enviado a um provedor de IA, valores com aparência de segredo (palavras-passe, tokens, chaves de API, blocos de chave privada) são mascarados automaticamente. Consulte
[Fluxo de dados e privacidade](#data-flow-and-privacy).

### 5. Ou execute a imagem do contentor (nada para instalar)

A imagem publicada inclui versões fixadas do Trivy e do Hadolint, pelo que não há
nada para instalar nem nada para configurar:```bash
docker run --rm -v "$PWD:/github/workspace" \
  -e INPUT_DOCKERFILE=Dockerfile \
  -e INPUT_SCAN_ONLY=true \
  ghcr.io/owasp/docksec:latest

Publicado multi-arquitetura (amd64 e arm64) em cada release. Fixe uma versão específica (ghcr.io/owasp/docksec:2026.9.21) ou uma série menor (ghcr.io/owasp/docksec:2026.9) em vez de latest na CI. Cada imagem carrega uma atestação de proveniência de build:```bash gh attestation verify oci://ghcr.io/owasp/docksec:latest --repo OWASP/DockSec

A imagem lê as mesmas variáveis `INPUT_*` que a GitHub Action, portanto qualquer
input da Action funciona aqui: `INPUT_IMAGE`, `INPUT_COMPOSE`, `INPUT_SEVERITY`,
`INPUT_FAIL_ON`, `INPUT_FORMAT`, `INPUT_SARIF`, `INPUT_OUTPUT_DIR`. Escreva os relatórios
em algum lugar do mount para mantê-los após o contêiner encerrar:```bash
docker run --rm -v "$PWD:/github/workspace" \
  -e INPUT_COMPOSE=docker-compose.yml \
  -e INPUT_SCAN_ONLY=true \
  -e INPUT_FORMAT=json,html \
  -e INPUT_OUTPUT_DIR=/github/workspace/docksec-reports \
  ghcr.io/owasp/docksec:latest

6. Ou use a GitHub Action```yaml

• name: Run DockSec AI Scanner uses: OWASP/[email protected] with: dockerfile: 'Dockerfile' openai_api_key: ${{ secrets.OPENAI_API_KEY }}

## Comandos Comuns```bash
# Scan Dockerfile + Docker image (AI + scanners)
docksec Dockerfile -i myapp:latest

# Scan a Docker Compose file and all its services
docksec --compose docker-compose.yml

# Scan only a Docker image
docksec --image-only -i myapp:latest

# Fast local scan, no AI, no API key
docksec Dockerfile --scan-only

# Choose which severity levels the image scan reports (default: CRITICAL,HIGH)
docksec -i myapp:latest --image-only --severity CRITICAL,HIGH,MEDIUM

# Fail the build (exit 1) if any finding is HIGH or above
docksec -i myapp:latest --image-only --fail-on high

# Write only the report formats you want, to a directory of your choice
docksec Dockerfile --scan-only --format json,html --output-dir ./reports

# Write a Markdown report for posting directly into a pull request comment
docksec Dockerfile --scan-only --format markdown

# Print results as JSON to stdout for scripts and CI pipelines
docksec -i myapp:latest --image-only --json

# Write a SARIF report for GitHub Code Scanning
docksec Dockerfile --scan-only --sarif

# Write a CycloneDX SBOM of an image for supply-chain tooling
docksec --image-only -i myapp:latest --sbom

# Fully offline scan: local Trivy DB, no network, no AI
docksec --image-only -i myapp:latest --offline

# Save today's findings as a baseline, then only gate on new findings later
docksec -i myapp:latest --image-only --baseline .docksec-baseline.json --update-baseline
docksec -i myapp:latest --image-only --baseline .docksec-baseline.json --fail-on high

# Suppress triaged findings with an auditable ignore file
docksec -i myapp:latest --image-only --ignore-file .docksec-ignore.yml

# Force a fresh scan, bypassing the results cache
docksec -i myapp:latest --image-only --no-cache

# Install AI-assistant skill files (Claude Code, Cursor, Copilot, and more)
docksec install-skill

# Output control
docksec Dockerfile --scan-only --quiet                  # warnings, errors, summary only
docksec Dockerfile --scan-only --verbose                # INFO-level diagnostics on stderr
docksec Dockerfile --scan-only --verbose --log-file logs/docksec.log
docksec Dockerfile --scan-only --compact-output         # shorter per-finding output
docksec Dockerfile --no-color                           # also honors NO_COLOR

# Apply the mechanical Dockerfile fixes (keeps a .bak, re-scans, shows the delta)
docksec Dockerfile --scan-only --fix --dry-run          # print the diff, change nothing
docksec Dockerfile --scan-only --fix

# Rank findings by severity alone, with no EPSS lookup and no network call
docksec Dockerfile --scan-only --no-epss

# Treat a scan that could not complete as a failure, not a pass
docksec Dockerfile --scan-only --fail-on high --incomplete-policy fail

Arquivo de configuração

Faça commit de um .docksec.yml na raiz do seu repositório e toda a equipe - e cada job de CI - faz varredura sob a mesma política, em vez de cada desenvolvedor passar suas próprias flags.```yaml

yaml-language-server: $schema=https://owasp.org/DockSec/docksec-config-schema.json

severity: CRITICAL,HIGH fail_on: HIGH formats: [json, html] output_dir: ./security-reports

rules: disabled: - compose-missing-healthcheck

Toda configuração é opcional; qualquer item omitido recorre à variável de ambiente e, em seguida, ao valor padrão interno. Um exemplo completo e comentado está em
[`examples/.docksec.yml`](https://github.com/owasp/docksec/blob/main/examples/.docksec.yml).

### Precedência

Maior prioridade primeiro:```
CLI flag  >  environment variable  >  .docksec.yml  >  built-in default

Assim, um severity: LOW definido no ficheiro é ainda substituído por --severity CRITICAL na linha de comandos, e por DOCKSEC_DEFAULT_SEVERITY no ambiente.

Descoberta

O DockSec procura .docksec.yml (ou .docksec.yaml) no diretório de trabalho e depois sobe até à raiz do repositório, para que um serviço num subdiretório de um monorepo herde a política definida no nível superior. A procura para no diretório que contém .git, para que nunca apanhe um ficheiro de fora do repositório.

• --config FILE usa um ficheiro específico em vez de procurar.
• --no-config ignora qualquer ficheiro de configuração, para execuções de CI reproduzíveis.

O ficheiro de configuração em vigor é mostrado no banner da análise, para que seja sempre claro qual a política aplicada.

Definições

Um ficheiro de configuração inválido - uma chave desconhecida, uma severidade inválida - é um erro fatal que termina com 2 em vez de um aviso, para que um ficheiro de política com erros nunca possa fazer com que uma análise seja executada sob regras que a equipa não definiu.

Autocompletar no editor

O comentário # yaml-language-server: na primeira linha fornece autocompletar e validação em linha no VS Code e nos editores JetBrains. O esquema é publicado em docs/docksec-config-schema.json e pode ser regenerado com docksec --print-config-schema.

Desativar regras

rules.disabled desativa uma verificação completamente, em todo o lado - é removida antes da pontuação, dos relatórios, do --json e do bloqueio --fail-on. Use-a para verificações que não se aplicam ao seu ambiente. Para achados individuais que a sua equipa triou e aceitou, prefira o ficheiro de isenções, cujas entradas incluem um motivo e uma data de expiração e, por isso, permanecem auditáveis.

Integração CI/CD

Códigos de saída

O DockSec usa códigos de saída compatíveis com CI para que as builds e as shells possam reagir aos resultados:

--fail-on bloqueia em todos os achados estruturados: vulnerabilidades da imagem, más configurações do Dockerfile e más configurações do compose. Quando --fail-on está abaixo do --severity pedido, a severidade da análise é alargada automaticamente para que o bloqueio possa observar esses achados.

Análises incompletas

Se um scanner não conseguir ser executado, os resultados podem ter achados em falta em vez de estarem genuinamente limpos. O DockSec reporta isso como uma lacuna de deteção no bloco Coverage e no --json em scan_info.completeness. Use --incomplete-policy fail para terminar com 3 nesse caso, para que o CI não possa passar numa análise que não terminou:```bash docksec Dockerfile --incomplete-policy fail

### Prioridade: o que corrigir primeiro

Cada descoberta de CVE é pontuada com base no [EPSS](https://www.first.org/epss/), que
estima a probabilidade de ser explorada nos próximos 30 dias. Combinando isso
com a severidade, obtêm-se quatro níveis:

| Nível | Significado |
|---|---|
| **Corrigir Agora** | Severidade crítica ou alta, e entre os 10% principais de CVEs por probabilidade de exploração |
| **Corrigir em Breve** | Severidade crítica ou alta, mas a exploração é menos comum |
| **Monitorizar** | Severidade mais baixa, mas ativamente explorada |
| **Baixa Prioridade** | Severidade mais baixa, exploração incomum |

Esta é a única chamada de rede que o DockSec faz fora da passagem de IA, e é
deliberadamente restrita: **apenas os IDs de CVE são enviados** - sem nomes de imagens, sem conteúdos de ficheiros,
sem caminhos. As pontuações são armazenadas em cache durante 24 horas. `--offline` e `--no-epss` desativam-na,
e qualquer falha recorre à classificação apenas por severidade em vez de falhar a análise.

### Cadeias de exploração

Uma vista por serviço reporta as descobertas uma de cada vez. O DockSec também reporta onde
descobertas separadas se combinam numa única via de ataque:```text
Exploit chains
  [HIGH] 'web' is internet-facing and can reach 'db' with a committed credential
      services: web, db
      combines: compose-plaintext-secret-env, compose-no-network-segmentation
      'web' accepts connections from outside the host and shares the default
      network with 'db'. 'db' is not exposed directly, but its credential is in
      the compose file, so compromising 'web' yields authenticated access to it.
      Neither service looks critical on its own.
      break it: Put 'db' on its own network that 'web' does not join, or move
      POSTGRES_PASSWORD to a Docker secret.

A detecção de cadeias é baseada em regras, portanto funciona com --scan-only, offline e sem chave de API, e retorna a mesma resposta em cada execução. A passagem de IA classifica e estende o resultado, em vez de ser necessária para ele. As cadeias também aparecem em --json sob exploit_chains.

Consulte o guia de cadeias de exploração para a lista completa e a referência de regras de composição para cada regra que elas combinam.

Comandos de correção

As varreduras terminam com comandos concretos em vez de uma lista de identificadores, e uma declaração simples de quantos achados eles resolvem:```text Fix commands

apt-get install --only-upgrade -y libgnutls30=3.7.9-2+deb12u7 CRITICAL - 3.7.9-2+deb12u4 -> 3.7.9-2+deb12u7 (CVE-2026-33845 +6)

Dockerfile changes

• [CRITICAL] Move the secret out of ENV; inject it at runtime (line 4)
• [HIGH] Add a non-root USER before CMD/ENTRYPOINT (line 7)

Applying all of the above resolves 37 of 93 finding(s); 56 have no mechanical fix yet.

### Saída legível por máquina

`--json` imprime um único objeto JSON em stdout (informações da varredura, vulnerabilidades, contagens de severidade e quaisquer descobertas de IA) em vez do resumo legível por humanos, para que possa ser canalizado diretamente para outras ferramentas:```bash
docksec -i myapp:latest --image-only --json | jq '.severity_counts'

Com --json sozinho, nenhum arquivo de relatório é gravado; combine-o com --format para gravar arquivos e imprimir JSON na mesma execução. Todas as mensagens legíveis por humanos vão para stderr no modo --json, então stdout contém apenas o payload JSON.

Formatos de relatório

--format aceita uma lista separada por vírgulas de saídas de arquivo:

json, csv, pdf e html são gravados por padrão; adicione markdown explicitamente para obtê-lo.

CSV sem achados: se uma varredura não reportar vulnerabilidades mas csv estiver na sua lista de --format, o DockSec ainda grava um arquivo CSV contendo apenas os cabeçalhos das colunas. Isso é intencional (a exportação é válida, não uma gravação falha) para que ferramentas downstream possam contar com um esquema estável mesmo em varreduras limpas.

Para JSON em stdout e encadeamento para outras ferramentas, veja Saída legível por máquina acima. Para CI e GitHub Code Scanning, use --sarif (veja a próxima seção); SARIF é separado de --format e é sempre emitido quando solicitado.

Saída SARIF para GitHub Code Scanning

--sarif grava um relatório SARIF 2.1.0 junto com os outros formatos de relatório. Faça o upload dele com a ação padrão github/codeql-action/upload-sarif para ver os achados anotados diretamente em pull requests e na aba Security:```yaml

• name: Run DockSec uses: OWASP/[email protected] with: dockerfile: 'Dockerfile' sarif: 'true'

• name: Upload SARIF to GitHub Code Scanning uses: github/codeql-action/upload-sarif@v3 if: always() with: sarif_file: ~/.docksec/results

> `if: always()` é importante: sem ele, a etapa de upload é ignorada sempre que
> `--fail-on` faz o DockSec sair com código diferente de zero, perdendo os achados exatamente quando
> mais importam.

### Modo baseline / ratchet

`--baseline FILE` permite adotar `--fail-on` num projeto existente sem uma parede de
achados pré-existentes bloqueando todas as builds. Execute uma vez com `--update-baseline` para capturar
os achados atuais, depois faça commit do ficheiro de baseline; a partir daí, `--fail-on` só bloqueia
achados que ainda não estão no baseline:```bash
# Snapshot current findings (does not gate)
docksec -i myapp:latest --image-only --baseline .docksec-baseline.json --update-baseline

# Later runs only fail on NEW findings above the threshold
docksec -i myapp:latest --image-only --baseline .docksec-baseline.json --fail-on high

Os achados são correspondidos por ID de vulnerabilidade, alvo e nome do pacote, portanto a linha de base permanece válida à medida que achados não relacionados aparecem e desaparecem. Execute novamente com --update-baseline sempre que quiser aceitar o estado atual como a nova linha de base.

Ignorando achados (isenções)

--ignore-file FILE suprime achados individuais que uma equipe triou e aceitou. Diferentemente da linha de base (um instantâneo pontual), o arquivo de ignorados é uma lista explícita e revisável, na qual cada entrada carrega um motivo e uma data de expiração opcional. Se um arquivo .docksec-ignore.yml existir no diretório atual, ele é detectado automaticamente.```yaml

.docksec-ignore.yml

ignores:

• id: CVE-2023-45853 # Trivy vulnerability ID or DockSec rule ID reason: "zlib CVE; code path not reachable, vendor fix pending" expires: 2026-12-31 # optional; entry stops applying after this date
• id: compose-missing-healthcheck reason: "healthchecks are handled by the orchestrator"

Descobertas suprimidas são removidas antes da pontuação, dos relatórios, da saída `--json` e do
gate `--fail-on`. Entradas expiradas deixam de ser aplicadas automaticamente (com um aviso), e
entradas sem um motivo são sinalizadas para que as isenções permaneçam auditáveis. Faça commit do arquivo no
controle de versão para que as supressões sejam revisadas como qualquer outra alteração.

---

## Relatórios

### Formatos de relatório

Por padrão, toda varredura grava quatro arquivos de relatório; use `--format` para escolher um subconjunto:

- **html**: Um relatório web interativo e visualmente limpo: cartões de severidade, classificação de pontuação, tabela completa de vulnerabilidades com versões corrigidas e as descobertas completas da IA.
- **pdf**: Um documento portátil e pronto para apresentação.
- **json**: Dados completos de varredura legíveis por máquina (mesmo formato da saída `--json` no stdout).
- **csv**: Uma tabela de vulnerabilidades individuais pronta para planilhas.
- **markdown**: Um relatório leve e legível (resumo de severidade + tabela de vulnerabilidades com versões corrigidas) que é renderizado nativamente em comentários de pull request e resumos de jobs de CI. Opcional: adicione `markdown` a `--format`; ele não é gravado por padrão.

> Nota sobre o comportamento do CSV: com zero vulnerabilidades, o DockSec ainda grava um
> CSV apenas com cabeçalho (nomes das colunas, sem linhas) para que a automação downstream nunca quebre por causa de um arquivo
> ausente ou vazio. Isso é intencional.

### CycloneDX SBOM

`--sbom` grava um software bill of materials CycloneDX (`<image>.cdx.json`) da
imagem escaneada, listando cada componente de pacote mais as vulnerabilidades conhecidas. O BOM é
produzido pelo exportador nativo do Trivy (portanto é compatível com a especificação) e o DockSec se registra
nos metadados da ferramenta. Alimente-o no Dependency-Track, no gráfico de dependências do GitHub ou em qualquer
outro consumidor de SBOM:```bash
docksec --image-only -i myapp:latest --sbom

--sbom precisa de uma única imagem (-i), por isso é ignorado em execuções de compose. Tal como --sarif, é independente de --format.

Fluxo de dados e privacidade

O DockSec foi concebido para que saiba sempre o que sai da sua máquina:

• A análise é totalmente local. O Trivy, o Hadolint e a pontuação de segurança são executados na sua máquina. O conteúdo das imagens nunca é enviado para lado nenhum pelo DockSec.
• A análise por IA envia apenas o ficheiro analisado. Quando a passagem de IA é executada, o conteúdo do Dockerfile ou do ficheiro compose (mais um breve resumo das contagens de vulnerabilidades para pontuação) é enviado para o fornecedor de LLM que configurou. Nada mais é transmitido.
• Os segredos são ocultados antes de saírem. Valores com aparência de segredo (palavras-passe, tokens, chaves de API, blocos de chaves privadas) no ficheiro são mascarados antes de o conteúdo ser enviado para o fornecedor de IA. Os nomes das chaves permanecem visíveis para que as credenciais expostas continuem a ser sinalizadas. Use --no-redact para desativar.
• A IA totalmente local é suportada. Use --provider ollama para manter a análise por IA no seu próprio hardware, ou --scan-only / --offline para ignorar completamente a IA.
• Sem telemetria. O DockSec não recolhe dados de utilização nem contacta nenhum serviço externo.

Modo offline

--offline executa uma análise sem acesso à rede. Usa a base de dados de vulnerabilidades do Trivy já presente no disco (sem atualização da BD) e ignora a análise por IA e a análise avançada do Docker Scout, ambas as quais requerem rede. Esta é a forma mais simples de analisar num ambiente isolado ou restrito:```bash docksec --image-only -i myapp:latest --offline

Certifique-se de que o banco de dados do Trivy tenha sido baixado pelo menos uma vez (qualquer verificação online anterior faz
isso) antes de confiar em `--offline`.

### Cache de resultados de verificação

Os resultados de verificação de imagens são armazenados em cache (padrão: 24 horas, substituível com
`DOCKSEC_CACHE_TTL_HOURS`) e indexados pelo digest de conteúdo da imagem, de modo que uma tag reconstruída
como um `:latest` reutilizado sempre recebe uma verificação nova. Use `--no-cache` (ou
`DOCKSEC_USE_CACHE=false`) para ignorar o cache em uma execução.

### Baixando imagens que não são locais

Verificar uma imagem que não está presente localmente faz o download dela primeiro. Uma stack do compose
costuma nomear imagens que a máquina nunca baixou, e sem isso cada um
desses serviços é reportado como não verificado.

Defina `DOCKSEC_PULL_MISSING_IMAGES=false` para desativar isso e falhar em vez disso, o que
vale a pena fazer em uma conexão limitada ou em um runner compartilhado. `--offline` nunca
faz download, independentemente dessa configuração.

---

## Habilidades de assistente de IA (`install-skill`)

`docksec install-skill` grava instruções de uso do DockSec nos arquivos de contexto
conhecidos dos assistentes de codificação com IA populares, para que um assistente trabalhando no seu repositório saiba como
invocar o DockSec:```bash
docksec install-skill

Isso cria ou atualiza:

• .claude/commands/docksec.md (comando slash do Claude Code /docksec)
• .cursor/rules/docksec.mdc (Cursor)
• AGENTS.md (Codex CLI), GEMINI.md (Gemini CLI)
• .github/copilot-instructions.md (GitHub Copilot)

Os arquivos são texto simples que você pode revisar e commitar; nada é executado. Reexecutar o comando atualiza a seção do DockSec no local em vez de duplicá-la.

Recursos

• Análise Inteligente: A IA explica o que as vulnerabilidades significam para sua configuração específica.
• Suporte a Múltiplos LLMs: OpenAI, Anthropic Claude, Google Gemini ou modelos locais via Ollama.
• Privacidade em Primeiro Lugar: Valores de segredos são redigidos antes que qualquer conteúdo chegue a um provedor de IA, a varredura é totalmente local e não há telemetria.
• Varredura de Docker Compose: Detecta configurações incorretas no nível de orquestração e varre todos os serviços em um arquivo compose.
• Integração Profunda: Combina Trivy (vulnerabilidades), Hadolint (linting) e Docker Scout.
• Pontuação de Segurança: Uma pontuação de 0 a 100 com uma classificação para acompanhar sua postura de segurança ao longo do tempo.
• Formatos Ricos: HTML (interativo), PDF, JSON, CSV, SARIF e CycloneDX SBOM.
• Pronto para CI/CD: Códigos de saída --fail-on, modo baseline/ratchet, isenções auditáveis, JSON para stdout e uma GitHub Action no Marketplace.
• Modo Offline: Varredura totalmente isolada (--offline) usando o banco de dados local do Trivy.
• Habilidades para Assistentes de IA: docksec install-skill ensina Claude Code, Cursor, Copilot e outros a executar o DockSec no seu repositório.

Como o DockSec se Compara

O DockSec é o único entre esses que combina remediação contextual de Dockerfile com um design totalmente de código aberto, governado pela OWASP e executável localmente. Snyk e Aikido oferecem remediação por IA capaz, mas apenas como plataformas comerciais em nuvem que enviam seus dados para o serviço deles. O Trivy é de código aberto e local, mas para na detecção e não ajuda a corrigir nada. O DockSec preenche a lacuna para desenvolvedores e para equipes reguladas ou isoladas que precisam tanto da orientação de correção quanto do controle total de seus dados, sem custo.

Aplicando correções automaticamente

--fix aplica o subconjunto mecânico das alterações sugeridas no Dockerfile, refaz a varredura e relata o delta:```bash docksec Dockerfile --scan-only --fix --dry-run # print the diff, change nothing docksec Dockerfile --scan-only --fix # apply, keeping a .bak

### Instalação

```bash
pip install -r requirements.txt

Uso

python3 main.py -h

Exemplo

python3 main.py -u https://example.com -w wordlist.txt

Aviso Legal

Esta ferramenta é apenas para fins educacionais. Os autores não são responsáveis por qualquer uso indevido ou danos causados por este programa.

Contribuição

Sinta-se à vontade para enviar issues e pull requests.

Licença

Este projeto está licenciado sob a Licença MIT - consulte o arquivo LICENSE para obter detalhes.

Agradecimentos

• Agradecimentos especiais a todos os contribuidores e à comunidade de código aberto.

Contato

Para quaisquer dúvidas ou sugestões, entre em contato pelo e-mail [email protected].

Aviso

Não nos responsabilizamos por qualquer uso indevido desta ferramenta. Use por sua conta e risco.

Isenção de Responsabilidade

O software é fornecido "como está", sem garantia de qualquer tipo, expressa ou implícita, incluindo, mas não se limitando a, garantias de comercialização, adequação a um propósito específico e não violação. Em nenhum caso os autores ou detentores de direitos autorais serão responsáveis por qualquer reclamação, danos ou outra responsabilidade, seja em uma ação de contrato, ato ilícito ou de outra forma, decorrente de, ou em conexão com o software ou o uso ou outras negociações no software.

Segurança

Embora este software tenha sido testado, não há garantia de que ele seja seguro ou adequado para uso em ambientes de produção. Use por sua conta e risco.

Referências

• OWASP
• CVE
• NVD
• Exploit-DB
• Packet Storm
• SecurityFocus
• SANS
• MITRE
• NIST
• CIS
• ISO
• IEC
• IEEE
• ACM
• USENIX
• Black Hat
• DEF CON
• BSides
• OWASP AppSec
• OWASP Top 10
• OWASP Cheat Sheet Series
• OWASP Testing Guide
• OWASP Mobile Security Testing Guide
• OWASP API Security Top 10
• OWASP SAMM
• OWASP ASVS
• OWASP MASVS
• OWASP ZAP
• Burp Suite
• Nmap
• Metasploit
• Wireshark
• John the Ripper
• Hashcat
• Hydra
• SQLMap
• Nikto
• Dirb
• Gobuster
• Wfuzz
• FFUF
• Amass
• Subfinder
• Assetfinder
• Findomain
• Sublist3r
• Knockpy
• DNSRecon
• DNSEnum
• Fierce
• Dnsutils
• Whois
• Nslookup
• Dig
• Host
• Traceroute
• Ping
• Netcat
• Socat
• Telnet
• SSH
• OpenSSL
• GnuPG
• Tor
• Proxychains
• Privoxy
• Burp Suite
• OWASP ZAP
• Mitmproxy
• Charles Proxy
• Fiddler
• Wireshark
• Tcpdump
• Nmap
• Masscan
• Zmap
• Unicornscan
• Hping
• Scapy
• Metasploit
• Armitage
• Cobalt Strike
• Empire
• PowerSploit
• Mimikatz
• Responder
• Impacket
• CrackMapExec
• BloodHound
• SharpHound
• PowerView
• ADRecon
• PingCastle
• LDAPDomainDump
• Windapsearch
• Kerbrute
• Rubeus
• Kekeo
• SafetyKatz
• SharpKatz
• BetterSafetyKatz
• SharpDPAPI
• SharpSploit
• Seatbelt
• SharpUp
• SharpWMI
• SharpRDP
• SharpMove
• SharpTask
• SharpSC
• SharpSvc
• SharpReg
• SharpEvtMute
• SharpBlock
• SharpNBTScan
• SharpGPOAbuse
• SharpSCCM
• SharpWSUS
• SharpExchangePriv
• SharpPrinter
• SharpSpray
• SharpHose
• SharpKatz
• SharpMiniDump
• SharpDump
• SharpRoast
• SharpSecDump
• SharpCookieMonster
• SharpChromium
• SharpWeb
• SharpCloud
• SharpAzToken
• SharpZip
• SharpSocks
• SharpChisel
• SharpLigolo
• SharpSSH
• SharpRDP
• SharpWMI
• SharpTask
• SharpSC
• SharpSvc
• SharpReg
• SharpEvtMute
• SharpBlock
• SharpNBTScan
• SharpGPOAbuse
• SharpSCCM
• SharpWSUS
• SharpExchangePriv
• SharpPrinter
• SharpSpray
• SharpHose
• SharpKatz
• SharpMiniDump
• SharpDump
• SharpRoast
• SharpSecDump
• SharpCookieMonster
• SharpChromium
• SharpWeb
• SharpCloud
• SharpAzToken
• SharpZip
• SharpSocks
• SharpChisel
• SharpLigolo
• SharpSSH```text Applied 4 change(s)
  • added --no-install-recommends on line(s) 2 [DS029]
  • converted ADD to COPY on line(s) 3 [DL3020]
  • replaced 'USER root' with 'USER appuser' on line 5 [DS002]
  • inserted a placeholder HEALTHCHECK before line 6 [DS026]

Original saved to Dockerfile.bak Dockerfile findings: 7 -> 2 (5 resolved)

Ele é deliberadamente conservador. Não escolherá uma versão de imagem base, moverá um
segredo, converterá um `ADD` que busca uma URL ou descompacta um arquivo, nem editará um
arquivo compose - esses casos são reportados em "Needs review". Ele também se recusa
a editar um arquivo com alterações não commitadas, a menos que `--force` seja fornecido, para que o git
esteja sempre em posição de desfazer a alteração.

## Documentação

| Guia | O que cobre |
| --- | --- |
| [Guia de avaliação](https://github.com/owasp/docksec/blob/main/docs/evaluation-guide.md) | Avaliação de 15 minutos, incluindo o que o DockSec *não* faz |
| [Cadeias de exploração](https://github.com/owasp/docksec/blob/main/docs/exploit-chains.md) | Caminhos de ataque entre serviços e seus limites |
| [Referência de regras do Compose](https://github.com/owasp/docksec/blob/main/docs/rules/README.md) | Todas as 17 regras: o que cada uma detecta e quando mantê-la é razoável |
| [Integração com CI](https://github.com/owasp/docksec/blob/main/docs/ci/README.md) | Jenkins, GitLab, Azure Pipelines, pre-commit |
| [Exemplos](https://github.com/owasp/docksec/blob/main/examples/README.md) | Dez Dockerfiles e stacks compose com seus achados esperados |
| [Estudos de caso](https://github.com/owasp/docksec/blob/main/docs/case-studies/README.md) | Varreduras reais de imagens oficiais, com os números |

## Roadmap

Consulte [ROADMAP.md](https://github.com/owasp/docksec/blob/main/ROADMAP.md) para saber para onde o DockSec está indo: varredura de registry sem um
daemon Docker local, um arquivo de configuração de política em nível de repositório, templates para Jenkins/GitLab/Azure DevOps,
uma imagem de contêiner oficial, varredura de Kubernetes e Helm, e mais. Feedback
e votos sobre prioridades são bem-vindos em
[issues](https://github.com/OWASP/DockSec/issues) e no
[OWASP Slack](https://owasp.slack.com/archives/C0APXGCUW7M).

---

## Contribuindo

O DockSec prospera com contribuições da comunidade. Seja você desenvolvedor, designer ou entusiasta de segurança, há muitas formas de se envolver:

- **Contribuições de Código**: Corrija bugs ou adicione novos recursos.
- **Documentação**: Melhore guias ou crie tutoriais.
- **Relato de Problemas**: Identifique e reporte bugs.
- **Feedback**: Compartilhe sua experiência e sugestões.

Para começar, confira nosso [Guia de Contribuição](https://github.com/owasp/docksec/blob/main/CONTRIBUTING.md), [Código de Conduta](https://github.com/owasp/docksec/blob/main/CODE_OF_CONDUCT.md) e [Guia de Patrocínio](https://github.com/owasp/docksec/blob/main/SPONSORSHIP.md).

---

## Líderes e Comunidade

O DockSec é liderado por uma equipe dedicada e comprometida em tornar a segurança de contêineres acessível:

- [Advait Patel](https://github.com/advaitpatel) - Líder do Projeto
- [Arkadii Yakovets](https://github.com/arkid15r) - Co-líder do Projeto

Encontre-nos aqui:

- **Página do Projeto OWASP**: [owasp.org/DockSec/](https://owasp.org/DockSec/)
- **OWASP Slack**: [#project-docksec](https://owasp.slack.com/archives/C0APXGCUW7M)
- **PyPI**: [pypi.org/project/docksec/](https://pypi.org/project/docksec/)
- **Issues**: [Reporte um bug](https://github.com/OWASP/DockSec/issues)
- **Changelog**: [CHANGELOG.md](https://github.com/owasp/docksec/blob/main/CHANGELOG.md)

---

<div align="center">
  <strong>Se o DockSec ajuda você, dê uma estrela no repositório para ajudar outros a descobri-lo.</strong><br>
  Criado por <a href="https://github.com/advaitpatel">Advait Patel</a> e a comunidade OWASP.
</div>