Server data from the Official MCP Registry
Read-only network & security recon tools (DNS, TLS, headers, CORS) for AI agents, each graded.
Read-only network & security recon tools (DNS, TLS, headers, CORS) for AI agents, each graded.
Valid MCP server (1 strong, 1 medium validity signals). 3 known CVEs in dependencies (0 critical, 3 high severity) Package registry verified. Imported from the Official MCP Registry.
3 files analyzed · 4 issues found
Security scores are indicators to help you make informed decisions, not guarantees. Always review permissions before connecting any MCP server.
This plugin requests these system permissions. Most are normal for its category.
Add this to your MCP configuration file:
{
"mcpServers": {
"io-github-nan786521-recon-kit-mcp": {
"args": [
"recon-kit-mcp"
],
"command": "uvx"
}
}
}From the project's GitHub README.
English | 繁體中文
An MCP server that gives AI coding agents — Claude Code, Codex, Cline, and any MCP client — safe, structured network and security reconnaissance tools.
Most MCP servers wrap CRUD APIs. recon-mcp instead exposes the kind of
read-only recon an engineer reaches for when investigating an asset, and returns
clean JSON — with a graded verdict — so the agent can reason over results
instead of parsing console output.
⚠️ Authorized use only. These tools are for security testing of assets you own or have explicit written permission to assess, for CTF practice, and for education. Do not point them at third-party infrastructure without authorization. You are responsible for how you use this software.
| Tool | What it does |
|---|---|
recon_report | Start here. One call → DNS, TLS, and HTTP headers checked together, with an overall grade |
dns_recon | DNS + WHOIS + email security (SPF/DMARC/DKIM), graded |
subdomain_enum | Discover subdomains via DNS brute-force and/or Certificate Transparency logs |
subdomain_takeover | Check subdomains for a dangling-CNAME takeover risk against known services |
tls_check | Certificate, protocols, ciphers, and known TLS vulnerabilities, graded |
http_headers_audit | HTTP security headers (CSP, HSTS, X-Frame-Options, …), graded |
cookie_audit | Redirect chain + cookie flags (Secure / HttpOnly / SameSite), graded |
cors_check | CORS policy probe — flags arbitrary-Origin reflection and wildcard misuse |
tech_detect | Fingerprint the web stack (server, CDN/WAF, language, framework, CMS, JS) from one GET |
http_methods_audit | Report which HTTP methods a server allows and grade the risk (TRACE/PUT/DELETE) |
well_known_audit | Fetches & parses security.txt (RFC 9116) and robots.txt |
ip_info | Resolves the host and enriches its IP via RDAP (owner, country, CIDR, abuse) |
port_scan | TCP port scan of one host (≤1024 ports/call), open ports + services |
Just ask your agent: "run a security recon report on example.com." It calls
recon_report once and gets a graded overview it can act on:
{
"domain": "example.com",
"overall_grade": "F",
"summary": "Overall posture F: email A, TLS B, headers F; 13 actionable issue(s).",
"components": {
"email": { "grade": "A", "issues": [] },
"tls": { "grade": "B", "issues": [] },
"headers": { "grade": "F", "issues": [
{ "severity": "high", "label": "Missing Content-Security-Policy", "detail": "CSP not set; cannot restrict resource load sources" }
] }
}
}
Need more detail on one area? The agent can call dns_recon, subdomain_enum,
subdomain_takeover, tls_check, http_headers_audit, cookie_audit,
cors_check, tech_detect, http_methods_audit, well_known_audit,
ip_info, or port_scan directly.
Requires Python ≥ 3.10. Runs on Linux, macOS, and Windows (tested in CI).
Recommended — no clone, via uv:
uvx recon-kit-mcp
Or from source (for development):
git clone https://github.com/nan786521/recon-mcp
cd recon-mcp
python -m venv .venv
# Windows
.venv\Scripts\activate
# macOS / Linux
source .venv/bin/activate
pip install -e .
Add the server (stdio transport). With uvx you don't need an absolute path:
claude mcp add recon -- uvx recon-kit-mcp
Or add it manually to any MCP client config:
{
"mcpServers": {
"recon": {
"command": "uvx",
"args": ["recon-kit-mcp"]
}
}
}
(From a source checkout, point the command at /absolute/path/to/.venv/bin/recon-kit-mcp instead.)
Then just ask: "run a security recon report on example.com" — or target one area, e.g. "check the email security of example.com."
The server also ships a security_recon prompt: pick it from your client's
prompt menu and pass a domain for a guided, severity-sorted audit.
recon_report(domain, timeout?) -> dictRuns DNS/email, TLS, HTTP-header, web-stack (tech_detect), and apex
subdomain-takeover checks together and returns overall_grade (as weak as the
weakest component, capped at F if a live takeover is found), a one-line
summary, components (email / tls / headers, each with its grade and
actionable issues), a tech section (detected technologies + any version
disclosure), and a takeover section when the apex is at risk. Uses a fast
single-handshake TLS check for speed — call tls_check for the full
cipher/vulnerability analysis. The best starting point; use the tools below for
raw detail.
dns_recon(domain, checks?, timeout?) -> dictassessment
(letter grade A–F, a summary, and per-check findings with severity and a
recommended fix). The advisory signals surface as findings but don't move the
core SPF/DKIM/DMARC grade.checks is any subset of ["records", "whois", "email"]; omit it to run all.
subdomain_enum(domain, wordlist?, source="dns", timeout?) -> dictDiscovers subdomains from two complementary sources:
source="dns" (default) — resolves candidate labels via DNS. wordlist is
comma-separated labels ("www,api,dev"); omit it for a built-in common list.
Capped at 512 candidates per call. Returns resolved ips.source="ct" — queries public Certificate Transparency logs (crt.sh) for
every name ever certified for the domain. Fully passive; finds real hosts no
wordlist would guess.source="both" — runs both and merges, recording which source(s) saw each host.Returns sources, found_count, and found (each with subdomain, the
sources that saw it, and ips when resolved).
subdomain_takeover(hosts, timeout?) -> dictChecks subdomains for a dangling-CNAME takeover — a subdomain that CNAMEs to
a third-party service (GitHub Pages, S3, Heroku, Azure, Fastly, Shopify, …)
whose resource was deleted or never claimed, letting anyone who registers that
resource serve content on the victim's subdomain. For each host it resolves the
CNAME, recognizes known takeover-prone services, fetches the page, and flags
the provider's "unclaimed resource" fingerprint and/or a CNAME target that no
longer resolves. hosts is one hostname or a comma-separated list (capped at
100). Read-only — DNS lookups plus one HTTP GET per host. Pair it with
subdomain_enum: enumerate first, then check the interesting hosts.
Returns checked, vulnerable_count, and results (each with host, cname,
service, status, vulnerable, severity, and detail). status is one of
not_applicable, not_vulnerable, potential, dangling_cname, or
vulnerable.
tls_check(host, port=443, timeout?) -> dictReturns grade, certificate (validity / expiry / key algorithm),
protocols (flags legacy SSLv3 / TLS 1.0 / 1.1), cipher info,
forward_secrecy, hsts, vulnerabilities (each with a vulnerable flag),
and a findings list.
http_headers_audit(host, port?, use_ssl=True, timeout?) -> dictReturns grade, score, the observed security headers, and a findings
list with a recommendation per header. Defaults to HTTPS (port 443).
cookie_audit(host, port?, use_ssl=True, timeout?) -> dictFollows the redirect chain from the host (capped at 10 hops, flagging any
HTTPS→HTTP downgrade) and audits every Set-Cookie seen for the Secure,
HttpOnly, and SameSite flags. Returns redirect_chain, final_url,
cookies (flags only — values are never returned), cookie_grade,
cookie_score, and a findings list.
cors_check(host, port?, use_ssl=True, timeout?) -> dictSends one GET with an untrusted Origin and inspects the
Access-Control-Allow-Origin / -Allow-Credentials response. Reflecting an
arbitrary Origin with credentials is high severity (any site can read
authenticated responses); a wildcard or trusted null origin are lesser issues.
Returns acao, allows_credentials, reflects_origin, wildcard, severity,
and findings.
tech_detect(host, port?, use_ssl=True, timeout?) -> dictFingerprints the technology stack behind a website from one HTTP GET. It
matches response headers, set cookies, the HTML body, and the
<meta name="generator"> tag against a signature table to identify the web
server, reverse proxy / CDN, WAF, programming language, web framework, CMS,
JavaScript framework, and analytics. Where a version is exposed it is captured
and flagged (info) — a precise version eases known-CVE lookup. Read-only.
Returns status, technology_count, technologies (each with name,
category, version when known, and evidence), and a findings list noting
any version disclosure.
http_methods_audit(host, port?, use_ssl=True, path="/", timeout?) -> dictReports which HTTP request methods a server allows and grades the risk. Enabled
write/diagnostic methods widen the attack surface: TRACE enables Cross-Site
Tracing (XST), and PUT / DELETE can allow file upload or deletion under
weak access control. Safe by design — it never sends a mutating request: it
actively probes only OPTIONS, HEAD, and TRACE (TRACE merely echoes), and reads
PUT / DELETE / PATCH / CONNECT from the OPTIONS Allow header as advertised,
never invoking them.
Returns grade, score, allow_header, advertised_methods, trace_enabled,
dangerous_methods, and a findings list (each with the method, severity, and a
recommendation).
well_known_audit(host, timeout?) -> dictFetches and parses security.txt (RFC 9116, tried at /.well-known/ then the
legacy path) and robots.txt. Returns security_txt (parsed fields, structural
issues, location) and robots_txt (sitemaps, disallow/allow paths,
user_agents), each with a present flag.
ip_info(host, timeout?) -> dictResolves the host's IP and looks it up in the public RDAP registry (via
rdap.org's bootstrap to the right RIR). Returns ip and rdap (handle,
name, country, cidr, org, abuse_email).
port_scan(host, ports?, timeout?) -> dictTCP connect scan of a single host. ports is a string — "22,80,443", a
range "1-1024", or a mix — and omitting it scans a built-in common-port set.
Hard-capped at 1024 ports per call (single-host recon, not mass scanning).
Returns host, ip, scanned, open_count, and open_ports (port +
service). Scan only hosts you are authorized to assess.
Be the first to review this server!
by Modelcontextprotocol · Developer Tools
Web content fetching and conversion for efficient LLM usage
by Modelcontextprotocol · Developer Tools
Read, search, and manipulate Git repositories programmatically
by Toleno · Developer Tools
Toleno Network MCP Server — Manage your Toleno mining account with Claude AI using natural language.