## 1. Project Overview & Quickstart (six2dez/reconftw)
## File: README.md
[](https://github.com/six2dez/reconftw)
reconFTW
**reconFTW** is a powerful automated reconnaissance tool designed for security researchers and penetration testers. It streamlines the process of gathering intelligence on a target by performing subdomain enumeration, vulnerability scanning, OSINT and more. With a modular design, extensive configuration options, and support for distributed scanning via AX Framework, reconFTW is built to deliver comprehensive results efficiently.
reconFTW leverages a wide range of techniques, including passive and active subdomain discovery, web vulnerability checks (e.g., XSS, SSRF, SQLi), OSINT, directory fuzzing, port scanning and screenshotting. It integrates with cutting-edge tools and APIs to maximize coverage and accuracy, ensuring you stay ahead in your reconnaissance efforts.
**Key Features:**
- Comprehensive subdomain enumeration (passive, bruteforce, permutations, certificate transparency, etc.)
- Vulnerability scanning for XSS, SSRF, SQLi, LFI, SSTI, and more
- OSINT for emails, metadata, API leaks, and third-party misconfigurations
- Distributed scanning with AX Framework for faster execution
- Customizable workflows with a detailed configuration file
- Integration with Faraday for reporting and visualization
- Support for Docker, Terraform and Ansible deployments
**Disclaimer:** Usage of reconFTW for attacking targets without prior consent is illegal. It is the user's responsibility to obey all applicable laws. The developers assume no liability for misuse or damage caused by this tool. Use responsibly.
---
## π Table of Contents
- [π Table of Contents](#-table-of-contents)
- [β¨ Features](#-features)
- [OSINT](#osint)
- [Subdomains](#subdomains)
- [Hosts](#hosts)
- [Web Analysis](#web-analysis)
- [Vulnerability Checks](#vulnerability-checks)
- [Extras](#extras)
- [ποΈ Architecture](#οΈ-architecture)
- [πΏ Installation](#-installation)
- [Local Installation (PC/VPS/VM)](#local-installation-pcvpsvm)
- [Docker](#docker)
- [Terraform + Ansible](#terraform--ansible)
- [βοΈ Configuration](#οΈ-configuration)
- [π Usage](#-usage)
- [Target Options](#target-options)
- [Mode Options](#mode-options)
- [General Options](#general-options)
- [Example Usage](#example-usage)
- [βοΈ Ax Framework Support (previously Axiom)](#οΈ-ax-framework-support-previously-axiom)
- [π» Faraday Support](#-faraday-support)
- [π§ AI Integration](#-ai-integration)
- [ποΈ Data Management](#οΈ-data-management)
- [Makefile](#makefile)
- [Manual](#manual)
- [π§ͺ Testing](#-testing)
- [Mindmap/Workflow](#mindmapworkflow)
- [Sample video](#sample-video)
- [π€ How to Contribute](#-how-to-contribute)
- [π Security](#-security)
- [β Need Help?](#-need-help)
- [π Support This Project](#-support-this-project)
- [π Thanks](#-thanks)
- [π Changelog](#-changelog)
- [π οΈ Development](#οΈ-development)
- [π License](#-license)
- [β Star History](#-star-history)
---
## β¨ Features
reconFTW is packed with features to make reconnaissance thorough and efficient. Below is a detailed breakdown of its capabilities, updated to reflect the latest functionality in the script and configuration.
### OSINT
- **Domain Information**: WHOIS lookup for domain registration details ([whois](https://github.com/rfc1036/whois)).
- **Email and Password Leaks**: Searches for leaked emails and credentials ([emailfinder](https://github.com/Josue87/EmailFinder) and [LeakSearch](https://github.com/JoelGMSec/LeakSearch)).
- **Microsoft 365/Azure Mapping**: Identifies Microsoft 365 and Azure tenants ([msftrecon](https://github.com/Arcanum-Sec/msftrecon)).
- **Metadata Extraction**: Extracts metadata from indexed office documents ([metagoofil](https://github.com/opsdisk/metagoofil)).
- **API Leaks**: Detects exposed APIs in public sources ([porch-pirate](https://github.com/MandConsultingGroup/porch-pirate), [SwaggerSpy](https://github.com/UndeadSec/SwaggerSpy) and [postleaksNg](https://github.com/six2dez/postleaksNG)).
- **Google Dorking**: Automated Google dork queries for sensitive information ([dorks_hunter](https://github.com/six2dez/dorks_hunter) and [xnldorker](https://github.com/xnl-h4ck3r/xnldorker)).
- **GitHub Analysis**: Scans GitHub organizations for repositories and secrets with selectable engines ([enumerepo](https://github.com/trickest/enumerepo), [trufflehog](https://github.com/trufflesecurity/trufflehog), [gitleaks](https://github.com/gitleaks/gitleaks), [titus](https://github.com/praetorian-inc/titus), [noseyparker](https://github.com/praetorian-inc/noseyparker)).
- **GitHub Actions Audit (Optional)**: Audits workflow artifacts and CI/CD exposure with [gato](https://github.com/praetorian-inc/gato).
- **Third-Party Misconfigurations**: Identifies misconfigured third-party services ([misconfig-mapper](https://github.com/intigriti/misconfig-mapper)).
- **Mail Hygiene**: Reviews SPF/DMARC configuration to flag spoofing or deliverability issues.
- **Cloud Storage Enumeration**: Surveys buckets across major providers for exposure ([cloud_enum](https://github.com/initstring/cloud_enum)).
- **Spoofable Domains**: Checks for domains vulnerable to spoofing ([spoofcheck](https://github.com/MattKeeley/Spoofy)).
### Subdomains
- **Passive Enumeration**: Uses APIs and public sources for subdomain discovery ([subfinder](https://github.com/projectdiscovery/subfinder) and [github-subdomains](https://github.com/gwen001/github-subdomains)).
- **Certificate Transparency**: Queries certificate transparency logs ([crt](https://github.com/cemulus/crt)).
- **NOERROR Discovery**: Identifies subdomains with DNS NOERROR responses ([dnsx](https://github.com/projectdiscovery/dnsx), more info [here](https://www.securesystems.de/blog/enhancing-subdomain-enumeration-ents-and-noerror/)).
- **Bruteforce**: Performs DNS bruteforcing with customizable wordlists ([puredns](https://github.com/d3mondev/puredns) and custom wordlists).
- **Permutations**: Generates subdomain permutations using AI, regex and tools ([Gotator](https://github.com/Josue87/gotator) as the single permutation engine, plus [regulator](https://github.com/cramppet/regulator) and [subwiz](https://github.com/hadriansecurity/subwiz)).
- **Web Scraping**: Extracts subdomains from passive URL sources and live web metadata ([urlfinder](https://github.com/projectdiscovery/urlfinder), [waymore](https://github.com/xnl-h4ck3r/waymore), [httpx](https://github.com/projectdiscovery/httpx), [csprecon](https://github.com/edoardottt/csprecon)).
- **DNS Records**: Resolves DNS records for subdomains ([dnsx](https://github.com/projectdiscovery/dnsx)).
- **Google Analytics**: Identifies subdomains via Analytics IDs ([AnalyticsRelationships](https://github.com/Josue87/AnalyticsRelationships)).
- **TLS Handshake**: Discovers subdomains via TLS ports ([tlsx](https://github.com/projectdiscovery/tlsx)).
- **Recursive Search**: Performs recursive passive or bruteforce enumeration combined ([dsieve](https://github.com/trickest/dsieve)).
- **Subdomain Takeover**: Detects vulnerable subdomains ([nuclei](https://github.com/projectdiscovery/nuclei) and [dnstake](https://github.com/pwnesia/dnstake)).
- **DNS Zone Transfer**: Checks for misconfigured DNS zone transfers ([dig](https://linux.die.net/man/1/dig)).
- **Cloud Buckets**: Identifies misconfigured cloud buckets and exposed storage assets ([S3Scanner](https://github.com/sa7mon/S3Scanner) and [cloud_enum](https://github.com/initstring/cloud_enum)).
- **Cloud Coverage Note**: Cloud bucket checks no longer include Alibaba OSS coverage after replacing CloudHunter with cloud_enum.
- **Cloud Output Migration**: Legacy `cloudhunter_*` bucket artifacts were removed; use `subdomains/cloud_enum_buckets_trufflehog.txt` instead.
- **Reverse IP Lookup**: Discovers subdomains via IP ranges ([hakip2host](https://github.com/hakluke/hakip2host)).
### Hosts
- **IP Information**: Retrieves geolocation and WHOIS data ([ipinfo](https://www.ipinfo.io/)).
- **CDN Detection**: Identifies IPs behind CDNs ([cdncheck](https://github.com/projectdiscovery/cdncheck)).
- **WAF Detection**: Detects Web Application Firewalls ([wafw00f](https://github.com/EnableSecurity/wafw00f)).
- **Port Scanning**: Active scanning with [nmap](https://github.com/nmap/nmap) (optionally preceded by [naabu](https://github.com/projectdiscovery/naabu)) and passive scanning with [smap](https://github.com/s0md3v/Smap).
- **Service Fingerprinting**: Fingerprints exposed services on discovered host:port pairs with [nerva](https://github.com/praetorian-inc/nerva).
- **Service Vulnerabilities (Optional)**: Deep portscan profile can enrich results with CVE matching via [vulners](https://github.com/vulnersCom/nmap-vulners).
- **Password Spraying**: Attempts password spraying on identified services with engine selection ([brutespray](https://github.com/x90skysn3k/brutespray) or [brutus](https://github.com/praetorian-inc/brutus)).
- **Geolocation**: Maps IP addresses to geographic locations ([ipinfo](https://www.ipinfo.io/)).
- **IPv6 Discovery**: Optionally enumerates and scans discovered IPv6 targets when `IPV6_SCAN` is enabled.
### Web Analysis
- **Web Probing**: Detects live web servers on standard and uncommon ports (([httpx](https://github.com/projectdiscovery/httpx))).
- **Screenshots**: Captures screenshots of web pages ([nuclei](https://github.com/projectdiscovery/nuclei)).
- **Virtual Host Fuzzing**: Identifies virtual hosts by fuzzing HTTP headers ([VhostFinder](https://github.com/wdahlenburg/VhostFinder)).
- **CMS Detection**: Identifies content management systems ([CMSeeK](https://github.com/Tuhinshubhra/CMSeeK)).
- **URL Extraction**: Collects URLs passively and actively ([urlfinder](https://github.com/projectdiscovery/urlfinder), [waymore](https://github.com/xnl-h4ck3r/waymore), [katana](https://github.com/projectdiscovery/katana), [github-endpoints](https://gist.github.com/six2dez/d1d516b606557526e9a78d7dd49cacd3) and [JSA](https://github.com/w9w/JSA)).
- **URL Pattern Analysis**: Classifies URLs using patterns ([urless](https://github.com/xnl-h4ck3r/urless), [gf](https://github.com/tomnomnom/gf) and [gf-patterns](https://github.com/1ndianl33t/Gf-Patterns)).
- **Favicon Tech Recon**: Identifies technologies from favicon hashes ([favirecon](https://github.com/edoardottt/favirecon)).
- **JavaScript Analysis**: Extracts secrets and endpoints from JS files ([subjs](https://github.com/lc/subjs), [JSA](https://github.com/w9w/JSA), [xnLinkFinder](https://github.com/xnl-h4ck3r/xnLinkFinder), [getjswords](https://github.com/m4ll0k/BBTz), [mantra](https://github.com/MrEmpy/mantra), [jsluice](https://github.com/BishopFox/jsluice)).
- **Source Map Extraction**: Retrieves sensitive data from JavaScript source maps ([sourcemapper](https://github.com/denandz/sourcemapper)).
- **GraphQL Detection**: Discovers GraphQL endpoints with nuclei and optionally performs in-depth introspection ([GQLSpection](https://github.com/doyensec/GQLSpection)).
- **Parameter Discovery**: Bruteforces hidden parameters on endpoints ([arjun](https://github.com/s0md3v/Arjun)).
- **WebSocket Auditing**: Validates upgrade handshakes and origin handling on `ws://` and `wss://` endpoints.
- **gRPC Reflection**: Probes common gRPC ports for exposed service reflection ([grpcurl](https://github.com/fullstorydev/grpcurl)).
- **LLM Service Fingerprinting (Optional)**: Probes discovered web/API endpoints for exposed LLM services with [julius](https://github.com/praetorian-inc/julius).
- **Fuzzing**: Performs directory and parameter fuzzing ([ffuf](https://github.com/ffuf/ffuf)).
- **File Extension Sorting**: Organizes URLs by file extensions.
- **Wordlist Generation**: Creates custom wordlists for fuzzing.
- **Password Dictionary**: Generates password dictionaries from live content ([cewler](https://github.com/roys/cewler)).
- **IIS Shortname Scanning**: Detects IIS shortname vulnerabilities ([shortscan](https://github.com/bitquark/shortscan)).
### Vulnerability Checks
- **CVEs**: Checks for CVE and common vulnerabilites [nuclei](https://github.com/projectdiscovery/nuclei)
- **Nuclei DAST**: Runs `nuclei -dast` templates over collected URLs and GF candidates for additional DAST coverage.
- **XSS**: Tests for cross-site scripting vulnerabilities ([dalfox](https://github.com/hahwul/dalfox)).
- **SSL/TLS**: Checks for SSL/TLS misconfigurations ([testssl](https://github.com/drwetter/testssl.sh)).
- **SSRF**: Tests for server-side request forgery ([interactsh](https://github.com/projectdiscovery/interactsh), parameter values with [ffuf](https://github.com/ffuf/ffuf), and optional alternate protocol payloads).
- **CRLF**: Checks for CRLF injection vulnerabilities ([crlfuzz](https://github.com/dwisiswant0/crlfuzz)).
- **LFI**: Tests for local file inclusion via fuzzing ([ffuf](https://github.com/ffuf/ffuf)).
- **SSTI**: Detects server-side template injection ([TInjA](https://github.com/Hackmanit/TInjA)).
- **SQLi**: Tests for SQL injection ([SQLMap](https://github.com/sqlmapproject/sqlmap) and [ghauri](https://github.com/r0oth3x49/ghauri)).
- **Broken Links**: Identifies broken links and external references likely to be takeover-prone ([second-order](https://github.com/mhmdiaa/second-order)).
- **Command Injection**: Tests for command injection vulnerabilities ([commix](https://github.com/commixproject/commix)).
- **HTTP Request Smuggling**: Checks for request smuggling vulnerabilities ([smugglex](https://github.com/hahwul/smugglex)).
- **Web Cache**: Identifies web cache vulnerabilities ([Web-Cache-Vulnerability-Scanner](https://github.com/Hackmanit/Web-Cache-Vulnerability-Scanner) and [toxicache](https://github.com/xhzeem/toxicache)).
- **4XX Bypassing**: Attempts to bypass 4XX responses ([nomore403](https://github.com/devploit/nomore403)).
- **Parameter Fuzzing**: Fuzzes URL parameters for vulnerabilities ([nuclei](https://github.com/projectdiscovery/nuclei)).
### Extras
- **Multithreading**: Optimizes performance ([Interlace](https://github.com/codingo/Interlace)).
- **Custom Resolvers**: Generates DNS resolvers ([dnsvalidator](https://github.com/vortexau/dnsvalidator)).
- **Docker Support**: Official Docker image on [DockerHub](https://hub.docker.com/r/six2dez/reconftw).
- **AWS Deployment**: Deploys via Terraform and Ansible.
- **IP/CIDR Support**: Scans IP ranges and CIDR blocks.
- **Scan Resumption**: Resumes scans from the last completed step.
- **Custom Output**: Saves results to a user-defined directory.
- **Diff Mode**: Highlights new findings in subsequent scans.
- **Scope Filtering**: Supports in-scope and out-of-scope lists ([inscope](https://github.com/tomnomnom/hacks/tree/master/inscope)).
- **Notifications**: Sends alerts via Slack, Discord, or Telegram ([notify](https://github.com/projectdiscovery/notify)).
- **Result Zipping**: Compresses and sends results.
- **Faraday Integration**: Exports results to [Faraday](https://github.com/infobyte/faraday) for reporting .
- **AI Report Generation**: Generates reports using local AI models ([reconftw_ai](https://github.com/six2dez/reconftw_ai)).
- **Quick Rescan Mode**: Skips heavy stages automatically when no new assets are discovered (`--quick-rescan` / `QUICK_RESCAN`).
- **Hotlist Builder**: Scores and highlights the riskiest assets (`hotlist.txt`) based on new findings.
- **Command Tracing**: Toggle `SHOW_COMMANDS` to log every executed command into target logs for debugging.
- **Asset Store**: Appends findings to `assets.jsonl` for downstream automation when `ASSET_STORE` is enabled.
- **Consolidated Report**: Auto-generates `report/report.json` and `report/index.html` at end of scan.
- **ARM Support**: Compatible with Raspberry Pi and ARM architectures (including MacOS MX).
- **Health Check**: Built-in system health check via `--health-check` (also used by Docker `HEALTHCHECK`).
- **Incremental Mode**: Only scan new findings since last run (`--incremental`).
- **Adaptive Rate Limiting**: Automatically back off on 429/503 errors (`--adaptive-rate`).
- **Structured Logging**: Optional JSON log output for advanced analysis (`STRUCTURED_LOGGING`).
- **Input Sanitization**: All user input is sanitized to prevent command injection.
- **Dry-Run Mode**: Preview what would be executed without running commands (`--dry-run`).
- **Parallel Mode**: Run independent functions in parallel for faster scans (`--parallel`, disable with `--no-parallel`).
- **Modular Architecture**: Codebase split into 8 focused modules for maintainability.
- **Secrets Management**: Environment variables, `secrets.cfg`, and Docker runtime secrets (see [SECURITY.md](SECURITY.md)).
- **Circuit Breaker**: Automatically skips tools after repeated failures to avoid scan hangs.
- **Checkpoint System**: Resume interrupted scans from the last successful phase.
- **macOS Native Support**: Full compatibility with macOS (BSD coreutils, Homebrew Bash 4+).
---
## ποΈ Architecture
reconFTW uses a modular architecture. The main entry point (`reconftw.sh`) handles argument parsing and sources 8 specialized modules from the `modules/` directory.
### Directory Layout
```
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
```
### Module Reference
| Module | Lines | Purpose |
|--------|------:|---------|
| `core.sh` | 1024 | Lifecycle management, logging, notifications, cleanup traps |
| `modes.sh` | 902 | Scan mode definitions, argument parsing, help output |
| `subdomains.sh` | 1938 | All subdomain enumeration functions |
| `web.sh` | 1712 | Web analysis, fuzzing, JS analysis, CMS detection |
| `vulns.sh` | 926 | Vulnerability scanning (XSS, SQLi, SSRF, etc.) |
| `osint.sh` | 500 | OSINT functions (WHOIS, emails, dorks, metadata) |
| `utils.sh` | 508 | Shared utilities, input sanitization, validation |
| `axiom.sh` | 143 | Ax/Axiom distributed fleet management |
The `--source-only` flag allows sourcing `reconftw.sh` without executing the main logic, enabling unit testing of individual functions.
---
## πΏ Installation
reconFTW supports multiple installation methods to suit different environments. Ensure you have sufficient disk space (at least 10 GB recommended) and a stable internet connection.
### Quickstart
1) Clone and install
```yaml
git clone https://github.com/six2dez/reconftw
cd reconftw
./install.sh --verbose
```
2) Run a scan (full + resume)
```bash
./reconftw.sh -d example.com -r
```
3) Minimal run (passive-only footprint)
```bash
./reconftw.sh -d example.com -p
```
> Tip: re-run `./install.sh --tools` later to refresh the toolchain without reinstalling system packages.
### Local Installation (PC/VPS/VM)
1. **Prerequisites**:
- **Golang**: Latest version (`install_golang` enabled by default in `reconftw.cfg`).
- **System Permissions**: If not running as root, configure sudo to avoid prompts:
```bash
sudo echo "${USERNAME} ALL=(ALL:ALL) NOPASSWD: ALL" | sudo tee -a /etc/sudoers.d/reconFTW
```
2. **Steps**:
```bash
git clone https://github.com/six2dez/reconftw
cd reconftw
./install.sh
./reconftw.sh -d target.com -r
```
3. **Notes**:
- The `install.sh` script installs dependencies, tools, and configures paths (`GOROOT`, `GOPATH`, `PATH`).
- Set `install_golang=false` in `reconftw.cfg` if Golang is already configured.
- For existing setups, run `./install.sh --tools` to refresh Go binaries, pipx packages, and repositories without touching system packages.
- Check the [Installation Guide](https://github.com/six2dez/reconftw/wiki/0.-Installation-Guide) for detailed instructions.
### Docker
1. **Pull the Image**:
```bash
docker pull six2dez/reconftw:main
```
2. **Run the Container**:
```bash
docker run -it --rm \
-v "${PWD}/OutputFolder/:/reconftw/Recon/" \
six2dez/reconftw:main -d example.com -r
```
For a list of targets, bind the list file into the container and reference the in-container path:
```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
```
3. **View Results**:
- Results are saved in the `OutputFolder` directory on the host (not inside the container).
4. **Customization**:
- Modify the Docker image or build your own; see the [Docker Guide](https://github.com/six2dez/reconftw/wiki/4.-Docker).
- To skip Ax tooling in custom builds, pass `--build-arg INSTALL_AXIOM=false`.
- Mount your notify config at `~/.config/notify/provider-config.yaml` inside the container if you use notifications.
5. **Secrets at Runtime**:
Pass API keys and secrets via environment variables β never bake them into the image:
```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
```
See [SECURITY.md](SECURITY.md) for full secrets management guidance.
6. **Health Check**:
The Docker image includes a built-in `HEALTHCHECK` that runs `./reconftw.sh --health-check` every 60 seconds. You can also run it manually:
```bash
docker exec ./reconftw.sh --health-check
```
### Terraform + Ansible
- Deploy reconFTW on AWS using Terraform and Ansible.
- Follow the guide in [Terraform/README.md](Terraform/README.md) for setup instructions.
---
## π οΈ Troubleshooting
- Bash 4+ on macOS: The scripts auto-relaunch under Homebrew Bash. If you see a message about Bash < 4, run `brew install bash`, open a new terminal, and re-run `./install.sh`.
- timeout on macOS: macOS provides `gtimeout` via `brew install coreutils`. The scripts now detect and use it automatically.
- Network hiccups: Installers hide most command output. If something fails, re-run with `upgrade_tools=true` in `reconftw.cfg`, execute `./install.sh --tools`, or install the missing tool manually (the error will name it).
- GOPATH binaries: Binaries are copied to `/usr/local/bin`. If you prefer not to, ensure `~/go/bin` is in your `PATH`.
- Nuclei templates: If templates werenβt cloned, remove `~/nuclei-templates` and re-run `./install.sh`.
## π API Checklist (Optional)
- `subfinder`: `~/.config/subfinder/provider-config.yaml`
- GitHub tokens: `~/Tools/.github_tokens` (one per line)
- GitLab tokens: `~/Tools/.gitlab_tokens` (one per line)
- WHOISXML: set `WHOISXML_API` in `reconftw.cfg` or env var
- ASN enumeration (`asnmap`): set `PDCP_API_KEY` in env/config (`ASN_ENUM` skips if unset)
- Slack/Discord/Telegram: configure `notify` in `~/.config/notify/provider-config.yaml`
- SSRF server: set `COLLAB_SERVER` env/cfg if used
- Blind XSS server: set `XSS_SERVER` env/cfg if used
## πΎ Requirements
- Disk: 10β20 GB free recommended (toolchain + data)
- Network: stable connection during installation and updates
- OS: Linux/macOS with Bash β₯ 4
- Extras: `shellcheck` and `shfmt` (optional) for `make lint`/`make fmt`
## βοΈ Configuration
The `reconftw.cfg` file controls the entire execution of reconFTW. It allows fine-grained customization of:
- **Tool Paths**: Set paths for tools, resolvers, and wordlists (`tools`, `resolvers`, `fuzz_wordlist`).
- **API Keys**: Configure keys for Shodan, WHOISXML, etc. via environment variables or `secrets.cfg` (see [SECURITY.md](SECURITY.md)).
- **Scanning Modes**: Enable/disable modules (e.g., `OSINT`, `SUBDOMAINS_GENERAL`, `VULNS_GENERAL`).
- **Performance**: Adjust threads, rate limits, and timeouts (e.g., `FFUF_THREADS`, `HTTPX_RATELIMIT`).
- **Adaptive Rate Limiting**: Automatically back off on 429/503 errors (`ADAPTIVE_RATE_LIMIT`, `MIN_RATE_LIMIT`, `MAX_RATE_LIMIT`).
- **Incremental Scanning**: Only scan new findings since last run (`INCREMENTAL_MODE`).
- **Notifications**: Set up Slack, Discord, or Telegram notifications (`NOTIFY_CONFIG`).
- **Ax (formerly Axiom)**: Configure distributed scanning and resolver paths (`AXIOM_FLEET_NAME`, `AXIOM_FLEET_COUNT`, `AXIOM_RESOLVERS_PATH`).
- **AI Reporting**: Configure model/profile/format and context controls (`AI_MODEL`, `AI_REPORT_PROFILE`, `AI_REPORT_TYPE`, `AI_MAX_CHARS_PER_FILE`).
- **Advanced Web Checks**: Toggle GraphQL introspection, parameter discovery, WebSocket testing, gRPC probing, and IPv6 scanning.
- **Automation & Data**: Control quick rescan heuristics, asset logging, chunk sizes, hotlists, and debug tracing (`QUICK_RESCAN`, `ASSET_STORE`, `CHUNK_LIMIT`, `HOTLIST_TOP`, `SHOW_COMMANDS`).
- **Disk & Logging**: Pre-flight disk check (`MIN_DISK_SPACE_GB`), log rotation (`MAX_LOG_FILES`, `MAX_LOG_AGE_DAYS`), structured JSON logging (`STRUCTURED_LOGGING`).
- **Caching**: Configure cache expiry for wordlists and resolvers (`CACHE_MAX_AGE_DAYS`).
- **DNS Resolver Safety**: Missing resolver files fail fast, resolver downloads use configurable retry/timeout knobs (`RESOLVER_DOWNLOAD_*`), and DNS brute/resolve timeout defaults to disabled (`DNS_*_TIMEOUT=0`) with heartbeat progress.
- **Secrets**: Use `secrets.cfg` for local overrides or environment variables for CI/Docker (see [SECURITY.md](SECURITY.md)).
**Example Configuration**:
```
/* Detailed source-code truncated for AI context efficiency. */
```
**DNS resolver guardrails**:
- Missing/empty resolver files now fail fast before DNS brute/resolve starts.
- Resolver downloads are configurable with `RESOLVER_DOWNLOAD_CONNECT_TIMEOUT`, `RESOLVER_DOWNLOAD_MAX_TIME`, `RESOLVER_DOWNLOAD_RETRY`, and `RESOLVER_DOWNLOAD_RETRY_DELAY`.
- `DNS_BRUTE_TIMEOUT=0` and `DNS_RESOLVE_TIMEOUT=0` disable hard-timeout by default (recommended for very large target sets). Heartbeat progress still prints every `DNS_HEARTBEAT_INTERVAL_SECONDS`.
```bash
DNS_BRUTE_TIMEOUT=4h
DNS_RESOLVE_TIMEOUT=6h
DNS_HEARTBEAT_INTERVAL_SECONDS=20
```
**Full Details**: See the [Configuration Guide](https://github.com/six2dez/reconftw/wiki/3.-Configuration-file).
---
## π Usage
reconFTW supports multiple modes and options for flexible reconnaissance. Use the `-h` flag to view the help menu.
### Target Options
| Flag | Description |
| ---- | ------------------------------------------------------------ |
| `-d` | Single target domain (e.g., `example.com`) |
| `-l` | File with list of target domains (one per line) |
| `-m` | Multi-domain target (e.g., company name for related domains) |
| `-x` | Exclude subdomains (out-of-scope list) |
| `-i` | Include subdomains (in-scope list) |
### Mode Options
| Flag | Description |
| ---- | --------------------------------------------------------------------- |
| `-r` | **Recon**: Full reconnaissance without active attacks |
| `-s` | **Subdomains**: Subdomain enumeration, web probing, and takeovers |
| `-p` | **Passive**: Passive reconnaissance only |
| `-a` | **All**: Full reconnaissance plus active vulnerability checks |
| `-w` | **Web**: Vulnerability checks on specific web targets |
| `-n` | **OSINT**: OSINT scan without subdomain enumeration or attacks |
| `-z` | **Zen**: Lightweight recon with basic checks and some vulnerabilities |
| `-c` | **Custom**: Run a specific function (requires additional arguments) |
| `-h` | Show help menu |
### General Options
| Flag | Description |
| ----------------- | -------------------------------------------------------- |
| `--deep` | Enable deep scanning (slower, VPS recommended) |
| `-f` | Custom configuration file path |
| `-o` | Output directory for results |
| `-v` | Enable Ax distributed scanning |
| `--vps-count` | Override Ax fleet instance count for this run |
| `-q` | Set rate limit (requests per second) |
| `-y` | Enables AI results analysis |
| `--check-tools` | Exit if required tools are missing |
| `--quick-rescan` | Skip heavy modules when no new subs/webs are found |
| `--health-check` | Run system health check and exit |
| `--incremental` | Only scan new findings since last run |
| `--adaptive-rate` | Automatically adjust rate limits on errors (429/503) |
| `--dry-run` | Show what would be executed without running commands |
| `--parallel` | Run independent functions in parallel (faster, more RAM) |
| `--no-parallel` | Force sequential execution even if parallel is enabled |
| `--monitor` | Continuous monitoring mode (single target; `-w` supports `-l`) |
| `--monitor-interval` | Minutes between monitor cycles |
| `--monitor-cycles` | Stop after N cycles (0 = infinite) |
| `--report-only` | Rebuild report artifacts without scanning |
| `--refresh-cache` | Force refresh of cached resolvers/wordlists |
| `--export` | Export artifacts: `json`, `html`, `csv`, or `all` |
### Example Usage
1. **Full Recon on a Single Target**:
```bash
./reconftw.sh -d target.com -r
```
2. **Recon on Multiple Targets**:
```bash
./reconftw.sh -l targets.txt -r -o /path/to/output/
```
3. **Deep Recon (VPS Recommended)**:
```bash
./reconftw.sh -d target.com -r --deep
```
4. **Parallel Mode (Faster, requires more RAM)**:
```bash
./reconftw.sh -d target.com -r --parallel
```
5. **Force Sequential Mode**:
```bash
./reconftw.sh -d target.com -r --no-parallel
```
6. **Multi-Domain Recon**:
```bash
./reconftw.sh -m company -l domains.txt -r
```
7. **Ax Integration**:
```bash
./reconftw.sh -d target.com -r -v
```
8. **Ax Integration with fleet override**:
```bash
./reconftw.sh -d target.com -r -v 30
```
9. **Full Recon with Attacks (YOLO Mode)**:
```bash
./reconftw.sh -d target.com -a
```
10. **Show Help**:
```bash
./reconftw.sh -h
```
11. **Force cache refresh**:
```bash
./reconftw.sh -d target.com -r --refresh-cache
```
12. **Export all report artifacts**:
```bash
./reconftw.sh -d target.com -r --export all
```
13. **Continuous monitoring (every 30m, 48 cycles)**:
```bash
./reconftw.sh -d target.com -r --monitor --monitor-interval 30 --monitor-cycles 48
```
14. **Rebuild reports only (no scan):**
```bash
./reconftw.sh -d target.com --report-only --export all
```
**Full Guide**: See the [Usage Guide](https://github.com/six2dez/reconftw/wiki/2.-Usage-Guide).
---
## βοΈ Ax Framework Support (previously Axiom)
reconFTW integrates with [Ax](https://github.com/attacksurge/ax) for distributed scanning, reducing execution time by distributing tasks across multiple cloud instances.
- **Setup**: Select `reconftw` as the provisioner during Ax configuration (`axiom-configure`).
- **Fleet Management**: Automatically create and destroy fleets (`AXIOM_FLEET_LAUNCH`, `AXIOM_FLEET_SHUTDOWN`) or use an existing fleet.
- **Configuration**: Set fleet size, region, and name in `reconftw.cfg` (`AXIOM_FLEET_COUNT`, `AXIOM_FLEET_REGIONS`, `AXIOM_FLEET_NAME`).
**Example**:
```bash
./reconftw.sh -d target.com -r -v
```
**Details**: See the official [Ax Docs](https://ax.attacksurge.com/) and the [attacksurge/ax repo](https://github.com/attacksurge/ax).
---
## π» Faraday Support
reconFTW integrates with [Faraday](https://faradaysec.com/) for web-based reporting and vulnerability management.
- **Setup**: Install Faraday, authenticate via `faraday-cli`, and configure the workspace in `reconftw.cfg` (`FARADAY_WORKSPACE`).
- **Usage**: Enable with `FARADAY=true` in `reconftw.cfg`.
---
## π§ AI Integration
reconFTW uses AI to generate detailed reports from scan results with the tool [reconftw_ai](https://github.com/six2dez/reconftw_ai).
- **Model**: Configurable AI model (e.g., `llama3:8b` via `AI_MODEL`).
- **Report Types**: Markdown or plain text (`AI_REPORT_TYPE`).
- **Profiles**: Executive, brief, or bug hunter (`AI_REPORT_PROFILE`).
- **Structured Output**: `reconftw` stores a machine-readable report in `ai_result/reconftw_analysis.json`.
- **Context Controls**: Bound input size using `AI_MAX_CHARS_PER_FILE` and `AI_MAX_FILES_PER_CATEGORY`.
- **Safety Controls**: Toggle redaction and strict mode with `AI_REDACT` and `AI_STRICT`.
**Example**:
```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
```
---
## ποΈ Data Management
Manage scan data and API keys securely using a private repository.
When `ASSET_STORE=true`, reconFTW aggregates key findings into `assets.jsonl` during each run, making it easy to sync only actionable deltas to your private repo.
### Makefile
Use the provided `Makefile` for easy repository management (requires [GitHub CLI](https://cli.github.com/)).
1. **Bootstrap**:
```bash
export PRIV_REPO="$HOME/reconftw-data"
make bootstrap
```
2. **Sync with Upstream**:
```bash
make sync
```
3. **Upload Data**:
```bash
make upload
```
4. **Lint / Format Scripts**:
```bash
make lint # shellcheck for reconftw.sh, modules/*.sh & install.sh
make fmt # shfmt with project defaults
```
5. **Run Tests**:
```bash
make test # unit tests (bats-core)
make test-all # unit + integration tests
```
### Manual
1. Create a private repository on GitHub/GitLab.
2. Clone and 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
```
3. **Upload Changes**:
```bash
git add .
git commit -m "Data upload"
git push origin master
```
4. **Update Tool**:
```bash
git fetch upstream
git rebase upstream/main master
```
---
## π§ͺ Testing
reconFTW uses [bats-core](https://github.com/bats-core/bats-core) for automated testing.
### Install 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
```
### Running Tests
```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
```
### Test Directory Structure
```
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
```
### Running Security Tests
```bash
# Test command injection prevention
make test-security
# Or directly
bats tests/security/
```
### Writing Tests
Tests use the `--source-only` pattern to load functions without executing the main script:
```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" ]
}
```
### CI Pipeline
The GitHub Actions workflow (`.github/workflows/tests.yml`) runs on every push and pull request:
1. **ShellCheck** β lints `reconftw.sh`, `modules/*.sh`, and `install.sh`
2. **Unit Tests** β runs all `tests/unit/*.bats` files
3. **Integration Tests** β installs reconFTW and validates tool availability
---
## Mindmap/Workflow
---
## Sample video
---
## π€ How to Contribute
See [CONTRIBUTING.md](CONTRIBUTING.md) for the full contributing guide, including development setup, code style, testing, and PR process.
Quick links:
- [Report a Bug](https://github.com/six2dez/reconftw/issues/new/choose)
- [Submit a Pull Request](https://github.com/six2dez/reconftw/tree/dev) (target the `dev` branch)
- [Code of Conduct](CODE_OF_CONDUCT.md)
---
## π Security
For security policy, secrets management, and vulnerability reporting, see [SECURITY.md](SECURITY.md).
---
## β Need Help?
- **Wiki**: Explore the [reconFTW Wiki](https://github.com/six2dez/reconftw/wiki).
- **FAQ**: Check the [FAQ](https://github.com/six2dez/reconftw/wiki/7.-FAQs).
- **Community**: Join the [Discord server](https://discord.gg/R5DdXVEdTy) or [Telegram group](https://t.me/joinchat/TO_R8NYFhhbmI5co).
---
## π Support This Project
Support reconFTWβs development through:
- **Buy Me a Coffee**: [buymeacoffee.com/six2dez](https://www.buymeacoffee.com/six2dez)
[](https://www.buymeacoffee.com/six2dez)
- **DigitalOcean Referral**: [Referral Link](https://www.digitalocean.com/?refcode=f362a6e193a1&utm_campaign=Referral_Invite&utm_medium=Referral_Program&utm_source=badge)
[](https://www.digitalocean.com/?refcode=f362a6e193a1&utm_campaign=Referral_Invite&utm_medium=Referral_Program&utm_source=badge)
- **GitHub Sponsorship**: [github.com/sponsors/six2dez](https://github.com/sponsors/six2dez)
---
## π Thanks
Special thanks to the following services for supporting 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/)
---
## π Changelog
See [CHANGELOG.md](CHANGELOG.md) for a detailed list of changes in each release.
---
## π οΈ Development
### Project Structure
```
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
```
### Running Tests
```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
```
### Development Workflow
```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
See [CONTRIBUTING.md](CONTRIBUTING.md) for development guidelines and [docs/ARCHITECTURE.md](docs/ARCHITECTURE.md) for technical details.
---
## π License
reconFTW is licensed under the [MIT License](LICENSE).
---
## β Star History
[](https://www.star-history.com/#six2dez/reconftw&Date)
---
## File: Proxmox/README.md
# ReconFTW Proxmox LXC Deployment Script
This script automates the deployment of ReconFTW in a Linux Container (LXC) on a Proxmox server. It simplifies the process of setting up a dedicated environment for reconnaissance activities.
## Prerequisites
- A Proxmox VE server (version 6.x or later)
- Root access to the Proxmox server
- Sufficient storage space on the Proxmox server
## Usage
1. Copy the script `bash -c "$(curl -fsSL https://raw.githubusercontent.com/six2dez/reconftw/master/Proxmox/reconftw_prox_deploy.sh)"` to your Proxmox server.
4. Follow the prompts to configure your LXC container. You'll be asked for:
- Container ID
- Storage location
- Root filesystem size
- RAM allocation
- Number of CPU cores
- Hostname
- Password
5. The script will then:
- Download the Debian template if not already present
- Create and configure the LXC container
- Install ReconFTW and its dependencies
6. Once completed, the script will display the container information, including ID, hostname, and password.
## Logging
The script generates a log file in `/var/log/` with the format `reconftw_deploy_YYYYMMDD_HHMMSS.log`. Refer to this log for detailed information about the deployment process.
## Post-Installation
After the script completes:
1. You can access the container using:
```bash
pct enter
```
2. ReconFTW will be installed in `/opt/reconftw/`. Navigate to this directory to use ReconFTW.
3. Refer to the [ReconFTW documentation](https://github.com/six2dez/reconftw) for usage instructions.
## Troubleshooting
- If the script fails, check the log file for error messages.
- Ensure you have sufficient storage space and resources on your Proxmox server.
- Verify that your Proxmox server has internet access to download necessary packages.
## Security Note
Remember to change the default password after accessing the container for the first time.
## Support
For issues related to this deployment script, please open an issue in the GitHub repository. For ReconFTW-specific questions, refer to the [ReconFTW GitHub page](https://github.com/six2dez/reconftw).
---
## File: Terraform/README.md
# reconFTW loves Ansible+Terraform <3
This is an automated script created to work under AWS by using Terraform and Ansible. It allows you to easily deploy it or to easily adapt it into your IaaC strategy.
> Note (best-effort): This Terraform/Ansible setup is provided as a reference. Cloud images, SSH usernames, and
> package repos change over time, so you may need to adjust it for your environment. It is not covered by reconFTW CI.
## Requirements
You would need to have installed:
- AWS CLI ()
- Terraform ()
- Ansible ()
And AWS credentials configured via the standard AWS provider chain (e.g., `AWS_PROFILE`, env vars, or an IAM role).
## Deploying reconFTW on the AWS Cloud using Terraform and Ansible
Note: **this will charge costs (unless you are in the Free Tier)**
1. Move to the Terraform folder (optional but recommended): `cd Terraform`
- Put your own Subfinder config file and reconFTW config file on the files/ folder
1. Create a key pair to be used, e.g: `ssh-keygen -f terraform-keys -t ecdsa -b 521`
1. Run `terraform init`
1. Run `terraform apply`
- You will be prompted for `allowed_ssh_cidr` (recommended: your public IP + `/32`)
1. Type "yes" and hit enter
1. Wait, because it can take up to 15 min.
1. Once the process has finished, you can now login, using `ssh admin@ip -i terraform-keys`
1. ???
1. If you have finished playing with reconFTW and hacking the world, remember to destroy the instance using `terraform destroy`
## 2. Official Technical Reference & Guides (six2dez/reconftw-docs)
## File: README.md
# reconFTW Documentation
---
## Welcome to reconFTW
**reconFTW** is a modular reconnaissance automation framework designed for security researchers, penetration testers, and bug bounty hunters. It orchestrates 80+ security tools to perform full reconnaissance on your targets, from subdomain enumeration to vulnerability scanning.
### Why reconFTW?
| Feature | Description |
|---------|-------------|
| **Automated Workflow** | Complete reconnaissance pipeline with a single command |
| **Modular Design** | Enable/disable any module or function as needed |
| **Distributed Scanning** | Scale with [Axiom](08-integrations/axiom.md) across cloud infrastructure |
| **Structured Output** | Organized results with multiple export formats |
| **Continuous Monitoring** | Recurrent scan cycles with delta and alert snapshots |
| **Report Rebuild Mode** | Recreate report/export artifacts from existing scan data |
| **Highly Configurable** | 300+ configuration options for fine-tuning |
| **Incremental Scans** | Only scan new findings since last run |
| **AI Integration** | Generate structured JSON + markdown/txt security summaries with local AI models |
### What Can reconFTW Do?
```
/* Detailed source-code truncated for AI context efficiency. */
```
---
## Quick Start
```bash
# Install reconFTW
git clone https://github.com/six2dez/reconftw.git
cd reconftw
./install.sh
# Run your first scan
./reconftw.sh -d example.com -r
# Full scan with vulnerabilities
./reconftw.sh -d example.com -a
```
---
## Documentation Overview
This documentation is organized to help you get the most out of reconFTW:
### π For Beginners
1. **[First 30 Minutes](first-30-minutes.md)** - Quick start guide to get scanning
2. **[Getting Started](01-getting-started/getting-started.md)** - Installation and setup
3. **[Concepts](02-concepts/concepts.md)** - Understanding how reconFTW works
4. **[Usage Guide](03-usage/usage.md)** - All command-line options explained
### π§ For Configuration
5. **[Configuration](04-configuration/configuration.md)** - Deep dive into reconftw.cfg
6. **[Modules](05-modules/)** - Detailed documentation for each module
7. **[Tools Reference](06-tools/tools.md)** - All 80+ integrated tools
### π For Results
8. **[Output Interpretation](07-output/output.md)** - Understanding your results
9. **[Data Model & I/O](data-model.md)** - Complete input/output reference
10. **[Integrations](08-integrations/)** - Axiom and Faraday setup
### For Advanced Users
11. **[Deployment](09-deployment/deployment.md)** - Docker, Terraform, VPS, CI/CD
12. **[Performance Tuning](tuning.md)** - Optimize for speed and target size
13. **[Case Studies](case-studies.md)** - Real-world usage examples
14. **[Advanced Usage](10-advanced/advanced.md)** - Custom functions and optimization
15. **[Troubleshooting](11-troubleshooting/troubleshooting.md)** - Common issues and solutions
16. **[Release Gate](release-gate.md)** - Required checks before publishing updates
### βοΈ Legal & Security
17. **[OPSEC & Legal](opsec-legal.md)** - Stay safe and authorized
---
## Scan Modes at a Glance
| Mode | Flag | Description | Use Case |
|------|------|-------------|----------|
| **Recon** | `-r` | Full reconnaissance | Standard bug bounty recon |
| **Subdomains** | `-s` | Subdomain enumeration only | Quick subdomain discovery |
| **Passive** | `-p` | Passive reconnaissance | Stealth/non-intrusive |
| **All** | `-a` | Full recon + vulnerabilities | Full assessment |
| **Web** | `-w` | Web analysis only | Analyze known URLs |
| **OSINT** | `-n` | OSINT gathering only | Intelligence gathering |
| **Custom** | `-c` | Run custom function | Advanced workflows |
| **Zen** | `-z` | Minimal output mode | Clean terminal output |
| **AI Report** | `-y` | Generate AI-assisted report | Post-scan summarization |
| **VPS Fleet** | `-v` | Run via Axiom distributed fleet | Large surfaces / faster runs |
Additional workflow flags:
- `--monitor`, `--monitor-interval`, `--monitor-cycles`
- `--report-only`, `--no-report`
- `--export json|html|csv|all`
- `--refresh-cache`, `--gen-resolvers`
- `--incremental`, `--adaptive-rate`, `--quick-rescan`
- `--quiet`, `--verbose`, `--no-color`
- `--log-format plain|jsonl|jsonl-strict`
- `--parallel-log summary|tail|full`
Bundled config profiles:
- `config/reconftw_quick.cfg`
- `config/reconftw_full.cfg`
- `config/reconftw_stealth.cfg`
---
## β οΈ Legal & OPSEC
> **IMPORTANT**: reconFTW is designed for authorized security testing only.
### Authorization Checklist
Before running any scan, verify:
- [ ] Written permission from target owner
- [ ] Defined scope (in-scope and out-of-scope assets)
- [ ] Rate limits agreed upon
- [ ] Testing window defined (if applicable)
- [ ] Emergency contact available
- [ ] NDA signed (if required)
### OPSEC Considerations
| Risk | Mitigation |
|------|------------|
| **IP Blocking** | Use VPS, rotate IPs with Axiom |
| **WAF Detection** | Start with passive mode (`-p`) |
| **Rate Limiting** | Use `--adaptive-rate` flag |
| **Legal Issues** | Always have written authorization |
| **Data Exposure** | Keep `secrets.cfg` secure, never commit |
### Legal Disclaimer
By using this tool, you confirm that:
- You have explicit written permission to test the target
- You will comply with all applicable laws and regulations
- You understand that unauthorized testing is illegal
The developers assume no liability for misuse of this tool. **Use responsibly.**
β‘οΈ **[Full OPSEC Guide](02-concepts/concepts.md#opsec-and-legal)**
---
## Community & Support
- **GitHub Issues**: [Report bugs or request features](https://github.com/six2dez/reconftw/issues)
- **Discord**: [Join our community](https://discord.gg/R5DdXVEdTy)
- **Telegram**: [Discussion group](https://t.me/joinchat/H5bAaw3YbzzmI5co)
- **Twitter**: [@Six2dez1](https://twitter.com/Six2dez1)
---
## Contributing
reconFTW is open source and welcomes contributions! See our [Contributing Guide](https://github.com/six2dez/reconftw/blob/main/CONTRIBUTING.md) for details.
---
---
---
## File: assets/README.md
# Assets Directory
This directory contains images and other media files for the reconFTW documentation.
## Directory Structure
```
assets/
βββ images/ # Screenshots, diagrams, and illustrations
β βββ architecture/ # Architecture diagrams
β βββ screenshots/ # UI screenshots
β βββ diagrams/ # Flow diagrams
β βββ icons/ # Icons and logos
βββ README.md # This file
```
## Required Images
The following images are referenced in the documentation and need to be created:
### Architecture Diagrams
| Filename | Location | Description |
|----------|----------|-------------|
| `architecture-overview.png` | concepts.md | High-level reconFTW architecture showing modules and data flow |
| `data-flow.png` | concepts.md | Data flow between modules showing how results propagate |
| `checkpoint-system.png` | concepts.md | Visual explanation of checkpoint/resume system |
| `axiom-architecture.png` | axiom.md | Axiom distributed scanning architecture |
| `faraday-integration.png` | faraday.md | Data flow from reconFTW to Faraday |
### Screenshot Examples
| Filename | Location | Description |
|----------|----------|-------------|
| `terminal-scan-output.png` | getting-started.md | Terminal showing reconFTW running a scan |
| `screenshot-gallery.png` | web-analysis.md | Nuclei screenshot gallery example |
| `nuclei-results.png` | vulnerabilities.md | Example Nuclei vulnerability output |
| `faraday-dashboard.png` | faraday.md | Faraday web interface with imported results |
### Module Diagrams
| Filename | Location | Description |
|----------|----------|-------------|
| `osint-flow.png` | osint.md | OSINT module data flow |
| `subdomain-flow.png` | subdomains.md | Subdomain enumeration pipeline |
| `web-analysis-flow.png` | web-analysis.md | Web analysis module flow |
| `vuln-scanning-flow.png` | vulnerabilities.md | Vulnerability scanning workflow |
| `host-analysis-flow.png` | hosts.md | Host analysis pipeline |
## Image Guidelines
### Dimensions
- **Architecture diagrams:** 1200x800px (landscape)
- **Screenshots:** 1400x900px or native resolution
- **Flow diagrams:** 800x1200px (portrait) or 1200x800px (landscape)
- **Icons:** 64x64px or 128x128px
### Format
- **Diagrams:** PNG with transparent background preferred
- **Screenshots:** PNG
- **Icons:** SVG preferred, PNG acceptable
### Style Guidelines
- Use consistent color scheme matching reconFTW branding
- Primary color: `#2D3748` (dark blue-gray)
- Accent color: `#48BB78` (green)
- Use clean, readable fonts (Inter, Roboto, or system fonts)
- Include proper contrast for accessibility
## Creating Images
### Recommended Tools
- **Diagrams:** draw.io, Excalidraw, Mermaid
- **Screenshots:** macOS Screenshot, Flameshot, ShareX
- **Image editing:** GIMP, Figma, Canva
### Using Mermaid (for GitBook)
GitBook supports Mermaid diagrams. Example:
```mermaid
graph TD
A[Target Domain] --> B[OSINT]
B --> C[Subdomains]
C --> D[Host Analysis]
D --> E[Web Analysis]
E --> F[Vulnerabilities]
```
### ASCII Diagrams
The documentation includes ASCII diagrams as fallbacks. These work in all environments and don't require images.
## Placeholder Convention
In the documentation, image placeholders are marked with HTML comments:
```html
```
## Contributing Images
1. Create image following guidelines above
2. Place in appropriate subdirectory
3. Use descriptive filename (kebab-case)
4. Update documentation to reference image:
```markdown
```
5. Submit PR with image and documentation update
## License
All images in this directory should be:
- Original creations, OR
- Properly licensed for open source use (CC0, CC-BY, MIT, etc.)
Do not include copyrighted images without permission.
---
## File: 05-modules/README.md
# Modules Overview
reconFTW is organized into specialized modules, each handling a specific phase of reconnaissance. This page provides an overview and quick navigation to each module's detailed documentation.
---
## Module Architecture
```mermaid
flowchart TD
T[Target Input] --> O[OSINT]
O --> S[Subdomains]
S --> H[Hosts]
H --> W[Web Analysis]
W --> V[Vulnerabilities]
O -.-> O1[Dorks, emails, metadata, leaks]
S -.-> S1[Passive, brute, permutations, takeover]
H -.-> H1[Ports, CDN, WAF, geolocation]
W -.-> W1[Probing, screenshots, JS analysis, fuzzing]
V -.-> V1[Nuclei, XSS, SQLi, SSRF, etc.]
```
---
## Module Summary
| Module | Functions | Primary Tools | Output Directory |
|--------|-----------|---------------|------------------|
| [OSINT](osint.md) | 13 | dorks_hunter, ghleaks, postleaksNg, trufflehog, gato | `osint/` |
| [Subdomains](subdomains.md) | 17 | subfinder, puredns, dnsx, dnstake, hakip2host | `subdomains/` |
| [Hosts](hosts.md) | 6 | nmap, naabu, nerva (Praetorian Suite), smap, cdncheck | `hosts/` |
| [Web Analysis](web-analysis.md) | 19 | httpx, favirecon, katana, ffuf, julius | `webs/`, `fuzzing/`, `js/` |
| [Vulnerabilities](vulnerabilities.md) | 18 | nuclei, dalfox, sqlmap, TInjA, second-order, toxicache, brutus/brutespray | `vulns/` |
---
## OSINT Module
**Purpose:** Gather intelligence about the target organization without direct interaction.
**Key Capabilities:**
- Google dorking for sensitive files
- GitHub secret scanning
- Email harvesting
- Document metadata extraction
- Cloud storage enumeration
- API leak detection
**When to use:** At the beginning of an engagement for initial intelligence gathering.
β‘οΈ **[Full OSINT Documentation](osint.md)**
---
## Subdomains Module
**Purpose:** Discover all subdomains associated with the target domain.
**Key Capabilities:**
- Passive enumeration (40+ sources)
- Certificate Transparency logs
- DNS brute-forcing
- Permutation generation
- Recursive enumeration
- Subdomain takeover detection
**When to use:** After OSINT, to map the attack surface.
β‘οΈ **[Full Subdomains Documentation](subdomains.md)**
---
## Hosts Module
**Purpose:** Analyze infrastructure behind discovered assets.
**Key Capabilities:**
- Port scanning (passive + active)
- Service fingerprinting on discovered ports
- CDN detection and filtering
- WAF identification
- IP geolocation
**When to use:** After subdomain enumeration, to understand infrastructure.
β‘οΈ **[Full Hosts Documentation](hosts.md)**
---
## Web Analysis Module
**Purpose:** Analyze web applications and discover endpoints.
**Key Capabilities:**
- HTTP probing and status detection
- Screenshot capture
- URL extraction from archives
- JavaScript analysis for secrets
- Directory/file fuzzing
- Technology detection
**When to use:** After identifying live web servers.
β‘οΈ **[Full Web Analysis Documentation](web-analysis.md)**
---
## Vulnerabilities Module
**Purpose:** Identify security vulnerabilities in discovered assets.
**Key Capabilities:**
- Template-based scanning (Nuclei)
- XSS testing
- SQL injection detection
- SSRF testing
- CORS misconfiguration
- SSL/TLS analysis
- And many more...
**When to use:** Final phase, after mapping all assets.
β‘οΈ **[Full Vulnerabilities Documentation](vulnerabilities.md)**
---
## Module Execution Order
In a full scan (`-a` flag), modules execute in this order:
```
1. OSINT β Intelligence gathering
2. Subdomains β Asset discovery
3. Hosts β Infrastructure analysis
4. Web Analysis β Application mapping
5. Vulnerabilities β Security testing
```
Each module builds on the previous one's output, creating a full reconnaissance pipeline.
---
## Enabling/Disabling Modules
### Via Configuration
```bash
# In reconftw.cfg
OSINT=true
SUBDOMAINS_GENERAL=true
PORTSCANNER=true
WEBPROBEFULL=true # Unified web probing over 80/443 + uncommon ports
NUCLEICHECK=true
# Use VULNS_GENERAL=true if you want to enable the full vulnerability module by config
```
### Via Command Line
```bash
# Run only specific modules
./reconftw.sh -d example.com -s # Subdomains only
./reconftw.sh -d example.com -n # OSINT only
./reconftw.sh -d example.com -w # Web analysis only
# Custom function selection
./reconftw.sh -d example.com -c sub_passive
./reconftw.sh -d example.com -c webprobe_full
```
---
## Module Dependencies
Some modules depend on outputs from others:
```
OSINT ββββββββββββββββββββββββββββββββββββββ
β
Subdomains ββββββββ¬βββββββββββββββββββββββββ€
β β
βΌ β
Hosts ββββββββββββββββββββββββ€
β β
βΌ β
Web Analysis ββββββββββββββββββββ€
β β
βΌ β
Vulnerabilities ββββββββββββββββββ
```
---
## Next Steps
Choose a module to explore in detail:
- **[OSINT Module](osint.md)** - Start with intelligence gathering
- **[Subdomains Module](subdomains.md)** - Discover your attack surface
- **[Hosts Module](hosts.md)** - Understand the infrastructure
- **[Web Analysis Module](web-analysis.md)** - Map web applications
- **[Vulnerabilities Module](vulnerabilities.md)** - Find security issues