Skip to content
KitploitKITPLOIT
FerramentasBlog
Enviar
FerramentasBlog
Enviar

Ferramentas de Hacking, PenTest e Cibersegurança para o seu Arsenal de Segurança!

Kitploit é um diretório de ferramentas de hacking, cibersegurança e pentesting. Descubra as últimas atualizações de projetos para encontrar vulnerabilidades, analisar sistemas, automatizar testes e fortalecer sua segurança.

··Feeds·Contato·Privacidade·© 2026 Kitploit

Diretório de Ferramentas

Categorias

Ver todas as categorias
Loading categories
reconftw — reconFTW é uma ferramenta projetada para realizar recon automatizado em um domínio alvo, executando o melhor conjunto de ferramentas para realizar varredura e encontrar vulnerabilidades. | Kitploit
Ferramentas/GitHubGitHub/six2dez/reconftw
OSINT (Inteligência de Fontes Abertas)ReconhecimentoScanners de VulnerabilidadesOSINT para Engenharia SocialEscaneamento de PortasEnumeração de DNS e SubdomíniosScripting e AutomaçãoColeta de InformaçõesSegurança WebTestes de PenetraçãoSegurança na NuvemEnumeração de Subdomínios
8.0k1.2k50há 8 diasRevisado pelo Kitploit

Mais Populares

Ver todos →

Descubra as ferramentas mais usadas pela nossa comunidade.

Explore todas as ferramentas

Navegue pela nossa coleção de ferramentas

Ver todas as ferramentas →
Compartilhar
Coleta de Emails
Análise de DNS
Top em Enumeração de DNS e Subdomínios nº17
Top em Coleta de Emails nº20
Top em Coleta de Informações nº6
Top em OSINT (Inteligência de Fontes Abertas) nº20
Top em OSINT para Engenharia Social nº20
Top em Reconhecimento nº3
Top em Scripting e Automação nº1
Top em Enumeração de Subdomínios nº17
GitHubsix2dez/reconftw

reconftw

reconFTW é uma ferramenta projetada para realizar recon automatizado em um domínio alvo, executando o melhor conjunto de ferramentas para realizar varredura e encontrar vulnerabilidades.

Ver RepositórioSite


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 é uma poderosa ferramenta automatizada de reconhecimento projetada para pesquisadores de segurança e testadores de penetração. Ela simplifica o processo de coleta de inteligência sobre um alvo, realizando enumeração de subdomínios, varredura de vulnerabilidades, OSINT e muito mais. Com design modular, opções extensivas de configuração e suporte a varredura distribuída via AX Framework, o reconFTW foi construído para entregar resultados abrangentes de forma eficiente.

O reconFTW aproveita uma ampla gama de técnicas, incluindo descoberta passiva e ativa de subdomínios, verificações de vulnerabilidades web (ex.: XSS, SSRF, SQLi), OSINT, fuzzing de diretórios, varredura de portas e captura de telas. Ele se integra a ferramentas e APIs de ponta para maximizar a cobertura e a precisão, garantindo que você esteja à frente em seus esforços de reconhecimento.

Principais Recursos:

  • Enumeração abrangente de subdomínios (passiva, bruteforce, permutações, transparência de certificados, etc.)
  • Varredura de vulnerabilidades para XSS, SSRF, SQLi, LFI, SSTI e mais
  • OSINT para e-mails, metadados, vazamentos de APIs e configurações incorretas de terceiros
  • Varredura distribuída com AX Framework para execução mais rápida
  • Fluxos de trabalho personalizáveis com um arquivo de configuração detalhado
  • Integração com Faraday para relatórios e visualização
  • Suporte a implantações com Docker, Terraform e Ansible

Aviso Legal: O uso do reconFTW para atacar alvos sem consentimento prévio é ilegal. É responsabilidade do usuário obedecer a todas as leis aplicáveis. Os desenvolvedores não assumem responsabilidade por uso indevido ou danos causados por esta ferramenta. Use com responsabilidade.


📔 Índice

  • 📔 Índice
  • ✨ Recursos
    • OSINT
    • Subdomínios
    • Hosts
    • Análise Web
    • Verificações de Vulnerabilidades
    • Extras
  • 🏗️ Arquitetura
  • 💿 Instalação
    • Instalação Local (PC/VPS/VM)
    • Docker
    • Terraform + Ansible
  • Testando a v2 beta (reescrita em Go)
  • ⚙️ Configuração
  • 🚀 Uso
    • Opções de Alvo
    • Opções de Modo
    • Opções Gerais
    • Exemplo de Uso
  • ☁️ Suporte ao AX Framework (anteriormente Axiom)
  • 💻 Suporte ao Faraday
  • 🧠 Integração com IA
  • 🗂️ Gerenciamento de Dados
    • Makefile
    • Manual
  • 🧪 Testes
  • Mapa Mental/Fluxo de Trabalho
  • Vídeo de exemplo
  • 🤝 Como Contribuir
  • 🔒 Segurança
  • ❓ Precisa de Ajuda?
  • 💖 Apoie Este Projeto
  • 🙏 Agradecimentos
  • 📝 Registro de Alterações
  • 🛠️ Desenvolvimento
  • 📜 Licença
  • ⭐ Histórico de Estrelas

✨ Recursos

O reconFTW está repleto de recursos para tornar o reconhecimento minucioso e eficiente. Abaixo está um detalhamento abrangente de suas capacidades, atualizado para refletir a funcionalidade mais recente no script e na configuração.

OSINT

  • Informações de Domínio: Consulta WHOIS para detalhes de registro de domínio (whois).
  • Vazamentos de E-mail e Senhas: Busca por e-mails e credenciais vazadas (emailfinder e LeakSearch).
  • Mapeamento Microsoft 365/Azure: Identifica tenants do Microsoft 365 e Azure (msftrecon).
  • Extração de Metadados: Extrai metadados de documentos do Office indexados (metagoofil).
  • Vazamentos de API: Detecta APIs expostas em fontes públicas (porch-pirate, SwaggerSpy e postleaksNg).
  • Google Dorking: Consultas automatizadas de Google dork para informações sensíveis (dorks_hunter e xnldorker).
  • Análise do GitHub: Varre organizações do GitHub em busca de repositórios e segredos com mecanismos selecionáveis (enumerepo, trufflehog, gitleaks, titus, noseyparker).
  • Auditoria de GitHub Actions (Opcional): Audita artefatos de fluxos de trabalho e exposição de CI/CD com gato.
  • Configurações Incorretas de Terceiros: Identifica serviços de terceiros mal configurados (misconfig-mapper).
  • Higiene de E-mail: Revisa a configuração de SPF/DMARC para sinalizar problemas de spoofing ou entregabilidade.

Subdomínios

  • Enumeração Passiva: Usa APIs e fontes públicas para descoberta de subdomínios (subfinder e github-subdomains).
  • Transparência de Certificados: Consulta logs de transparência de certificados (crt).
  • Descoberta NOERROR: Identifica subdomínios com respostas DNS NOERROR (dnsx, mais informações aqui).
  • Bruteforce: Realiza bruteforce de DNS com wordlists personalizáveis (puredns e wordlists personalizadas).
  • Permutações: Gera permutações de subdomínios usando IA, regex e ferramentas (Gotator como o único mecanismo de permutação, além de regulator e subwiz).
  • Web Scraping: Extrai subdomínios de fontes passivas de URLs e metadados web ao vivo (urlfinder, waymore, httpx, csprecon).
  • Registros DNS: Resolve registros DNS para subdomínios (dnsx).
  • Google Analytics: Identifica subdomínios via IDs do Analytics (AnalyticsRelationships).
  • Handshake TLS: Descobre subdomínios via portas TLS (tlsx).
  • Busca Recursiva: Realiza enumeração passiva ou bruteforce recursiva combinados (dsieve).
  • Subdomain Takeover: Detecta subdomínios vulneráveis ( e ).

Hosts

  • Informações de IP: Recupera dados de geolocalização e WHOIS (ipinfo).
  • Detecção de CDN: Identifica IPs atrás de CDNs (cdncheck).
  • Detecção de WAF: Detecta Web Application Firewalls (wafw00f).
  • Varredura de Portas: Varredura ativa com nmap (opcionalmente precedida por naabu) e varredura passiva com smap.
  • Fingerprinting de Serviços: Identifica serviços expostos em pares host:porta descobertos com nerva.
  • Vulnerabilidades de Serviços (Opcional): O perfil de varredura de portas profunda pode enriquecer resultados com correspondência de CVEs via vulners.
  • Password Spraying: Tenta password spraying em serviços identificados com seleção de mecanismo (brutespray ou brutus).
  • Geolocalização: Mapeia endereços IP para localizações geográficas (ipinfo).
  • Descoberta IPv6: Opcionalmente enumera e varre alvos IPv6 descobertos quando IPV6_SCAN está habilitado.

Análise Web

  • Sondagem Web: Detecta servidores web ativos em portas padrão e incomuns ((httpx)).
  • Capturas de Tela: Captura capturas de tela de páginas web (nuclei).
  • Fuzzing de Hosts Virtuais: Identifica hosts virtuais por fuzzing de cabeçalhos HTTP (VhostFinder).
  • Detecção de CMS: Identifica sistemas de gerenciamento de conteúdo (CMSeeK).
  • Extração de URLs: Coleta URLs passiva e ativamente (urlfinder, waymore, katana, github-endpoints e JSA).
  • Análise de Padrões de URL: Classifica URLs usando padrões (urless, gf e gf-patterns).
  • Reconhecimento de Tecnologia por Favicon: Identifica tecnologias a partir de hashes de favicons (favirecon).
  • Análise de JavaScript: Extrai segredos e endpoints de arquivos JS (subjs, JSA, xnLinkFinder, getjswords, mantra, jsluice).
  • Extração de Source Maps: Recupera dados sensíveis de source maps de JavaScript (sourcemapper).
  • : Descobre endpoints GraphQL com nuclei e opcionalmente realiza introspecção aprofundada ().

Verificações de Vulnerabilidades

  • CVEs: Verifica CVEs e vulnerabilidades comuns nuclei
  • Nuclei DAST: Executa templates nuclei -dast sobre URLs coletadas e candidatos GF para cobertura adicional de DAST.
  • XSS: Testa vulnerabilidades de cross-site scripting (dalfox).
  • SSL/TLS: Verifica configurações incorretas de SSL/TLS (testssl).
  • SSRF: Testa server-side request forgery (interactsh, valores de parâmetros com ffuf e payloads opcionais de protocolos alternativos).
  • CRLF: Verifica vulnerabilidades de injeção CRLF (crlfuzz).
  • LFI: Testa local file inclusion via fuzzing (ffuf).
  • SSTI: Detecta server-side template injection (TInjA).
  • SQLi: Testa injeção SQL (SQLMap e ghauri).
  • Links Quebrados: Identifica links quebrados e referências externas provavelmente propensas a takeover (second-order).
  • Injeção de Comandos: Testa vulnerabilidades de injeção de comandos (commix).
  • HTTP Request Smuggling: Verifica vulnerabilidades de request smuggling (smugglex).
  • Cache Web: Identifica vulnerabilidades de cache web (Web-Cache-Vulnerability-Scanner e toxicache).

Extras- Multithreading: Otimiza o desempenho (Interlace).

  • Resolvedores Personalizados: Gera resolvedores DNS (dnsvalidator).
  • Suporte a Docker: Imagem Docker oficial no DockerHub.
  • Implantação AWS: Implanta via Terraform e Ansible.
  • Suporte a IP/CIDR: Escaneia faixas de IP e blocos CIDR.
  • Retomada de Escaneamento: Retoma escaneamentos a partir da última etapa concluída.
  • Saída Personalizada: Salva resultados em um diretório definido pelo usuário.
  • Modo Diff: Destaca novas descobertas em escaneamentos subsequentes.
  • Filtragem de Escopo: Suporta listas de escopo incluído e excluído (inscope).
  • Notificações: Envia alertas via Slack, Discord ou Telegram (notify).
  • Compactação de Resultados: Comprime e envia resultados.
  • Integração Faraday: Exporta resultados para Faraday para relatórios.
  • Geração de Relatórios com IA: Gera relatórios usando modelos de IA locais (reconftw_ai).
  • Modo de Reescaneamento Rápido: Ignora etapas pesadas automaticamente quando nenhum novo ativo é descoberto (--quick-rescan / QUICK_RESCAN).
  • Construtor de Hotlist: Pontua e destaca os ativos de maior risco (hotlist.txt) com base em novas descobertas.
  • Rastreamento de Comandos: Ative SHOW_COMMANDS para registrar cada comando executado nos logs de destino para depuração.

🏗️ Arquitetura

O reconFTW usa uma arquitetura modular. O ponto de entrada principal (reconftw.sh) lida com a análise de argumentos e carrega 8 módulos especializados do diretório modules/.

Layout do Diretório```

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:~
### Referência de Módulos

| Módulo | Linhas | Finalidade |
|--------|------:|---------|
| `core.sh` | 1024 | Gerenciamento do ciclo de vida, logging, notificações, traps de limpeza |
| `modes.sh` | 902 | Definições de modos de varredura, análise de argumentos, saída de ajuda |
| `subdomains.sh` | 1938 | Todas as funções de enumeração de subdomínios |
| `web.sh` | 1712 | Análise web, fuzzing, análise de JS, detecção de CMS |
| `vulns.sh` | 926 | Varredura de vulnerabilidades (XSS, SQLi, SSRF, etc.) |
| `osint.sh` | 500 | Funções de OSINT (WHOIS, e-mails, dorks, metadados) |
| `utils.sh` | 508 | Utilitários compartilhados, sanitização de entrada, validação |
| `axiom.sh` | 143 | Gerenciamento de frota distribuída Ax/Axiom |

A flag `--source-only` permite carregar o `reconftw.sh` sem executar a lógica principal, possibilitando testes unitários de funções individuais.

---

## 💿 Instalação

O reconFTW suporta múltiplos métodos de instalação para atender a diferentes ambientes. Certifique-se de ter espaço em disco suficiente (pelo menos 10 GB recomendados) e uma conexão de internet estável.

### Início Rápido

1) Clone e instale```yaml
git clone https://github.com/six2dez/reconftw
cd reconftw
./install.sh --verbose
  1. Execute uma verificação (completa + retomada)```bash ./reconftw.sh -d example.com -r
root@kitploit:~
3) Execução mínima (footprint apenas passivo)```bash
./reconftw.sh -d example.com -p

Dica: execute novamente ./install.sh --tools mais tarde para atualizar o toolchain sem reinstalar pacotes do sistema.

Instalação Local (PC/VPS/VM)

  1. Pré-requisitos:

    • Golang: Versão mais recente (install_golang habilitado por padrão em reconftw.cfg).
    • Permissões do Sistema: Se não estiver executando como root, configure o sudo para evitar solicitações:
      root@kitploit:~
      sudo echo "${USERNAME} ALL=(ALL:ALL) NOPASSWD: ALL" | sudo tee -a /etc/sudoers.d/reconFTW
      
  2. Passos: ```bash git clone https://github.com/six2dez/reconftw cd reconftw ./install.sh ./reconftw.sh -d target.com -r

    root@kitploit:~
  3. Notas:

  • O script install.sh instala dependências, ferramentas e configura caminhos (GOROOT, GOPATH, PATH).
  • Defina install_golang=false em reconftw.cfg se o Golang já estiver configurado.
  • Para instalações existentes, execute ./install.sh --tools para atualizar binários Go, pacotes pipx e repositórios sem alterar pacotes do sistema.
  • Consulte o Guia de Instalação para instruções detalhadas.

Docker

  1. Baixe a Imagem: ```bash docker pull six2dez/reconftw:main
    root@kitploit:~
  2. Execute o Container: ```bash docker run -it --rm
    -v "${PWD}/OutputFolder/:/reconftw/Recon/"
    six2dez/reconftw:main -d example.com -r
    root@kitploit:~

Para uma lista de alvos, vincule o arquivo de lista ao contêiner e referencie o caminho dentro do contêiner: ```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 os Resultados**:

- Os resultados são guardados no diretório `OutputFolder` no host (não dentro do contentor).

4. **Personalização**:
- Modifique a imagem Docker ou crie a sua própria; consulte o [Guia Docker](https://github.com/six2dez/reconftw/wiki/4.-Docker).
- Para omitir as ferramentas Ax em builds personalizados, passe `--build-arg INSTALL_AXIOM=false`.
- Monte a sua configuração do notify em `~/.config/notify/provider-config.yaml` dentro do contentor se utilizar notificações.

5. **Segredos em Tempo de Execução**:

Passe chaves de API e segredos através de variáveis de ambiente — nunca os incorpore na imagem:   ```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

Vê SECURITY.md para obter orientações completas sobre a gestão de segredos.

  1. Verificação de Saúde:

    A imagem Docker inclui um HEALTHCHECK integrado que executa ./reconftw.sh --health-check a cada 60 segundos. Também pode executá-lo manualmente: ```bash docker exec ./reconftw.sh --health-check

    root@kitploit:~

Terraform + Ansible

  • Implante o reconFTW na AWS usando Terraform e Ansible.
  • Siga o guia em Terraform/README.md para instruções de configuração.

Experimentando o beta v2 (reescrita em Go)

O reconFTW está sendo reescrito em Go. A reescrita é distribuída como uma pré-versão opcional: ela está listada na página de releases, e o GitHub nunca aponta releases/latest para uma pré-versão — então, se você não fizer nada, continuará recebendo a versão em bash. Isso é intencional.

O binário em Go é reconftw; o ponto de entrada em bash é reconftw.sh. Eles não sobrescrevem um ao outro, então você pode manter ambos e reverter a qualquer momento.

O beta atual é v5.0.0-beta.1. Ele não é servido por releases/latest, então você especifica a tag explicitamente:```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:~
Escolha o asset correspondente à sua plataforma na
[página de releases](https://github.com/six2dez/reconftw/releases/tag/v5.0.0-beta.1) — builds para `Darwin`
e `arm64`, um build estático musl e pacotes `.deb`/`.rpm` são todos publicados.

- [**O que a beta é, e o que ela não é**](https://github.com/six2dez/reconftw/blob/main/docs/V2-BETA-ANNOUNCEMENT.md) — incluindo três
  coisas que explicitamente ainda não estão finalizadas.
- [**Reportar algo**](https://github.com/six2dez/reconftw/issues/new?template=v2-beta-feedback.md)
  — o template de feedback da v2 beta. Bugs na versão bash ainda vão para o relatório de Bug normal.


## 🛠️ Solução de Problemas

- Bash 4+ no macOS: Os scripts se relançam automaticamente sob o Homebrew Bash. Se você vir uma mensagem sobre Bash < 4, execute `brew install bash`, abra um novo terminal e re-execute `./install.sh`.
- timeout no macOS: O macOS fornece `gtimeout` via `brew install coreutils`. Os scripts agora o detectam e usam automaticamente.
- Problemas de rede: Os instaladores ocultam a maior parte da saída dos comandos. Se algo falhar, re-execute com `upgrade_tools=true` em `reconftw.cfg`, execute `./install.sh --tools`, ou instale a ferramenta ausente manualmente (o erro indicará o nome dela).
- Binários GOPATH: Os binários são copiados para `/usr/local/bin`. Se preferir não fazer isso, garanta que `~/go/bin` esteja no seu `PATH`.
- Templates Nuclei: Se os templates não foram clonados, remova `~/nuclei-templates` e re-execute `./install.sh`.

## 🔑 Checklist de APIs (Opcional)

- `subfinder`: `~/.config/subfinder/provider-config.yaml`
- Tokens GitHub: `~/Tools/.github_tokens` (um por linha)
- Tokens GitLab: `~/Tools/.gitlab_tokens` (um por linha)
- WHOISXML: defina `WHOISXML_API` em `reconftw.cfg` ou como variável de ambiente
- Enumeração ASN (`asnmap`): defina `PDCP_API_KEY` no ambiente/config (`ASN_ENUM` é ignorado se não estiver definido)
- Slack/Discord/Telegram: configure `notify` em `~/.config/notify/provider-config.yaml`
- Servidor SSRF: defina `COLLAB_SERVER` no ambiente/cfg se for usado
- Servidor Blind XSS: defina `XSS_SERVER` no ambiente/cfg se for usado

## 💾 Requisitos

- Disco: 10–20 GB livres recomendados (toolchain + dados)
- Rede: conexão estável durante instalação e atualizações
- SO: Linux/macOS com Bash ≥ 4
- Extras: `shellcheck` e `shfmt` (opcionais) para `make lint`/`make fmt`

## ⚙️ Configuração

O arquivo `reconftw.cfg` controla toda a execução do reconFTW. Ele permite personalização detalhada de:

- **Caminhos de Ferramentas**: Defina caminhos para ferramentas, resolvers e wordlists (`tools`, `resolvers`, `fuzz_wordlist`).
- **Chaves de API**: Configure chaves para Shodan, WHOISXML, etc. via variáveis de ambiente ou `secrets.cfg` (veja [SECURITY.md](https://github.com/six2dez/reconftw/blob/main/SECURITY.md)).
- **Modos de Escaneamento**: Habilite/desabilite módulos (ex.: `OSINT`, `SUBDOMAINS_GENERAL`, `VULNS_GENERAL`).
- **Desempenho**: Ajuste threads, limites de taxa e timeouts (ex.: `FFUF_THREADS`, `HTTPX_RATELIMIT`).
- **Limitação de Taxa Adaptativa**: Reduza automaticamente em erros 429/503 (`ADAPTIVE_RATE_LIMIT`, `MIN_RATE_LIMIT`, `MAX_RATE_LIMIT`).
- **Escaneamento Incremental**: Escaneie apenas novos achados desde a última execução (`INCREMENTAL_MODE`).
- **Notificações**: Configure notificações Slack, Discord ou Telegram (`NOTIFY_CONFIG`).
- **Ax (anteriormente Axiom)**: Configure escaneamento distribuído e caminhos de resolvers (`AXIOM_FLEET_NAME`, `AXIOM_FLEET_COUNT`, `AXIOM_RESOLVERS_PATH`).
- **Relatórios com IA**: Configure modelo/perfil/formato e controles de contexto (`AI_MODEL`, `AI_REPORT_PROFILE`, `AI_REPORT_TYPE`, `AI_MAX_CHARS_PER_FILE`).
- **Verificações Web Avançadas**: Alterne introspecção GraphQL, descoberta de parâmetros, testes WebSocket, sondagem gRPC e escaneamento IPv6.
- **Automação e Dados**: Controle heurísticas de reescaneamento rápido, registro de assets, tamanhos de chunk, hotlists e rastreamento de depuração (`QUICK_RESCAN`, `ASSET_STORE`, `CHUNK_LIMIT`, `HOTLIST_TOP`, `SHOW_COMMANDS`).
- **Disco e Logging**: Verificação de disco pré-voo (`MIN_DISK_SPACE_GB`), rotação de logs (`MAX_LOG_FILES`, `MAX_LOG_AGE_DAYS`), logging JSON estruturado (`STRUCTURED_LOGGING`).
- **Cache**: Configure a expiração de cache para wordlists e resolvers (`CACHE_MAX_AGE_DAYS`).
- **Segurança do Resolver DNS**: Arquivos de resolvers ausentes falham rapidamente, downloads de resolvers usam tentativas/timeouts configuráveis (`RESOLVER_DOWNLOAD_*`), e o timeout de brute/resolve DNS é desabilitado por padrão (`DNS_*_TIMEOUT=0`) com progresso por heartbeat.
- **Segredos**: Use `secrets.cfg` para sobrescritas locais ou variáveis de ambiente para CI/Docker (veja [SECURITY.md](https://github.com/six2dez/reconftw/blob/main/SECURITY.md)).

**Exemplo de Configuração**:```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'

Proteções do resolvedor DNS:

  • Arquivos de resolvedores ausentes ou vazios agora falham rapidamente antes do início do brute/resolve de DNS.
  • Os downloads de resolvedores são configuráveis com RESOLVER_DOWNLOAD_CONNECT_TIMEOUT, RESOLVER_DOWNLOAD_MAX_TIME, RESOLVER_DOWNLOAD_RETRY e RESOLVER_DOWNLOAD_RETRY_DELAY.
  • DNS_BRUTE_TIMEOUT=0 e DNS_RESOLVE_TIMEOUT=0 desativam o tempo limite rígido por padrão (recomendado para conjuntos de alvos muito grandes). O progresso do heartbeat ainda é exibido a cada DNS_HEARTBEAT_INTERVAL_SECONDS.```bash DNS_BRUTE_TIMEOUT=4h DNS_RESOLVE_TIMEOUT=6h DNS_HEARTBEAT_INTERVAL_SECONDS=20
root@kitploit:~
**Detalhes completos**: Consulte o [Guia de Configuração](https://github.com/six2dez/reconftw/wiki/3.-Configuration-file).

---

## 🚀 Uso

O reconFTW suporta vários modos e opções para reconhecimento flexível. Use o sinalizador `-h` para visualizar o menu de ajuda.

### Opções de Alvo

| Sinalizador | Descrição                                                  |
| ----------- | ------------------------------------------------------------ |
| `-d`        | Domínio alvo único (ex.: `example.com`)                      |
| `-l`        | Arquivo com lista de domínios alvo (um por linha)            |
| `-m`        | Alvo multi-domínio (ex.: nome da empresa para domínios relacionados) |
| `-x`        | Excluir subdomínios (lista fora do escopo)                   |
| `-i`        | Incluir subdomínios (lista dentro do escopo)                 |

### Opções de Modo

| Sinalizador | Descrição                                                           |
| ----------- | --------------------------------------------------------------------- |
| `-r`        | **Recon**: Reconhecimento completo sem ataques ativos                 |
| `-s`        | **Subdomínios**: Enumeração de subdomínios, sondagem web e takeover   |
| `-p`        | **Passivo**: Somente reconhecimento passivo                           |
| `-a`        | **Tudo**: Reconhecimento completo mais verificações ativas de vulnerabilidades |
| `-w`        | **Web**: Verificações de vulnerabilidades em alvos web específicos    |
| `-n`        | **OSINT**: Varredura OSINT sem enumeração de subdomínios ou ataques   |
| `-z`        | **Zen**: Reconhecimento leve com verificações básicas e algumas vulnerabilidades |
| `-c`        | **Personalizado**: Executar uma função específica (requer argumentos adicionais) |
| `-h`        | Mostrar menu de ajuda                                                 |

### Opções Gerais

| Sinalizador          | Descrição                                              |
| -------------------- | -------------------------------------------------------- |
| `--deep`             | Ativar varredura profunda (mais lenta, VPS recomendado)  |
| `-f`                 | Caminho do arquivo de configuração personalizado         |
| `-o`                 | Diretório de saída para os resultados                    |
| `-v`                 | Ativar varredura distribuída Ax                           |
| `--vps-count`        | Substituir a contagem de instâncias da frota Ax nesta execução |
| `-q`                 | Definir limite de taxa (requisições por segundo)         |
| `-y`                 | Ativa análise de resultados com IA                       |
| `--check-tools`      | Sair se as ferramentas necessárias estiverem ausentes    |
| `--quick-rescan`     | Pular módulos pesados quando nenhum novo subdomínio/web for encontrado |
| `--health-check`     | Executar verificação de saúde do sistema e sair          |
| `--incremental`      | Escanear apenas novas descobertas desde a última execução |
| `--adaptive-rate`    | Ajustar automaticamente os limites de taxa em erros (429/503) |
| `--dry-run`          | Mostrar o que seria executado sem rodar os comandos      |
| `--parallel`         | Executar funções independentes em paralelo (mais rápido, mais RAM) |
| `--no-parallel`      | Forçar execução sequencial mesmo se o paralelo estiver ativado |
| `--monitor`          | Modo de monitoramento contínuo (alvo único; `-w` suporta `-l`) |
| `--monitor-interval` | Minutos entre ciclos de monitoramento                    |
| `--monitor-cycles`   | Parar após N ciclos (0 = infinito)                       |
| `--report-only`      | Reconstruir artefatos de relatório sem escanear          |
| `--refresh-cache`    | Forçar atualização de resolvedores/wordlists em cache    |
| `--export`           | Exportar artefatos: `json`, `html`, `csv` ou `all`       |

### Exemplo de Uso

1. **Reconhecimento Completo em um Único Alvo**:   ```bash
   ./reconftw.sh -d target.com -r
  1. Recon em Múltiplos Alvos: ```bash ./reconftw.sh -l targets.txt -r -o /path/to/output/
    root@kitploit:~
  2. Reconhecimento Profundo (VPS Recomendado): ```bash ./reconftw.sh -d target.com -r --deep
    root@kitploit:~
  3. Modo Paralelo (Mais rápido, requer mais RAM): ```bash ./reconftw.sh -d target.com -r --parallel
    root@kitploit:~
  4. Forçar Modo Sequencial: ```bash ./reconftw.sh -d target.com -r --no-parallel
    root@kitploit:~
  5. Reconhecimento Multi-Domínio: ```bash ./reconftw.sh -m company -l domains.txt -r
    root@kitploit:~
  6. Integração com Ax: ```bash ./reconftw.sh -d target.com -r -v
    root@kitploit:~
  7. Integração do Ax com override de frota: ```bash ./reconftw.sh -d target.com -r -v 30
    root@kitploit:~
  8. Reconhecimento Completo com Ataques (Modo YOLO): ```bash ./reconftw.sh -d target.com -a
    root@kitploit:~
  9. Mostrar Ajuda: ```bash ./reconftw.sh -h
root@kitploit:~
11. **Forçar atualização de cache**:   ```bash
./reconftw.sh -d target.com -r --refresh-cache
  1. Exportar todos os artefatos do relatório: ```bash ./reconftw.sh -d target.com -r --export all
root@kitploit:~
13. **Monitorização contínua (a cada 30m, 48 ciclos)**:   ```bash
./reconftw.sh -d target.com -r --monitor --monitor-interval 30 --monitor-cycles 48
  1. Reconstruir relatórios apenas (sem verificação): ```bash ./reconftw.sh -d target.com --report-only --export all
root@kitploit:~
**Guia Completo**: Consulte o [Guia de Uso](https://github.com/six2dez/reconftw/wiki/2.-Usage-Guide).

---

## ☁️ Suporte ao Ax Framework (anteriormente Axiom)

O reconFTW integra-se com o [Ax](https://github.com/attacksurge/ax) para varredura distribuída, reduzindo o tempo de execução ao distribuir tarefas entre múltiplas instâncias na nuvem.

- **Configuração**: Selecione `reconftw` como o provisionador durante a configuração do Ax (`axiom-configure`).
- **Gerenciamento de Frotas**: Crie e destrua frotas automaticamente (`AXIOM_FLEET_LAUNCH`, `AXIOM_FLEET_SHUTDOWN`) ou use uma frota existente.
- **Configuração**: Defina o tamanho da frota, região e nome em `reconftw.cfg` (`AXIOM_FLEET_COUNT`, `AXIOM_FLEET_REGIONS`, `AXIOM_FLEET_NAME`).

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

Detalhes: Consulte a documentação oficial do Ax e o repositório attacksurge/ax.


💻 Suporte ao Faraday

O reconFTW integra-se ao Faraday para relatórios baseados na web e gerenciamento de vulnerabilidades.

  • Configuração: Instale o Faraday, autentique-se via faraday-cli e configure o workspace em reconftw.cfg (FARADAY_WORKSPACE).
  • Uso: Ative com FARADAY=true em reconftw.cfg.

🧠 Integração com IA

O reconFTW usa IA para gerar relatórios detalhados a partir dos resultados de varredura com a ferramenta reconftw_ai.

  • Modelo: Modelo de IA configurável (por exemplo, llama3:8b via AI_MODEL).
  • Tipos de Relatório: Markdown ou texto simples (AI_REPORT_TYPE).
  • Perfis: Executivo, resumido ou caçador de bugs (AI_REPORT_PROFILE).
  • Saída Estruturada: O reconftw armazena um relatório legível por máquina em ai_result/reconftw_analysis.json.
  • Controles de Contexto: Limite o tamanho da entrada usando AI_MAX_CHARS_PER_FILE e AI_MAX_FILES_PER_CATEGORY.
  • Controles de Segurança: Alterne a redação e o modo estrito com AI_REDACT e AI_STRICT.

Exemplo:```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:~
---

## 🗂️ Gestão de Dados

Gerencie dados de varredura e chaves de API com segurança usando um repositório privado.

Quando `ASSET_STORE=true`, o reconFTW agrega descobertas principais em `assets.jsonl` durante cada execução, facilitando a sincronização apenas de deltas acionáveis para o seu repositório privado.

### Makefile

Use o `Makefile` fornecido para gerenciamento fácil do repositório (requer [GitHub CLI](https://cli.github.com/)).

1. **Bootstrap**:   ```bash
   export PRIV_REPO="$HOME/reconftw-data"
   make bootstrap
  1. Sincronizar com o Upstream: ```bash make sync
    root@kitploit:~
  2. Carregar Dados: ```bash make upload
    root@kitploit:~
  3. Scripts de Lint / Formatação: ```bash make lint # shellcheck for reconftw.sh, modules/*.sh & install.sh make fmt # shfmt with project defaults
    root@kitploit:~
  4. Executar Testes: ```bash make test # unit tests (bats-core) make test-all # unit + integration tests
    root@kitploit:~

Manual

  1. Crie um repositório privado no GitHub/GitLab.
  2. Clone e configure: ```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. Carregar alterações: ```bash git add . git commit -m "Data upload" git push origin master
    root@kitploit:~
  4. Atualizar Ferramenta: ```bash git fetch upstream git rebase upstream/main master
    root@kitploit:~

🧪 Testes

O reconFTW utiliza bats-core para testes automatizados.

Instalar o 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:~
### Executando Testes```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

Estrutura do Diretório de Testes```

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:~
### Executando Testes de Segurança```bash
# Test command injection prevention
make test-security

# Or directly
bats tests/security/

Escrever Testes

Os testes usam o padrão --source-only para carregar funções sem executar o 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:~
### Pipeline de CI

O fluxo de trabalho do GitHub Actions (`.github/workflows/tests.yml`) é executado a cada push e pull request:

1. **ShellCheck** — verifica `reconftw.sh`, `modules/*.sh` e `install.sh`
2. **Testes de Unidade** — executa todos os arquivos `tests/unit/*.bats`
3. **Testes de Integração** — instala o reconFTW e valida a disponibilidade das ferramentas

---

## Mapa Mental/Fluxo de Trabalho

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

---

## Vídeo de exemplo

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

---

## 🤝 Como Contribuir

Consulte [CONTRIBUTING.md](https://github.com/six2dez/reconftw/blob/main/CONTRIBUTING.md) para o guia completo de contribuição, incluindo configuração de desenvolvimento, estilo de código, testes e processo de PR.

Links rápidos:

- [Reportar um Bug](https://github.com/six2dez/reconftw/issues/new/choose)
- [Enviar um Pull Request](https://github.com/six2dez/reconftw/tree/dev) (direcione para a branch `dev`)
- [Código de Conduta](https://github.com/six2dez/reconftw/blob/main/CODE_OF_CONDUCT.md)

---

## 🔒 Segurança

Para política de segurança, gerenciamento de segredos e relato de vulnerabilidades, consulte [SECURITY.md](https://github.com/six2dez/reconftw/blob/main/SECURITY.md).

---

## ❓ Precisa de Ajuda?

- **Wiki**: Explore a [Wiki do reconFTW](https://github.com/six2dez/reconftw/wiki).
- **FAQ**: Consulte as [Perguntas Frequentes](https://github.com/six2dez/reconftw/wiki/7.-FAQs).
- **Comunidade**: Junte-se ao [servidor Discord](https://discord.gg/R5DdXVEdTy) ou ao [grupo Telegram](https://t.me/joinchat/TO_R8NYFhhbmI5co).

---

## 💖 Apoie Este Projeto

Apoie o desenvolvimento do reconFTW através de:

- **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)

- **Indicação DigitalOcean**: [Link de Indicação](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>

- **Patrocínio no GitHub**: [github.com/sponsors/six2dez](https://github.com/sponsors/six2dez)

---

## 🙏 Agradecimentos

Agradecimentos especiais aos seguintes serviços por apoiarem o 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 Alterações

Consulte [CHANGELOG.md](https://github.com/six2dez/reconftw/blob/main/CHANGELOG.md) para uma lista detalhada das alterações em cada versão.

---

## 🛠️ Desenvolvimento

### Estrutura do Projeto```
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

Executando Testes```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:~
### Fluxo de Trabalho de Desenvolvimento```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

Consulte CONTRIBUTING.md para as diretrizes de desenvolvimento e docs/ARCHITECTURE.md para detalhes técnicos.


📜 Licença

reconFTW é licenciado sob a Licença MIT.


⭐ Histórico de Estrelas

Star History Chart

Baixar ferramenta
  • Enumeração de Armazenamento em Nuvem: Pesquisa buckets em grandes provedores em busca de exposição (cloud_enum).
  • Domínios Spoofáveis: Verifica domínios vulneráveis a spoofing (spoofcheck).
  • nuclei
    dnstake
  • Transferência de Zona DNS: Verifica transferências de zona DNS mal configuradas (dig).
  • Buckets na Nuvem: Identifica buckets na nuvem mal configurados e ativos de armazenamento expostos (S3Scanner e cloud_enum).
  • Nota sobre Cobertura na Nuvem: As verificações de buckets na nuvem não incluem mais cobertura do Alibaba OSS após a substituição do CloudHunter pelo cloud_enum.
  • Migração de Saída na Nuvem: Artefatos legados de buckets cloudhunter_* foram removidos; use subdomains/cloud_enum_buckets_trufflehog.txt em seu lugar.
  • Pesquisa Reversa de IP: Descobre subdomínios via faixas de IP (hakip2host).
  • Detecção de GraphQL
    GQLSpection
  • Descoberta de Parâmetros: Realiza bruteforce de parâmetros ocultos em endpoints (arjun).
  • Auditoria de WebSocket: Valida handshakes de upgrade e tratamento de origem em endpoints ws:// e wss://.
  • Reflexão gRPC: Sonda portas gRPC comuns em busca de reflexão de serviços exposta (grpcurl).
  • Fingerprinting de Serviços LLM (Opcional): Sonda endpoints web/API descobertos em busca de serviços LLM expostos com julius.
  • Fuzzing: Realiza fuzzing de diretórios e parâmetros (ffuf).
  • Classificação por Extensão de Arquivo: Organiza URLs por extensões de arquivo.
  • Geração de Wordlists: Cria wordlists personalizadas para fuzzing.
  • Dicionário de Senhas: Gera dicionários de senhas a partir de conteúdo ao vivo (cewler).
  • Varredura de Shortname IIS: Detecta vulnerabilidades de shortname IIS (shortscan).
  • Bypass de 4XX: Tenta contornar respostas 4XX (nomore403).
  • Fuzzing de Parâmetros: Realiza fuzzing de parâmetros de URL em busca de vulnerabilidades (nuclei).
  • Armazenamento de Ativos: Adiciona descobertas a assets.jsonl para automação downstream quando ASSET_STORE está habilitado.
  • Relatório Consolidado: Gera automaticamente report/report.json e report/index.html ao final do escaneamento.
  • Suporte ARM: Compatível com Raspberry Pi e arquiteturas ARM (incluindo MacOS MX).
  • Verificação de Saúde: Verificação de saúde do sistema integrada via --health-check (também usada pelo HEALTHCHECK do Docker).
  • Modo Incremental: Escaneia apenas novas descobertas desde a última execução (--incremental).
  • Limitação de Taxa Adaptativa: Recua automaticamente em erros 429/503 (--adaptive-rate).
  • Registro Estruturado: Saída de log JSON opcional para análise avançada (STRUCTURED_LOGGING).
  • Sanitização de Entrada: Toda entrada do usuário é sanitizada para prevenir injeção de comandos.
  • Modo Simulação: Pré-visualiza o que seria executado sem executar comandos (--dry-run).
  • Modo Paralelo: Executa funções independentes em paralelo para escaneamentos mais rápidos (--parallel, desative com --no-parallel).
  • Arquitetura Modular: Código dividido em 8 módulos focados para manutenibilidade.
  • Gerenciamento de Segredos: Variáveis de ambiente, secrets.cfg e segredos de runtime do Docker (veja SECURITY.md).
  • Disjuntor: Ignora ferramentas automaticamente após falhas repetidas para evitar travamentos no escaneamento.
  • Sistema de Ponto de Verificação: Retoma escaneamentos interrompidos a partir da última fase bem-sucedida.
  • Suporte Nativo a macOS: Compatibilidade total com macOS (coreutils BSD, Homebrew Bash 4+).