Skip to main content
Glama
Pathfinder
by dewhush

Python MCP License Docker Tests

MCP server exposing offensive recon tooling to LLM agents — Claude Code, OpenCode, Codex, Hermes, any MCP client.

pathfinder-mcp demo

Pathfinder wraps the recon CLI tools security researchers already use (subfinder, httpx, nmap, ffuf, nuclei) into a single MCP server, so an LLM agent can plan and execute reconnaissance itself — not just tell you which commands to run.

Roadmap

  • Phase 1 — passive subdomain enum, DNS, WAF detection, tech fingerprint, wayback discovery

  • Phase 2 — active port scan, origin-bypass checks, nuclei templates

  • Phase 3 — session state — the agent chains outputs across tools (scan_result tokens) instead of re-parsing raw text

  • Phase 4 — HTML/JSON report export, target diffing (today vs. yesterday)

Related MCP server: Bug Bounty Assistant MCP

⚡ Quick start

One command, no clone, no venv (needs uv):

uvx --from "git+https://github.com/dewhush/pathfinder-mcp" pathfinder

Or the classic way:

git clone https://github.com/dewhush/pathfinder-mcp.git
cd pathfinder-mcp
python3 -m venv .venv && source .venv/bin/activate
pip install -e .

Requirements

Pathfinder wraps these CLIs. It degrades gracefully — a tool that can't find its binary reports MISSING_TOOL rather than crashing. Install the ones you want:

Tool

Used by

Install

subfinder

subdomain_enum

go install -v github.com/projectdiscovery/subfinder/v2/cmd/subfinder@latest

httpx

http_probe, tech_detect, waf_detect

go install -v github.com/projectdiscovery/httpx/cmd/httpx@latest

nmap

port_scan

apt install nmap

ffuf

endpoint_discover

apt install ffuf or go install github.com/ffuf/ffuf/v2@latest

nuclei

nuclei_scan

go install -v github.com/projectdiscovery/nuclei/v3/cmd/nuclei@latest

No external API keys required. Everything is local or free public APIs (CertSpotter, HackerTarget, AlienVault OTX, urlscan.io, Wayback).

🔌 Connect to your agent

Local Python:

claude mcp add pathfinder -- python -m pathfinder.server

uvx — no local Python, no clone:

claude mcp add pathfinder -- uvx --from "git+https://github.com/dewhush/pathfinder-mcp" pathfinder

Docker — no local Python needed:

# pull the release tarball and load it (no registry auth needed)
curl -L -o /tmp/pathfinder.tar.gz \
  https://github.com/dewhush/pathfinder-mcp/releases/download/v0.1.0/pathfinder.tar.gz
gunzip /tmp/pathfinder.tar.gz
docker load -i /tmp/pathfinder.tar
claude mcp add pathfinder -- docker run --rm -i ghcr.io/dewhush/pathfinder-mcp:0.1.0
hermes mcp add pathfinder --command "python -m pathfinder.server"

Add to your config:

{
  "mcpServers": {
    "pathfinder": {
      "command": "python",
      "args": ["-m", "pathfinder.server"]
    }
  }
}

Any MCP client (Docker, manual command): docker run --rm -i ghcr.io/dewhush/pathfinder-mcp:0.1.0

The Docker image bundles subfinder, httpx, nmap, ffuf and nuclei — the full toolset works with zero local installs. Local Python still needs those CLIs on PATH; anything missing degrades to MISSING_TOOL instead of crashing.

WARNING

Pathfinder is a tool-wrapper.You are responsible for running it only against infrastructure you own or are authorized to test.

🧰 Tools

Tool

Wraps

Use

🔍

subdomain_enum

subfinder + public APIs

passive subdomain enumeration

🌐

dns_resolve

—

A / AAAA / MX / TXT / NS / CNAME

🧭

tech_detect

httpx

web technology fingerprint

🕰

wayback_discover

Wayback

historical URLs

📡

http_probe

httpx

live HTTP(S) services

🎯

port_scan

nmap

top-N ports

🛡

waf_detect

headers + TLS

WAF/CDN identification

🕳

origin_bypass_check

DNS + ranges

WAF origin bypass (doc)

🧨

endpoint_discover

ffuf

path fuzzing (raft-small default, seclists supported)

💉

nuclei_scan

nuclei

template scans

subdomain_enum(domain="example.com", source="all")     # or source="otx"
dns_resolve(host="example.com", record_type="A")
tech_detect(url="https://example.com")
wayback_discover(host="example.com", limit=500)

http_probe(hosts=["sub.example.com", "api.example.com"])
port_scan(host="example.com", top_ports=1000)
waf_detect(url="https://example.com")
origin_bypass_check(host="example.com")        # ORIGIN_EXPOSED / WAF_PROTECTED / UNKNOWN
endpoint_discover(url="https://example.com", wordlist="raft-small")
nuclei_scan(target="https://example.com", severity=["high", "critical"])
nuclei_scan(target="https://example.com", templates=["cves", "exposures"])

Origin bypass technique: docs/waf-origin-bypass.md. If a host reports ORIGIN_EXPOSED, the origin IP can be reached directly with a spoofed Host header:

curl -H "Host: example.com" https://<origin-ip>/

Built-in wordlists: raft-small (default), raft-medium, raft-big, common, seclists (expects /usr/share/seclists). Use wordlist="/abs/path" for a custom file.

🔗 Session chaining

Every tool returns structured JSON plus a scan_token. Pass it back into any other tool as from_token — Pathfinder resolves the token to the relevant hosts/URLs from the current session, so the agent chains steps without you re-typing targets:

flowchart LR
    A["subdomain_enum<br/>42 hosts"] -->|scan_token| B["http_probe<br/>7 live"]
    B -->|scan_token| C["waf_detect<br/>1 origin exposed"]
    C -->|"scan_token"| D["origin_bypass_check<br/>origin IP confirmed"]

Sessions are per-process and in-memory — nothing leaves the machine.

Development

pip install -e ".[dev]"
pytest                       # unit tests, no network, all tools mocked
ruff check src tests
ruff format src tests

License

MIT — 0xDew. Authorized use only.

Available Tools

10 tools
dns_resolveDns ResolveC

Resolve DNS records for a host.

Inputs: host (required), from_token, record_type. Returns: result

endpoint_discoverEndpoint DiscoverC

Fuzz common paths on a URL with ffuf.

Inputs: url (required), wordlist, from_token. Returns: result

http_probeHttp ProbeC

Probe hosts for live HTTP(S) services.

Inputs: hosts, from_token. Returns: result

nuclei_scanNuclei ScanC

Run nuclei templates against a target.

Inputs: target (required), severity, templates, from_token. Returns: result

origin_bypass_checkOrigin Bypass CheckA

Check whether a WAF-protected host resolves directly to its origin IP.

If the A record lands outside known WAF/CDN ranges, the origin is exposed and the WAF can be bypassed by hitting that IP with a spoofed Host header.

Inputs: host (required), from_token. Returns: result

port_scanPort ScanC

nmap top-N port scan of a host.

Inputs: host (required), top_ports, from_token. Returns: result

subdomain_enumSubdomain EnumC

Passive subdomain enumeration for a domain.

Inputs: domain (required), source, from_token. Returns: result

tech_detectTech DetectC

Fingerprint web technology behind a URL (httpx tech-detect).

Inputs: url (required), from_token. Returns: result

waf_detectWaf DetectC

Detect a WAF/CDN in front of a URL from headers and response body.

Inputs: url (required), from_token. Returns: result

wayback_discoverWayback DiscoverB

Pull historical URLs for a host from the Wayback Machine.

Inputs: host (required), limit, from_token. Returns: result

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    B3.4/5.0

    Scored across 10 tools

    Disambiguation4/5

    Most tools target distinct phases of reconnaissance (enumeration, probing, detection, scanning). Slight overlap exists between tech_detect and waf_detect, both analyzing URL response characteristics, and between http_probe and port_scan in service discovery, but descriptions clarify boundaries.

    Naming Consistency5/5

    All tool names follow a consistent snake_case noun_verb pattern (tech_detect, port_scan, dns_resolve, etc.), making the set highly predictable and readable.

    Tool Count5/5

    10 tools is well-scoped for a reconnaissance toolkit, covering the essential discovery, fingerprinting, and scanning operations without redundancy or bloat.

    Completeness4/5

    The set covers subdomain enumeration, DNS resolution, port scanning, HTTP probing, technology/WAF detection, origin bypass checks, historical URL discovery, endpoint fuzzing, and vulnerability scanning. Minor gaps include whois/ASN lookups or SSL/TLS inspection, but core recon workflows are well supported.

    Maintenance

    ActivityMaintained
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      B
      maintenance
      A scope-aware bug-bounty & reconnaissance MCP server that works out of the box on the Python standard library and augments itself with your favourite CLI tools when they're present.
      22
      MIT
    • A
      license
      A
      quality
      B
      maintenance
      An MCP server that provides passive and low-impact active reconnaissance tools for authorized bug bounty and security assessments, enabling LLMs to perform structured recon and generate reports.
      11
      Apache 2.0
    • A
      license
      B
      quality
      C
      maintenance
      MCP server for offensive-security tooling, enabling AI agents to run reconnaissance, CVE intelligence, JavaScript analysis, HTTP probing, and port scanning against authorized targets.
      10
      MIT
    • A
      license
      Not graded
      quality
      Not graded
      maintenance
      A secure, modular MCP server that wraps seven industry-standard security tools (nmap, nuclei, gobuster, subfinder, httpx, nikto, sqlmap) into thirteen MCP tools, enabling AI agents to perform port scanning, vulnerability scanning, directory enumeration, subdomain discovery, web probing, and SQL injection testing through natural language.
      1
      MIT