# Vulnerability Exposure MCP

[![Tests](https://github.com/MRFrazer25/Vulnerability-Exposure-MCP/actions/workflows/tests.yml/badge.svg)](https://github.com/MRFrazer25/Vulnerability-Exposure-MCP/actions/workflows/tests.yml)
[![PyPI version](https://img.shields.io/pypi/v/vulnerability-exposure-mcp)](https://pypi.org/project/vulnerability-exposure-mcp/)
[![Python versions](https://img.shields.io/pypi/pyversions/vulnerability-exposure-mcp)](https://pypi.org/project/vulnerability-exposure-mcp/)
[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/MRFrazer25/Vulnerability-Exposure-MCP/blob/main/LICENSE)
[![vulnerability-exposure-mcp MCP server – quality and maintenance score on Glama](https://glama.ai/mcp/servers/MRFrazer25/Vulnerability-Exposure-MCP/badges/score.svg)](https://glama.ai/mcp/servers/MRFrazer25/Vulnerability-Exposure-MCP)
[![Add to Cursor](https://cursor.com/deeplink/mcp-install-dark.svg)](https://cursor.com/en/install-mcp?name=vulnerability-exposure&config=eyJjb21tYW5kIjoidXZ4IiwiYXJncyI6WyJ2dWxuZXJhYmlsaXR5LWV4cG9zdXJlLW1jcCJdfQ%3D%3D)
[![Install in VS Code](https://img.shields.io/badge/VS_Code-Install_server-0098FF?logo=visualstudiocode&logoColor=white)](https://vscode.dev/redirect/mcp/install?name=vulnerability-exposure&config=%7B%22command%22%3A%22uvx%22%2C%22args%22%3A%5B%22vulnerability-exposure-mcp%22%5D%7D)

<!-- mcp-name: io.github.MRFrazer25/vulnerability-exposure-mcp -->

An [MCP](https://modelcontextprotocol.io) server that checks public IPs, domains, CVEs and software versions for **confirmed vulnerabilities and exposure**. A CVE only counts as affecting a version when NVD's version ranges confirm it; everything else is listed for review, so related or vendor-wide CVEs are never reported as yours.

It's the MCP version of [Vulnerability Exposure Analyzer](https://github.com/MRFrazer25/Vulnerability-Exposure-Analyzer). The app needs a Cohere key to run its own agent; this one doesn't need any LLM key, because the model in your MCP client calls the tools and writes the report.

It runs locally over stdio, so it works with clients that launch local MCP servers: Claude Desktop, Claude Code, Codex, Cursor, Antigravity, Windsurf, VS Code, LM Studio and similar. Web-only clients such as ChatGPT on the web and claude.ai connectors only accept remote (HTTPS) servers; this server is not hosted, because a public deployment would need its own authentication to keep your API keys from being used by anyone.

Give it a public IP, a domain, a CVE ID (`CVE-2026-111497`), a product and version (`PHP 8.3.10`, `OpenSSH 8.9p1 Ubuntu-3ubuntu0.6`), or your project's lockfile or SBOM, and it pulls evidence from NVD, CISA KEV, FIRST EPSS, Exploit-DB, OSV.dev, Shodan, VirusTotal, AbuseIPDB, Spamhaus, GreyNoise, SANS ISC, the internet registries and certificate transparency logs.

![Claude running "Run a security assessment of PHP 8.3.10" with this server: 7 tool calls, a report that passed check_report, an executive summary and a key findings table](https://raw.githubusercontent.com/MRFrazer25/Vulnerability-Exposure-MCP/main/docs/mcp-report.png)

![The same report's confirmed CVEs for PHP 8.3.10, highest EPSS first, with severity, CISA KEV status and fix versions](https://raw.githubusercontent.com/MRFrazer25/Vulnerability-Exposure-MCP/main/docs/mcp-cve-table.png)

## Install

Requires Python 3.11+. Setup is three steps: install, optionally store your keys, connect your AI client.

The simplest way is [uv](https://docs.astral.sh/uv/getting-started/installation/), which runs the server straight from [PyPI](https://pypi.org/project/vulnerability-exposure-mcp/) with nothing to set up:

```bash
uvx vulnerability-exposure-mcp keys status
```

Or install it with pip (`pip install vulnerability-exposure-mcp`) and use the `vulnerability-exposure-mcp` command the same way. To run from source instead, see [From source](#from-source) below.

Free keys: [Shodan](https://account.shodan.io/), [VirusTotal](https://www.virustotal.com/gui/join-us), [AbuseIPDB](https://www.abuseipdb.com/register), [NVD](https://nvd.nist.gov/developers/request-an-api-key) (optional, raises the rate limit), [GreyNoise](https://viz.greynoise.io/signup) (optional; GreyNoise only gives keys to accounts made with a work email, not Gmail or similar. Without one it allows a limited number of lookups, and SANS ISC covers the rest). CVE and software checks work with no keys at all. IP and domain checks also run without keys, using Shodan's free InternetDB, the internet registries, Spamhaus DROP and GreyNoise; the report then lists VirusTotal and AbuseIPDB as not checked.

Then ask: *"Run a security assessment of PHP 8.3.10"* or use the `security_assessment` prompt. [Examples](#examples) has more to try.

## Store your keys securely

Keys can live in your operating system's credential store (Windows Credential Manager, macOS Keychain, or the Secret Service on Linux) instead of a config file. Run this in your own terminal; the key is typed into a hidden prompt and goes straight to the store:

```bash
uvx vulnerability-exposure-mcp keys set shodan
```

Do the same for `virustotal`, `abuseipdb`, `nvd` and `greynoise` as needed. `keys status` shows which are stored (never their values) and `keys delete NAME` removes one. With keys stored this way, leave the `env` block below empty. An environment variable, if set, takes precedence over a stored key.

Servers, Docker containers and other headless Linux systems usually have no credential store. There `keys set` says so, and keys go in the `env` block instead.

## Connect a client

Pass keys through the client's `env` block, not the command line.

**Claude Desktop**

Download `vulnerability-exposure-mcp-<version>.mcpb` from the [latest release](https://github.com/MRFrazer25/Vulnerability-Exposure-MCP/releases/latest) and open it: Claude Desktop installs it and asks for your (optional) keys in a form. Or add the JSON config below. From 1.1.0 each bundle has a signed build provenance attestation, so you can check it was built by this repository's release workflow: `gh attestation verify vulnerability-exposure-mcp-<version>.mcpb --repo MRFrazer25/Vulnerability-Exposure-MCP`.

**Claude Code**

Store your keys first (see above), so none go on the command line, then run:

```bash
claude mcp add vulnerability-exposure -- uvx vulnerability-exposure-mcp
```

Start a new Claude Code session afterwards: MCP servers load when a session starts.

Or install it as a plugin, which asks for each (optional) key in a masked prompt and keeps it in your credential store:

```
/plugin marketplace add MRFrazer25/Vulnerability-Exposure-MCP
/plugin install vulnerability-exposure@vulnerability-exposure
```

**Codex (CLI, IDE extension and ChatGPT desktop app)**

Store your keys first (see above), so none go on the command line, then run:

```bash
codex mcp add vulnerability-exposure -- uvx vulnerability-exposure-mcp
```

Or add it to `~/.codex/config.toml`, which all three share:

```toml
[mcp_servers.vulnerability-exposure]
command = "uvx"
args = ["vulnerability-exposure-mcp"]
```

**Antigravity CLI**

Store your keys first (see above), then install the plugin straight from this repo:

```bash
agy plugin install https://github.com/MRFrazer25/Vulnerability-Exposure-MCP/tree/main/plugin
```

**Cursor, Windsurf, VS Code, Claude Desktop and other JSON-configured clients**

Add this to the client's MCP config (in Claude Desktop: Settings → Developer → Edit Config), then restart the client. With keys stored in the credential store, leave the `env` values empty or remove the block.

```json
{
  "mcpServers": {
    "vulnerability-exposure": {
      "command": "uvx",
      "args": ["vulnerability-exposure-mcp"],
      "env": {
        "SHODAN_API_KEY": "",
        "VIRUSTOTAL_API_KEY": "",
        "ABUSEIPDB_API_KEY": "",
        "NVD_API_KEY": "",
        "GREYNOISE_API_KEY": ""
      }
    }
  }
}
```

(VS Code uses `"servers"` instead of `"mcpServers"` in `.vscode/mcp.json`.)

**Docker**

Build the image once with `docker build -t vulnerability-exposure-mcp .`, then point the client at it. Containers have no credential store, so keys go in `env`; listing them as bare `-e` names passes their values through without putting them on the command line:

```json
{
  "mcpServers": {
    "vulnerability-exposure": {
      "command": "docker",
      "args": ["run", "-i", "--rm", "-e", "SHODAN_API_KEY", "-e", "VIRUSTOTAL_API_KEY", "-e", "ABUSEIPDB_API_KEY",
               "-e", "NVD_API_KEY", "-e", "GREYNOISE_API_KEY", "vulnerability-exposure-mcp"],
      "env": {
        "SHODAN_API_KEY": "",
        "VIRUSTOTAL_API_KEY": "",
        "ABUSEIPDB_API_KEY": "",
        "NVD_API_KEY": "",
        "GREYNOISE_API_KEY": ""
      }
    }
  }
}
```

### From source

```bash
git clone https://github.com/MRFrazer25/Vulnerability-Exposure-MCP.git
cd Vulnerability-Exposure-MCP
python -m venv .venv
.venv/Scripts/python -m pip install -e .   # macOS/Linux: .venv/bin/python
```

Then use `.venv/Scripts/python -m vulnerability_exposure_mcp` (on macOS or Linux, `.venv/bin/python`) wherever the steps above say `uvx vulnerability-exposure-mcp`, with the full path to that Python in client configs, for example `"command": "C:/path/to/Vulnerability-Exposure-MCP/.venv/Scripts/python.exe", "args": ["-m", "vulnerability_exposure_mcp"]`.

It keeps everything that makes the original app's reports reliable:

- **The same analyst rules** as the app's system prompt. The server's instructions are a short summary, since clients cut long ones short; `investigate_target` returns the full rules and report format as `analyst_guide`.
- **Baseline lookups run in code**, so reputation and exposure checks never depend on the model remembering them.
- **Analysis depth** (Quick Scan, Standard, Comprehensive, Expert) sets the tool-call budget, per-service caps and how much detail each result keeps. The model can't override these limits.
- **Key facts computed from the data, not the model**, including the CISA KEV split into *confirmed for this target* and *related*, so the numbers are the same whichever model runs it.
- **Fresher and more accurate than NVD alone**: Ubuntu and Debian packages are checked against the distro's own fix data, so backported fixes count; recent CVEs NVD hasn't analysed are listed for review; and for packages such as Next.js, React and Django, GitHub advisories fill gaps before NVD has them. Each CVE carries its patch status and whether exploit code is published.
- **One investigation per `investigation_id`**: a random handle returned by `investigate_target`, so several chats sharing one server process never mix evidence.

### How this differs

Most CVE servers search NVD by keyword or product and hand back every match, so a report on `nginx 1.30.0` can list CVEs that were fixed years earlier. This one:

- **Checks the exact version.** A CVE is *confirmed* only when NVD's version ranges include that version, and for an Ubuntu or Debian package, CVEs the distro fixed by backport are ruled out. Keyword and product-level matches are listed separately as *related*.
- **Sets aside what isn't the product's.** Plugin CVEs (Jenkins plugins), other products that share the name (Nginx Proxy Manager, Grafana Alloy) and CVEs NVD confirms only on another OS (PHP on Windows, for a Linux build) are listed separately instead of being counted against it.
- **Combines the context a fix decision needs.** One call returns CISA KEV status and ransomware use, EPSS and whether it's rising, the minimum safe version (and how far your current major version gets), end-of-life status, published exploits and patch status, instead of the model stitching together separate lookups.
- **Checks the report, not just the data.** `check_report` flags a draft that cites a CVE, version or host name no tool returned, calls a related CVE confirmed, swaps an affected and an unaffected version, or gets a fix version, count, KEV, port, reputation or exploit claim wrong, before you see it.
- **Says what it didn't check.** Every report lists the sources that weren't checked (a missing key, a failed lookup), so a missing result is never presented as a clean one.

### What it doesn't do

- **No scanning.** It never connects to the target. Everything comes from public databases and the target's DNS records, so it can't find services that Shodan hasn't seen or vulnerabilities in software it isn't told about.
- **Public targets only.** Private, local and reserved IPs and local hostnames are refused.
- **No authenticated or internal checks.** It can't see installed packages, configuration or anything behind a login. For that, use a scanner on the host.
- **No exploitation or remediation.** It reports what's published about a target and what to upgrade to. It doesn't test exploits or change anything.
- **It's only as current as its sources.** CVEs that NVD hasn't analysed yet can't be version-confirmed; they're listed for review instead.

## Examples

Ask your AI client in plain words; it picks the tools. Some things to try:

| Ask | What you get |
|---|---|
| *"Does CVE-2024-6387 affect my server running `OpenSSH_8.9p1 Ubuntu-3ubuntu0.6`?"* | AFFECTED, NOT_AFFECTED or CAN'T CONFIRM, using Ubuntu's own fix data, and the exact package to update to |
| *"Check `C:\path\to\project\package-lock.json` for vulnerable packages and tell me what to upgrade first."* | Every pinned package checked in one OSV.dev call, the most urgent first, with the version that fixes each, and any package that's published malware flagged to remove. Works with a pinned `requirements.txt` or a CycloneDX SBOM too |
| *"I'm on nginx 1.24.0. What would upgrading to 1.27.3 fix, and what would still be open?"* | The CVEs the upgrade fixes, the ones it leaves, and any it adds |
| *"My site returns `Server: Apache/2.4.49 (Unix) OpenSSL/1.1.1k`. Am I at risk?"* | Both products checked, exploited CVEs and ransomware use first |
| *"What got added to CISA's exploited list this week? Does any of it touch Fortinet?"* | New CISA KEV entries with CISA's required action, ransomware use and EPSS |
| *"Explain CVE-2021-44228 for my manager: how bad is it, and what does CISA say to do?"* | The CVSS score in plain words, CISA's SSVC values and its required action, quoted |
| *"Run a security assessment of PHP 8.1.2."* | A full report with end-of-life status and a remediation checklist, checked by `check_report` |
| *"Add nginx 1.24.0 and PHP 8.1.2 to my watchlist."* Later: *"Check my watchlist. What's new?"* | Only what changed since the last check: new CVEs, new KEV entries, EPSS jumps |
| *"Am I affected? Windows 10 19045.4046."* or *"Exchange Server 2019 CU12"* | The build or cumulative update mapped to what NVD files it under, with end-of-life status and CISA KEV CVEs first |
| *"Investigate 8.8.8.8."* | Open ports, network owner, reputation and threat lists, with what wasn't checked |

Each answer says where every fact came from, and says "can't confirm" or "not checked" rather than calling something safe when the data doesn't show it.

## Tools

| Tool | What it does | Key needed |
|---|---|---|
| `investigate_target` | **Start here.** Classifies the target, sets the depth, runs the baseline lookups, returns an `investigation_id` and next steps | depends on target |
| `am_i_affected` | **Is my software affected?** Give the products and versions you run (typed, or pasted from a banner or `Server` header), a lockfile (pinned `requirements.txt`, `package-lock.json`) or a CycloneDX SBOM, optionally with one CVE ID. Each gets AFFECTED, NOT_AFFECTED or CAN'T CONFIRM with what decided it, uses Ubuntu and Debian backport data for package builds, and `nginx 1.24.0 -> 1.26.2` shows what an upgrade fixes | none (NVD key optional) |
| `watchlist` | **Keep an eye on your software.** Add the products and versions you run once; `check` reports only what changed since last time: newly confirmed CVEs, CVEs newly in CISA KEV, EPSS jumps. Kept in a file on your machine | none (NVD key optional) |
| `newly_exploited` | **What got exploited this week?** CVEs CISA added to its Known Exploited Vulnerabilities catalog in the last few days (up to 90), optionally only for products you name, with CISA's required action, known ransomware use and EPSS | none |
| `version_specific_vulnerability_check` | CVEs NVD confirms affect this exact version, ranked by KEV, EPSS and CVSS, with each one's patch status, any published exploit (Exploit-DB), the minimum safe version and whether the release line is end-of-life (endoflife.date). CVEs NVD hasn't analysed yet are confirmed from the vendor's own CVE record (CVE.org) when it covers this version. For packages such as Next.js, React, Express and Django it also adds GitHub advisories NVD doesn't have yet | none (NVD key optional) |
| `distro_patch_check` | Whether an Ubuntu or Debian package (e.g. `openssh 8.9p1-3ubuntu0.6` from an SSH banner) already has each CVE fixed by a backport, from the distro's own data | none |
| `nvd_lookup` | Full NVD record for one CVE, with KEV, EPSS, the CVSS vector in plain words and CISA's SSVC values (exploitation, automatable, technical impact) | none |
| `cisa_kev_check` | CVE IDs or product names against CISA's Known Exploited Vulnerabilities | none |
| `cve_search` | Keyword search of recent NVD CVEs | none |
| `resolve_domain` | DNS A/AAAA lookup | none |
| `shodan_search` | Open ports, services, versions, hosting. Without a key: Shodan's free InternetDB (ports, software and CVEs, no banners) | `SHODAN_API_KEY` for full results |
| `ip_owner` | Who an IP's network is registered to, from the regional internet registry (RDAP) | none |
| `threat_lists_check` | Spamhaus DROP (hijacked or criminal networks) and GreyNoise (internet scanners), with SANS ISC as the fallback when GreyNoise can't answer | none (`GREYNOISE_API_KEY` optional) |
| `subdomains` | Hostnames under a domain from certificate transparency logs (crt.sh, or Cert Spotter as a fallback) | none |
| `virustotal_check` | Reputation from VirusTotal engines | `VIRUSTOTAL_API_KEY` |
| `abuseipdb_check` | Abuse reports and confidence score | `ABUSEIPDB_API_KEY` |
| `get_key_facts` | Facts, the CISA KEV confirmed/related split, a remediation checklist in priority order and the sources used (with when each was queried), computed from this investigation's results | none |
| `check_report` | Checks a draft report against the investigation's data, with no model involved, and lists CVE IDs, versions, EPSS figures and claims (end-of-life, no patch, internet-facing) that no lookup supports | none |
| `check_api_keys` | Which keys are set (never their values) and where to get the rest | none |

There's also a `security_assessment` prompt (target + depth) that loads the analyst rules and the workflow: `investigate_target` → pass its `investigation_id` to each lookup → `get_key_facts` → draft the report →
`check_report` → fix what it flags. Lookups also work on their own without an id: they get Standard result sizes and the hourly cap below, but no tool-call budget, and they aren't counted in any investigation's key facts.

| Depth | Tool calls | Calls per Shodan/VirusTotal/AbuseIPDB |
|---|---|---|
| Quick Scan | 8 | 1 |
| Standard Analysis (default) | 15 | 2 |
| Comprehensive Investigation | 25 | 4 |
| Expert Deep Dive | 40 | 6 |

Every tool is read-only except `watchlist`, which only writes its own file in your config folder. Private, reserved and cloud-metadata IPs are refused.

### What each tool sends, and where

**No tool ever contacts the target.** Every lookup asks a public data source about the target, so the target's own servers never see a request from you. Those services do see what you looked up and your IP address (and your key, if you use one).

| Tool | What it sends | Sent to |
|---|---|---|
| `resolve_domain` | The domain | Your normal DNS resolver |
| `shodan_search` | The IP | Shodan with a key, or Shodan InternetDB without one |
| `virustotal_check` | The IP or domain | VirusTotal |
| `abuseipdb_check` | The IP | AbuseIPDB |
| `ip_owner` | The IP | IANA, then the regional internet registry (RDAP) |
| `threat_lists_check` | The IP | GreyNoise, or SANS ISC when GreyNoise can't answer. Spamhaus DROP is downloaded whole, so the IP isn't sent to Spamhaus |
| `subdomains` | The domain | crt.sh, or Cert Spotter when crt.sh is down |
| `am_i_affected` | Each product name and version, and the CVE ID if given. For a lockfile or SBOM, each pinned package's name and version (never the file) | NVD for products; OSV.dev for packages, lockfiles, SBOMs and distro builds |
| `watchlist` | `check` sends what `am_i_affected` does, for each entry; add, remove and list send nothing | NVD, OSV.dev, as `am_i_affected` |
| `newly_exploited` | Nothing (the KEV catalog is downloaded whole) | CISA |
| `version_specific_vulnerability_check` | The software name and version (plus the product name to endoflife.date, and CVE IDs to CVE.org for CVEs NVD hasn't analysed) | NVD, plus OSV.dev for framework packages such as Next.js or Django |
| `distro_patch_check` | The package name and version | OSV.dev |
| `nvd_lookup`, `cve_search` | A CVE ID or search term | NVD (Shodan CVEDB if NVD is down), and the CVE ID to CVE.org for CISA's SSVC values |
| CVE enrichment inside the tools above | CVE IDs only | FIRST (EPSS). The CISA KEV catalog and the Exploit-DB index are downloaded whole, so nothing is sent to them |
| `investigate_target` | Runs the lookups that fit the target, as above | |
| `get_key_facts`, `check_report`, `check_api_keys` | Nothing | Run on your machine |

## Check your watchlist on a schedule

The `watch` command (1.2.0 and later; `uvx` fetches the newest release) checks the watchlist and prints what changed, so your operating system's scheduler can run it daily with no server. Add entries first, from your AI client (*"add nginx 1.24.0 to my watchlist"*). The list is a file in your config folder (`%APPDATA%\vulnerability-exposure-mcp\watchlist.json` on Windows, `~/Library/Application Support/...` on macOS, `~/.config/...` on Linux).

```bash
uvx vulnerability-exposure-mcp watch          # check now and print what changed
uvx vulnerability-exposure-mcp watch list     # show the entries
```

- **Windows (Task Scheduler):** `schtasks /Create /SC DAILY /ST 09:00 /TN "Vulnerability watchlist" /TR "cmd /c uvx vulnerability-exposure-mcp watch >> %USERPROFILE%\vuln-watch.log"`
- **Linux (cron):** `0 9 * * * uvx vulnerability-exposure-mcp watch >> ~/vuln-watch.log 2>&1`
- **macOS:** the same cron line, or a launchd agent that runs the same command.

With the disk cache on (`VULN_EXPOSURE_CACHE=on`), repeat checks are faster and use less of NVD's rate limit.

## Settings

| Variable | Default | Meaning |
|---|---|---|
| `VULN_EXPOSURE_QUOTA_PER_HOUR` | `20` | Max calls per hour to each of Shodan, VirusTotal and AbuseIPDB across all investigations, on top of the per-depth caps |
| `VULN_EXPOSURE_LOG_LEVEL` | `WARNING` | Log level (logs go to stderr) |
| `VULN_EXPOSURE_CACHE` | off | `on` keeps public data-source responses (NVD, CISA KEV, EPSS, Exploit-DB, CVE.org, endoflife.date, OSV advisories) on disk for a few hours, so repeat checks are much faster (a Jenkins check: 4 s, then 0.7 s) and use less of NVD's rate limit. Never stores keys or results, and each file is signed with a key in your OS credential store, so an edited file is fetched again instead of trusted. `vulnerability-exposure-mcp cache status` and `cache clear` show and empty it |
| `VULN_EXPOSURE_WATCHLIST` | your user config folder | Where the watchlist file lives |
| `VULN_EXPOSURE_CACHE_DIR` | your user cache folder | Where the disk cache lives (default: `%LOCALAPPDATA%\vulnerability-exposure-mcp` on Windows, `~/Library/Caches/...` on macOS, `~/.cache/...` on Linux) |

Repeating an identical call in the same investigation returns the earlier result without spending quota. Large results are trimmed to about 15,000 characters.

## Security notes

- Tool results contain third-party text (banners, hostnames, CVE descriptions). They're returned as data, the server's instructions tell the model never to follow instructions found in them, and instruction-like text in banners, hostnames and registry records is replaced with `[instruction-like text removed]` before the model sees it. Still, use a client that shows you tool calls.
- `check_report` checks a draft report against the investigation's data in code, and lists IDs, versions, EPSS figures and claims no lookup supports.
- To be alerted if any MCP server's tool descriptions change after you approve them (tool poisoning), you can run it behind Trail of Bits' [mcp-context-protector](https://github.com/trailofbits/mcp-context-protector).
- Keys are read from the environment or the OS credential store on each call, never logged, and redacted from error messages. Targets are not logged either, and failures are logged without tracebacks.
- Failed lookups are returned as tool errors (`isError`), and every tool is marked read-only.
- The server speaks stdio only, so it runs on your machine and only your client can reach it.
- Nothing is stored on disk unless you turn on the disk cache (`VULN_EXPOSURE_CACHE=on`), which keeps only public data-source responses, never keys or results. There's no telemetry. Targets are sent only to the data provider each lookup uses; see [PRIVACY.md](https://github.com/MRFrazer25/Vulnerability-Exposure-MCP/blob/main/PRIVACY.md) for what each one receives.
- Lockfiles and SBOMs given to `am_i_affected` are untrusted input: files over 5 MB, JSON nested more than 64 levels and more than 5,000 packages are refused before parsing, a path is read only when it names a lockfile or SBOM, and only package names and versions are sent anywhere.
- Every push and pull request runs the tests, [pip-audit](https://pypi.org/project/pip-audit/) against known-vulnerable dependencies, and [gitleaks](https://github.com/gitleaks/gitleaks) over the whole history so no key is ever committed. Dependencies are pinned and updated by Dependabot. See [SECURITY.md](https://github.com/MRFrazer25/Vulnerability-Exposure-MCP/blob/main/SECURITY.md) to report a problem.

## Responsible use

For legitimate security research, defensive security and education only. Only investigate systems you own or are authorized to assess, and follow each data provider's terms of service. Automated findings can be wrong; verify before acting.

## Data sources and terms

Lookups use your own accounts and keys, so each provider's terms apply to you directly.

| Source | Used for | Terms to know |
|---|---|---|
| [Shodan](https://www.shodan.io/) | Open ports, services, versions | Uses your own Shodan account and key. Without one, [InternetDB](https://internetdb.shodan.io/) is free for non-commercial use |
| Regional internet registries (RDAP) | Who an IP's network is registered to | Public registry data, found through [IANA's RDAP bootstrap](https://data.iana.org/rdap/) |
| [Spamhaus DROP](https://www.spamhaus.org/blocklists/do-not-route-or-peer/) | Hijacked or criminal networks | Free; [credit Spamhaus](https://www.spamhaus.org/drop/terms/) when you use it. Downloaded at most once a day, as Spamhaus asks |
| [GreyNoise](https://www.greynoise.io/) | Internet scanners and known business services | Community API: a limited number of lookups without a key (GreyNoise sets and changes the limit); keys need a work-email account |
| [crt.sh](https://crt.sh/), [Cert Spotter](https://sslmate.com/ct_search_api/) | Subdomains from certificate transparency logs | Free public search; Cert Spotter allows a few keyless lookups an hour for personal use |
| [Shodan CVEDB](https://cvedb.shodan.io/) | CVE details when NVD can't be reached | Free for non-commercial use |
| [SANS ISC](https://isc.sans.edu/) (DShield) | Attack reports for an IP when GreyNoise can't answer | Free and keyless; data is [CC BY-NC-SA 4.0](https://isc.sans.edu/api/) (non-commercial), and SANS asks for contact details in the user agent |
| [Exploit-DB](https://www.exploit-db.com/) | Whether exploit code is published for a CVE | Its index is downloaded at most once a day; GPL-2.0-or-later |
| [GitHub Advisory Database](https://github.com/advisories) and the [PyPA Advisory Database](https://github.com/pypa/advisory-database) via OSV.dev | Advisories for npm, PyPI, Maven and RubyGems packages before NVD has them | Free, no key; data is [CC BY 4.0](https://github.com/github/advisory-database#license) |
| [VirusTotal](https://www.virustotal.com/) | Reputation from security engines | The free public API allows 4 lookups a minute and 500 a day, and [must not be used in commercial products or services](https://docs.virustotal.com/reference/public-vs-premium-api) |
| [AbuseIPDB](https://www.abuseipdb.com/) | Abuse reports for IPs | [Free plans](https://www.abuseipdb.com/legal) are for non-commercial personal projects; don't republish its data |
| [NVD](https://nvd.nist.gov/) (NIST) | CVE details and affected versions | Public data; free API key optional |
| [CISA KEV](https://www.cisa.gov/known-exploited-vulnerabilities-catalog) | Known exploited vulnerabilities | Public US government data |
| [FIRST EPSS](https://www.first.org/epss/) | Exploitation probability | Published freely by FIRST's EPSS SIG |
| [CVE.org](https://www.cve.org/) (CVE Program) | The vendor's own affected versions for CVEs NVD hasn't analysed, and CISA's SSVC values | Public CVE records; free, no key |
| [endoflife.date](https://endoflife.date/) | Whether a release line still gets fixes | Free, no key; community-maintained, [MIT licensed](https://github.com/endoflife-date/endoflife.date/blob/master/LICENSE) |
| [OSV.dev](https://osv.dev/) | Ubuntu and Debian fixes for installed packages, and every package in a lockfile or SBOM (npm, PyPI, Maven, Go, crates.io, NuGet and more) | Free, no key. OSV.dev gathers advisories from each project's own database: the distros' security teams (Ubuntu's is [CC BY-SA 4.0](https://github.com/canonical/ubuntu-security-notices#license); Debian's [security tracker](https://security-tracker.debian.org/)), the [GitHub](https://github.com/advisories), [PyPA](https://github.com/pypa/advisory-database), [Go](https://pkg.go.dev/vuln/) and [RustSec](https://rustsec.org/) databases, and [OpenSSF Malicious Packages](https://github.com/ossf/malicious-packages) for the malware flag |

Several free tiers are for non-commercial use only: VirusTotal, AbuseIPDB, and Shodan's InternetDB and CVEDB. If you use this at work or in a paid product, get plans that allow commercial use.

This product uses data from the NVD API but is not endorsed or certified by the NVD.

Spamhaus DROP data is (c) The Spamhaus Project. Package advisories are from the GitHub Advisory Database (CC BY 4.0), the PyPA Advisory Database (CC BY 4.0), the Go Vulnerability Database (CC BY 4.0), the RustSec Advisory Database (CC0, with advisories adapted from GitHub's under CC BY 4.0), OpenSSF Malicious Packages (Apache-2.0), Debian's security tracker and Ubuntu's security notices (CC BY-SA 4.0, (c) Canonical), all via OSV.dev; SANS ISC data is CC BY-NC-SA 4.0. CVE® is a registered trademark of The MITRE Corporation.

Vulnerability Exposure MCP is an independent project. It is not affiliated with, endorsed by or sponsored by Shodan, VirusTotal (Google), AbuseIPDB, NIST, CISA, FIRST, MITRE, Spamhaus, GreyNoise, SANS, OffSec (Exploit-DB), GitHub, Google (OSV.dev and the Go team), the RustSec project, the OpenSSF, Debian, Canonical, endoflife.date, Sectigo (crt.sh), SSLMate (Cert Spotter) or the internet registries. Their names are used only to say which services it works with.

## Tests

```bash
.venv/Scripts/python -m pip install -e ".[dev]"
.venv/Scripts/python -m pytest -q
```

## License

MIT