pentest-suite
This server exposes a scoped, non-destructive attack-surface reconnaissance toolkit (HTTP probing, port scanning, path discovery, template-based detection, and threat-intel lookup) for authorized targets only.
probe — Qualifies one or more comma-separated hosts: HTTP status, page title, server banner, and detected technologies.
ports — Runs a benign TCP connect scan with banner grabbing over default or custom port ranges (e.g.
80,443,8000-8100).dirs — Discovers hidden paths via a wordlist, with soft-404 baseline calibration and response-size filtering (
filter_size).tmpl — Applies nuclei-style JSON detection templates (e.g.
git-exposed,env-exposed), optionally restricted withonly.kev — Performs read-only threat intelligence lookups in CISA KEV and cve.now by exact CVE or by vendor/product/keyword.
Scope & safety — All active tools require an authorized target; no arbitrary command execution is exposed, only these five bounded tools.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@pentest-suite probe example.com and scan its common ports for open services"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Pentest-Suite
Pentest-Suite is a lightweight, zero-dependency cybersecurity toolkit designed for attack surface reconnaissance, active host qualification, port enumeration, content discovery, template-based vulnerability scanning, and threat intelligence enrichment.
Built in pure Python standard library (urllib, concurrent.futures, socket, ssl), it runs everywhere with zero compilation, no external package bloat, and predictable execution. It is the offensive security counterpart of osint-suite (sharing the same core engine, session models, correlation logic, and Markdown/Mermaid reporting).
⚡ Key Highlights
Pure Python Standard Library: Zero third-party dependencies. No
pip install, no C/Rust toolchains. Runs with Python ≥ 3.15 or via uv.Safe & Benign Active Probing: Non-destructive full TCP-connect scans, soft-404 baseline calibration, conservative wordlists, and strict authorization banners.
Threat Intelligence Engine: Integrated live lookups via sazabi/cve.now (CVSS scores, Exploit-DB links, EPSS probability, AI summaries) and official CISA KEV feeds without requiring API keys.
Autonomous OODA Loop: Deterministic Observe-Orient-Decide-Act orchestration (
chain) that dynamically adapts scan depth based on observed target signals.Native AI Agent MCP Server: Stdio JSON-RPC 2.0 Model Context Protocol server exposing
probe,ports,dirs,tmpl, andkevas first-class tools for AI coding assistants (Claude Code, Cursor, Codex).MITRE ATT&CK Tagging: Automated tagging of findings and recon phases to Enterprise ATT&CK techniques (T1595, T1046, T1552, T1190).
Tamper-Evident Session Reports: Every saved session is sealed into an Ed25519-signed, hash-chained sidecar (
.chain.json, pure-stdlib RFC 8032 — idea from lacs-project/sysknife);audit-verifyproves the delivered report has not been altered since signature.CI/CD Security Gate: Exits with return code
2on findings at or above--fail-on(default:high, preservinghigh/criticalfailure) and exports OASIS SARIF 2.1.0 (.sarif/--sarif) with CWE/STRIDE tags andsecurity-severity.Multi-Format Deliverables & Coverage: Every run produces structured session JSON, executive Markdown briefings (
.report.md, including verification/coverage/leads sections), Mermaid topology graphs, SARIF 2.1.0 reports, and a negative-space coverage ledger (.coverage.json) inreports/.Calibrated Evidence & Provenance: Distinguishes
confirmedvsprobablefindings (portsbanners,tmplbaseline checks), extracts observed versions inprobe, stampscveentities withretrieved_atandquery_modeinkev, and flags unverified tech leads asneeds_follow_upinchain.Enforceable Target Scope & Redirect Guard: Supports explicit target allowlists via
--scope-fileorPENTEST_SUITE_SCOPE/PENTEST_SUITE_SCOPE_FILE(withPENTEST_SUITE_ALLOW_LOCAL) and blocks out-of-scope or SSRF-risk HTTP redirects acrossprobe,ports,dirs,tmpl,chain, andmcp.ARTEX-derived Hardening (AGX stack): typed platform-control block codes with agent-readable guidance and a bounded guard audit ring; failure attribution (WAF-blocked
dirsis never read as clean and halts active probing); a deterministic intent frontier with typed terminal reasons (exhausted≠blocked≠failed) and zero silent skip; PoE evidence levels 0-4 with verbatim response-verified quotes; wrap-up gaps section (« non examiné ≠ propre »); noise governor (--noise), work-unit run budget with wrap-up reserve (--max-requests), operator constraints freeze (--constraints-file), targeted retest loop (--retest), and evidence-gated cross-run lessons — all stdlib-only, no LLM (docs/artex-architecture.md).
Related MCP server: mcp-shodan
🧭 Architecture & Upstream Inspirations
pentest-suite faithfully re-implements the core mechanics and operating principles of industry-standard tools within the Python standard library:
Upstream Project | Re-implemented Concept | Implementation |
Detection logic decoupled into declarative JSON templates with | ||
Per-query metadata ( |
| |
Concurrent HTTP host qualification: status code, HTML title, server header, technology markers | ||
Multi-threaded TCP connect scan, service identification, banner grabbing, and flagged port classification | ||
Wordlist content discovery with soft-404 baseline calibration and response size filtering ( | ||
Real-time threat intelligence lookup (CVSS, EPSS, Exploit-DB, CISA KEV) and critical technology feeds | ||
Deterministic OODA loop orchestration, stdio MCP server for autonomous agents, MITRE ATT&CK taxonomy | ||
SARIF 2.1.0 export ( |
| |
Honest negative-space coverage caveats, |
| |
Platform-control guard framing + bounded allow/block audit ring, failure attribution (Observer/G5), deterministic intent frontier with typed terminal reasons and stagnation detection, PoE levels 0-4 + verbatim response-verified evidence quotes, noise governor, hierarchical run budget with wrap-up reserve, operator constraints freeze, targeted retest loop, evidence-gated RSI lessons, wrap-up gaps |
| |
Ed25519-signed, hash-chained audit trail proving reports were not altered after the fact (sidecar document, session schema untouched); RFC 8032 in pure stdlib |
|
⚠️ Responsible Use
CRITICAL: This toolkit is strictly intended for security testing against systems you have explicit, documented authorization to assess (your own infrastructure, authorized penetration testing scopes, or bug bounty programs within scope).
Active probes are deliberately non-destructive: standard TCP handshakes only (no raw sockets or forged packets by default), safe wordlists, and no exploit payloads. Every active command requires and displays an authorization banner.
🚀 Installation
Managed with uv (Python ≥ 3.15, committed uv.lock):
git clone https://github.com/laurentvv/pentest-suite.git
cd pentest-suite
uv sync
uv run pentest-suite --versionAlternative without uv (using your system Python 3.15+ directly):
python -m pentest_suite --version🛠️ Usage & CLI Reference
1. HTTP Host Qualification (probe)
Sondes a comma-separated list of targets (or a --target-list file, one host per non-empty non-# line) over HTTPS and HTTP:
uv run pentest-suite probe example.com,api.example.com
uv run pentest-suite probe --target-list targets.txt2. TCP Port Scanning & Banner Grabbing (ports)
Performs a benign multi-threaded TCP connect scan:
uv run pentest-suite ports example.com
uv run pentest-suite ports example.com --ports 80,443,8000-8100 --workers 503. Path Discovery with Soft-404 Baseline & API Specs (dirs)
Discovers hidden endpoints, calibrating against soft-404 behaviors, or probes declared read-only (GET/HEAD) endpoints from a JSON OpenAPI 3.x, Swagger 2.0, or Postman v2.1 specification:
uv run pentest-suite dirs https://example.com
uv run pentest-suite dirs https://example.com --filter-size 150032,155455 --workers 12
uv run pentest-suite dirs --spec openapi.json4. Template-Based Detection (tmpl)
Scans against embedded nuclei-style JSON checks (git-exposed, env-exposed, actuator-exposed, server-status, etc.), applying a random-path catch-all baseline check to avoid wildcard false positives:
uv run pentest-suite tmpl https://example.com
uv run pentest-suite tmpl https://example.com --only git-exposed,env-exposed
uv run pentest-suite tmpl https://example.com --fail-on medium --sarif findings.sarifNote: Returns exit code 2 when any finding is at or above --fail-on (default: high, matching high/critical).
5. Threat Intelligence & Vulnerability Lookup (kev)
Queries cve.now and CISA KEV feeds (100% passive, read-only):
# Instant enriched CVE lookup (CVSS score, Exploit-DB IDs, EPSS, summary)
uv run pentest-suite kev CVE-2024-6387
uv run pentest-suite kev --cve CVE-2021-44228
# Critical vulnerabilities feed for a specific tracked technology
uv run pentest-suite kev nginx
uv run pentest-suite kev spring
# Search the official CISA KEV catalog by vendor or keyword
uv run pentest-suite kev tomcat --source cisa6. Full Autonomous OODA Chain (chain)
Executes the deterministic Observe-Orient-Decide-Act workflow over an intent frontier and records a negative-space coverage ledger (.coverage.json) alongside the SARIF 2.1.0 report:
uv run pentest-suite chain example.com
uv run pentest-suite chain --spec openapi.json --fail-on medium --sarif reports/api.sarif
# ARTEX-derived operator controls (AGX stack):
uv run pentest-suite chain example.com --noise quiet --max-requests 500 --constraints-file constraints.json
uv run pentest-suite chain --retest reports/chain-example.com.jsonHow the OODA loop decides:
Observe: Probes host reachability. If unreachable, halts immediately (intent
blocked: target unreachable) to prevent futile scans.Orient: Identifies open ports and detected server technologies.
Decide / Act: Web port open? Run template checks. If a high/critical issue is found, prioritizes alerting and skips brute-force directory discovery (intent
blocked: prioritized). Otherwise, proceeds to directory fuzzing.Orient Final: Detected technologies are cross-referenced with CISA KEV and
cve.nowfeeds (one intent per correlated technology, capped at 2).
Intent frontier (execution ledger): every phase — run, skipped, or frozen — exists as an intent with a typed terminal status (done | exhausted | blocked | not_applicable | failed) and an explicit reason, serialized in the chain result and rendered as a Mermaid graph in .graph.md. Nothing is silently skipped (settled() guarantees it).
Guard blocks & failure attribution: scope/locality violations carry typed codes (scope_denied, local_disallowed) with explicit platform-control, not target-defense framing so an agent reading the output never mistakes a policy decision for a WAF and tries to bypass it; decisions land in a bounded audit ring (guard_audit). A dirs run whose responses are majority-blocked (403/429/WAF markers) records a needs_follow_up verdict with explicit WAF attribution — never a clean one — and halts further active probing.
Proof of exploitation (PoE): tmpl findings carry a PoE level 0-4 (declared via info.poe, else matcher-derived: L2 for contains/regex, L1 for status-only) capped at L2 when the wildcard counterevidence could not apply (no baseline, non-GET, non-confirmed). The evidence includes a verbatim quote extracted from the actual response body and re-verified by whitespace-normalized containment — quotes never come from memory.
Targeted retest: chain --retest SESSION.json re-runs ONLY the confirmed tmpl templates of a previous session (probe liveness + tmpl --only, never a full scan) and returns one verdict per finding: reproduced (still matches), fixed (alive and clean — always carries a single-run caveat), or inconclusive (target unreachable).
Cross-run lessons: confirmed findings and retest verdicts are extracted into reports/lessons.json (each lesson = cue + action + evidence rows, deduplicated by source, retracted on reversed disposition, retired at zero support). Later runs on the same target surface prior lessons as caveats — data to verify, never instructions.
Operator controls:
--noise quiet|balanced|aggressive— caps ports/dirs workers (deterministic table; never raises the rate to meet a deadline).--max-requests N— work-unit budget over planned requests; over-budget phases endexhausted(budget)before launching, and the final passive KEV orient is protected by a wrap-up reserve (max(2, 5 % of N)).--constraints-file constraints.json—{"deny": ["dirs"], "allow": ["probe", "ports", "tmpl", "kev"]}: frozen phases endnot_applicable(denied); validation is fail-closed (unknown phase / overlap → error); a non-emptyallowfreezes everything not listed (minimal-scope principle).--lessons PATH/--no-lessons— override or disable the lessons file (default:reports/lessons.json, git-ignored).
Deep design notes (ARTEX → here mapping, terminal-status vocabulary, PoE scale, budget math): docs/artex-architecture.md.
7. Signed Audit Chain (audit-verify)
Every saved session (from probe, ports, dirs, tmpl, kev, chain) is sealed by an Ed25519-signed hash chain written to a sidecar <session>.chain.json. The session file itself keeps its schema untouched; the sidecar chains one row per top-level section (each row hashing the previous row), binds the raw file bytes via session_sha256, and signs the chain tip. Idea and trust model borrowed from lacs-project/sysknife — proof that a delivered pentest report was not altered after the fact.
# signing is automatic on every save; verify later:
uv run pentest-suite audit-verify reports/probe_example.com.json # exit 0 = valid, 3 = altered, 1 = missing file
uv run pentest-suite audit-verify reports/probe_example.com.json --key pubkey.hex # pin the expected public keyPure stdlib Ed25519 (RFC 8032) in
pentest_suite/utils/ed25519.py, tested against the RFC's official §7.1 vectors — keeps the zero-dependency invariant.Signing key: auto-generated at
~/.pentest-suite/audit_key.jsonon first save; override withPENTEST_SUITE_AUDIT_KEY=/path/key.json(or--keyon the CLI for the expected public key). The chain embeds the public key + its SHA-256 fingerprint; pin it out-of-band (--key) to detect a key swap by someone holding the private key.Any altered byte — a finding severity, a hostname, even trailing whitespace — fails verification with the offending section named (
chain_break: ligne N (findings)).Not exposed over MCP (the MCP tool list stays fixed:
probe,ports,dirs,tmpl,kev).
🤖 Model Context Protocol (MCP) Server
pentest-suite includes a built-in stdio MCP server (JSON-RPC 2.0) that allows AI coding agents (Claude Code, Cursor, Codex, Windsurf) to pilot penetration testing workflows safely.
Claude Code Configuration (~/.claude.json or .mcp.json):
{
"mcpServers": {
"pentest-suite": {
"command": "uv",
"args": [
"run", "--directory", "/path/to/pentest-suite",
"pentest-suite", "mcp",
"--scope-file", "scope.txt",
"--telemetry", "reports/mcp-telemetry.jsonl"
]
}
}
}Exposed MCP Tools:
probe: Qualifies HTTP hosts (status, title, banner, observed technology versions).ports: Multi-threaded TCP connect port scanner with banner confidence calibration.dirs: Wordlist path discovery with soft-404 size filtering and coverage caveats.tmpl: Nuclei-style JSON template scanner with baseline failure caveats.kev: CISA KEV and cve.now vulnerability intelligence lookup with provenance metadata.
Context Management, Scope & Telemetry:
Context Controls: All 5 tools accept optional
max_items(1..50) to cap verbose lists in agent context and optionalsave(true/false) to persist full session bundles (.json,.report.md,.graph.md,.sarif,.coverage.json) strictly insidereports/. Tool summaries also surface coverage status and caveats.Scope Enforcement: Pass
--scope-fileonprobe,ports,dirs,tmpl,chain, ormcp(or configurePENTEST_SUITE_SCOPE,PENTEST_SUITE_SCOPE_FILE, andPENTEST_SUITE_ALLOW_LOCAL). Empty scope files fail closed.Append-Only Telemetry: Pass
--telemetry PATHtopentest-suite mcp(or setPENTEST_SUITE_TELEMETRY) to record deterministic JSONL tool/error telemetry without polluting stdout.Bundled Agent Skill: See
skills/pentest-suite-harness/SKILL.mdand its templates inskills/pentest-suite-harness/assets/for multi-thread campaign handoff workflows.
Security Invariant: The tool registry is strictly bounded. No arbitrary shell execution tools are exposed.
📁 Repository Structure
pentest-suite/
├── assets/
│ └── banner.png # Project banner
├── pentest_suite/
│ ├── cli.py # CLI entry points and command handlers
│ ├── mcp_server.py # Stdio JSON-RPC 2.0 MCP server implementation
│ ├── config/
│ │ ├── attack.json # MITRE ATT&CK taxonomy mapping
│ │ ├── ports.json # Default & flagged sensitive ports (with risk notes)
│ │ ├── wordlist.txt # Embedded path discovery wordlist
│ │ └── templates/ # Nuclei-style JSON templates, in kics-style
│ │ ├── exposure/ # data exposure (.git, .env, dir listing)
│ │ ├── management/ # admin endpoints (Actuator, server-status)
│ │ └── metadata/ # public metadata (robots.txt, security.txt)
│ ├── core/ # Shared engine (models/engine/plugin/report) + suite extensions
│ │ ├── api_spec.py # Stdlib JSON OpenAPI/Swagger/Postman parser
│ │ ├── attack.py # MITRE ATT&CK session tagger
│ │ ├── budget.py # Work-unit run budget with wrap-up reserve (ARTEX)
│ │ ├── chain.py # Deterministic OODA loop over an intent frontier
│ │ ├── constraints.py # Operator deny/allow phase freeze, fail-closed (ARTEX)
│ │ ├── coverage.py # Negative-space coverage ledger & wrap-up gaps
│ │ ├── engine.py # Session runner and event dispatcher
│ │ ├── guard.py # Bounded allow/block audit ring (ARTEX guard)
│ │ ├── intents.py # Intent frontier, terminal reasons, stagnation (ARTEX)
│ │ ├── lessons.py # Evidence-gated cross-run lessons (ARTEX RSI)
│ │ ├── models.py # Entity, Finding, and Session models
│ │ ├── noise.py # Noise governor profiles quiet/balanced/aggressive
│ │ ├── plugin.py # Module registry and base classes
│ │ ├── poe.py # PoE levels 0-4 + verbatim verified quotes (ARTEX)
│ │ ├── retest.py # Targeted retest loop (ARTEX retester)
│ │ ├── report.py # Markdown dossier & Mermaid graph generators
│ │ └── sarif.py # OASIS SARIF 2.1.0 report generator
│ ├── modules/
│ │ ├── probe/ # HTTP host qualification
│ │ ├── ports/ # TCP connect port scanner
│ │ ├── dirs/ # Soft-404 path discovery + failure attribution
│ │ ├── tmpl/ # Template matcher engine (PoE + verbatim quotes)
│ │ └── intel/ # CISA KEV & cve.now threat intelligence
│ └── utils/
│ ├── http.py # Stdlib HTTP client & thread pool runner
│ ├── io.py # Atomic JSON artifact writer
│ └── url_safety.py # URL validation, ScopePolicy & SSRF-safe redirect handler
├── docs/
│ └── artex-architecture.md # AGX design doc: ARTEX ideas → here (deep notes)
├── skills/
│ └── pentest-suite-harness/
│ ├── SKILL.md # Agent skill for scoped verification & MCP workflows
│ └── assets/ # Thread index & evidence handoff Markdown templates
├── tests/
│ ├── test_core.py # Offline core & module tests
│ ├── test_strix_features.py # SARIF, coverage, API specs, CLI gate & URL safety tests
│ ├── test_templates.py # Per-template behavioral & catalog schema tests
│ ├── test_harness_lot1.py # Coverage caveats, confidence calibration & version provenance tests
│ ├── test_harness_lot2.py # ScopePolicy & redirect/SSRF boundary tests
│ ├── test_harness_lot3.py # MCP max_items/save, telemetry JSONL & skill tests
│ ├── test_artex_guard.py # AGX: block codes, platform-control framing, audit ring, G5 attribution
│ ├── test_artex_intents.py # AGX: intent frontier, terminal reasons, stagnation, ruled_out
│ ├── test_artex_ops.py # AGX: noise profiles, run budget, constraints freeze
│ ├── test_artex_poe_wrapup.py # AGX: PoE levels, verbatim quotes, wrap-up gaps
│ └── test_artex_retest_lessons.py # AGX: targeted retest verdicts, evidence-gated lessons
├── pyproject.toml # Project metadata & packaging configuration
└── README.md🧩 Extending Pentest-Suite
Adding a Detection Template
Create a JSON file in a category subdirectory of pentest_suite/config/templates/ (exposure/, management/, metadata/, or a new slug of your choice):
{
"id": "custom-check",
"info": {
"name": "Exposed Configuration File",
"severity": "high",
"cwe": "552",
"category": "exposure",
"references": ["https://owasp.org/Top10/A05_2021-Security_Misconfiguration/"],
"remediation": "Restrict public access to this path."
},
"requests": [
{ "path": "/config.json", "method": "GET" }
],
"matchers": [
{ "type": "status", "status": [200] },
{ "type": "contains", "words": ["\"database\":", "\"secret\":"], "any": false }
]
}Optional info fields (inspired by kics query metadata): cwe (numeric CWE id as a string), references (list of official doc URLs), category — the loader enforces that category matches the subdirectory the file lives in — confidence (confirmed | probable | possible; explicit confirmed skips the wildcard counterevidence calibration) and poe (integer 0-4, ARTEX-style proof-of-exploitation level: L3+ only takes effect when the wildcard counterevidence actually applied and the match is confirmed, otherwise capped at L2).
Every template ships with its behavioral test cases in tests/test_templates.py: extend the POSITIVE_ROUTES stub with a route that triggers the new template (positive case) and make sure the 404 / neutral-200 negative servers do not match it.
Adding a Custom Module
Subclass BaseModule and decorate with @register:
from pentest_suite.core.plugin import BaseModule, register
@register
class MyScannerModule(BaseModule):
name = "myscan"
description = "Custom passive analyzer."
target_hint = "<target>"
def run(self, target: str, session, options: dict):
session.add_entity("custom", target, "myscan")
session.note("Custom scan completed.")
return []🧪 Testing
Run the full offline test suite:
uv run python -m unittest discover -s tests -vAll unit tests run completely offline and verify models, deduplication, correlation, report generation, soft-404 logic, template matchers, and threat intelligence fallbacks in under 0.1s.
📄 License
This project is licensed under the MIT License.
Available Tools
5 toolsdirsB
Découverte de chemins (wordlist + filtre soft-404). Cible autorisée uniquement.
Inputs: url (required), filter_size.
kevB
Recherche dans CISA KEV et cve.now (vulns critiques / activement exploitées). Lecture seule.
Inputs: cve, keyword.
portsC
Scan TCP connect + bannières sur les ports courants. Cible autorisée uniquement.
Inputs: target (required), ports.
probeA
Sonde HTTP d'hôtes : statut, titre, bannière, technologies. Cible autorisée uniquement.
Inputs: targets (required).
tmplC
Détections par templates JSON façon nuclei. Cible autorisée uniquement.
Inputs: url (required), only.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 5 tools
Each tool targets a fairly distinct recon phase (HTTP probe, port scan, path discovery, template checks, vuln lookup). Minor overlap exists between probe and ports since both grab banners, and 'tmpl' is vague without reading its description.
All five names are single lowercase noun-like tokens following a consistent terse style. They deviate from a verb_noun convention, but the pattern itself is uniform and predictable.
Five tools is a lean but reasonable set for a recon/vuln-detection suite, and each earns its place. It's on the thin side for a 'pentest suite' but not mismatched.
Covers host probing, port scanning, dir discovery, template detections, and KEV lookup, but notable gaps remain: no subdomain/host enumeration, no exploitation/validation step, and no reporting or result aggregation.
Maintenance
Related MCP Connectors
CVE lookups (NVD) and dependency-manifest audits (OSV) for AI agents. No API keys.
CVE lookups (NVD) and dependency-manifest audits (OSV) for AI agents. No API keys.
AI pentesting: run scans, triage vulnerabilities, review PRs, manage schedules and assets.
Checks AI-written code for leaked keys and made-up packages, on your machine. Never uploads code.
Related MCP Servers
- AlicenseNot gradedqualityBmaintenanceExposes read-only local analysis tools for source auditing, web traffic review, binary reverse engineering, exploit scaffolding, OSINT, and reporting via JSON-RPC over stdio, enabling LLMs to orchestrate evidence-based security workflows without executing targets or sending network requests.1MIT
- FlicenseNot gradedqualityAmaintenanceEnables AI agents to search internet-connected devices, perform IP and host reconnaissance with port, banner and TLS data, run DNS lookups, and retrieve CVE/CPE vulnerability intelligence including CVSS, EPSS and KEV status. It supports credit-aware queries with both stdio and HTTP streaming transports for clients like Claude Code, Codex, Gemini CLI and Claude Desktop.-
- AlicenseNot gradedqualityAmaintenanceEnables AI agents to search internet-connected devices, perform IP and hostname reconnaissance (open ports, banners, TLS certificates, DNS records), and retrieve CVE/CPE vulnerability intelligence including CVSS, EPSS, and KEV status. Supports both stdio and HTTP streaming transports and works with Claude Code, Codex, Gemini CLI, and Claude Desktop.MIT
- AlicenseNot gradedqualityAmaintenanceEnables AI agents to perform internet reconnaissance through the Shodan and CVEDB APIs — searching internet-connected devices, inspecting host ports, banners, TLS certificates and DNS records, and pulling CVE, CPE, EPSS and KEV vulnerability intelligence. Supports both stdio and HTTP streaming transports for use with Claude Code, Codex, Gemini CLI and Claude Desktop.MIT