stanislav-web/opendoorPlataforma OWASP de Reconhecimento Web e Descoberta de Diretórios
# OpenDoor — Plataforma de Reconhecimento Web e Descoberta de Diretórios OWASP
**OpenDoor** é uma plataforma CLI de reconhecimento de código aberto para reconhecimento web autorizado, descoberta de diretórios, enumeração de subdomínios, fingerprints, deteção de WAF, sondagem de bypass, filtragem de respostas, relatórios, verificações de open-redirect, crawl limitado e fluxos de trabalho de scanning baseados em transporte.
Ajuda investigadores de segurança, testadores de penetração, caçadores de bug bounty, engenheiros DevSecOps e programadores a identificar caminhos expostos, painéis de login, listagens de diretórios, recursos restritos, ficheiros de backup, web shells, subdomínios e outros ativos web potencialmente sensíveis.
> Utilize o OpenDoor apenas em sistemas que possui ou para os quais tem permissão explícita de teste.
---
## ✅ Estado do projeto
[](https://pypi.org/project/opendoor/)
[](https://formulae.brew.sh/formula/opendoor)
[](https://www.python.org/)
[](https://github.com/stanislav-web/OpenDoor/actions/workflows/docker-image.yml)
[](https://codecov.io/github/stanislav-web/OpenDoor)
[](https://github.com/stanislav-web/OpenDoor/actions/workflows/github-code-scanning/codeql)
[](https://github.com/stanislav-web/OpenDoor/actions/workflows/codacy.yml)
[](https://opendoor.readthedocs.io/)
## 🧪 Matriz de CI
| Plataforma | Python 3.12 | Python 3.13 | Python 3.14 | Python 3.15 |
|---|---|---|---|---|
| Linux | [](https://github.com/stanislav-web/OpenDoor/actions/workflows/ci-linux-py312.yml) | [](https://github.com/stanislav-web/OpenDoor/actions/workflows/ci-linux-py313.yml) | [](https://github.com/stanislav-web/OpenDoor/actions/workflows/ci-linux-py314.yml) | [](https://github.com/stanislav-web/OpenDoor/actions/workflows/ci-linux-py315.yml) |
| macOS | [](https://github.com/stanislav-web/OpenDoor/actions/workflows/ci-macos-py312.yml) | [](https://github.com/stanislav-web/OpenDoor/actions/workflows/ci-macos-py313.yml) | [](https://github.com/stanislav-web/OpenDoor/actions/workflows/ci-macos-py314.yml) | [](https://github.com/stanislav-web/OpenDoor/actions/workflows/ci-macos-py315.yml) |
| Windows | [](https://github.com/stanislav-web/OpenDoor/actions/workflows/ci-windows-py312.yml) | [](https://github.com/stanislav-web/OpenDoor/actions/workflows/ci-windows-py313.yml) | [](https://github.com/stanislav-web/OpenDoor/actions/workflows/ci-windows-py314.yml) | [](https://github.com/stanislav-web/OpenDoor/actions/workflows/ci-windows-py315.yml) |
---
## 🚀 Ligações rápidas
- [Documentação](https://opendoor.readthedocs.io/)
- [Quickstart](https://opendoor.readthedocs.io/quickstart/)
- [Instalação e atualização](https://opendoor.readthedocs.io/Installation-and-update/)
- [Guia de utilização](https://opendoor.readthedocs.io/Usage/)
- [Exemplos práticos](https://opendoor.readthedocs.io/examples/basic-scans/)
- [Changelog](https://github.com/stanislav-web/opendoor/blob/master/CHANGELOG.md)
- [Pacote PyPI](https://pypi.org/project/opendoor/)
- [Fórmulas Homebrew](https://formulae.brew.sh/formula/opendoor)
- [Imagem Docker](https://github.com/users/stanislav-web/packages/container/package/opendoor)
- [Pacote AUR](https://aur.archlinux.org/packages/opendoor)
- [Pacote BlackArch](https://blackarch.org/webapp.html)
- [Issues](https://github.com/stanislav-web/OpenDoor/issues)
- [Contribuidores](https://github.com/stanislav-web/OpenDoor/graphs/contributors)
---
## ✨ Funcionalidades
- descoberta de diretórios;
- descoberta recursiva de diretórios;
- crawl limitado à mesma origem;
- seguimento de redirecionamentos;
- enumeração de subdomínios;
- scans multi-thread para pesquisas mais rápidas;
- modos de entrada de alvo único, ficheiro de alvos, stdin, IPv4 CIDR e intervalo IPv4;
- wordlists personalizadas, prefixos, shuffling para quebrar padrões de scan e filtros de extensão, suporte a wordlists remotas;
- cabeçalhos de pedido personalizados, encaminhamento de cookies e templates de pedidos HTTP em bruto;
- filtros de resposta por estado, tamanho, texto, regex e comprimento do corpo;
- sniffers de resposta para detetar listagens de diretórios, respostas vazias, exposições de ficheiros conhecidos, sondagens ativas de shadow-copy, collation, possíveis segredos expostos, endpoints expostos ao cliente, erros, stack traces de debug expostos e vulnerabilidades de open redirect verificadas;
- auto-calibração inteligente para casos de soft-404, wildcard, catch-all, diff semântico de respostas e wildcard DNS;
- deteção de fingerprint de tecnologias para CMS, plataformas de e-commerce, frameworks, stacks de runtime, infraestrutura e postura HSTS;
- verificações passivas de risco de privacidade em `--fingerprint`, incluindo possíveis superfícies de HSTS, ETag/cache e supercookie.
- deteção passiva de WAF e bypass em modo de scanning seguro;
- condição de paragem WAF guard para terminar scans de baixo valor quando as respostas classificadas iniciais estão esmagadoramente bloqueadas por WAF;
- sondagens controladas de bypass de cabeçalhos e caminhos para recursos bloqueados `401` e `403`;
- runtime de scan tolerante a falhas com retries, proteção contra sequências de falhas, tratamento de falhas de transporte, sessões retomáveis e controlos de pausa/retoma em runtime;
- regras de bucket de resultados fail-on para CI/CD;
- comparação diferencial de relatórios para relatórios JSON ou SQLite anteriores/atuais;
- relatórios em formatos terminal, texto, JSON, CSV, HTML, SARIF e SQLite;
- suporte de transporte proxy, OpenVPN, WireGuard, TLS legacy e certificado de cliente mTLS;
- rotação sequencial de transporte por alvo para fluxos de trabalho em lote;
- assistente de configuração para perfis de scan repetíveis;
- wordlists incorporadas (atualizado 2026-08)
---
## 🧭 Onde é que o OpenDoor faz sentido?
Foi concebido para alvos reais onde a velocidade por si só não é suficiente: WAFs, CDNs, páginas soft-404, rotas wildcard, recursos restritos, áreas autenticadas, redes instáveis, lotes multi-alvo e scans controlados por transporte.
Desde o seu primeiro lançamento em 2016 até aos dias de hoje, o OpenDoor mudou drasticamente, evoluindo de um brute forcer primitivo para uma nova framework de descoberta adaptativa. Tornou-se amigável para DevOps e QA.
O OpenDoor foca-se na **descoberta consciente do contexto** em vez da enumeração cega.
### O que torna o OpenDoor diferente
| Capacidade | Porque é importante |
|---|---|
| **Scanning fingerprint-first** | O OpenDoor consegue identificar prováveis plataformas CMS, frameworks, fornecedores de infraestrutura e sinais de WAF antes da descoberta mais profunda. Isto ajuda-o a fazer scan com contexto em vez de lançar cegamente uma wordlist genérica contra o alvo. |
| **Comportamento consciente de WAF** | O OpenDoor consegue detetar provável comportamento de WAF / anti-bot e mudar para um perfil de runtime mais seguro com `--waf-safe-mode`, reduzindo scans bloqueados ruidosos e tornando as respostas defensivas mais fáceis de compreender. |
| **Condição de paragem WAF guard** | O OpenDoor consegue parar um scan antecipadamente quando as respostas classificadas iniciais estão esmagadoramente bloqueadas por WAF. Isto evita gastar execuções longas em wordlists que apenas produzem páginas repetidas de bloqueio edge/WAF. |
| **Evidência de bypass controlada** | O OpenDoor pode opcionalmente sondar recursos bloqueados `401` e `403` com variantes controladas de injeção de cabeçalhos e manipulação de caminhos. Regista evidência exata como tipo de bypass, variante de cabeçalho ou caminho, valor da sondagem, código de estado original e código de estado resultante sem alterar os cabeçalhos globais do scan. |
| **Auto-calibração multi-sinal** | O OpenDoor não depende apenas do código de estado ou do tamanho da resposta. Compara múltiplos sinais de resposta como hashes de corpo, texto visível, frases semânticas de soft-404, estrutura de tokens DOM, títulos, redirecionamentos, cabeçalhos estáveis, contagem de palavras, contagem de linhas, densidade de texto, tokens dinâmicos normalizados e baselines de wildcard DNS para reduzir falsos positivos de soft-404 e wildcard. |
| **Crawl limitado à mesma origem** | `--crawl` pode enriquecer scans de diretórios com links de mesma origem de um salto encontrados em respostas HTML já analisadas. Utiliza o pipeline de scan existente, deduplicação global de pedidos, deduplicação de relatórios por bucket e limites de memória delimitados em vez de se tornar um spider ou renderizador de browser. |
| **Sistema de plugins sniffer heurístico** | O OpenDoor inclui uma camada plugável de análise de respostas para sniffers heurísticos como segredos, stack traces, listagens de diretórios, indicadores de malware, shadow copies, ficheiros suspeitos, open redirects e templates de soft-error repetidos. Isto permite que os scans revelem evidência significativa a partir de corpos de resposta em vez de reportar apenas códigos de estado e tamanhos. |
| **Fluxos de trabalho ao nível do transporte** | O OpenDoor suporta modos de transporte direto, proxy, OpenVPN e WireGuard. Também pode rodar perfis de transporte por alvo em scans em lote autorizados, o que não é o mesmo que iniciar manualmente uma VPN antes de executar um scanner. |
| **Suporte a pool de proxies** | O OpenDoor pode usar pools de proxies através de `--proxy-list`, validar proxies disponíveis antes do scan, rodar pedidos pelo pool ativo. Isto ajuda scans autorizados longos a sobreviver a rotas não fiáveis sem codificar um único endpoint de proxy. |
| **Runtime de scan tolerante a falhas** | O OpenDoor foi concebido para manter os scans úteis em alvos instáveis e redes não fiáveis. Combina retries de pedidos, proteção contra falhas consecutivas, tratamento recuperável de erros de transporte, rotação de proxies, condições de paragem conscientes de WAF, sessões de checkpoint e controlos interativos de pausa/retoma para que scans longos possam falhar em segurança em vez de perder silenciosamente cobertura. |
| **Scans longos retomáveis** | O OpenDoor pode guardar checkpoints de scan e retomar mais tarde. Isto é importante quando os scans são interrompidos por crashes, redes instáveis, rotas bloqueadas, desconexões de terminal ou trabalhos longos multi-alvo. |
| **Pausa/retoma em runtime** | Prima `Ctrl+C` uma vez durante um scan para pausar os workers, depois escolha `C` para continuar ou `E` para abortar sem envolver ficheiros de sessão. |
| **Comparação diferencial de relatórios** | O OpenDoor pode comparar um relatório SQLite/JSON anterior e atual com `--diff old:new`, mostrando descobertas adicionadas, removidas e alteradas sem reescanear o alvo. Isto transforma relatórios de scan em verificações de regressão de exposição de release para release. |
| **Resultados prontos para CI/CD** | O OpenDoor pode devolver um código de saída de falha apenas quando buckets de resultados selecionados são encontrados, tornando-o utilizável como gate de release ou verificação de regressão de exposição sem scripts de pós-processamento personalizados. |
| **Engenharia auditável** | O OpenDoor é mantido com CI multiplataforma, verificações de cobertura, verificações de pacotes, builds de documentação e uma grande suite de unittest, tornando-o mais fácil de auditar, contribuir e do qual depender. |
## 🧬 Tecnologias reconhecidas
O OpenDoor inclui um motor de fingerprint heurístico para detetar prováveis stacks de aplicações, plataformas CMS, frameworks, site builders, ferramentas de sites estáticos, fornecedores de infraestrutura, prontidão HSTS / preload e sistemas WAF / anti-bot.
| Categoria | Exemplos |
|----------------------------|---|
| CMS | WordPress, Drupal, Joomla, TYPO3, GravCMS, Open Journal Systems, InstantCMS, DiafanCMS, CMS.S3 / Megagroup, Discuz!, NetCat |
| E-commerce | Magento, WooCommerce, Shopify, PrestaShop, OpenCart, Shopware, Webasyst / Shop-Script |
| Frameworks / plataformas de aplicações | Laravel, Symfony, Django, Flask, FastAPI, Express, NestJS, Next.js, Nuxt, Rails, Spring |
| Stack de runtime / linguagem | PHP, Node.js, JavaScript, Python, Ruby, .NET, Java/JVM, Elixir, alvos de sites estáticos |
| Site builders | Wix, Webflow, Squarespace, Tilda, Duda, Hostinger Website Builder |
| Geradores estáticos / de docs | MkDocs, Docusaurus, Hugo, Jekyll, VitePress |
| Infraestrutura / alojamento | Cloudflare, AWS, Vercel, Netlify, GitHub Pages, GitLab Pages, Heroku, Azure, Google Cloud, Fastly, Akamai, Hostinger, DDoS-Guard, Tencent Cloud |
| Infraestrutura / servidores | Nginx, Apache HTTP Server, Microsoft IIS, Caddy, LiteSpeed, lighttpd, Tornado, Gunicorn, Uvicorn, Hypercorn, Waitress, Apache Tomcat, Eclipse Jetty, Envoy, Traefik |
| WAF / anti-bot | Cloudflare, AWS WAF, Azure Front Door, Akamai, Imperva, Sucuri, ModSecurity, DataDome, Kasada, BunkerWeb, F5 BIG-IP ASM |
| Cabeçalhos de segurança | Presença de HSTS, max-age, includeSubDomains, diretiva preload, prontidão de preload local |
Lista completa de tecnologias suportadas:
[Tecnologias de fingerprinting](https://opendoor.readthedocs.io/detection/fingerprinting)
Executar deteção de fingerprint:
```bash
opendoor --host https://example.com --fingerprint
```
Depois que a passagem de fingerprint é concluída, o OpenDoor imprime um resumo compacto de pré-varredura antes que a enumeração de dicionário comece:
```text
Fingerprint result: cms/WordPress (95%)
Web stack: WordPress | PHP | Cloudflare
Security posture: HSTS preload-ready
```
Leia mais:
- [Guia de fingerprinting](https://opendoor.readthedocs.io/detection/fingerprinting/)
- [Guia de detecção de WAF](https://opendoor.readthedocs.io/detection/waf-detection/)
## 📦 Instalação
### pipx
Recomendado para a maioria dos usuários de CLI:
```bash
pipx install opendoor
```
### pip
```bash
python3 -m pip install --upgrade opendoor
```
### Windows / Chocolatey
O OpenDoor está disponível no Chocolatey Community Package Repository:
```powershell
choco install opendoor -y
```
Os pacotes Chocolatey podem ficar atrás do lançamento mais recente do GitHub/PyPI enquanto a moderação da comunidade é concluída.
### Arch Linux / AUR
O OpenDoor está disponível no Arch User Repository:
```bash
yay -S opendoor
```
### Homebrew
O OpenDoor também está disponível no gerenciador de pacotes Brew:
```bash
brew install opendoor
```
### Docker
O OpenDoor está disponível como uma imagem Docker oficial do projeto via GitHub Container Registry.
```bash
docker pull ghcr.io/stanislav-web/opendoor:latest
docker run --rm -it ghcr.io/stanislav-web/opendoor:latest --version
```
Execute um scan e grave os relatórios no host:
```bash
mkdir -p reports
docker run --rm \
-v "$PWD/reports:/work/reports" \
ghcr.io/stanislav-web/opendoor:latest \
--host https://example.com \
--reports json,html \
--reports-dir reports
```
### BlackArch Linux
O OpenDoor está disponível no BlackArch Linux:
```bash
sudo pacman -Syu
sudo pacman -S opendoor
```
### A partir do código-fonte
```bash
git clone https://github.com/stanislav-web/OpenDoor.git
cd OpenDoor
python3 -m pip install -r requirements.txt
python3 opendoor.py --help
```
Consulte o [guia de instalação](https://opendoor.readthedocs.io/Installation-and-update/) completo.
---
## 🚀 Uso rápido
### Verificação básica de diretório
```bash
opendoor --host https://example.com
```
### Rastrear links de mesma origem
```bash
opendoor --host https://example.com --crawl
```
`--crawl` é opt-in e só funciona com varreduras de diretórios. Ele usa `GET`, extrai atributos HTML conservadores de respostas já escaneadas, mantém apenas URLs da mesma origem, respeita extensões ignoradas, ignora formulários POST e origens externas, e reporta URLs descobertas através dos buckets de resultados normais.
### Varredura de subdomínios
```bash
opendoor --host example.com --scan subdomains
```
### Lista de alvos
```bash
opendoor --hostlist targets.txt
```
Arquivos de destino podem misturar URLs, domínios, endereços IPv4, blocos CIDR IPv4 e intervalos IPv4 inclusivos:
```text
https://example.com
app.example.com
192.168.1.10
192.168.1.0/24
192.168.1.10-192.168.1.50
```
### Entrada padrão
```bash
cat targets.txt | opendoor --stdin
```
O mesmo formato de destino misto é suportado através de STDIN.
### Varredura de baixo ruído
```bash
opendoor \
--host https://example.com \
--method GET \
--auto-calibrate \
--include-status 200-299,301,302,403 \
--exclude-status 404,429,500-599 \
--exclude-size-range 0-256 \
--sniff endpoint,secret,shadow,openredirect,malware,skipempty,collation,indexof,file,stacktrace \
--reports std,json,csv,sarif
```
### Sniffers de resposta
Sniffers de resposta classificam corpos de resposta interessantes durante a descoberta. Eles são úteis quando o código de status e o tamanho não são suficientes para entender o que foi encontrado.
```bash
opendoor \
--host https://example.com \
--method GET \
--sniff endpoint,secret,shadow,openredirect,malware,stacktrace,indexof,file,collation \
--reports std,json,csv,html,sqlite,sarif
```
Sniffers úteis incluem:
| Sniffer | Propósito |
|---------------------|-------------------------------------------------------------------------------------------------------------------------------------|
| `indexof` | Detectar páginas de listagem de diretórios. |
| `file` | Detectar padrões conhecidos de exposição de arquivos sensíveis. |
| `collation` | Detecta respostas repetidas ou semelhantes a redirecionamentos que podem gerar falsos positivos. |
| `skipempty` | Ignorar respostas vazias. |
| `skipsizes=46` | Ignorar respostas com tamanhos exatos conhecidos como ruidosos. |
| `skipsizes=46:1024` | Ignorar respostas dentro de um intervalo de tamanho ruidoso. |
| `stacktrace` | Detectar stack traces de depuração/execução expostos e detalhes internos de erros. |
| `secret` | Detectar possíveis chaves de API, tokens, chaves privadas e credenciais expostas com metadados de relatório redigidos. |
| `shadow` | Sondar ativamente hits confirmados `200 OK` do tipo arquivo em busca de variantes limitadas de backup/shadow, como `.bak`, `.old` e templates de caminho . |
| `openredirect` | Verificar ativamente parâmetros de consulta semelhantes a redirecionamentos com URLs marcadoras controladas e reportar apenas vulnerabilidades de open redirect confirmadas. |
| `endpoint` | Detectar passivamente endpoints WebSocket, Socket.IO, SSE/EventSource e AJAX expostos pelo cliente a partir de respostas já obtidas. |
| `malware` | Detectar possíveis conteúdos maliciosos, marcadores de webshell, scripts injetados ou payloads ofuscados. |
Sniffers dependentes de corpo forçam automaticamente `GET` internamente quando o método configurado é `HEAD`.
Leia mais: [Referência de Sniffers](https://opendoor.readthedocs.io/Sniffers/)
### Varredura autenticada a partir de requisição bruta
```bash
opendoor \
--raw-request request.txt \
--scheme https \
--method GET \
--auto-calibrate \
--reports json,html,sqlite,sarif
```
### Varredura segura para WAF
```bash
opendoor \
--host https://example.com \
--waf-safe-mode \
--timeout 60 \
--retries 5 \
--delay 0.5
```
### Varredura tolerante a falhas
Use um perfil de execução mais conservador para alvos instáveis, redes lentas, bloqueios temporários de WAF, instabilidade de proxy ou varreduras autorizadas de longa duração.
```bash
opendoor \
--host https://example.com \
--method GET \
--timeout 60 \
--retries 5 \
--retries-fail-streak 25 \
--auto-calibrate \
--waf-detect \
--waf-guard \
--session-save session.json \
--reports std,json,html
```
Este perfil torna os scans mais resilientes ao aumentar o timeout por requisição e a tolerância a retentativas, limitando os abortos a caminhos repetidamente esgotados, filtrando respostas soft-404 e catch-all com auto-calibração, interrompendo scans de baixo valor quando respostas bloqueadas por WAF dominam, e salvando o estado de checkpoint para retomar mais tarde.
Retome o scan mais tarde:
```bash
opendoor --session-load session.json
```
Durante uma varredura ativa, pressione `Ctrl+C` uma vez para pausar os workers, depois escolha `C` para continuar ou `E` para abortar.
### Sondagens de bypass de cabeçalho e caminho
Use isto apenas em sistemas que você está autorizado a testar. O recurso é opt-in e sonda recursos bloqueados com cabeçalhos temporários controlados e variantes de caminho seguras.
```bash
opendoor \
--host https://example.com \
--method GET \
--waf-detect \
--header-bypass \
--header-bypass-limit 32 \
--reports std,json,csv,sarif,sqlite
```
Quando --header-bypass está ativado, o OpenDoor primeiro tenta variantes configuradas de injeção de cabeçalho e depois variantes seguras de manipulação de caminho, como barra final, segmento de ponto, sufixo de ponto e vírgula, variação de maiúsculas/minúsculas e segmento codificado em URL.
Personalize status de acionamento, valores de IP confiáveis e cabeçalhos:
```bash
opendoor \
--host https://example.com \
--method GET \
--header-bypass \
--header-bypass-status 401,403 \
--header-bypass-ips 127.0.0.1,10.0.0.1 \
--header-bypass-headers X-Original-URL,X-Rewrite-URL,X-Forwarded-For,X-Real-IP \
--reports json,html,sqlite,sarif,csv
```
### Roteamento de proxy
Use um único proxy explícito:
```bash
opendoor --host https://example.com --proxy socks5://127.0.0.1:9050
```
Use o pool de proxies rotativos incluído:
```bash
opendoor --host https://example.com --proxy-pool
```
Use uma lista de proxy rotativa personalizada:
```bash
opendoor --host https://example.com --proxy-list proxies.txt
```
### Transporte OpenVPN
```bash
opendoor \
--host https://example.com \
--transport openvpn \
--transport-profile ./profile.ovpn
```
Se o OpenVPN estiver instalado fora do `PATH`, passe o backend explicitamente:
```bash
opendoor \
--host https://example.com \
--transport openvpn \
--transport-profile ./profile.ovpn \
--transport-bin /opt/homebrew/sbin/openvpn
```
No Windows, `--transport-bin` pode apontar para `C:\Program Files\OpenVPN\bin\openvpn.exe`. Se um cliente GUI ou agente VPN corporativo já controla o túnel, inicie essa VPN fora do OpenDoor e execute o OpenDoor em modo direto.
### Transporte WireGuard
```bash
opendoor \
--host https://example.com \
--transport wireguard \
--transport-profile ./profile.conf
```
Mais exemplos:
- [Varreduras básicas](https://opendoor.readthedocs.io/examples/basic-scans/)
- [Varreduras em lote](https://opendoor.readthedocs.io/examples/batch-scans/)
- [Varreduras autenticadas](https://opendoor.readthedocs.io/examples/authenticated-scans/)
- [Varreduras seguras para WAF](https://opendoor.readthedocs.io/examples/waf-safe-scans/)
- [Varreduras com bypass de cabeçalho](https://opendoor.readthedocs.io/examples/header-bypass-scans/)
- [Varreduras com transporte VPN](https://opendoor.readthedocs.io/examples/vpn-transport-scans/)
- [Exemplos de CI/CD](https://opendoor.readthedocs.io/examples/ci-cd/)
---
### Comparação de relatórios diferenciais
O OpenDoor pode comparar exatamente dois relatórios anteriores/atuais sem executar uma nova varredura. Use isto quando quiser ver o que apareceu, desapareceu ou mudou entre dois resultados de varredura autorizados.
Os pares de entrada suportados são apenas SQLite-para-SQLite e JSON-para-JSON. Formatos mistos, arquivos ausentes, relatórios inválidos e tipos de relatório não suportados falham com um erro de validação gracioso.
```bash
opendoor --diff reports/baseline/example.com.sqlite:reports/current/example.com.sqlite --reports std,json
opendoor --diff reports/baseline/example.com.json:reports/current/example.com.json --reports std,json --reports-dir ./diff
```
### Relatórios SARIF para CI/CD
O OpenDoor pode exportar descobertas como SARIF 2.1.0 para o GitHub Code Scanning e pipelines de segurança compatíveis com SARIF.
```bash
opendoor \
--host https://example.com \
--reports sarif,json \
--reports-dir ./reports
```
Exemplo de upload do GitHub Actions:
```yaml
- name: Upload OpenDoor SARIF
uses: github/codeql-action/upload-sarif@v3
with:
sarif_file: reports/example.com/example.com.sarif
category: opendoor
```
## 🎓 Dominando o OpenDoor
Série de artigos práticos para aprender o OpenDoor por meio de fluxos de trabalho de reconhecimento web reproduzíveis e autorizados.
- [Parte 1 — Reconhecimento Web com Consciência de Contexto Além da Força Bruta de Diretórios](https://medium.com/@stanisov/mastering-opendoor-context-aware-web-recon-beyond-directory-brute-force-part-1-cc13eda8cd3d)
- [Parte 2 — Reconhecimento de Baixo Ruído com Redirecionamentos, Sniffing de Endpoints e Crawl Limitado](https://medium.com/@stanisov/mastering-opendoor-low-noise-recon-with-redirects-endpoint-sniffing-and-bounded-crawl-part-2-411b92675d6d)
- [Página complementar da série](https://opendoor.readthedocs.io/guides/mastering-opendoor/)
## 📚 Documentação
A documentação completa está disponível no ReadTheDocs:
- [Início](https://opendoor.readthedocs.io/)
- [Início Rápido](https://opendoor.readthedocs.io/quickstart/)
- [Instalação e atualização](https://opendoor.readthedocs.io/Installation-and-update/)
- [Guia de uso](https://opendoor.readthedocs.io/Usage/)
- [Entrada de alvos](https://opendoor.readthedocs.io/concepts/target-input/)
- [Relatórios](https://opendoor.readthedocs.io/concepts/reports/)
- [Fingerprinting](https://opendoor.readthedocs.io/detection/fingerprinting/)
- [Detecção de WAF e modo seguro](https://opendoor.readthedocs.io/detection/waf-detection/)
- [Proteção de WAF](https://opendoor.readthedocs.io/detection/waf-guard/)
- [Bypass de Injeção de Cabeçalho](https://opendoor.readthedocs.io/detection/header-bypass/)
- [Auto-calibração](https://opendoor.readthedocs.io/detection/auto-calibration/)
- [Transportes de rede](https://opendoor.readthedocs.io/transports/overview/)
- [Compatibilidade TLS e mTLS](https://opendoor.readthedocs.io/transports/tls/)
- [Transporte OpenVPN](https://opendoor.readthedocs.io/transports/openvpn/)
- [Transporte WireGuard](https://opendoor.readthedocs.io/transports/wireguard/)
- [Exemplos práticos](https://opendoor.readthedocs.io/examples/basic-scans/)
- [Testes](https://opendoor.readthedocs.io/Testing/)
- [Contribuição](https://opendoor.readthedocs.io/Contribution/)
---
## 🧪 Desenvolvimento
Instale as dependências de desenvolvimento:
```bash
python3 -m venv .venv
source .venv/bin/activate
python -m pip install --upgrade pip setuptools wheel
python -m pip install -r requirements-dev.txt
python -m pip install -e .
```
Execute os testes:
```bash
python -m unittest
```
Executar cobertura:
```bash
coverage run -m unittest discover -s tests -p "test_*.py"
coverage report -m
```
Documentação de compilação:
```bash
python3 -m venv .docs-venv
source .docs-venv/bin/activate
python -m pip install -r docs/requirements.txt
python -m mkdocs build --strict
```
Criar artefatos do pacote:
```bash
python -m build
```
Consulte o [guia de testes](https://opendoor.readthedocs.io/Testing/) completo e o [guia de contribuição](https://opendoor.readthedocs.io/Contribution/).
---
## 🔐 Segurança e higiene de segredos
Não faça commit de segredos reais ou perfis de transporte privados.
Nunca publique:
- perfis OpenVPN reais;
- chaves privadas WireGuard;
- certificados de cliente mTLS e chaves privadas;
- arquivos auth-user-pass;
- cookies;
- tokens bearer;
- listas de alvos de clientes;
- relatórios de varredura privados;
- artefatos de CI sensíveis.
Use apenas exemplos de placeholder.
---
## ⚖️ Uso responsável
OpenDoor é uma ferramenta de teste de segurança.
Use-a apenas contra sistemas que você possui ou tem permissão explícita para testar.
Recursos como detecção de WAF, varredura segura para WAF, reprodução de requisições brutas, perfis de transporte e sondagens de Header Injection Bypass destinam-se a testes de segurança autorizados, validação defensiva e verificações de regressão de exposição.
O projeto não concede permissão para escanear sistemas de terceiros, organizações, serviços comerciais ou infraestrutura pública sem autorização.
---
## 🧾 Changelog
Consulte [CHANGELOG.md](https://github.com/stanislav-web/opendoor/blob/master/CHANGELOG.md) e [GitHub Releases](https://github.com/stanislav-web/OpenDoor/releases).
---
## 🤝 Contribuindo
Pull requests são bem-vindos.
Antes de contribuir, leia o [guia de contribuição](https://opendoor.readthedocs.io/Contribution/) e execute os testes relevantes.
OpenDoor melhora através de contribuições de código, atualizações de documentação, testes, relatórios de problemas, feedback de segurança, ideias de recursos e validação da comunidade.
Obrigado a todos que ajudaram a melhorar o projeto.
---
[Read more](https://github.com/stanislav-web/opendoor)