Skip to content
n4uuPublic

About

Single static-binary recon orchestrator in Go: chains subfinder, httpx, nmap, nuclei, ffuf, katana + injection testing (dalfox/crlfuzz/sqlmap), with dedup, diff-based webhook alerts, an interactive TUI and JSON/CSV/SARIF export.

Topics

Resources

Stars

2 stars

Watchers

0 watching

Forks

Repository files navigation

snitch

CI Go Report Card

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.

Why it's different

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

Features

  • 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=1 and ?q=2 aren'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).
  • monitor mode 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 -race with 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 curl command, plus a "how to act on this report" triage section.
  • Interactive TUI: snitch tui --project X opens 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 --open runs 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-severity so it buckets correctly.

Installation

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.

Prebuilt binary

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.

On Kali / Debian (one command)

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 version

Then point it at a target you own or are authorised to test:

./snitch scan yourdomain.com --project demo --report html --open

install.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.

Other distros / building the tools from source

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/

Quickstart

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 --open

That 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

Commands

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.

Why Go, and why not SQLite

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.

Testing

go vet ./...
gofmt -l .          # should print nothing
go test -race ./... # concurrency test + webhook delivery test

integration_test.go runs the whole parse → dedup → report pipeline against the sample files in samples/, so no live nmap/nuclei/ffuf is needed.

Architecture

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

Roadmap

  • Webhook alerts + monitor mode
  • 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

Legal

For use only against systems you own or are explicitly authorized to test.

About

Single static-binary recon orchestrator in Go: chains subfinder, httpx, nmap, nuclei, ffuf, katana + injection testing (dalfox/crlfuzz/sqlmap), with dedup, diff-based webhook alerts, an interactive TUI and JSON/CSV/SARIF export.

Topics

Resources

Stars

2 stars

Watchers

0 watching

Forks

Releases

Packages

Contributors

Languages