stanislav-web/opendoorPlataforma de reconocimiento web y descubrimiento de directorios de OWASP
# OpenDoor — Plataforma de reconocimiento web y descubrimiento de directorios OWASP
**OpenDoor** es una plataforma CLI de reconocimiento de código abierto para reconocimiento web autorizado, descubrimiento de directorios, enumeración de subdominios, huellas digitales, detección de WAF, sondeo de bypass, filtrado de respuestas, informes, comprobaciones de redirecciones abiertas, rastreo acotado y flujos de trabajo de escaneo basados en transporte.
Ayuda a investigadores de seguridad, testers de penetración, cazadores de bug bounty, ingenieros DevSecOps y desarrolladores a identificar rutas expuestas, paneles de inicio de sesión, listados de directorios, recursos restringidos, archivos de respaldo, web shells, subdominios y otros activos web potencialmente sensibles.
> Utiliza OpenDoor solo en sistemas que poseas o para los que tengas permiso explícito de prueba.
---
## ✅ Estado del proyecto
[](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) |
---
## 🚀 Enlaces rápidos
- [Documentación](https://opendoor.readthedocs.io/)
- [Inicio rápido](https://opendoor.readthedocs.io/quickstart/)
- [Instalación y actualización](https://opendoor.readthedocs.io/Installation-and-update/)
- [Guía de uso](https://opendoor.readthedocs.io/Usage/)
- [Ejemplos prácticos](https://opendoor.readthedocs.io/examples/basic-scans/)
- [Registro de cambios](https://github.com/stanislav-web/opendoor/blob/master/CHANGELOG.md)
- [Paquete PyPI](https://pypi.org/project/opendoor/)
- [Fórmulas de Homebrew](https://formulae.brew.sh/formula/opendoor)
- [Imagen Docker](https://github.com/users/stanislav-web/packages/container/package/opendoor)
- [Paquete AUR](https://aur.archlinux.org/packages/opendoor)
- [Paquete BlackArch](https://blackarch.org/webapp.html)
- [Incidencias](https://github.com/stanislav-web/OpenDoor/issues)
- [Colaboradores](https://github.com/stanislav-web/OpenDoor/graphs/contributors)
---
## ✨ Características
- descubrimiento de directorios;
- descubrimiento recursivo de directorios;
- rastreo acotado del mismo origen;
- seguimiento de redirecciones;
- enumeración de subdominios;
- escaneos multihilo para búsquedas más rápidas;
- modos de entrada de objetivo único, archivo de objetivos, stdin, CIDR IPv4 y rango IPv4;
- listas de palabras personalizadas, prefijos, aleatorización para romper patrones de escaneo y filtros de extensiones, soporte de listas de palabras remotas;
- cabeceras de solicitud personalizadas, reenvío de cookies y plantillas de solicitud HTTP sin procesar;
- filtros de respuesta por estado, tamaño, texto, regex y longitud del cuerpo;
- sniffers de respuesta para detectar listados de directorios, respuestas vacías, exposiciones de archivos conocidas, sondeos activos de shadow-copy, colación, posibles secretos expuestos, endpoints expuestos al cliente, errores, trazas de pila de depuración expuestas y vulnerabilidades de redirección abierta verificadas;
- auto-calibración inteligente para casos de soft-404, wildcard, catch-all, diff semántico de respuestas y wildcard DNS;
- detección de huellas de tecnologías para CMS, plataformas de comercio electrónico, frameworks, stacks de ejecución, infraestructura y postura HSTS;
- comprobaciones pasivas de riesgo de privacidad en `--fingerprint`, incluyendo posibles superficies de HSTS, ETag/caché y supercookie.
- detección pasiva de WAF y bypass en modo de escaneo seguro;
- condición de parada de protección WAF para finalizar escaneos de bajo valor cuando las respuestas clasificadas iniciales están abrumadoramente bloqueadas por WAF;
- sondeos controlados de bypass de cabeceras y rutas para recursos bloqueados `401` y `403`;
- tiempo de ejecución de escaneo tolerante a fallos con reintentos, protección contra rachas de fallos, manejo de fallos de transporte, sesiones reanudables y controles de pausa/reanudación en tiempo de ejecución;
- reglas de fallo en CI/CD por bucket de resultados;
- comparación diferencial de informes para informes JSON o SQLite anteriores/actuales;
- informes en formatos terminal, texto, JSON, CSV, HTML, SARIF y SQLite;
- soporte de transporte proxy, OpenVPN, WireGuard, TLS heredado y certificado de cliente mTLS;
- rotación secuencial de transporte por objetivo para flujos de trabajo por lotes;
- asistente de configuración para perfiles de escaneo repetibles;
- listas de palabras integradas (act. 2026-08)
---
## 🧭 ¿Dónde tiene sentido OpenDoor?
Está diseñado para objetivos reales donde la velocidad por sí sola no es suficiente: WAFs, CDNs, páginas soft-404, rutas wildcard, recursos restringidos, áreas autenticadas, redes inestables, lotes multiobjetivo y escaneos controlados por transporte.
Desde su primer lanzamiento en 2016 hasta la actualidad, OpenDoor ha cambiado drásticamente, creciendo de un primitivo brute forcer a un nuevo framework de descubrimiento adaptativo. Se ha vuelto amigable para DevOps y QA.
OpenDoor se centra en el **descubrimiento consciente del contexto** en lugar de la enumeración ciega.
### Qué hace diferente a OpenDoor
| Capacidad | Por qué importa |
|---|---|
| **Escaneo con huella primero** | OpenDoor puede identificar probables plataformas CMS, frameworks, proveedores de infraestructura y señales de WAF antes del descubrimiento más profundo. Esto te ayuda a escanear con contexto en lugar de lanzar ciegamente una lista de palabras genérica contra el objetivo. |
| **Comportamiento consciente del WAF** | OpenDoor puede detectar probable comportamiento de WAF / anti-bot y cambiar a un perfil de ejecución más seguro con `--waf-safe-mode`, reduciendo escaneos bloqueados ruidosos y facilitando la comprensión de las respuestas defensivas. |
| **Condición de parada de protección WAF** | OpenDoor puede detener un escaneo anticipadamente cuando las respuestas clasificadas iniciales están abrumadoramente bloqueadas por WAF. Esto evita dedicar ejecuciones largas a listas de palabras que solo producen páginas repetidas de bloqueo de edge/WAF. |
| **Evidencia de bypass controlada** | OpenDoor puede sondear opcionalmente recursos bloqueados `401` y `403` con variantes controladas de inyección de cabeceras y manipulación de rutas. Registra evidencia exacta como tipo de bypass, variante de cabecera o ruta, valor de sondeo, código de estado original y código de estado resultante sin mutar las cabeceras globales del escaneo. |
| **Auto-calibración multiseñal** | OpenDoor no depende solo del código de estado o el tamaño de la respuesta. Compara múltiples señales de respuesta como hashes del cuerpo, texto visible, frases semánticas de soft-404, estructura de tokens del DOM, títulos, redirecciones, cabeceras estables, recuento de palabras, recuento de líneas, densidad de texto, tokens dinámicos normalizados y líneas base de wildcard DNS para reducir falsos positivos de soft-404 y wildcard. |
| **Rastreo acotado del mismo origen** | `--crawl` puede enriquecer los escaneos de directorios con enlaces del mismo origen a un salto encontrados en respuestas HTML ya escaneadas. Utiliza el pipeline de escaneo existente, deduplicación global de solicitudes, deduplicación de informes por bucket y límites de memoria acotados en lugar de convertirse en un spider o renderizador de navegador. |
| **Sistema de plugins sniffers heurísticos** | OpenDoor incluye una capa conectable de análisis de respuestas para sniffers heurísticos como secretos, trazas de pila, listados de directorios, indicadores de malware, shadow copies, archivos sospechosos, redirecciones abiertas y plantillas de soft-error repetidas. Esto permite que los escaneos revelen evidencia significativa de los cuerpos de respuesta en lugar de informar solo códigos de estado y tamaños. |
| **Flujos de trabajo a nivel de transporte** | OpenDoor soporta modos de transporte directo, proxy, OpenVPN y WireGuard. También puede rotar perfiles de transporte por objetivo en escaneos por lotes autorizados, lo cual no es lo mismo que iniciar manualmente una VPN antes de ejecutar un escáner. |
| **Soporte de pool de proxies** | OpenDoor puede usar pools de proxies mediante `--proxy-list`, validar proxies disponibles antes de escanear y rotar solicitudes a través del pool activo. Esto ayuda a que escaneos autorizados largos sobrevivan a rutas poco fiables sin codificar un único endpoint de proxy. |
| **Tiempo de ejecución de escaneo tolerante a fallos** | OpenDoor está diseñado para mantener los escaneos útiles en objetivos inestables y redes poco fiables. Combina reintentos de solicitudes, protección contra fallos consecutivos, manejo recuperable de errores de transporte, rotación de proxies, condiciones de parada conscientes del WAF, sesiones de checkpoint y controles interactivos de pausa/reanudación para que los escaneos largos puedan fallar de forma segura en lugar de perder cobertura silenciosamente. |
| **Escaneos largos reanudables** | OpenDoor puede guardar checkpoints de escaneo y reanudarlos después. Esto importa cuando los escaneos se interrumpen por fallos, redes inestables, rutas bloqueadas, desconexiones de terminal o trabajos largos multiobjetivo. |
| **Pausa/reanudación en tiempo de ejecución** | Pulsa `Ctrl+C` una vez durante un escaneo para pausar los workers, luego elige `C` para continuar o `E` para abortar sin involucrar archivos de sesión. |
| **Comparación diferencial de informes** | OpenDoor puede comparar un informe SQLite/JSON anterior y actual con `--diff old:new`, mostrando hallazgos añadidos, eliminados y modificados sin reescanear el objetivo. Esto convierte los informes de escaneo en comprobaciones de regresión de exposición entre versiones. |
| **Resultados listos para CI/CD** | OpenDoor puede devolver un código de salida de fallo solo cuando se encuentran buckets de resultados seleccionados, lo que lo hace utilizable como puerta de release o comprobación de regresión de exposición sin scripts de postprocesamiento personalizados. |
| **Ingeniería auditable** | OpenDoor se mantiene con CI multiplataforma, comprobaciones de cobertura, comprobaciones de paquetes, compilaciones de documentación y una gran suite de unittest, lo que facilita auditarlo, contribuir a él y depender de él. |
## 🧬 Tecnologías reconocidas
OpenDoor incluye un motor heurístico de huellas para detectar probables stacks de aplicaciones, plataformas CMS, frameworks, constructores de sitios, herramientas de sitios estáticos, proveedores de infraestructura, preparación HSTS / preload y sistemas WAF / anti-bot.
| Categoría | Ejemplos |
|----------------------------|---|
| CMS | WordPress, Drupal, Joomla, TYPO3, GravCMS, Open Journal Systems, InstantCMS, DiafanCMS, CMS.S3 / Megagroup, Discuz!, NetCat |
| Comercio electrónico | Magento, WooCommerce, Shopify, PrestaShop, OpenCart, Shopware, Webasyst / Shop-Script |
| Frameworks / plataformas de aplicaciones | Laravel, Symfony, Django, Flask, FastAPI, Express, NestJS, Next.js, Nuxt, Rails, Spring |
| Stack de ejecución / lenguaje | PHP, Node.js, JavaScript, Python, Ruby, .NET, Java/JVM, Elixir, objetivos de sitios estáticos |
| Constructores de sitios | Wix, Webflow, Squarespace, Tilda, Duda, Hostinger Website Builder |
| Generadores estáticos / de documentación | MkDocs, Docusaurus, Hugo, Jekyll, VitePress |
| Infraestructura / hosting | Cloudflare, AWS, Vercel, Netlify, GitHub Pages, GitLab Pages, Heroku, Azure, Google Cloud, Fastly, Akamai, Hostinger, DDoS-Guard, Tencent Cloud |
| Infraestructura / 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 |
| Cabeceras de seguridad | Presencia de HSTS, max-age, includeSubDomains, directiva preload, preparación de preload local |
Lista completa de tecnologías soportadas:
[Tecnologías de fingerprinting](https://opendoor.readthedocs.io/detection/fingerprinting)
Ejecutar detección de huellas:
```bash
opendoor --host https://example.com --fingerprint
```
Después de que finaliza la fase de fingerprinting, OpenDoor imprime un resumen compacto previo al escaneo antes de que comience la enumeración del diccionario:
```text
Fingerprint result: cms/WordPress (95%)
Web stack: WordPress | PHP | Cloudflare
Security posture: HSTS preload-ready
```
Leer más:
- [Guía de fingerprinting](https://opendoor.readthedocs.io/detection/fingerprinting/)
- [Guía de detección de WAF](https://opendoor.readthedocs.io/detection/waf-detection/)
## 📦 Instalación
### pipx
Recomendado para la mayoría de usuarios de CLI:
```bash
pipx install opendoor
```
### pip
```bash
python3 -m pip install --upgrade opendoor
```
### Windows / Chocolatey
OpenDoor está disponible en el repositorio de paquetes de la comunidad de Chocolatey:
```powershell
choco install opendoor -y
```
Los paquetes de Chocolatey pueden retrasarse respecto a la última versión de GitHub/PyPI mientras se completa la moderación de la comunidad.
### Arch Linux / AUR
OpenDoor está disponible en el Arch User Repository:
```bash
yay -S opendoor
```
### Homebrew
OpenDoor también está disponible en el gestor de paquetes Brew:
```bash
brew install opendoor
```
### Docker
OpenDoor está disponible como imagen Docker oficial del proyecto a través de GitHub Container Registry.
```bash
docker pull ghcr.io/stanislav-web/opendoor:latest
docker run --rm -it ghcr.io/stanislav-web/opendoor:latest --version
```
Ejecute un escaneo y escriba los informes en el 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á disponible en BlackArch Linux:
```bash
sudo pacman -Syu
sudo pacman -S opendoor
```
### Desde el código fuente
```bash
git clone https://github.com/stanislav-web/OpenDoor.git
cd OpenDoor
python3 -m pip install -r requirements.txt
python3 opendoor.py --help
```
Consulte la [guía de instalación](https://opendoor.readthedocs.io/Installation-and-update/) completa.
---
## 🚀 Uso rápido
### Escaneo básico de directorio
```bash
opendoor --host https://example.com
```
### Rastrear enlaces del mismo origen
```bash
opendoor --host https://example.com --crawl
```
`--crawl` es opcional y solo funciona con escaneos de directorios. Utiliza `GET`, extrae atributos HTML conservadores de las respuestas ya escaneadas, mantiene únicamente URLs del mismo origen, respeta las extensiones ignoradas, omite formularios POST y orígenes externos, y reporta las URLs descubiertas a través de los buckets de resultados normales.
### Escaneo de subdominios
```bash
opendoor --host example.com --scan subdomains
```
### Lista de objetivos
```bash
opendoor --hostlist targets.txt
```
Los archivos objetivo pueden mezclar URLs, dominios, direcciones IPv4, bloques CIDR IPv4 y rangos 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 estándar
```bash
cat targets.txt | opendoor --stdin
```
El mismo formato de destino mixto es compatible a través de STDIN.
### Escaneo de bajo ruido
```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
```
### Analizadores de respuestas
Los analizadores de respuestas clasifican cuerpos de respuesta interesantes durante el descubrimiento. Son útiles cuando el código de estado y el tamaño no son suficientes para entender qué se encontró.
```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
```
Los sniffers útiles incluyen:
| Sniffer | Propósito |
|---------------------|-------------------------------------------------------------------------------------------------------------------------------------|
| `indexof` | Detectar páginas de listado de directorios. |
| `file` | Detectar patrones conocidos de exposición de archivos sensibles. |
| `collation` | Detecta respuestas repetidas o de tipo redirección que pueden generar falsos positivos. |
| `skipempty` | Omitir respuestas vacías. |
| `skipsizes=46` | Omitir respuestas con tamaños ruidosos conocidos exactos. |
| `skipsizes=46:1024` | Omitir respuestas dentro de un rango de tamaño ruidoso. |
| `stacktrace` | Detectar trazas de pila de depuración/ejecución expuestas y detalles de errores internos. |
| `secret` | Detectar posibles claves de API, tokens, claves privadas y credenciales expuestas con metadatos de informe redactados. |
| `shadow` | Sondear activamente los aciertos confirmados de tipo archivo `200 OK` en busca de variantes acotadas de copia de seguridad/shadow como `.bak`, `.old` y plantillas de ruta . |
| `openredirect` | Verificar activamente parámetros de consulta de tipo redirección con URL marcadoras controladas y reportar solo vulnerabilidades de redirección abierta confirmadas. |
| `endpoint` | Detectar pasivamente endpoints WebSocket, Socket.IO, SSE/EventSource y AJAX expuestos al cliente a partir de respuestas ya obtenidas. |
| `malware` | Detectar posible contenido malicioso, marcadores de webshell, scripts inyectados o cargas útiles ofuscadas. |
Los sniffers dependientes del cuerpo fuerzan automáticamente `GET` internamente cuando el método configurado es `HEAD`.
Leer más: [Referencia de Sniffers](https://opendoor.readthedocs.io/Sniffers/)
### Escaneo autenticado desde solicitud sin procesar
```bash
opendoor \
--raw-request request.txt \
--scheme https \
--method GET \
--auto-calibrate \
--reports json,html,sqlite,sarif
```
### Escaneo seguro para WAF
```bash
opendoor \
--host https://example.com \
--waf-safe-mode \
--timeout 60 \
--retries 5 \
--delay 0.5
```
### Escaneo tolerante a fallos
Utilice un perfil de ejecución más conservador para objetivos inestables, redes lentas, bloqueos temporales de WAF, inestabilidad del proxy o escaneos autorizados de larga duración.
```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 hace que los escaneos sean más resilientes al aumentar el tiempo de espera por solicitud y la tolerancia a reintentos, limitar los abortos a rutas repetidamente agotadas, filtrar respuestas soft-404 y catch-all con auto-calibración, detener escaneos de bajo valor cuando dominan las respuestas bloqueadas por WAF y guardar el estado del checkpoint para reanudar más tarde.
Reanuda el escaneo más tarde:
```bash
opendoor --session-load session.json
```
Durante un escaneo activo, presione `Ctrl+C` una vez para pausar los workers, luego elija `C` para continuar o `E` para abortar.
### Sondas de omisión de encabezados y rutas
Use esto solo en sistemas que esté autorizado a probar. La función es opcional y sondea recursos bloqueados con encabezados temporales controlados y variantes de rutas seguras.
```bash
opendoor \
--host https://example.com \
--method GET \
--waf-detect \
--header-bypass \
--header-bypass-limit 32 \
--reports std,json,csv,sarif,sqlite
```
Cuando se habilita --header-bypass, OpenDoor primero prueba las variantes de inyección de encabezados configuradas y luego variantes seguras de manipulación de rutas, como barra diagonal final, segmento de punto, sufijo de punto y coma, variación de mayúsculas y minúsculas y segmento codificado en URL.
Personaliza los estados de activación, los valores de IP de confianza y los encabezados:
```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
```
### Enrutamiento de proxy
Usar un único proxy explícito:
```bash
opendoor --host https://example.com --proxy socks5://127.0.0.1:9050
```
Utilice el grupo de proxies rotativos incluido:
```bash
opendoor --host https://example.com --proxy-pool
```
Use una 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
```
Si OpenVPN está instalado fuera del `PATH`, pasa el backend explícitamente:
```bash
opendoor \
--host https://example.com \
--transport openvpn \
--transport-profile ./profile.ovpn \
--transport-bin /opt/homebrew/sbin/openvpn
```
En Windows, `--transport-bin` puede apuntar a `C:\Program Files\OpenVPN\bin\openvpn.exe`. Si un cliente GUI o un agente VPN corporativo ya controla el túnel, inicie esa VPN fuera de OpenDoor y ejecute OpenDoor en modo directo.
### Transporte WireGuard
```bash
opendoor \
--host https://example.com \
--transport wireguard \
--transport-profile ./profile.conf
```
Más ejemplos:
- [Escaneos básicos](https://opendoor.readthedocs.io/examples/basic-scans/)
- [Escaneos por lotes](https://opendoor.readthedocs.io/examples/batch-scans/)
- [Escaneos autenticados](https://opendoor.readthedocs.io/examples/authenticated-scans/)
- [Escaneos seguros para WAF](https://opendoor.readthedocs.io/examples/waf-safe-scans/)
- [Escaneos con omisión de encabezados](https://opendoor.readthedocs.io/examples/header-bypass-scans/)
- [Escaneos con transporte VPN](https://opendoor.readthedocs.io/examples/vpn-transport-scans/)
- [Ejemplos de CI/CD](https://opendoor.readthedocs.io/examples/ci-cd/)
---
### Comparación diferencial de informes
OpenDoor puede comparar exactamente dos informes anteriores/actuales sin ejecutar un nuevo escaneo. Use esto cuando quiera ver qué apareció, desapareció o cambió entre dos resultados de escaneo autorizados.
Los pares de entrada admitidos son únicamente SQLite a SQLite y JSON a JSON. Los formatos mixtos, los archivos faltantes, los informes no válidos y los tipos de informe no admitidos fallan con un error de validación controlado.
```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
```
### Informes SARIF para CI/CD
OpenDoor puede exportar hallazgos como SARIF 2.1.0 para GitHub Code Scanning y canalizaciones de seguridad compatibles con SARIF.
```bash
opendoor \
--host https://example.com \
--reports sarif,json \
--reports-dir ./reports
```
Ejemplo de carga de 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 OpenDoor
Serie de artículos prácticos para aprender OpenDoor mediante flujos de trabajo de reconocimiento web reproducibles y autorizados.
- [Parte 1 — Reconocimiento web consciente del contexto más allá de la fuerza bruta de directorios](https://medium.com/@stanisov/mastering-opendoor-context-aware-web-recon-beyond-directory-brute-force-part-1-cc13eda8cd3d)
- [Parte 2 — Reconocimiento de bajo ruido con redirecciones, sniffing de endpoints y rastreo acotado](https://medium.com/@stanisov/mastering-opendoor-low-noise-recon-with-redirects-endpoint-sniffing-and-bounded-crawl-part-2-411b92675d6d)
- [Página complementaria de la serie](https://opendoor.readthedocs.io/guides/mastering-opendoor/)
## 📚 Documentación
La documentación completa está disponible en ReadTheDocs:
- [Inicio](https://opendoor.readthedocs.io/)
- [Inicio rápido](https://opendoor.readthedocs.io/quickstart/)
- [Instalación y actualización](https://opendoor.readthedocs.io/Installation-and-update/)
- [Guía de uso](https://opendoor.readthedocs.io/Usage/)
- [Entrada de objetivos](https://opendoor.readthedocs.io/concepts/target-input/)
- [Informes](https://opendoor.readthedocs.io/concepts/reports/)
- [Fingerprinting](https://opendoor.readthedocs.io/detection/fingerprinting/)
- [Detección de WAF y modo seguro](https://opendoor.readthedocs.io/detection/waf-detection/)
- [WAF guard](https://opendoor.readthedocs.io/detection/waf-guard/)
- [Bypass de inyección de cabeceras](https://opendoor.readthedocs.io/detection/header-bypass/)
- [Autocalibración](https://opendoor.readthedocs.io/detection/auto-calibration/)
- [Transportes de red](https://opendoor.readthedocs.io/transports/overview/)
- [Compatibilidad TLS y mTLS](https://opendoor.readthedocs.io/transports/tls/)
- [Transporte OpenVPN](https://opendoor.readthedocs.io/transports/openvpn/)
- [Transporte WireGuard](https://opendoor.readthedocs.io/transports/wireguard/)
- [Ejemplos prácticos](https://opendoor.readthedocs.io/examples/basic-scans/)
- [Testing](https://opendoor.readthedocs.io/Testing/)
- [Contribución](https://opendoor.readthedocs.io/Contribution/)
---
## 🧪 Desarrollo
Instala las dependencias de desarrollo:
```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 .
```
Ejecutar pruebas:
```bash
python -m unittest
```
Ejecutar cobertura:
```bash
coverage run -m unittest discover -s tests -p "test_*.py"
coverage report -m
```
Compilar la documentación:
```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 artefactos del paquete:
```bash
python -m build
```
Consulta la [guía de pruebas](https://opendoor.readthedocs.io/Testing/) completa y la [guía de contribución](https://opendoor.readthedocs.io/Contribution/).
---
## 🔐 Seguridad e higiene de secretos
No hagas commit de secretos reales ni de perfiles de transporte privados.
Nunca publiques:
- perfiles OpenVPN reales;
- claves privadas de WireGuard;
- certificados de cliente mTLS y claves privadas;
- archivos auth-user-pass;
- cookies;
- tokens de portador;
- listas de objetivos de clientes;
- informes de escaneo privados;
- artefactos de CI sensibles.
Utiliza únicamente ejemplos de marcador de posición.
---
## ⚖️ Uso responsable
OpenDoor es una herramienta de pruebas de seguridad.
Úsala únicamente contra sistemas que poseas o para los que tengas permiso explícito de probar.
Funciones como la detección de WAF, el escaneo seguro para WAF, la repetición de solicitudes sin procesar, los perfiles de transporte y las sondas de Header Injection Bypass están destinadas a pruebas de seguridad autorizadas, validación defensiva y comprobaciones de regresión de exposición.
El proyecto no otorga permiso para escanear sistemas de terceros, organizaciones, servicios comerciales o infraestructura pública sin autorización.
---
## 🧾 Registro de cambios
---
[Read more](https://github.com/stanislav-web/opendoor)