The recon tool that snitches on your attack surface.
snitch chains subfinder → naabu → httpx → Nmap → Nuclei → ffuf → katana into
one correlated, deduplicated, re-runnable recon pipeline, and then watches
your targets: run it on a schedule and it alerts a webhook (Discord/Slack/
anything) the moment something new appears. One static Go binary, no runtime
dependencies, no infra.
Most recon tooling is either heavy (spin up Docker + Postgres + a web stack) or
fire-and-forget (scan once, diff by hand). snitch is the lightweight middle
ground: a single binary you can cron and forget, that tells you what changed.
| snitch | typical bash orchestrator | reNgine-style platform | |
|---|---|---|---|
| Deploy | one static binary | scripts + tool deps | Docker + Postgres + web |
| Re-runnable + dedup | ✅ built in | ✗ | ✅ |
| Diff + webhook alerts | ✅ monitor |
✗ | partial |
| Correlated per-host report | ✅ MD + HTML | ✗ | ✅ |
| Actionable findings (remediation/CVE/curl) | ✅ | ✗ | varies |
- Full discovery chain: subfinder widens a domain into its subdomains,
naabu fast-scans them for open ports, httpx probes for live HTTP(S) (title,
tech, status), Nmap adds service/version depth, Nuclei + ffuf run against the
confirmed web targets, and katana crawls them for linked endpoints. Every
stage is optional (
--skip-subfinder,--skip-naabu,--skip-katana, …). - Injection testing: the parameterized URLs katana discovers are
filtered to the target and its subdomains (never a third-party host) and
deduplicated by parameter signature, so
?q=1and?q=2aren't tested twice. What's left goes to dalfox (XSS) and crlfuzz (CRLF) automatically, and, opt-in with--sqli, to sqlmap. Confirmed hits land in the report as priority findings with a reproduction command. sqlmap is off by default and capped (--sqli-max) because it actively exploits. - Chained, not parallel-blind: discovery drives what gets tested: only live web services reach Nuclei and ffuf, no HTTP templates fired at an SSH port. Findings from every tool are correlated back onto one asset per host:port (nmap's service + httpx's title/tech merged into a single row).
monitormode with alerts: re-scan on a schedule, diff against everything seen before, and POST an alert to a Discord/Slack/generic webhook when a new service or finding shows up. Auto-detects the webhook type from the URL.- Deduplication with a real dedup key: re-run next week and you see what's
new, not the same 200 rows, verified under
go test -racewith 20 concurrent goroutines writing at once. - Concurrent ffuf: every web target fuzzed in its own goroutine, bounded by
a worker pool (
-workers, default 5). - Live progress: each tool's output streams line by line with elapsed-time banners and heartbeats, so you're never staring at a frozen terminal.
- Actionable reports, not data dumps: findings split into priority
(critical/high/medium) and informational, each priority finding expanded
with description, remediation, CVE/CVSS, references and a reproduction
curlcommand, plus a "how to act on this report" triage section. - Interactive TUI:
snitch tui --project Xopens a Bubble Tea terminal UI to page through subdomains, services, findings (colour-coded by severity) and crawled paths, with a detail pane showing a finding's remediation and repro. - One-command flow:
scan --report html --openruns the chain and pops the finished report open in your browser. - Export to JSON, CSV (a flat findings sheet), or SARIF 2.1.0, the
latter uploads straight into GitHub code scanning or DefectDojo, with
severity mapped to
security-severityso it buckets correctly.
snitch is a single Go binary that shells out to well-known recon tools. You
don't need all of them: any that are missing are skipped with a warning, so
even just nmap, httpx, nuclei and ffuf gives you a working scan.
Binaries for Linux, macOS and Windows (amd64 and arm64) are on the
releases page, built by GitHub
Actions with a signed build provenance attestation
(gh attestation verify snitch_*_linux_amd64.tar.gz -R n4uu/snitch). You still
need the recon tools below on your PATH.
git clone https://github.com/n4uu/snitch.git
cd snitch
./install.sh # installs EVERY tool: apt packages + the few via go install
make build
./snitch versionThen point it at a target you own or are authorised to test:
./snitch scan yourdomain.com --project demo --report html --openinstall.sh is short and readable (have a look before running it). It apt installs the packaged tools (nmap, ffuf, sqlmap, subfinder, httpx, naabu,
nuclei), links ProjectDiscovery's httpx, then go installs the three that
aren't in apt (katana, dalfox, crlfuzz) and fetches nuclei's templates. Anything
that fails is simply skipped by snitch at scan time with a warning, so a partial
install still works.
No apt? make tools installs every Go-based tool with go install. Heads-up:
this compiles each from source and pulls a lot of dependencies (nuclei and
katana are big), so it's slow; prefer precompiled packages when you can.
sudo apt install -y libpcap-dev # naabu needs libpcap
make tools
# put the go-installed tools on PATH for every shell (no per-terminal fiddling):
sudo ln -sf "$(go env GOPATH)"/bin/* /usr/local/bin/All you need is a target (a bare domain or a full URL; snitch normalizes
it) and a project name to store results under. ffuf uses the bundled
wordlists/common.txt by default, so you don't have to pass one:
./snitch scan example.com --project acme --report html --openThat runs the whole chain and pops a correlated HTML report open. More:
# A full URL is fine too
./snitch scan https://example.com/ --project acme
# Deeper fuzzing with your own wordlist
./snitch scan example.com --project acme --wordlist /usr/share/wordlists/dirb/big.txt
# Add active SQL-injection testing with sqlmap (opt-in; scoped & deduped param URLs)
./snitch scan example.com --project acme --sqli
# A lab box by IP, all 65535 ports (subfinder auto-skips for an IP)
./snitch scan 10.10.10.5 --project lab --full-ports
# Enumeration only: skips nuclei/dalfox/crlfuzz/sqlmap (e.g. OSCP-legal recon)
./snitch scan 10.10.10.5 --project lab --enum-only --full-ports
# Watch a target and get pinged on Discord/Slack when something new appears
./snitch monitor example.com --project acme \
--notify https://discord.com/api/webhooks/XXX/YYY --interval 6h
# Browse results in an interactive terminal UI
./snitch tui --project acme
# Export for other tooling (json | csv | sarif)
./snitch export --project acme -format sarif -o findings.sarif
# Start a project over
./snitch reset --project acme| Command | What it does |
|---|---|
scan |
Run the full recon + injection chain against a target |
monitor |
Re-scan on a schedule and alert a webhook about what's new |
report |
Write a correlated Markdown/HTML report (--open to view it) |
tui |
Browse a project's results interactively |
status |
Show stored counts and recent scan history |
export |
Dump results as JSON, CSV or SARIF |
reset |
Delete a project's stored data and start fresh |
version |
Print the snitch version |
Run snitch <command> -h for that command's flags. Any recon tool that isn't
installed is skipped with a warning and the rest of the chain still runs.
Go's standard SQLite driver needs CGO, which defeats the "ship one static
binary" advantage that's the whole reason to use Go for a CLI like this.
Storage is a JSON file guarded by a mutex, which is plenty for a project's recon data
(thousands of rows, not millions) and no database to stand up. The scan
pipeline, storage and alerts use only the standard library; the only
third-party code is the pure-Go Bubble Tea stack behind tui. Everything still
compiles to a single CGO-free static binary.
go vet ./...
gofmt -l . # should print nothing
go test -race ./... # concurrency test + webhook delivery testintegration_test.go runs the whole parse → dedup → report pipeline against
the sample files in samples/, so no live nmap/nuclei/ffuf is needed.
cmd/snitch/main.go # CLI: scan / monitor / report / status / export
internal/store/ # JSON-backed workspace, dedup, concurrency-safe
internal/parsers/ # subfinder/naabu/httpx/nmap/nuclei/ffuf/katana/dalfox/sqlmap -> structs
internal/orchestrator/ # Chains the tools, runs ffuf concurrently, live output
internal/report/ # Actionable Markdown + HTML reports
internal/notify/ # Discord / Slack / generic webhook alerts
internal/export/ # JSON / CSV / SARIF exporters
internal/tui/ # Bubble Tea interactive results browser
wordlists/common.txt # bundled default ffuf wordlist
samples/ # Sample tool output for testing
integration_test.go # End-to-end pipeline test
- Webhook alerts +
monitormode - Full discovery chain: subfinder → naabu → httpx → nmap → nuclei → ffuf → katana
- Injection testing: dalfox (XSS), crlfuzz (CRLF), opt-in sqlmap (SQLi)
- Interactive TUI (Bubble Tea) for browsing results
- Exporters: JSON, CSV, SARIF 2.1.0
- Scan profiles + in/out-of-scope rules
For use only against systems you own or are explicitly authorized to test.