OpenDoor — Plataforma OWASP de Reconhecimento Web e Descoberta de Diretórios

OpenDoor é uma plataforma de reconhecimento (Recon) CLI de código aberto para reconhecimento web autorizado, descoberta de diretórios, enumeração de subdomínios, fingerprints, detecção de WAF, sondagem de bypass, filtragem de respostas, relatórios, verificações de open redirect, crawl limitado e fluxos de trabalho de varredura baseados em transporte.

Ela ajuda pesquisadores de segurança, testadores de penetração, caçadores de bug bounty, engenheiros de DevSecOps e desenvolvedores a identificar caminhos expostos, painéis de login, listagens de diretório, recursos restritos, arquivos de backup, web shells, subdomínios e outros ativos web potencialmente sensíveis.

Use o OpenDoor apenas em sistemas que você possui ou para os quais tenha permissão explícita de teste.

✅ Status do projeto

Chocolatey Version

🧪 Matriz de CI

🚀 Links rápidos

✨ Recursos

descoberta de diretórios;
descoberta recursiva de diretórios;
crawl limitado de mesma origem;
seguimento de redirecionamentos;
enumeração de subdomínios;
varreduras com múltiplas threads para consultas mais rápidas;
modos de entrada para alvo único, arquivo de alvos, stdin, IPv4 CIDR e faixa IPv4;
suporte a wordlists personalizadas, prefixos, embaralhamento para quebrar padrões de varredura e filtros de extensão, e wordlists remotas;
cabeçalhos de requisição personalizados, encaminhamento de cookies e modelos brutos de requisição HTTP;
filtros de resposta por status, tamanho, texto, regex e comprimento do corpo;
sniffers de resposta para detectar listagens de diretório, respostas vazias, exposições de arquivos conhecidos, sondas ativas de shadow copy, collation, possíveis segredos expostos, endpoints expostos ao cliente, erros, stack traces de depuração expostas e vulnerabilidades verificadas de open redirect;
autocalibração inteligente para casos de soft-404, wildcard, catch-all, diff semântico de resposta e DNS wildcard;
detecção de fingerprints de tecnologia 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.
detecção passiva de WAF e bypass em modo de varredura segura;
condição de parada WAF guard para encerrar varreduras de baixo valor quando as respostas classificadas iniciais estiverem majoritariamente bloqueadas por WAF;
sondas controladas de bypass por cabeçalho e caminho para recursos bloqueados com 401 e 403;
runtime de varredura tolerante a falhas com novas tentativas, proteção contra sequências de falhas, tratamento de falhas de transporte, sessões retomáveis e controles de pausa/retomada em tempo de execução;
regras de falha de CI/CD por bucket de resultados;
comparação diferencial de relatórios anteriores/atuais em JSON ou SQLite;
relatórios nos formatos terminal, texto, JSON, CSV, HTML, SARIF e SQLite;
suporte a proxy, OpenVPN, WireGuard, TLS legado e mTLS com certificado de cliente;

🧭 Onde o OpenDoor faz sentido?

Ele foi projetado para alvos reais onde somente a velocidade não é suficiente: WAFs, CDNs, páginas soft-404, rotas wildcard, recursos restritos, áreas autenticadas, redes instáveis, lotes de múltiplos alvos e varreduras controladas por transporte. Desde seu primeiro lançamento em 2016 até os dias atuais, o OpenDoor mudou drasticamente, evoluindo de um brute forcer primitivo para um novo framework adaptativo de descoberta. Tornou-se amigável para DevOps e QA. O OpenDoor foca em descoberta ciente do contexto em vez de enumeração cega.

O que torna o OpenDoor diferente

🧬 Tecnologias reconhecidas

O OpenDoor inclui um mecanismo heurístico de fingerprints para detectar prováveis stacks de aplicação, plataformas CMS, frameworks, construtores de sites, ferramentas de sites estáticos, provedores de infraestrutura, prontidão HSTS / preload e sistemas WAF / anti-bot.

Lista completa de tecnologias suportadas: Tecnologias de fingerprinting

Execute a detecção de fingerprint:```bash opendoor --host https://example.com --fingerprint

Após a passada de fingerprint terminar, o OpenDoor imprime um resumo compacto de pré-verificação antes de a enumeração de dicionário começar:```text
Fingerprint result: cms/WordPress (95%)
Web stack: WordPress | PHP | Cloudflare
Security posture: HSTS preload-ready

📦 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

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

OpenDoor está disponível no Arch User Repository:```bash
yay -S opendoor

Homebrew

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 uma varredura e escreva 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

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

### Scan básico 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ório. Ele usa `GET`, extrai atributos HTML conservadores de respostas já varridas, mantém apenas URLs de mesma origem, respeita extensões ignoradas, pula formulários POST e origens externas, e reporta URLs descobertas através dos buckets normais de resultados.

### Varredura de subdomínio```bash
opendoor --host example.com --scan subdomains

Lista de alvos```bash

opendoor --hostlist targets.txt

Os 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 alvo misto é suportado via 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             | Finalidade                                                                                                                             |
|---------------------|-------------------------------------------------------------------------------------------------------------------------------------|
| `indexof`           | Detecta páginas de listagem de diretórios.                                                                                          |
| `file`              | Detecta padrões conhecidos de exposição de arquivos sensíveis.                                                                      |
| `collation`         | Detecta respostas repetidas ou de fallback semelhantes a redirecionamentos que podem criar falsos positivos.                        |
| `skipempty`         | Ignora respostas vazias.                                                                                                            |
| `skipsizes=46`      | Ignora respostas com tamanhos exatos conhecidos de ruído.                                                                           |
| `skipsizes=46:1024` | Ignora respostas dentro de uma faixa de tamanhos ruidosos.                                                                          |
| `stacktrace`        | Detecta stack traces de debug/execução expostos e detalhes internos de erro.                                                        |
| `secret`            | Detecta possíveis chaves de API, tokens, chaves privadas e credenciais expostas com metadados de relatório redigidos.               |
| `shadow`            | Sonda ativamente hits confirmados do tipo arquivo com `200 OK` para variantes limitadas de backup/shadow, como `.bak`, `.old`, e modelos de caminho .` |
| `openredirect`      | Verifica ativamente parâmetros de consulta semelhantes a redirecionamentos com URLs de marcador controladas e relata apenas vulnerabilidades de open redirect confirmadas. |
| `endpoint`          | Detecta passivamente endpoints WebSocket, Socket.IO, SSE/EventSource e AJAX expostos ao cliente a partir de respostas já obtidas.    |
| `malware`           | Detecta possíveis conteúdos maliciosos, marcadores de webshell, scripts injetados ou payloads ofuscados.                            |

Sniffers dependentes do 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

Scan seguro contra WAF```bash

opendoor
--host https://example.com
--waf-safe-mode
--timeout 60
--retries 5
--delay 0.5

### Scan tolerante a falhas

Use um perfil de runtime 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 tempo limite por requisição e a tolerância a tentativas, limitando abortos a caminhos exaustos repetidos, filtrando respostas soft-404 e catch-all com autocalibração, interrompendo scans de baixo valor quando respostas bloqueadas por WAF dominam, e salvando o estado do checkpoint para retomar depois.

Retomar o scan depois:```bash opendoor --session-load session.json

Durante uma verificação ativa, pressione `Ctrl+C` uma vez para pausar os workers e, em seguida, escolha `C` para continuar ou `E` para abortar.

### Sondas de bypass de cabeçalho e caminho

Use isso 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 seguras de caminho.```bash
opendoor \
  --host https://example.com \
  --method GET \
  --waf-detect \
  --header-bypass \
  --header-bypass-limit 32 \
  --reports std,json,csv,sarif,sqlite

Quando o --header-bypass está habilitado, o OpenDoor primeiro tenta as variantes configuradas de injeção de cabeçalho e, em seguida, variantes seguras de manipulação de caminho, como barra final, segmento de ponto, sufixo de ponto e vírgula, variação de maiúsculas e minúsculas e segmento codificado por URL. Personalize os status de gatilho, os valores de IP confiáveis e os 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 proxies rotativos 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á possui 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 de transporte via 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 isso quando quiser ver o que apareceu, desapareceu ou mudou entre dois resultados de varredura autorizados.

Os pares de entrada suportados são somente SQLite-para-SQLite e JSON-para-JSON. Formatos mistos, arquivos ausentes, relatórios inválidos e tipos de relatório não suportados falham de forma controlada com um erro de validação.```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 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 reproduzíveis e autorizados de reconhecimento web.

OpenDoor

📚 Documentação

A documentação completa está disponível no ReadTheDocs:

🧪 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 .

Executar testes:```bash
python -m unittest

Cobertura de execução:```bash coverage run -m unittest discover -s tests -p "test_*.py" coverage report -m

Documentação de build:```bash
python3 -m venv .docs-venv
source .docs-venv/bin/activate
python -m pip install -r docs/requirements.txt
python -m mkdocs build --strict

Construir artefatos de pacote:```bash python -m build

Consulte o [guia de testes](https://opendoor.readthedocs.io/Testing/) 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 sensíveis de CI.

Use apenas exemplos de espaço reservado.

---

## ⚖️ Uso responsável

OpenDoor é uma ferramenta de teste de segurança.

Use-a apenas contra sistemas que você possui ou para os quais tenha permissão explícita para testar.

Recursos como detecção de WAF, varredura segura para WAF, repetição de requisições brutas, perfis de transporte e sondas de bypass de injeção de cabeçalho 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/HEAD/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 por meio 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.

[![Contributors](https://contrib.rocks/image?repo=stanislav-web/OpenDoor)](https://github.com/stanislav-web/OpenDoor/graphs/contributors)

---

## 📄 Licença

OpenDoor é distribuído sob a GNU General Public License v3.0 apenas.

Consulte [LICENSE](https://github.com/stanislav-web/opendoor/blob/HEAD/LICENSE).

---

## Suporte

Se OpenDoor ajuda no seu trabalho de segurança autorizado, você pode apoiar a manutenção contínua por meio do Giveth.

[Apoie OpenDoor no Giveth](https://giveth.io/project/opendoor)

---
[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/stanislav-web/OpenDoor) [![License: GPL v3](https://img.shields.io/badge/license-GPL%20v3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)

Varredura com prioridade para fingerprint	O OpenDoor pode identificar prováveis plataformas CMS, frameworks, provedores de infraestrutura e sinais de WAF antes de uma descoberta mais profunda. Isso ajuda você a escanear com contexto em vez de lançar cegamente uma wordlist genérica contra o alvo.
Comportamento ciente de WAF	O OpenDoor pode detectar provável comportamento de WAF / anti-bot e alternar para um perfil de runtime mais seguro com `--waf-safe-mode`, reduzindo varreduras bloqueadas ruidosas e facilitando a compreensão de respostas defensivas.
Condição de parada do WAF guard	O OpenDoor pode interromper uma varredura antecipadamente quando as respostas classificadas iniciais estiverem majoritariamente bloqueadas por WAF. Isso evita gastar longas execuções em wordlists que só produzem páginas repetidas de bloqueio de edge/WAF.
Evidência controlada de bypass	O OpenDoor pode opcionalmente sondar recursos bloqueados `401` e `403` com variantes controladas de injeção de cabeçalho e manipulação de caminho. Ele registra evidências exatas, como tipo de bypass, variante de cabeçalho ou caminho, valor da sonda, código de status original e código de status resultante, sem modificar os cabeçalhos globais da varredura.
Autocalibração multi-sinal	O OpenDoor não depende apenas do código de status ou do tamanho da resposta. Ele 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 linhas de base de DNS wildcard para reduzir falsos positivos de soft-404 e wildcard.
Crawl limitado de mesma origem	`--crawl` pode enriquecer varreduras de diretórios com links de mesma origem de um salto encontrados em respostas HTML já varridas. Ele usa o pipeline de varredura existente, deduplicação global de requisições, deduplicação de relatórios por bucket e limites de memória, em vez de se tornar um spider ou renderizador de navegador.
Sistema de plugins de sniffers heurísticos	O OpenDoor inclui uma camada de análise de resposta plugável para sniffers heurísticos como segredos, stack traces, listagens de diretório, indicadores de malware, shadow copies, arquivos suspeitos, open redirects e modelos repetidos de soft-error. Isso permite que as varreduras evidenciem informações relevantes dos corpos de resposta em vez de relatar apenas códigos de status e tamanhos.
Fluxos de trabalho em nível de transporte	O OpenDoor suporta modos de transporte direto, proxy, OpenVPN e WireGuard. Ele também pode alternar perfis de transporte por alvo em varreduras em lote autorizadas, 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 por meio de `--proxy-list`, validar proxies disponíveis antes da varredura e alternar requisições pelo pool ativo. Isso ajuda varreduras longas autorizadas a sobreviver a rotas não confiáveis sem fixar um único endpoint de proxy no código.
Runtime de varredura tolerante a falhas	O OpenDoor foi projetado para manter varreduras úteis em alvos instáveis e redes não confiáveis. Ele combina novas tentativas de requisição, proteção contra falhas consecutivas, tratamento recuperável de erros de transporte, rotação de proxy, condições de parada cientes de WAF, sessões com checkpoint e controles interativos de pausa/retomada para que varreduras longas possam falhar com segurança em vez de perder cobertura silenciosamente.
Varreduras longas retomáveis	O OpenDoor pode salvar checkpoints de varredura e retomar depois. Isso é importante quando as varreduras são interrompidas por falhas, redes instáveis, rotas bloqueadas, desconexões de terminal ou trabalhos longos com múltiplos alvos.
Pausa/retomada em runtime	Pressione `Ctrl+C` uma vez durante uma varredura para pausar os workers; em seguida, escolha `C` para continuar ou `E` para abortar, sem envolver arquivos 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 achados adicionados, removidos e alterados sem revarrer o alvo. Isso transforma relatórios de varredura em verificações de regressão de exposição entre versões.
Resultados prontos para CI/CD	O OpenDoor pode retornar um código de saída de falha somente 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 personalizados de pós-processamento.
Engenharia auditável	O OpenDoor é mantido com CI multiplataforma, verificações de cobertura, verificações de pacotes, builds de documentação e uma grande suíte de testes unitários, facilitando auditar, contribuir e depender do projeto.

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 aplicativos	Laravel, Symfony, Django, Flask, FastAPI, Express, NestJS, Next.js, Nuxt, Rails, Spring
Runtime / stack de linguagem	PHP, Node.js, JavaScript, Python, Ruby, .NET, Java/JVM, Elixir, alvos de sites estáticos
Construtores de sites	Wix, Webflow, Squarespace, Tilda, Duda, Hostinger Website Builder
Geradores de sites estáticos / documentação	MkDocs, Docusaurus, Hugo, Jekyll, VitePress
Infraestrutura / hospedagem	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 de preload, prontidão de preload local