Skip to content
KitploitKITPLOIT
HerramientasBlog
Enviar
HerramientasBlog
Enviar

¡Herramientas de Hacking, PenTest y Ciberseguridad para tu Arsenal de Seguridad!

Kitploit es un directorio de herramientas de hacking, ciberseguridad y pentesting. Descubre las últimas actualizaciones de proyectos para encontrar vulnerabilidades, analizar sistemas, automatizar pruebas y fortalecer tu seguridad.

··Feeds·Contacto·Privacidad·© 2026 Kitploit

Directorio de Herramientas

Categorías

Ver todas las categorías
Loading categories
Herramientas/GitHubGitHub/six2dez/reconftw
OSINT (Inteligencia de Fuentes Abiertas)ReconocimientoEscáneres de VulnerabilidadesOSINT para Ingeniería SocialEscaneo de PuertosEnumeración de DNS y SubdominiosScripting y AutomatizaciónRecopilación de InformaciónSeguridad WebPruebas de PenetraciónSeguridad en la NubeEnumeración de Subdominios
8.0k1.2k51hace 8 díasRevisado por Kitploit

Más Populares

Ver todos →

Descubre las herramientas más usadas por nuestra comunidad.

Explora todas las herramientas

Explora nuestra colección de herramientas

Ver todas las herramientas →
Compartir
Recolección de Correos
Análisis de DNS
Top en Enumeración de DNS y Subdominios #17
Top en Recolección de Correos #20
Top en Recopilación de Información #6
Top en OSINT (Inteligencia de Fuentes Abiertas) #20
Top en OSINT para Ingeniería Social #20
Top en Reconocimiento #3
Top en Scripting y Automatización #1
Top en Enumeración de Subdominios #17
GitHubsix2dez/reconftw

reconftw

reconFTW es una herramienta diseñada para realizar reconocimiento automatizado en un dominio objetivo ejecutando el mejor conjunto de herramientas para realizar escaneos y encontrar vulnerabilidades.

Ver RepositorioSitio web


reconftw
reconFTW

Release License Closed Issues Discord Telegram Twitter

Docs Bash Script Linux macOS GitHub

GitHub Actions Docker Terraform Ansible Go Python

Buy Me a Coffee GitHub Sponsors PayPal

reconFTW es una potente herramienta automatizada de reconocimiento diseñada para investigadores de seguridad y pentesters. Agiliza el proceso de recopilación de inteligencia sobre un objetivo mediante la enumeración de subdominios, el escaneo de vulnerabilidades, OSINT y más. Con un diseño modular, amplias opciones de configuración y soporte para escaneo distribuido mediante AX Framework, reconFTW está construido para ofrecer resultados completos de manera eficiente.

reconFTW aprovecha una amplia gama de técnicas, incluido el descubrimiento de subdominios pasivo y activo, comprobaciones de vulnerabilidades web (p. ej., XSS, SSRF, SQLi), OSINT, fuzzing de directorios, escaneo de puertos y captura de pantallas. Se integra con herramientas y APIs de vanguardia para maximizar la cobertura y la precisión, garantizando que te mantengas a la vanguardia en tus esfuerzos de reconocimiento.

Características clave:

  • Enumeración integral de subdominios (pasiva, fuerza bruta, permutaciones, transparencia de certificados, etc.)
  • Escaneo de vulnerabilidades para XSS, SSRF, SQLi, LFI, SSTI y más
  • OSINT para correos electrónicos, metadatos, fugas de APIs y configuraciones incorrectas de terceros
  • Escaneo distribuido con AX Framework para una ejecución más rápida
  • Flujos de trabajo personalizables con un archivo de configuración detallado
  • Integración con Faraday para informes y visualización
  • Soporte para despliegues con Docker, Terraform y Ansible

Aviso legal: El uso de reconFTW para atacar objetivos sin consentimiento previo es ilegal. Es responsabilidad del usuario cumplir todas las leyes aplicables. Los desarrolladores no asumen ninguna responsabilidad por el uso indebido o los daños causados por esta herramienta. Úsala de forma responsable.


📔 Tabla de Contenidos

  • 📔 Tabla de Contenidos
  • ✨ Características
    • OSINT
    • Subdominios
    • Hosts
    • Análisis Web
    • Comprobaciones de Vulnerabilidades
    • Extras
  • 🏗️ Arquitectura
  • 💿 Instalación
    • Instalación Local (PC/VPS/VM)
    • Docker
    • Terraform + Ansible
  • Probar la versión beta v2 (reescritura en Go)
  • ⚙️ Configuración
  • 🚀 Uso
    • Opciones de Objetivo
    • Opciones de Modo
    • Opciones Generales
    • Ejemplos de Uso
  • ☁️ Soporte de AX Framework (anteriormente Axiom)
  • 💻 Soporte de Faraday
  • 🧠 Integración de IA
  • 🗂️ Gestión de Datos
    • Makefile
    • Manual
  • 🧪 Pruebas
  • Mindmap/Flujo de trabajo
  • Vídeo de muestra
  • 🤝 Cómo Contribuir
  • 🔒 Seguridad
  • ❓ ¿Necesitas Ayuda?
  • 💖 Apoya Este Proyecto
  • 🙏 Agradecimientos
  • 📝 Registro de Cambios
  • 🛠️ Desarrollo
  • 📜 Licencia
  • ⭐ Historial de Estrellas

✨ Características

reconFTW está repleto de funciones para que el reconocimiento sea exhaustivo y eficiente. A continuación se muestra un desglose detallado de sus capacidades, actualizado para reflejar la funcionalidad más reciente del script y la configuración.

OSINT

  • Información de Dominio: Consulta WHOIS para obtener detalles de registro del dominio (whois).
  • Fugas de Correos y Contraseñas: Busca correos electrónicos y credenciales filtrados (emailfinder y LeakSearch).
  • Mapeo de Microsoft 365/Azure: Identifica inquilinos de Microsoft 365 y Azure (msftrecon).
  • Extracción de Metadatos: Extrae metadatos de documentos de Office indexados (metagoofil).
  • Fugas de APIs: Detecta APIs expuestas en fuentes públicas (porch-pirate, SwaggerSpy y postleaksNg).
  • Google Dorking: Consultas automatizadas de Google dork para información sensible (dorks_hunter y xnldorker).
  • Análisis de GitHub: Escanea organizaciones de GitHub en busca de repositorios y secretos con motores seleccionables (enumerepo, trufflehog, gitleaks, titus, noseyparker).
  • Auditoría de GitHub Actions (Opcional): Audita artefactos de flujos de trabajo y exposición de CI/CD con gato.
  • Configuraciones Incorrectas de Terceros: Identifica servicios de terceros mal configurados (misconfig-mapper).
  • Higiene de Correo: Revisa la configuración de SPF/DMARC para señalar problemas de suplantación o entregabilidad.

Subdominios

  • Enumeración Pasiva: Utiliza APIs y fuentes públicas para el descubrimiento de subdominios (subfinder y github-subdomains).
  • Transparencia de Certificados: Consulta registros de transparencia de certificados (crt).
  • Descubrimiento NOERROR: Identifica subdominios con respuestas DNS NOERROR (dnsx, más información aquí).
  • Fuerza Bruta: Realiza fuerza bruta DNS con listas de palabras personalizables (puredns y listas de palabras personalizadas).
  • Permutaciones: Genera permutaciones de subdominios mediante IA, regex y herramientas (Gotator como único motor de permutaciones, además de regulator y subwiz).
  • Web Scraping: Extrae subdominios de fuentes de URLs pasivas y metadatos web en vivo (urlfinder, waymore, httpx, csprecon).
  • Registros DNS: Resuelve registros DNS de subdominios (dnsx).
  • Google Analytics: Identifica subdominios mediante IDs de Analytics (AnalyticsRelationships).
  • Handshake TLS: Descubre subdominios mediante puertos TLS (tlsx).
  • Búsqueda Recursiva: Realiza enumeración recursiva pasiva o de fuerza bruta combinada (dsieve).

Hosts

  • Información de IP: Recupera datos de geolocalización y WHOIS (ipinfo).
  • Detección de CDN: Identifica IPs detrás de CDNs (cdncheck).
  • Detección de WAF: Detecta firewalls de aplicaciones web (wafw00f).
  • Escaneo de Puertos: Escaneo activo con nmap (opcionalmente precedido por naabu) y escaneo pasivo con smap.
  • Huella de Servicios: Obtiene la huella de servicios expuestos en pares host:puerto descubiertos con nerva.
  • Vulnerabilidades de Servicios (Opcional): El perfil de escaneo de puertos profundo puede enriquecer los resultados con coincidencias de CVE mediante vulners.
  • Password Spraying: Intenta password spraying en servicios identificados con selección de motor (brutespray o brutus).
  • Geolocalización: Mapea direcciones IP a ubicaciones geográficas (ipinfo).
  • Descubrimiento de IPv6: Opcionalmente enumera y escanea objetivos IPv6 descubiertos cuando IPV6_SCAN está habilitado.

Análisis Web

  • Sondeo Web: Detecta servidores web en vivo en puertos estándar y poco comunes ((httpx)).
  • Capturas de Pantalla: Captura capturas de pantalla de páginas web (nuclei).
  • Fuzzing de Hosts Virtuales: Identifica hosts virtuales mediante fuzzing de cabeceras HTTP (VhostFinder).
  • Detección de CMS: Identifica sistemas de gestión de contenidos (CMSeeK).
  • Extracción de URLs: Recopila URLs de forma pasiva y activa (urlfinder, waymore, katana, github-endpoints y JSA).
  • Análisis de Patrones de URL: Clasifica URLs mediante patrones (urless, gf y gf-patterns).
  • Reconocimiento de Tecnología por Favicon: Identifica tecnologías a partir de hashes de favicon (favirecon).
  • Análisis de JavaScript: Extrae secretos y endpoints de archivos JS (subjs, JSA, xnLinkFinder, getjswords, mantra, jsluice).
  • Extracción de Source Maps: Recupera datos sensibles de source maps de JavaScript (sourcemapper).

Comprobaciones de Vulnerabilidades

  • CVEs: Comprueba CVEs y vulnerabilidades comunes nuclei
  • Nuclei DAST: Ejecuta plantillas nuclei -dast sobre URLs recopiladas y candidatos GF para cobertura DAST adicional.
  • XSS: Prueba vulnerabilidades de cross-site scripting (dalfox).
  • SSL/TLS: Comprueba configuraciones incorrectas de SSL/TLS (testssl).
  • SSRF: Prueba server-side request forgery (interactsh, valores de parámetros con ffuf, y payloads de protocolos alternativos opcionales).
  • CRLF: Comprueba vulnerabilidades de inyección CRLF (crlfuzz).
  • LFI: Prueba inclusión local de archivos mediante fuzzing (ffuf).
  • SSTI: Detecta inyección de plantillas del lado del servidor (TInjA).
  • SQLi: Prueba inyección SQL (SQLMap y ghauri).
  • Enlaces Rotos: Identifica enlaces rotos y referencias externas propensas a toma de control (second-order).
  • Inyección de Comandos: Prueba vulnerabilidades de inyección de comandos (commix).
  • HTTP Request Smuggling: Comprueba vulnerabilidades de contrabando de solicitudes (smugglex).
  • Caché Web: Identifica vulnerabilidades de caché web (Web-Cache-Vulnerability-Scanner y ).

Extras- Multithreading: Optimiza el rendimiento (Interlace).

  • Resolvedores personalizados: Genera resolvedores DNS (dnsvalidator).
  • Soporte Docker: Imagen oficial de Docker en DockerHub.
  • Despliegue en AWS: Se despliega mediante Terraform y Ansible.
  • Soporte IP/CIDR: Escanea rangos de IP y bloques CIDR.
  • Reanudación de escaneos: Reanuda escaneos desde el último paso completado.
  • Salida personalizada: Guarda los resultados en un directorio definido por el usuario.
  • Modo Diff: Destaca nuevos hallazgos en escaneos posteriores.
  • Filtrado de alcance: Admite listas dentro y fuera del alcance (inscope).
  • Notificaciones: Envía alertas mediante Slack, Discord o Telegram (notify).
  • Compresión de resultados: Comprime y envía los resultados.
  • Integración con Faraday: Exporta resultados a Faraday para informes .
  • Generación de informes con IA: Genera informes usando modelos de IA locales (reconftw_ai).
  • Modo de reescaneo rápido: Omite automáticamente etapas pesadas cuando no se descubren nuevos activos (--quick-rescan / QUICK_RESCAN).
  • Constructor de listas calientes: Puntúa y resalta los activos de mayor riesgo (hotlist.txt) según nuevos hallazgos.
  • Rastreo de comandos: Activa SHOW_COMMANDS para registrar cada comando ejecutado en los registros del objetivo para depuración.

🏗️ Arquitectura

reconFTW usa una arquitectura modular. El punto de entrada principal (reconftw.sh) maneja el análisis de argumentos y carga 8 módulos especializados del directorio modules/.

Estructura de directorios```

reconftw/ ├── reconftw.sh # Entry point — arg parsing, module loading, dispatch ├── reconftw.cfg # Default configuration ├── install.sh # Installer ├── Makefile # Data management, lint, fmt, test targets ├── modules/ │ ├── core.sh # Lifecycle, logging, notifications, cleanup (1024 lines) │ ├── modes.sh # Scan modes, argument parsing, help (902 lines) │ ├── subdomains.sh # Subdomain enumeration (1938 lines) │ ├── web.sh # Web analysis, fuzzing, JS checks (1712 lines) │ ├── vulns.sh # Vulnerability scanning (926 lines) │ ├── osint.sh # OSINT functions (500 lines) │ ├── axiom.sh # Ax/Axiom fleet helpers (143 lines) │ └── utils.sh # Utilities, sanitization, validation (508 lines) ├── tests/ │ ├── run_tests.sh # Test runner │ ├── unit/ # bats-core unit tests │ ├── integration/ # Integration tests │ └── fixtures/ # Test data ├── Docker/ │ └── Dockerfile # Official Docker image └── Terraform/ # AWS deployment

root@kitploit:~
### Referencia de Módulos

| Módulo | Líneas | Propósito |
|--------|------:|---------|
| `core.sh` | 1024 | Gestión del ciclo de vida, registro, notificaciones, trampas de limpieza |
| `modes.sh` | 902 | Definiciones de modos de escaneo, análisis de argumentos, salida de ayuda |
| `subdomains.sh` | 1938 | Todas las funciones de enumeración de subdominios |
| `web.sh` | 1712 | Análisis web, fuzzing, análisis de JS, detección de CMS |
| `vulns.sh` | 926 | Escaneo de vulnerabilidades (XSS, SQLi, SSRF, etc.) |
| `osint.sh` | 500 | Funciones OSINT (WHOIS, correos electrónicos, dorks, metadatos) |
| `utils.sh` | 508 | Utilidades compartidas, saneamiento de entrada, validación |
| `axiom.sh` | 143 | Gestión de flota distribuida Ax/Axiom |

La bandera `--source-only` permite cargar `reconftw.sh` sin ejecutar la lógica principal, lo que habilita pruebas unitarias de funciones individuales.

---

## 💿 Instalación

reconFTW admite múltiples métodos de instalación para adaptarse a diferentes entornos. Asegúrate de tener suficiente espacio en disco (se recomienda al menos 10 GB) y una conexión a internet estable.

### Inicio rápido

1) Clonar e instalar```yaml
git clone https://github.com/six2dez/reconftw
cd reconftw
./install.sh --verbose
  1. Ejecutar un escaneo (completo + reanudar)```bash ./reconftw.sh -d example.com -r
root@kitploit:~
3) Ejecución mínima (huella solo pasiva)```bash
./reconftw.sh -d example.com -p

Consejo: vuelve a ejecutar ./install.sh --tools más tarde para actualizar el conjunto de herramientas sin reinstalar los paquetes del sistema.

Instalación local (PC/VPS/VM)

  1. Requisitos previos:

    • Golang: Última versión (install_golang habilitado por defecto en reconftw.cfg).
    • Permisos del sistema: Si no se ejecuta como root, configura sudo para evitar solicitudes de contraseña:
      root@kitploit:~
      sudo echo "${USERNAME} ALL=(ALL:ALL) NOPASSWD: ALL" | sudo tee -a /etc/sudoers.d/reconFTW
      
  2. Pasos: ```bash git clone https://github.com/six2dez/reconftw cd reconftw ./install.sh ./reconftw.sh -d target.com -r

    root@kitploit:~
  3. Notas:

  • El script install.sh instala dependencias, herramientas y configura rutas (GOROOT, GOPATH, PATH).
  • Establece install_golang=false en reconftw.cfg si Golang ya está configurado.
  • Para instalaciones existentes, ejecuta ./install.sh --tools para actualizar los binarios de Go, paquetes pipx y repositorios sin tocar los paquetes del sistema.
  • Consulta la Guía de instalación para instrucciones detalladas.

Docker

  1. Descargar la imagen: ```bash docker pull six2dez/reconftw:main
    root@kitploit:~
  2. Ejecuta el contenedor: ```bash docker run -it --rm
    -v "${PWD}/OutputFolder/:/reconftw/Recon/"
    six2dez/reconftw:main -d example.com -r
    root@kitploit:~

Para una lista de objetivos, vincula el archivo de lista al contenedor y referencia la ruta dentro del contenedor: ```bash docker run -it --rm
-v "${PWD}/domains.txt:/reconftw/domains.txt:ro"
-v "${PWD}/OutputFolder/:/reconftw/Recon/"
six2dez/reconftw:main -l /reconftw/domains.txt -r

root@kitploit:~
3. **Ver resultados**:

- Los resultados se guardan en el directorio `OutputFolder` del host (no dentro del contenedor).

4. **Personalización**:
- Modifica la imagen de Docker o crea la tuya propia; consulta la [Guía de Docker](https://github.com/six2dez/reconftw/wiki/4.-Docker).
- Para omitir las herramientas de Ax en compilaciones personalizadas, pasa `--build-arg INSTALL_AXIOM=false`.
- Monta tu configuración de notify en `~/.config/notify/provider-config.yaml` dentro del contenedor si usas notificaciones.

5. **Secretos en tiempo de ejecución**:

Pasa las claves de API y los secretos mediante variables de entorno; nunca los integres en la imagen:   ```bash
docker run -it --rm \
  -e SHODAN_API_KEY="your-key" \
  -e PDCP_API_KEY="your-projectdiscovery-key" \
  -e COLLAB_SERVER="your-server" \
  -e XSS_SERVER="your-server" \
  -v "${PWD}/OutputFolder/:/reconftw/Recon/" \
  six2dez/reconftw:main -d example.com -r

Vea SECURITY.md para obtener la guía completa sobre la gestión de secretos.

  1. Verificación de salud:

    La imagen de Docker incluye un HEALTHCHECK integrado que ejecuta ./reconftw.sh --health-check cada 60 segundos. También puede ejecutarlo manualmente: ```bash docker exec ./reconftw.sh --health-check

    root@kitploit:~

Terraform + Ansible

  • Despliega reconFTW en AWS usando Terraform y Ansible.
  • Sigue la guía en Terraform/README.md para las instrucciones de configuración.

Probando la versión beta v2 (reescritura en Go)

reconFTW se está reescribiendo en Go. La reescritura se distribuye como una pre-versión opcional: está listada en la página de versiones, y GitHub nunca apunta releases/latest a una pre-versión — así que si no haces nada, sigues recibiendo la versión bash. Eso es deliberado.

El binario de Go es reconftw; el punto de entrada de bash es reconftw.sh. No se sobrescriben entre sí, por lo que puedes mantener ambos y volver a cualquiera en cualquier momento.

La beta actual es v5.0.0-beta.1. No se sirve mediante releases/latest, por lo que debes especificar la etiqueta explícitamente:```bash curl -sSL "https://github.com/six2dez/reconftw/releases/download/v5.0.0-beta.1/reconftw_Linux_x86_64.tar.gz" | tar xz sudo install -m 755 reconftw /usr/local/bin/reconftw reconftw version

root@kitploit:~
Selecciona el binario que coincida con tu plataforma desde la
[página de lanzamientos](https://github.com/six2dez/reconftw/releases/tag/v5.0.0-beta.1) — se publican compilaciones para `Darwin`
y `arm64`, una compilación estática con musl, y paquetes `.deb`/`.rpm`.

- [**Qué es la beta y qué no es**](https://github.com/six2dez/reconftw/blob/main/docs/V2-BETA-ANNOUNCEMENT.md) — incluye tres
  cosas que explícitamente aún no están terminadas.
- [**Reportar algo**](https://github.com/six2dez/reconftw/issues/new?template=v2-beta-feedback.md)
  — la plantilla de comentarios de la beta v2. Los errores en la versión bash siguen yendo al informe de errores normal.


## 🛠️ Solución de problemas

- Bash 4+ en macOS: Los scripts se relanzan automáticamente con Homebrew Bash. Si ves un mensaje sobre Bash < 4, ejecuta `brew install bash`, abre una nueva terminal y vuelve a ejecutar `./install.sh`.
- timeout en macOS: macOS proporciona `gtimeout` mediante `brew install coreutils`. Los scripts ahora lo detectan y lo usan automáticamente.
- Problemas de red: Los instaladores ocultan la mayor parte de la salida de los comandos. Si algo falla, vuelve a ejecutar con `upgrade_tools=true` en `reconftw.cfg`, ejecuta `./install.sh --tools`, o instala manualmente la herramienta que falta (el error la nombrará).
- Binarios GOPATH: Los binarios se copian a `/usr/local/bin`. Si prefieres no hacerlo, asegúrate de que `~/go/bin` esté en tu `PATH`.
- Plantillas de Nuclei: Si las plantillas no se clonaron, elimina `~/nuclei-templates` y vuelve a ejecutar `./install.sh`.

## 🔑 Lista de verificación de API (Opcional)

- `subfinder`: `~/.config/subfinder/provider-config.yaml`
- Tokens de GitHub: `~/Tools/.github_tokens` (uno por línea)
- Tokens de GitLab: `~/Tools/.gitlab_tokens` (uno por línea)
- WHOISXML: establece `WHOISXML_API` en `reconftw.cfg` o como variable de entorno
- Enumeración ASN (`asnmap`): establece `PDCP_API_KEY` en entorno/config (`ASN_ENUM` se omite si no está definido)
- Slack/Discord/Telegram: configura `notify` en `~/.config/notify/provider-config.yaml`
- Servidor SSRF: establece `COLLAB_SERVER` en entorno/cfg si se usa
- Servidor Blind XSS: establece `XSS_SERVER` en entorno/cfg si se usa

## 💾 Requisitos

- Disco: 10–20 GB libres recomendados (toolchain + datos)
- Red: conexión estable durante la instalación y las actualizaciones
- SO: Linux/macOS con Bash ≥ 4
- Extras: `shellcheck` y `shfmt` (opcionales) para `make lint`/`make fmt`

## ⚙️ Configuración

El archivo `reconftw.cfg` controla toda la ejecución de reconFTW. Permite una personalización detallada de:

- **Rutas de herramientas**: Establece rutas para herramientas, resolvers y listas de palabras (`tools`, `resolvers`, `fuzz_wordlist`).
- **Claves API**: Configura claves para Shodan, WHOISXML, etc. mediante variables de entorno o `secrets.cfg` (consulta [SECURITY.md](https://github.com/six2dez/reconftw/blob/main/SECURITY.md)).
- **Modos de escaneo**: Habilita/deshabilita módulos (p. ej., `OSINT`, `SUBDOMAINS_GENERAL`, `VULNS_GENERAL`).
- **Rendimiento**: Ajusta hilos, límites de velocidad y tiempos de espera (p. ej., `FFUF_THREADS`, `HTTPX_RATELIMIT`).
- **Límite de velocidad adaptativo**: Retrocede automáticamente ante errores 429/503 (`ADAPTIVE_RATE_LIMIT`, `MIN_RATE_LIMIT`, `MAX_RATE_LIMIT`).
- **Escaneo incremental**: Solo escanea hallazgos nuevos desde la última ejecución (`INCREMENTAL_MODE`).
- **Notificaciones**: Configura notificaciones de Slack, Discord o Telegram (`NOTIFY_CONFIG`).
- **Ax (antes Axiom)**: Configura el escaneo distribuido y las rutas de resolvers (`AXIOM_FLEET_NAME`, `AXIOM_FLEET_COUNT`, `AXIOM_RESOLVERS_PATH`).
- **Informes con IA**: Configura modelo/perfil/formato y controles de contexto (`AI_MODEL`, `AI_REPORT_PROFILE`, `AI_REPORT_TYPE`, `AI_MAX_CHARS_PER_FILE`).
- **Comprobaciones web avanzadas**: Alterna introspección de GraphQL, descubrimiento de parámetros, pruebas de WebSocket, sondeo gRPC y escaneo IPv6.
- **Automatización y datos**: Controla heurísticas de reescaneo rápido, registro de activos, tamaños de fragmentos, listas destacadas y trazado de depuración (`QUICK_RESCAN`, `ASSET_STORE`, `CHUNK_LIMIT`, `HOTLIST_TOP`, `SHOW_COMMANDS`).
- **Disco y registro**: Comprobación de disco previa al vuelo (`MIN_DISK_SPACE_GB`), rotación de registros (`MAX_LOG_FILES`, `MAX_LOG_AGE_DAYS`), registro JSON estructurado (`STRUCTURED_LOGGING`).
- **Caché**: Configura la caducidad de la caché para listas de palabras y resolvers (`CACHE_MAX_AGE_DAYS`).
- **Seguridad del resolver DNS**: Los archivos de resolvers faltantes fallan rápidamente, las descargas de resolvers usan controles configurables de reintento/tiempo de espera (`RESOLVER_DOWNLOAD_*`), y el tiempo de espera de fuerza bruta/resolución DNS está deshabilitado por defecto (`DNS_*_TIMEOUT=0`) con progreso de latido.
- **Secretos**: Usa `secrets.cfg` para anulaciones locales o variables de entorno para CI/Docker (consulta [SECURITY.md](https://github.com/six2dez/reconftw/blob/main/SECURITY.md)).

**Ejemplo de configuración**:```bash
#############################################
#			reconFTW config file			#
#############################################

# General values
tools=$HOME/Tools   # Path installed tools
if [[ -z "${SCRIPTPATH:-}" ]]; then
	if [[ -n "${BASH_SOURCE[0]:-}" ]]; then
		SCRIPTPATH="$( cd "$(dirname "${BASH_SOURCE[0]}")" >/dev/null 2>&1 ; pwd -P )" # Get current script's path
	else
		SCRIPTPATH="$( cd "$(dirname "$0")" >/dev/null 2>&1 ; pwd -P )" # Get current script's path
	fi
fi
_detected_shell="${SHELL:-/bin/bash}"
profile_shell=".$(basename "${_detected_shell}")rc" # Get current shell profile
if git rev-parse --is-inside-work-tree >/dev/null 2>&1; then
	reconftw_version="$(git rev-parse --abbrev-ref HEAD)-$(git describe --tags 2>/dev/null || git rev-parse --short HEAD)"
else
	reconftw_version="standalone"
fi # Fetch current reconftw version
DATA_DIR="${SCRIPTPATH}/data"
WORDLISTS_DIR="${DATA_DIR}/wordlists"
PATTERNS_DIR="${DATA_DIR}/patterns"
generate_resolvers=false # Generate custom resolvers with dnsvalidator
update_resolvers=true # Fetch and rewrite resolvers from trickest/resolvers before DNS resolution
resolvers_url="https://raw.githubusercontent.com/trickest/resolvers/main/resolvers.txt"
resolvers_trusted_url="https://gist.githubusercontent.com/six2dez/ae9ed7e5c786461868abd3f2344401b6/raw/trusted_resolvers.txt"
RESOLVER_DOWNLOAD_CONNECT_TIMEOUT=10 # Seconds to wait for resolver download TCP connection
RESOLVER_DOWNLOAD_MAX_TIME=120 # Hard cap in seconds for resolver downloads
RESOLVER_DOWNLOAD_RETRY=2 # Retry count for resolver downloads
RESOLVER_DOWNLOAD_RETRY_DELAY=2 # Delay in seconds between resolver download retries
fuzzing_remote_list="https://raw.githubusercontent.com/six2dez/OneListForAll/main/onelistforallmicro.txt" # Used to send to Ax (if used) on fuzzing
proxy_url="http://127.0.0.1:8080/" # Proxy url
install_golang=true # Set it to false if you already have Golang configured and ready
upgrade_tools=true
upgrade_before_running=false # Upgrade tools before running
#dir_output=/custom/output/path
SHOW_COMMANDS=false # Set true to log every executed command to the per-target log (verbose; may include sensitive data)
MIN_DISK_SPACE_GB=0 # Minimum required disk space in GB before starting reconnaissance (0 to disable check)

# Incremental mode configuration
INCREMENTAL_MODE=false # Only scan new findings since last run (use --incremental flag to enable)
MONITOR_MODE=false # Continuous monitor mode (enabled by --monitor)
MONITOR_INTERVAL_MIN=60 # Minutes between monitoring cycles
MONITOR_MAX_CYCLES=0 # 0 = run forever until interrupted
ALERT_SUPPRESSION=true # Suppress repeated monitor alerts by fingerprint history
ALERT_SEEN_FILE=".incremental/alerts_seen.hashes" # Store of seen alert fingerprints

# Adaptive rate limiting configuration
ADAPTIVE_RATE_LIMIT=false # Automatically adjust rate limits when encountering 429/503 errors (use --adaptive-rate flag to enable)
MIN_RATE_LIMIT=10 # Minimum rate limit (requests per second)
MAX_RATE_LIMIT=500 # Maximum rate limit (requests per second)
RATE_LIMIT_BACKOFF_FACTOR=0.5 # Multiply rate by this when errors occur (0.5 = half speed)
RATE_LIMIT_INCREASE_FACTOR=1.2 # Multiply rate by this on success (1.2 = 20% faster)

# Cache configuration
CACHE_MAX_AGE_DAYS=30 # Maximum age in days for cached wordlists/resolvers (30 = 1 month)
CACHE_MAX_AGE_DAYS_RESOLVERS=7 # Resolver cache TTL
CACHE_MAX_AGE_DAYS_WORDLISTS=30 # Wordlist cache TTL
CACHE_MAX_AGE_DAYS_TOOLS=14 # Tool cache TTL
CACHE_REFRESH=false # Force-refresh cache (or use --refresh-cache)

# Log rotation
MAX_LOG_FILES=10       # Maximum number of log files to keep per target
MAX_LOG_AGE_DAYS=30    # Delete log files older than this many days

# Structured logging configuration (JSON format)
STRUCTURED_LOGGING=false # Enable JSON structured logging for advanced log analysis

# Golang Vars (Comment or change on your own)
export GOROOT="${GOROOT:-/usr/local/go}"
export GOPATH="${GOPATH:-$HOME/go}"
case ":${PATH}:" in
	*":$GOPATH/bin:"*) ;;
	*) PATH="$GOPATH/bin:$PATH" ;;
esac
case ":${PATH}:" in
	*":$GOROOT/bin:"*) ;;
	*) PATH="$GOROOT/bin:$PATH" ;;
esac
case ":${PATH}:" in
	*":$HOME/.local/bin:"*) ;;
	*) PATH="$HOME/.local/bin:$PATH" ;;
esac
export PATH

# Rust Vars (Comment or change on your own)
export PATH="$HOME/.cargo/bin:$PATH"

# Tools config files
#NOTIFY_CONFIG=~/.config/notify/provider-config.yaml # No need to define
GITHUB_TOKENS=${tools}/.github_tokens
GITLAB_TOKENS=${tools}/.gitlab_tokens
#CUSTOM_CONFIG=custom_config_path.txt # In case you use a custom config file, uncomment this line and set your files path

# APIs/TOKENS - Set via environment variables (preferred) or uncomment and edit below.
# Environment variables take precedence if set.
SHODAN_API_KEY="${SHODAN_API_KEY:-}"
WHOISXML_API="${WHOISXML_API:-}"
PDCP_API_KEY="${PDCP_API_KEY:-}"
XSS_SERVER="${XSS_SERVER:-}"
COLLAB_SERVER="${COLLAB_SERVER:-}"
slack_channel="${slack_channel:-}"
slack_auth="${slack_auth:-}"
# For additional secrets, create a secrets.cfg file (gitignored) and it will be auto-sourced

# File descriptors
DEBUG_STD="&>/dev/null" # Skips STD output on installer
DEBUG_ERROR="2>/dev/null" # Skips ERR output on installer

# Osint
OSINT=true # Enable or disable the whole OSINT module
GOOGLE_DORKS=true
GITHUB_DORKS=true
GITHUB_REPOS=true
METADATA=true # Fetch metadata from indexed office documents
EMAILS=true # Fetch emails from differents sites
DOMAIN_INFO=true # whois info
IP_INFO=true    # Reverse IP search, geolocation and whois
API_LEAKS=true # Check for API leaks
API_LEAKS_POSTLEAKS=true # Enhance API leaks with postleaksNg
THIRD_PARTIES=true # Check for 3rd parties misconfigs
SPOOF=true # Check spoofable domains
MAIL_HYGIENE=true # Check DMARC/SPF records
CLOUD_ENUM=true # Enumerate cloud storage across providers with cloud_enum
GITHUB_LEAKS=true # Search for leaked secrets across GitHub with ghleaks
GHLEAKS_THREADS=5 # Concurrent download threads for ghleaks
SECRETS_ENGINE="gitleaks" # gitleaks|titus|noseyparker|hybrid
SECRETS_SCAN_GIT_HISTORY=false # Include git history scans when supported
SECRETS_VALIDATE=false # Validate detected secrets when supported (titus)
GITHUB_ACTIONS_AUDIT=false # Audit GitHub Actions artifacts/workflows with gato
GATO_INCLUDE_ALL_ARTIFACT_SECRETS=false # Include noisy artifact secret matches in gato output

# Subdomains
SUBDOMAINS_GENERAL=true # Enable or disable the whole Subdomains module
SUBPASSIVE=true # Passive subdomains search
SUBCRT=true # crtsh search
CTR_LIMIT=999999 # Limit the number of results
SUBNOERROR=false # Check DNS NOERROR response and BF on them
SUBANALYTICS=true # Google Analytics search
SUBBRUTE=true # DNS bruteforcing
SUBSCRAPING=true # Subdomains extraction from passive URLs and live web metadata
SUBPERMUTE=true # DNS permutations
SUBIAPERMUTE=true # Permutations by AI analysis
SUBREGEXPERMUTE=true # Permutations by regex analysis
GOTATOR_FLAGS=" -depth 1 -numbers 3 -mindup -adv -md" # Flags for gotator
PERMUTATIONS_WORDLIST_MODE=auto # auto|full|short (auto: short if subs > threshold, full if DEEP)
PERMUTATIONS_SHORT_THRESHOLD=100 # Use short wordlist when subdomain count exceeds this
SUBTAKEOVER=true # Check subdomain takeovers, false by default cuz nuclei already check this
SUB_RECURSIVE_PASSIVE=false # Uses a lot of API keys queries
DEEP_RECURSIVE_PASSIVE=10 # Number of top subdomains for recursion
SUB_RECURSIVE_BRUTE=false # Needs big disk space and time to resolve
ZONETRANSFER=true # Check zone transfer
S3BUCKETS=true # Check S3 buckets misconfigs
REVERSE_IP=false # Check reverse IP subdomain search (set True if your target is CIDR/IP)
TLS_PORTS="21,22,25,80,110,135,143,261,271,324,443,448,465,563,614,631,636,664,684,695,832,853,854,990,993,989,992,994,995,1129,1131,1184,2083,2087,2089,2096,2221,2252,2376,2381,2478,2479,2482,2484,2679,2762,3077,3078,3183,3191,3220,3269,3306,3410,3424,3471,3496,3509,3529,3539,3535,3660,36611,3713,3747,3766,3864,3885,3995,3896,4031,4036,4062,4064,4081,4083,4116,4335,4336,4536,4590,4740,4843,4849,5443,5007,5061,5321,5349,5671,5783,5868,5986,5989,5990,6209,6251,6443,6513,6514,6619,6697,6771,7202,7443,7673,7674,7677,7775,8243,8443,8991,8989,9089,9295,9318,9443,9444,9614,9802,10161,10162,11751,12013,12109,14143,15002,16995,41230,16993,20003"
INSCOPE=false # Uses inscope tool to filter the scope, requires .scope file in reconftw folder

# Web detection
WEBPROBEFULL=true # Unified web probing over configured ports
WEBSCREENSHOT=true # Webs screenshooting
VIRTUALHOSTS=false # Check virtualhosts by fuzzing HOST header
UNCOMMON_PORTS_WEB="81,300,591,593,832,981,1010,1311,1099,2082,2095,2096,2480,3000,3001,3002,3003,3128,3333,4243,4567,4711,4712,4993,5000,5104,5108,5280,5281,5601,5800,6543,7000,7001,7396,7474,8000,8001,8008,8014,8042,8060,8069,8080,8081,8083,8088,8090,8091,8095,8118,8123,8172,8181,8222,8243,8280,8281,8333,8337,8443,8500,8834,8880,8888,8983,9000,9001,9043,9060,9080,9090,9091,9092,9200,9443,9502,9800,9981,10000,10250,11371,12443,15672,16080,17778,18091,18092,20720,32000,55440,55672"
WEBPROBE_PORTS="80,443,${UNCOMMON_PORTS_WEB}" # Ports used by webprobe_full

# Host
FAVIRECON=true # Favicon-based technology recon for discovered web targets
PORTSCANNER=true # Enable or disable the whole Port scanner module
GEO_INFO=true # Fetch Geolocalization info
PORTSCAN_PASSIVE=true # Port scanner with Shodan
PORTSCAN_ACTIVE=true # Port scanner with nmap
PORTSCAN_ACTIVE_OPTIONS="--top-ports 200 -sV -n -Pn --open --max-retries 2"
PORTSCAN_DEEP_OPTIONS="--top-ports 1000 -sV -n -Pn --open --max-retries 2 --script vulners"
PORTSCAN_STRATEGY=legacy # legacy|naabu_nmap
NAABU_ENABLE=true
NAABU_RATE=1000
NAABU_PORTS="--top-ports 1000"
SERVICE_FINGERPRINT=true # Fingerprint exposed services with nerva
SERVICE_FINGERPRINT_ENGINE="nerva" # nerva
SERVICE_FINGERPRINT_TIMEOUT_MS=2000 # nerva timeout per target (ms)
PORTSCAN_UDP=false
PORTSCAN_UDP_OPTIONS="--top-ports 20 -sU -sV -n -Pn --open"
CDN_IP=true # Check which IPs belongs to CDN
CDN_BYPASS=true # Try origin IP discovery on CDN-fronted hosts with hakoriginfinder

# Web analysis
WAF_DETECTION=true # Detect WAFs
NUCLEICHECK=true # Enable or disable nuclei
NUCLEI_TEMPLATES_PATH="$HOME/nuclei-templates" # Set nuclei templates path
NUCLEI_SEVERITY="info,low,medium,high,critical" # Set templates criticity
NUCLEI_EXTRA_ARGS="" # Additional nuclei extra flags, don't set the severity here but the exclusions like " -etags openssh"
#NUCLEI_EXTRA_ARGS="-etags openssh,ssl -eid node-express-dev-env,keycloak-xss,CVE-2023-24044,CVE-2021-20323,header-sql,header-reflection" # Additional nuclei extra flags, don't set the severity here but the exclusions like " -etags openssh"
NUCLEI_DAST=true # Run additional nuclei -dast module over webs/urls/gf candidates (forced on when VULNS_GENERAL=true, e.g. -a)
URL_CHECK=true # Enable or disable URL collection
URL_CHECK_PASSIVE=true # Search for urls, passive methods from Archive, OTX, CommonCrawl, etc
URL_CHECK_ACTIVE=true # Search for urls by crawling the websites
WAYMORE_TIMEOUT=30m # Timeout for waymore passive URL collection
WAYMORE_LIMIT=5000 # Optional URL collection limit for waymore
URL_GF=true # Url patterns classification
URL_EXT=true # Returns a list of files divided by extension
JSCHECKS=true # JS analysis
FUZZ=true # Web fuzzing
FUZZ_RECURSION_DEPTH=2 # ffuf recursion depth used in DEEP mode
IIS_SHORTNAME=true
CMS_SCANNER=true # CMS scanner
WORDLIST=true # Wordlist generation
ROBOTSWORDLIST=true # Check historic disallow entries on waybackMachine (DEEP mode only)
PASSWORD_DICT=true # Generate password dictionary
PASSWORD_DICT_ENGINE=cewler # cewler|pydictor
PASSWORD_MIN_LENGTH=5 # Min password length
PASSWORD_MAX_LENGTH=14 # Max password length
KATANA_HEADLESS_PROFILE=off # off|smart|full
CLOUD_ENUM_S3_PROFILE=optimized # optimized: quickscan (-qs + safe -m/-b paths) | exhaustive: -m/-b ${tools}/cloud_enum/enum_tools/fuzz.txt (missing fuzz => optimized)
CLOUD_ENUM_S3_THREADS=20 # Threads used by cloud_enum in s3buckets/cloud enumeration

# Vulns
VULNS_GENERAL=false # Enable or disable the vulnerability module (very intrusive and slow)
XSS=true # Check for xss with dalfox
TEST_SSL=true # SSL misconfigs
SSRF_CHECKS=true # SSRF checks
CRLF_CHECKS=true # CRLF checks
LFI=true # LFI by fuzzing
LFI_MAX_URLS=150 # Max single-parameter LFI candidates to test per target (0 = unlimited)
SSTI=true # SSTI by fuzzing
SSTI_ENGINE="TInjA" # SSTI engine
SQLI=true # Check SQLI
SQLMAP=true # Check SQLI with sqlmap
GHAURI=false # Check SQLI with ghauri
BROKENLINKS=true # Check for brokenlinks
BROKENLINKS_ENGINE="second-order" # Broken links engine
SPRAY=true # Performs password spraying
SPRAY_ENGINE="brutespray" # brutespray|brutus
SPRAY_BRUTUS_ONLY_DEEP=true # Run brutus only in DEEP mode unless disabled
BRUTUS_USERNAMES="" # Optional comma-separated usernames for brutus
BRUTUS_PASSWORDS="" # Optional comma-separated passwords for brutus
BRUTUS_KEY_FILE="" # Optional SSH private key path for brutus
COMM_INJ=true # Check for command injections with commix
SMUGGLING=true # Check for HTTP request smuggling flaws
WEBCACHE=true # Check for Web Cache issues
WEBCACHE_TOXICACHE=true # Complement web cache checks with toxicache
BYPASSER4XX=true # Check for 4XX bypasses
FUZZPARAMS=true # Fuzz parameters values

# Extra features
NOTIFICATION=false # Notification for every function
SOFT_NOTIFICATION=false # Only for start/end
DEEP=false # DEEP mode, really slow and don't care about the number of results
DEEP_LIMIT=500 # First limit to not run unless you run DEEP
DEEP_LIMIT2=1500 # Second limit to not run unless you run DEEP
DIFF=false # Diff function, run every module over an already scanned target, printing only new findings (but save everything)
REMOVETMP=false # Delete temporary files after execution (to free up space)
REMOVELOG=false # Delete logs after execution
PROXY=false # Send to proxy the websites found
SENDZIPNOTIFY=false # Send to zip the results (over notify)
PRESERVE=true      # set to true to avoid deleting the .called_fn files on really large scans
FFUF_FLAGS=" -mc all -fc 404 -sf -noninteractive -of json" # Ffuf flags

# HTTP options
HEADER="User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:72.0) Gecko/20100101 Firefox/72.0" # Default header

# Threads (auto-scaled based on CPU cores, override to set fixed values)
AVAILABLE_CORES=$(nproc 2>/dev/null || sysctl -n hw.ncpu 2>/dev/null || echo 4)
FFUF_THREADS=$((AVAILABLE_CORES * 10))
HTTPX_THREADS=$((AVAILABLE_CORES * 12))
HTTPX_UNCOMMONPORTS_THREADS=$((AVAILABLE_CORES * 25))
KATANA_THREADS=$((AVAILABLE_CORES * 5))
BRUTESPRAY_CONCURRENCE=$((AVAILABLE_CORES * 2))
DNSTAKE_THREADS=$((AVAILABLE_CORES * 25))
DALFOX_THREADS=$((AVAILABLE_CORES * 50))
DNS_RESOLVER=auto # auto|puredns|dnsx (auto: detects NAT/CGNAT → dnsx for home, puredns for VPS)
PUREDNS_PUBLIC_LIMIT=0 # Set between 2000 - 10000 if your router blows up, 0 means unlimited
PUREDNS_TRUSTED_LIMIT=400
PUREDNS_WILDCARDTEST_LIMIT=30
PUREDNS_WILDCARDBATCH_LIMIT=1500000
DNSX_THREADS=25 # Threads for dnsx when behind NAT (safe for home routers)
DNSX_RATE_LIMIT=100 # QPS for dnsx
DNSVALIDATOR_THREADS=200
INTERLACE_THREADS=10
LFI_INTERLACE_THREADS=4 # Dedicated interlace concurrency for LFI
TLSX_THREADS=1000
XNLINKFINDER_DEPTH=3

# Rate limits
HTTPX_RATELIMIT=150
NUCLEI_RATELIMIT=150
FFUF_RATELIMIT=0
LFI_FFUF_THREADS=20 # Dedicated ffuf threads for LFI
LFI_FFUF_RATELIMIT=50 # Dedicated ffuf rate limit for LFI

# Timeouts
SUBFINDER_ENUM_TIMEOUT=180          # Minutes
CMSSCAN_TIMEOUT=3600            # Seconds
FFUF_MAXTIME=900                # Seconds
LFI_INTERLACE_TIMEOUT=180       # Seconds per LFI interlace worker
LFI_FFUF_TIMEOUT=10             # Seconds per LFI HTTP request
LFI_FFUF_MAXTIME=90             # Seconds per single LFI ffuf job
LFI_FOLLOW_REDIRECTS=false      # Follow redirects during LFI fuzzing
HTTPX_TIMEOUT=10                # Seconds
HTTPX_UNCOMMONPORTS_TIMEOUT=10  # Seconds
PERMUTATIONS_LIMIT=21474836480  # Bytes, default is 20 GB
DNS_BRUTE_TIMEOUT=0             # timeout/gtimeout duration for DNS bruteforce (0 disables hard-timeout, e.g. 4h)
DNS_RESOLVE_TIMEOUT=0           # timeout/gtimeout duration for DNS resolve (0 disables hard-timeout, e.g. 6h)
DNS_HEARTBEAT_INTERVAL_SECONDS=20 # Progress heartbeat interval for long DNS jobs

# lists
fuzz_wordlist=${WORDLISTS_DIR}/fuzz_wordlist.txt
lfi_wordlist=${WORDLISTS_DIR}/lfi_wordlist.txt
ssti_wordlist=${WORDLISTS_DIR}/ssti_wordlist.txt
subs_wordlist=${WORDLISTS_DIR}/subdomains.txt
subs_wordlist_big=${tools}/subdomains_n0kovo_big.txt
headers_inject=${WORDLISTS_DIR}/headers_inject.txt
resolvers=${tools}/resolvers.txt
resolvers_trusted=${tools}/resolvers_trusted.txt

# Ax Fleet (formerly Axiom — uses attacksurge/ax)
# Resolver paths on Ax instances (change if your fleet uses a different home dir)
AXIOM_RESOLVERS_PATH="/home/op/lists/resolvers.txt"
AXIOM_RESOLVERS_TRUSTED_PATH="/home/op/lists/resolvers_trusted.txt"
# Will not start a new fleet if one exist w/ same name and size (or larger)
# AXIOM=false Uncomment only to overwrite command line flags
AXIOM_FLEET_LAUNCH=true # Enable or disable spin up a new fleet, if false it will use the current fleet with the AXIOM_FLEET_NAME prefix
AXIOM_FLEET_NAME="reconFTW" # Fleet's prefix name
AXIOM_FLEET_COUNT=10 # Fleet's number
AXIOM_FLEET_REGIONS="eu-central" # Fleet's region
AXIOM_FLEET_SHUTDOWN=true # # Enable or disable delete the fleet after the execution
AXIOM_AUTO_FIX_HOSTKEY=true # Auto-repair known_hosts entries on SSH host-key mismatch before fallback to local mode
# This is a script on your reconftw host that might prep things your way...
#AXIOM_POST_START="~/Tools/axiom_config.sh" # Useful  to send your config files to the fleet
AXIOM_EXTRA_ARGS="" # Leave empty if you don't want to add extra arguments
#AXIOM_EXTRA_ARGS=" --rm-logs" # Example

# Faraday-Server
FARADAY=false # Enable or disable Faraday integration
FARADAY_WORKSPACE="reconftw" # Faraday workspace

# AI
AI_EXECUTABLE="python3" # Python executable fallback if reconftw_ai venv python is not available
AI_MODEL="llama3:8b" # Model to use
AI_REPORT_TYPE="md" # Report type to use (md, txt)
AI_REPORT_PROFILE="bughunter" # Report profile to use (executive, brief, or bughunter)
AI_PROMPTS_FILE="" # Optional custom prompts file (empty uses reconftw_ai default)
AI_MAX_CHARS_PER_FILE=50000 # Max chars loaded per file before truncation
AI_MAX_FILES_PER_CATEGORY=200 # Max files loaded per category for AI context
AI_REDACT=true # Redact sensitive indicators before AI analysis
AI_ALLOW_MODEL_PULL=false # Allow reconftw_ai to auto-pull missing model
AI_STRICT=false # Fail AI analysis if one or more categories have no data

# API & Advanced Web Checks
GRAPHQL_CHECK=true # Detect GraphQL endpoints and introspection
GQLSPECTION=false # Run GQLSpection deep introspection on detected GraphQL endpoints (heavier)
PARAM_DISCOVERY=true # Parameter discovery with arjun
GRPC_SCAN=false # Attempt basic gRPC reflection on common ports
LLM_PROBE=false # Probe discovered web/API endpoints for LLM services with julius
LLM_PROBE_AUGUSTUS=false # Include augustus generator config in julius output

# IPv6
IPV6_SCAN=true # Attempt IPv6 discovery/portscan where addresses exist

# Wordlists / threads for new modules
ARJUN_THREADS=10

# Data & Automation
ASSET_STORE=true # Append assets/findings to assets.jsonl
EXPORT_FORMAT="" # Optional exporter at end of scan: json|html|csv|all
REPORT_ONLY=false # Rebuild report artifacts from existing results (or use --report-only)
QUICK_RESCAN=false # Skip heavy steps if no new subdomains/webs
CHUNK_LIMIT=2000 # Split very large lists into chunks (urls, webs)
HOTLIST_TOP=50 # Number of top risky assets to highlight

# Performance
RESOLVER_IQ=false # Prefer fast/healthy resolvers (experimental)
PERF_PROFILE="balanced" # low|balanced|max

# Estimated durations for skipped heavy modules (seconds)
TIME_EST_NUCLEI=600
TIME_EST_FUZZ=900
TIME_EST_URLCHECKS=300
TIME_EST_JSCHECKS=300
TIME_EST_API=300
TIME_EST_GQL=180
TIME_EST_PARAM=240
TIME_EST_GRPC=120
TIME_EST_IIS=60

# TERM COLORS
bred='\033[1;31m'
bblue='\033[1;34m'
bgreen='\033[1;32m'
byellow='\033[1;33m'
red='\033[0;31m'
blue='\033[0;34m'
green='\033[0;32m'
cyan='\033[0;36m'
yellow='\033[0;33m'
reset='\033[0m'

Protecciones del resolver DNS:

  • Los archivos de resolver faltantes o vacíos ahora fallan rápidamente antes de que comience el brute/resolve de DNS.
  • Las descargas de resolvers son configurables con RESOLVER_DOWNLOAD_CONNECT_TIMEOUT, RESOLVER_DOWNLOAD_MAX_TIME, RESOLVER_DOWNLOAD_RETRY y RESOLVER_DOWNLOAD_RETRY_DELAY.
  • DNS_BRUTE_TIMEOUT=0 y DNS_RESOLVE_TIMEOUT=0 deshabilitan el tiempo de espera estricto por defecto (recomendado para conjuntos de objetivos muy grandes). El progreso del heartbeat aún se imprime cada DNS_HEARTBEAT_INTERVAL_SECONDS.```bash DNS_BRUTE_TIMEOUT=4h DNS_RESOLVE_TIMEOUT=6h DNS_HEARTBEAT_INTERVAL_SECONDS=20
root@kitploit:~
**Detalles completos**: Consulta la [Guía de configuración](https://github.com/six2dez/reconftw/wiki/3.-Configuration-file).

---

## 🚀 Uso

reconFTW admite múltiples modos y opciones para un reconocimiento flexible. Usa la bandera `-h` para ver el menú de ayuda.

### Opciones de objetivo

| Bandera | Descripción                                                  |
| ---- | ------------------------------------------------------------ |
| `-d` | Dominio objetivo único (p. ej., `example.com`)               |
| `-l` | Archivo con lista de dominios objetivo (uno por línea)       |
| `-m` | Objetivo multidominio (p. ej., nombre de empresa para dominios relacionados) |
| `-x` | Excluir subdominios (lista fuera de alcance)                 |
| `-i` | Incluir subdominios (lista dentro de alcance)                |

### Opciones de modo

| Bandera | Descripción                                                           |
| ---- | --------------------------------------------------------------------- |
| `-r` | **Recon**: Reconocimiento completo sin ataques activos                |
| `-s` | **Subdominios**: Enumeración de subdominios, sondeo web y toma de control |
| `-p` | **Pasivo**: Solo reconocimiento pasivo                                |
| `-a` | **Todo**: Reconocimiento completo más comprobaciones activas de vulnerabilidades |
| `-w` | **Web**: Comprobaciones de vulnerabilidades en objetivos web específicos |
| `-n` | **OSINT**: Escaneo OSINT sin enumeración de subdominios ni ataques    |
| `-z` | **Zen**: Reconocimiento ligero con comprobaciones básicas y algunas vulnerabilidades |
| `-c` | **Personalizado**: Ejecutar una función específica (requiere argumentos adicionales) |
| `-h` | Mostrar menú de ayuda                                                |

### Opciones generales

| Bandera              | Descripción                                              |
| ----------------- | -------------------------------------------------------- |
| `--deep`          | Habilitar escaneo profundo (más lento, se recomienda VPS) |
| `-f`              | Ruta de archivo de configuración personalizado           |
| `-o`              | Directorio de salida para los resultados                 |
| `-v`              | Habilitar escaneo distribuido Ax                         |
| `--vps-count`     | Anular el recuento de instancias de la flota Ax para esta ejecución |
| `-q`              | Establecer límite de velocidad (peticiones por segundo)  |
| `-y`              | Habilita el análisis de resultados con IA                |
| `--check-tools`   | Salir si faltan herramientas requeridas                  |
| `--quick-rescan`  | Omitir módulos pesados cuando no se encuentran nuevos subs/webs |
| `--health-check`  | Ejecutar comprobación de salud del sistema y salir       |
| `--incremental`   | Escanear solo hallazgos nuevos desde la última ejecución |
| `--adaptive-rate` | Ajustar automáticamente los límites de velocidad en errores (429/503) |
| `--dry-run`       | Mostrar lo que se ejecutaría sin ejecutar comandos       |
| `--parallel`      | Ejecutar funciones independientes en paralelo (más rápido, más RAM) |
| `--no-parallel`   | Forzar ejecución secuencial incluso si el paralelo está habilitado |
| `--monitor`       | Modo de monitoreo continuo (objetivo único; `-w` admite `-l`) |
| `--monitor-interval` | Minutos entre ciclos de monitoreo                    |
| `--monitor-cycles`   | Detenerse después de N ciclos (0 = infinito)          |
| `--report-only`   | Reconstruir artefactos de informe sin escanear           |
| `--refresh-cache` | Forzar actualización de resolvers/wordlists en caché     |
| `--export`        | Exportar artefactos: `json`, `html`, `csv` o `all`       |

### Ejemplo de uso

1. **Reconocimiento completo en un objetivo único**:   ```bash
   ./reconftw.sh -d target.com -r
  1. Reconocimiento en Múltiples Objetivos: ```bash ./reconftw.sh -l targets.txt -r -o /path/to/output/
    root@kitploit:~
  2. Reconocimiento Profundo (VPS Recomendado): ```bash ./reconftw.sh -d target.com -r --deep
    root@kitploit:~
  3. Modo paralelo (más rápido, requiere más RAM): ```bash ./reconftw.sh -d target.com -r --parallel
    root@kitploit:~
  4. Forzar modo secuencial: ```bash ./reconftw.sh -d target.com -r --no-parallel
    root@kitploit:~
  5. Reconocimiento Multi-Dominio: ```bash ./reconftw.sh -m company -l domains.txt -r
    root@kitploit:~
  6. Integración con Ax: ```bash ./reconftw.sh -d target.com -r -v
    root@kitploit:~
  7. Integración de Ax con anulación de flota: ```bash ./reconftw.sh -d target.com -r -v 30
    root@kitploit:~
  8. Reconocimiento completo con ataques (modo YOLO): ```bash ./reconftw.sh -d target.com -a
    root@kitploit:~
  9. Mostrar Ayuda: ```bash ./reconftw.sh -h
root@kitploit:~
11. **Forzar la actualización de caché**:   ```bash
./reconftw.sh -d target.com -r --refresh-cache
  1. Exportar todos los artefactos del informe: ```bash ./reconftw.sh -d target.com -r --export all
root@kitploit:~
13. **Monitoreo continuo (cada 30 minutos, 48 ciclos)**:   ```bash
./reconftw.sh -d target.com -r --monitor --monitor-interval 30 --monitor-cycles 48
  1. Reconstruir informes únicamente (sin escaneo): ```bash ./reconftw.sh -d target.com --report-only --export all
root@kitploit:~
**Guía completa**: Consulta la [Guía de uso](https://github.com/six2dez/reconftw/wiki/2.-Usage-Guide).

---

## ☁️ Soporte del framework Ax (anteriormente Axiom)

reconFTW se integra con [Ax](https://github.com/attacksurge/ax) para el escaneo distribuido, reduciendo el tiempo de ejecución al distribuir las tareas entre múltiples instancias en la nube.

- **Configuración**: Selecciona `reconftw` como provisionador durante la configuración de Ax (`axiom-configure`).
- **Gestión de flotas**: Crea y destruye flotas automáticamente (`AXIOM_FLEET_LAUNCH`, `AXIOM_FLEET_SHUTDOWN`) o utiliza una flota existente.
- **Configuración**: Establece el tamaño de la flota, la región y el nombre en `reconftw.cfg` (`AXIOM_FLEET_COUNT`, `AXIOM_FLEET_REGIONS`, `AXIOM_FLEET_NAME`).

**Ejemplo**:```bash
./reconftw.sh -d target.com -r -v

Detalles: Consulta la documentación oficial de Ax y el repositorio attacksurge/ax.


💻 Soporte de Faraday

reconFTW se integra con Faraday para la generación de informes basados en web y la gestión de vulnerabilidades.

  • Configuración: Instala Faraday, autentícate mediante faraday-cli y configura el workspace en reconftw.cfg (FARADAY_WORKSPACE).
  • Uso: Actívalo con FARADAY=true en reconftw.cfg.

🧠 Integración de IA

reconFTW utiliza IA para generar informes detallados a partir de los resultados de los escaneos con la herramienta reconftw_ai.

  • Modelo: Modelo de IA configurable (p. ej., llama3:8b mediante AI_MODEL).
  • Tipos de informe: Markdown o texto plano (AI_REPORT_TYPE).
  • Perfiles: Ejecutivo, breve o cazador de bugs (AI_REPORT_PROFILE).
  • Salida estructurada: reconftw almacena un informe legible por máquina en ai_result/reconftw_analysis.json.
  • Controles de contexto: Limita el tamaño de entrada con AI_MAX_CHARS_PER_FILE y AI_MAX_FILES_PER_CATEGORY.
  • Controles de seguridad: Alterna la redacción y el modo estricto con AI_REDACT y AI_STRICT.

Ejemplo:```yaml AI_EXECUTABLE="python3" AI_MODEL="llama3:8b" AI_REPORT_TYPE="md" AI_REPORT_PROFILE="bughunter" AI_MAX_CHARS_PER_FILE=50000 AI_MAX_FILES_PER_CATEGORY=200 AI_REDACT=true AI_ALLOW_MODEL_PULL=false AI_STRICT=false

root@kitploit:~
---

## 🗂️ Gestión de Datos

Gestiona los datos de escaneo y las claves API de forma segura utilizando un repositorio privado.

Cuando `ASSET_STORE=true`, reconFTW agrega los hallazgos clave en `assets.jsonl` durante cada ejecución, lo que facilita sincronizar solo los deltas accionables con tu repositorio privado.

### Makefile

Utiliza el `Makefile` proporcionado para una gestión sencilla del repositorio (requiere [GitHub CLI](https://cli.github.com/)).

1. **Bootstrap**:   ```bash
   export PRIV_REPO="$HOME/reconftw-data"
   make bootstrap
  1. Sincronizar con el upstream: ```bash make sync
    root@kitploit:~
  2. Subir Datos: ```bash make upload
    root@kitploit:~
  3. Scripts de Lint / Formato: ```bash make lint # shellcheck for reconftw.sh, modules/*.sh & install.sh make fmt # shfmt with project defaults
    root@kitploit:~
  4. Ejecutar pruebas: ```bash make test # unit tests (bats-core) make test-all # unit + integration tests
    root@kitploit:~

Manual

  1. Crea un repositorio privado en GitHub/GitLab.
  2. Clona y configura: ```bash git clone https://github.com/yourusername/reconftw-data cd reconftw-data git commit --allow-empty -m "Initial commit" git remote add upstream https://github.com/six2dez/reconftw git fetch upstream git rebase upstream/main master
    root@kitploit:~
  3. Subir los cambios: ```bash git add . git commit -m "Data upload" git push origin master
    root@kitploit:~
  4. Actualizar herramienta: ```bash git fetch upstream git rebase upstream/main master
    root@kitploit:~

🧪 Pruebas

reconFTW utiliza bats-core para pruebas automatizadas.

Instalar bats-core```bash

macOS

brew install bats-core

Debian/Ubuntu

apt install bats

From source

git clone https://github.com/bats-core/bats-core.git /tmp/bats sudo /tmp/bats/install.sh /usr/local

root@kitploit:~
### Ejecutar Pruebas```bash
# Unit tests only
make test

# Unit + integration tests
make test-all

# Via the runner script
./tests/run_tests.sh         # unit only
./tests/run_tests.sh --all   # unit + integration

Estructura del Directorio de Pruebas```

tests/ ├── run_tests.sh # Test runner script ├── unit/ # Unit tests (fast, no network) │ ├── test_sanitize.bats │ ├── test_utils.bats │ └── test_validation.bats ├── integration/ # Integration tests (require installed tools) │ └── test_smoke.bats ├── security/ # Security tests (injection, etc.) │ └── test_injection.bats ├── mocks/ # Mock tools for offline testing └── fixtures/ # Shared test data files

root@kitploit:~
### Ejecución de Pruebas de Seguridad```bash
# Test command injection prevention
make test-security

# Or directly
bats tests/security/

Escritura de Pruebas

Las pruebas utilizan el patrón --source-only para cargar funciones sin ejecutar el script principal:```bash #!/usr/bin/env bats

setup() { source ./reconftw.sh --source-only }

@test "sanitize_domain strips invalid chars" { result="$(sanitize_domain 'exam;ple.com')" [ "$result" = "example.com" ] }

root@kitploit:~
### Canal de CI

El flujo de trabajo de GitHub Actions (`.github/workflows/tests.yml`) se ejecuta en cada push y pull request:

1. **ShellCheck** — revisa `reconftw.sh`, `modules/*.sh` e `install.sh`
2. **Pruebas unitarias** — ejecuta todos los archivos `tests/unit/*.bats`
3. **Pruebas de integración** — instala reconFTW y valida la disponibilidad de las herramientas

---

## Mapa mental/Flujo de trabajo

![Mindmap](https://assets.kitploit.com/production/public/readmes/670/935e9af062e82113e5ca06f4b13e80f243430684e8ece2643e868f3d2afa1403.png)

---

## Video de muestra

![Video](https://raw.githubusercontent.com/six2dez/reconftw/HEAD/images/reconFTW.gif)

---

## 🤝 Cómo contribuir

Consulta [CONTRIBUTING.md](https://github.com/six2dez/reconftw/blob/main/CONTRIBUTING.md) para obtener la guía completa de contribución, incluida la configuración de desarrollo, el estilo de código, las pruebas y el proceso de pull request.

Enlaces rápidos:

- [Reportar un error](https://github.com/six2dez/reconftw/issues/new/choose)
- [Enviar un pull request](https://github.com/six2dez/reconftw/tree/dev) (dirigido a la rama `dev`)
- [Código de conducta](https://github.com/six2dez/reconftw/blob/main/CODE_OF_CONDUCT.md)

---

## 🔒 Seguridad

Para la política de seguridad, gestión de secretos y reporte de vulnerabilidades, consulta [SECURITY.md](https://github.com/six2dez/reconftw/blob/main/SECURITY.md).

---

## ❓ ¿Necesitas ayuda?

- **Wiki**: Explora la [Wiki de reconFTW](https://github.com/six2dez/reconftw/wiki).
- **FAQ**: Consulta las [Preguntas frecuentes](https://github.com/six2dez/reconftw/wiki/7.-FAQs).
- **Comunidad**: Únete al [servidor de Discord](https://discord.gg/R5DdXVEdTy) o al [grupo de Telegram](https://t.me/joinchat/TO_R8NYFhhbmI5co).

---

## 💖 Apoya este proyecto

Apoya el desarrollo de reconFTW mediante:

- **Buy Me a Coffee**: [buymeacoffee.com/six2dez](https://www.buymeacoffee.com/six2dez)

[<img src="https://assets.kitploit.com/production/public/readmes/670/1177bf77de4c288d45b816dd405a8b5027116f0b1893449986cf200c765707ad.webp">](https://www.buymeacoffee.com/six2dez)

- **Referido de DigitalOcean**: [Enlace de referido](https://www.digitalocean.com/?refcode=f362a6e193a1&utm_campaign=Referral_Invite&utm_medium=Referral_Program&utm_source=badge)

<a href="https://www.digitalocean.com/?refcode=f362a6e193a1&utm_campaign=Referral_Invite&utm_medium=Referral_Program&utm_source=badge"><img src="https://web-platforms.sfo2.cdn.digitaloceanspaces.com/WWW/Badge%201.svg" alt="DigitalOcean Referral Badge" /></a>

- **Patrocinio en GitHub**: [github.com/sponsors/six2dez](https://github.com/sponsors/six2dez)

---

## 🙏 Agradecimientos

Un agradecimiento especial a los siguientes servicios por apoyar a reconFTW:

- [C99](https://api.c99.nl/)
- [CIRCL](https://www.circl.lu/)
- [NetworksDB](https://networksdb.io/)
- [ipinfo](https://ipinfo.io/)
- [hackertarget](https://hackertarget.com/)
- [Censys](https://censys.io/)
- [Fofa](https://fofa.info/)
- [intelx](https://intelx.io/)
- [Whoxy](https://www.whoxy.com/)

---

## 📝 Registro de cambios

Consulta [CHANGELOG.md](https://github.com/six2dez/reconftw/blob/main/CHANGELOG.md) para obtener una lista detallada de los cambios en cada versión.

---

## 🛠️ Desarrollo

### Estructura del proyecto```
reconftw/
├── reconftw.sh          # Main entry point (~500 lines)
├── reconftw.cfg         # Configuration file
├── modules/             # Phase modules
│   ├── utils.sh         # Utilities, sanitization, caching, circuit breaker
│   ├── core.sh          # Framework core, logging, lifecycle, health check
│   ├── modes.sh         # Scan modes, argument parsing
│   ├── subdomains.sh    # Subdomain enumeration
│   ├── web.sh           # Web analysis, nuclei scans
│   ├── vulns.sh         # Vulnerability scanning
│   ├── osint.sh         # OSINT functions
│   └── axiom.sh         # Ax/Axiom fleet helpers
├── lib/                 # Pure utility libraries
│   └── validation.sh    # Input validation functions
├── tests/               # Test suite (100+ tests)
│   ├── unit/            # Unit tests (bats)
│   ├── integration/     # Integration/smoke tests
│   └── security/        # Injection prevention tests
├── docs/                # Documentation
│   └── ARCHITECTURE.md  # Detailed architecture guide
└── secrets.cfg.example  # Template for API keys

Ejecutando Pruebas```bash

make test # Unit tests make test-security # Security tests make test-all # All tests make lint # Shellcheck make lint-fix # Auto-fix with shfmt

root@kitploit:~
### Flujo de trabajo de desarrollo```bash
# 1. Source without executing (for testing)
source ./reconftw.sh --source-only

# 2. Test individual functions
sanitize_domain "test;domain.com"

# 3. Run health check
./reconftw.sh --health-check

# 4. Dry run to preview
./reconftw.sh -d example.com -r --dry-run

Contributing

Consulta CONTRIBUTING.md para las pautas de desarrollo y docs/ARCHITECTURE.md para los detalles técnicos.


📜 Licencia

reconFTW está licenciado bajo la Licencia MIT.


⭐ Historial de Estrellas

Star History Chart

Descargar herramienta
  • Enumeración de Almacenamiento en la Nube: Inspecciona buckets de los principales proveedores en busca de exposición (cloud_enum).
  • Dominios Suplantables: Comprueba dominios vulnerables a la suplantación (spoofcheck).
  • Toma de Control de Subdominios: Detecta subdominios vulnerables (nuclei y dnstake).
  • Transferencia de Zona DNS: Comprueba transferencias de zona DNS mal configuradas (dig).
  • Buckets en la Nube: Identifica buckets en la nube mal configurados y activos de almacenamiento expuestos (S3Scanner y cloud_enum).
  • Nota sobre Cobertura en la Nube: Las comprobaciones de buckets en la nube ya no incluyen cobertura de Alibaba OSS tras reemplazar CloudHunter por cloud_enum.
  • Migración de Salida en la Nube: Los artefactos heredados de buckets cloudhunter_* se eliminaron; usa subdomains/cloud_enum_buckets_trufflehog.txt en su lugar.
  • Búsqueda Inversa de IP: Descubre subdominios mediante rangos de IP (hakip2host).
  • Detección de GraphQL: Descubre endpoints de GraphQL con nuclei y opcionalmente realiza introspección en profundidad (GQLSpection).
  • Descubrimiento de Parámetros: Fuerza bruta de parámetros ocultos en endpoints (arjun).
  • Auditoría de WebSockets: Valida handshakes de actualización y manejo de origen en endpoints ws:// y wss://.
  • Reflexión gRPC: Sondea puertos gRPC comunes en busca de reflexión de servicios expuesta (grpcurl).
  • Huella de Servicios LLM (Opcional): Sondea endpoints web/API descubiertos en busca de servicios LLM expuestos con julius.
  • Fuzzing: Realiza fuzzing de directorios y parámetros (ffuf).
  • Clasificación por Extensiones de Archivo: Organiza URLs por extensiones de archivo.
  • Generación de Listas de Palabras: Crea listas de palabras personalizadas para fuzzing.
  • Diccionario de Contraseñas: Genera diccionarios de contraseñas a partir de contenido en vivo (cewler).
  • Escaneo de Nombres Cortos IIS: Detecta vulnerabilidades de nombres cortos IIS (shortscan).
  • toxicache
  • Bypass de 4XX: Intenta eludir respuestas 4XX (nomore403).
  • Fuzzing de Parámetros: Fuzzea parámetros de URL en busca de vulnerabilidades (nuclei).
  • Almacén de activos: Añade hallazgos a assets.jsonl para automatización posterior cuando ASSET_STORE está habilitado.
  • Informe consolidado: Genera automáticamente report/report.json y report/index.html al final del escaneo.
  • Soporte ARM: Compatible con Raspberry Pi y arquitecturas ARM (incluido MacOS MX).
  • Verificación de salud: Verificación de salud del sistema integrada mediante --health-check (también usada por Docker HEALTHCHECK).
  • Modo incremental: Solo escanea nuevos hallazgos desde la última ejecución (--incremental).
  • Limitación de velocidad adaptativa: Retrocede automáticamente ante errores 429/503 (--adaptive-rate).
  • Registro estructurado: Salida de registro JSON opcional para análisis avanzado (STRUCTURED_LOGGING).
  • Saneamiento de entrada: Toda la entrada del usuario se sane para prevenir inyección de comandos.
  • Modo de prueba: Previsualiza lo que se ejecutaría sin ejecutar comandos (--dry-run).
  • Modo paralelo: Ejecuta funciones independientes en paralelo para escaneos más rápidos (--parallel, desactívelo con --no-parallel).
  • Arquitectura modular: El código se divide en 8 módulos enfocados para facilitar el mantenimiento.
  • Gestión de secretos: Variables de entorno, secrets.cfg y secretos de runtime de Docker (consulte SECURITY.md).
  • Interruptor de circuito: Omite automáticamente herramientas tras fallos repetidos para evitar que el escaneo se cuelgue.
  • Sistema de puntos de control: Reanuda escaneos interrumpidos desde la última fase exitosa.
  • Soporte nativo de macOS: Compatibilidad total con macOS (coreutils BSD, Homebrew Bash 4+).