🛡️ CVE MCP Server

KI-gestützte Security-Intelligence direkt zur Hand — 28 Tools + ein One-Call-triage_cve-Orchestrator, 24 Datenquellen, ein Protokoll.

Ein produktionsreifer Model-Context-Protocol-Server (MCP-Server), der Claude in einen Vollspektrum-Security-Analysten verwandelt. Statt mit 15+ Browser-Tabs zwischen NVD, EPSS, CISA KEV, Shodan, VirusTotal und GreyNoise zu jonglieren, stell Claude eine Frage und erhalte in Sekunden korrelierte Intelligence. Entwickelt mit Python, FastMCP, httpx, aiosqlite, Pydantic v2 und defusedxml.

Das Problem: Eine einzelne CVE zu triagieren bedeutet, NVD nach CVSS-Scores, EPSS nach Ausnutzungswahrscheinlichkeit, CISA KEV nach aktivem Ausnutzungsstatus, GitHub nach Patches und VirusTotal nach Malware-Zuordnungen abzufragen — und dann alles mental zu korrelieren. Bei 50 CVEs geht dafür ein ganzer Tag verloren.

Die Lösung: Der CVE-MCP-Server gibt Claude direkten Zugriff auf 28 Security-Tools über 24 APIs — mit dem triage_cve-One-Call-Orchestrator an der Spitze. Frag „Sollten wir CVE-2024-3400 patchen?", und Claude fragt parallel alle relevanten Quellen ab, berechnet einen Gesamtrisikoscore (mit einer harten Überschreibung durch CISA KEV) und liefert eine priorisierte Empfehlung mit Belegen.

🌍 GARS-2026 — Globale Umfrage zur Agentic-AI-Bereitschaft

Ich führe eine globale akademische Studie durch, die misst, wie bereit Sicherheitsexperten, Entwickler und Unternehmensteams tatsächlich für Agentic AI sind — MCP-Server, Tool-Calling, Governance und Human-in-the-Loop-Workflows.

Wenn du dieses Repository nutzt, wäre deine Antwort ein wirklich wertvoller Datenpunkt.

📋 Nimm an der Umfrage teil (10 Min.): Umfrage

• 60 Fragen · Anonym · Unter Aufsicht der SRH Berlin
• Du erhältst 50 Casky-Tokens für den Frühzugang zu casky.ai
• Ergebnisse werden als Open Access unter CC-BY 4.0 veröffentlicht

📑 Inhaltsverzeichnis

• Architektur
• Tool-Katalog
• Installation
• API-Schlüssel einrichten
• Konfiguration
• Schnellstart
• Anwendungsbeispiele
• Risikoscore erklärt
• Datenquellen
• Tests ausführen
• Architektur im Detail
• Sicherheit und Datenschutz
• Fehlerbehebung
• Roadmap und bekannte Einschränkungen
• Mitwirken
• Lizenz

🏗️ Architektur```

┌─────────────────────────────────────────────────────────────────────┐ │ Claude Desktop / Claude Code │ │ (MCP Client via stdio) │ └──────────────────────────────┬──────────────────────────────────────┘ │ Model Context Protocol (stdio) ▼ ┌─────────────────────────────────────────────────────────────────────┐ │ CVE MCP Server (Python) │ │ ┌─────────────┐ ┌──────────────┐ ┌───────────────┐ │ │ │ 27 MCP │ │ Composite │ │ SQLite Cache │ │ │ │ Tools │ │ Risk Engine │ │ + Audit Log │ │ │ └──────┬──────┘ └──────┬───────┘ └───────┬───────┘ │ │ │ │ │ │ │ ┌──────┴────────────────┴───────────────────┴──────┐ │ │ │ Async HTTP Client (httpx) │ │ │ │ Rate Limiter · Response Cache │ │ │ └──────────────────────┬───────────────────────────┘ │ └─────────────────────────┼───────────────────────────────────────────┘ │ HTTPS (outbound only) ┌───────────────┼───────────────────────────┐ ▼ ▼ ▼ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │ VULNERABILITY│ │ NETWORK │ │ THREAT │ │ INTELLIGENCE │ │ INTELLIGENCE │ │ INTELLIGENCE │ ├──────────────┤ ├──────────────┤ ├──────────────┤ │ NVD API 2.0 │ │ AbuseIPDB │ │ VirusTotal │ │ EPSS / FIRST │ │ GreyNoise v3 │ │ MalwareBazaar│ │ CISA KEV │ │ Shodan │ │ ThreatFox │ │ OSV.dev │ │ CIRCL PDNS │ │ Ransomwhere │ │ GitHub GHSA │ │ │ │ AlienVault │ │ MITRE ATT&CK │ │ │ │ URLScan.io │ └──────────────┘ └──────────────┘ └──────────────┘

Der gesamte Datenverkehr ist **ausschließlich ausgehendes HTTPS** — es werden keine eingehenden Ports geöffnet. API-Schlüssel werden aus Umgebungsvariablen geladen und niemals protokolliert. Private/interne IP-Adressen werden von allen Lookup-Tools blockiert.

---

## 🔍 Tool-Katalog (28 Tools)

### ⭐ Orchestrierung (v0.2.0) — hier beginnen

| Tool | Beschreibung | API-Schlüssel erforderlich | Beispielverwendung |
|------|-------------|-----------------|---------------|
| `triage_cve` | One-Call-Triage, das NVD + EPSS + CISA KEV (+ öffentlicher PoC für `depth != "quick"`) parallel ausführt, den zusammengesetzten Risikoscore mit einer harten KEV-Überschreibung berechnet, auf VulnCheck NVD++ zurückfällt, wenn NIST NVD gedrosselt ist, und bei `depth="deep"` die SSVC-v2-Gated-Entscheidung ausgibt | Kostenlos / Kein Schlüssel (Schlüssel empfohlen) | `triage_cve("CVE-2021-44228", depth="deep")` |

> **Auch über MCP-Primitive verfügbar** — Ressourcen: `kev://catalog`, `epss://scores/{cve_id}`, `manifest://tool-hash` (SHA-256 über die registrierte Tool-Oberfläche, zur Manipulationserkennung). Prompts: `patch_decision`, `compare_and_prioritize`, `dependency_triage`.

### Kern-Schwachstellen-Intelligence (8 Tools)

| Tool | Beschreibung | API-Schlüssel erforderlich | Beispielverwendung |
|------|-------------|-----------------|---------------|
| `lookup_cve` | Ruft detaillierten CVE-Datensatz von NVD ab, einschließlich CVSS-Scores, CWEs, betroffene Produkte, Referenzen und Zeitverlauf | Kostenlos / Kein Schlüssel (Schlüssel empfohlen) | `lookup_cve("CVE-2024-3400")` |
| `search_cves` | Durchsucht NVD nach CVEs anhand von Schlüsselwort, Produktname, Schweregrad oder Datumsbereich | Kostenlos / Kein Schlüssel (Schlüssel empfohlen) | `search_cves(keyword="Apache Log4j", severity="CRITICAL")` |
| `get_epss_score` | Ruft EPSS-Exploitation-Wahrscheinlichkeit (0–1) und Perzentil für eine oder mehrere CVEs ab | Kostenlos / Kein Schlüssel | `get_epss_score("CVE-2024-3400")` |
| `check_kev_status` | Prüft, ob eine CVE im Katalog der Known Exploited Vulnerabilities von CISA enthalten ist | Kostenlos / Kein Schlüssel | `check_kev_status("CVE-2021-44228")` |
| `get_cvss_details` | Analysiert und erklärt eine CVSS-v3.1-Vektorzeichenfolge mit Aufschlüsselung pro Metrik | Kostenlos / Kein Schlüssel | `get_cvss_details("CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H")` |
| `get_cwe_info` | Schlägt Details zur Common Weakness Enumeration anhand der CWE-ID in einer eingebetteten Datenbank nach | Kostenlos / Kein Schlüssel | `get_cwe_info("CWE-79")` |
| `get_cve_references` | Extrahiert und kategorisiert alle Referenzlinks für eine CVE (Patches, Advisories, Exploits) | Kostenlos / Kein Schlüssel (Schlüssel empfohlen) | `get_cve_references("CVE-2023-44487")` |
| `bulk_cve_lookup` | Ruft Details für bis zu 20 CVEs in einem einzigen Aufruf mit paralleler Anreicherung ab | Kostenlos / Kein Schlüssel (Schlüssel empfohlen) | `bulk_cve_lookup(["CVE-2024-3400", "CVE-2023-44487"])` |

### Exploit- & Angriffs-Intelligence (4 Tools)

| Tool | Beschreibung | API-Schlüssel erforderlich | Beispielverwendung |
|------|-------------|-----------------|---------------|
| `search_exploits` | Durchsucht GitHub nach öffentlichen Proof-of-Concept-Exploits und Exploit-Code-Repositorys | `GITHUB_TOKEN` (optional) | `search_exploits("CVE-2024-3400")` |
| `get_mitre_techniques` | Ordnet eine CVE oder CWE relevanten MITRE-ATT&CK-Techniken, Taktiken und Mitigationen zu | Kostenlos / Kein Schlüssel | `get_mitre_techniques("CVE-2021-44228")` |
| `check_poc_availability` | Ermittelt, ob bekannter Proof-of-Concept-Code für eine CVE in mehreren Quellen existiert | `GITHUB_TOKEN` (optional) | `check_poc_availability("CVE-2024-3400")` |
| `get_attack_patterns` | Ruft CAPEC-Angriffsmusterdetails ab, die mit einer CWE oder CVE verknüpft sind | Kostenlos / Kein Schlüssel | `get_attack_patterns("CWE-89")` |

### Phase 3: Erweitertes Risiko & Reporting (4 Tools)

| Tool | Beschreibung | API-Schlüssel erforderlich | Beispielverwendung |
|------|-------------|-----------------|---------------|
| `calculate_risk_score` | Berechnet einen zusammengesetzten Risikoscore von 0–100 anhand von CVSS, EPSS, KEV-Status und PoC-Verfügbarkeit | Kostenlos / Kein Schlüssel (Schlüssel empfohlen) | `calculate_risk_score("CVE-2024-3400")` |
| `generate_risk_report` | Erstellt einen formatierten Executive-Sicherheitsbericht für eine oder mehrere CVEs mit Empfehlungen | Kostenlos / Kein Schlüssel (Schlüssel empfohlen) | `generate_risk_report(["CVE-2024-3400", "CVE-2023-44487"])` |
| `prioritize_cves` | Sortiert eine Liste von CVEs nach zusammengesetztem Risikoscore für die Triage-Priorisierung | Kostenlos / Kein Schlüssel (Schlüssel empfohlen) | `prioritize_cves(["CVE-2024-3400", "CVE-2023-4966", "CVE-2023-44487"])` |
| `get_trending_cves` | Ruft aktuelle Trend-CVEs basierend auf hohen EPSS-Scores und kürzlichen KEV-Ergänzungen ab | Kostenlos / Kein Schlüssel | `get_trending_cves(days=7, min_epss=0.5)` |

### Netzwerk-Intelligence (4 Tools)

| Tool | Beschreibung | API-Schlüssel erforderlich | Beispielverwendung |
|------|-------------|-----------------|---------------|
| `lookup_ip_reputation` | Prüft Missbrauchshistorie und Konfidenz-Score einer IP-Adresse über AbuseIPDB | `ABUSEIPDB_API_KEY` | `lookup_ip_reputation("185.220.101.34")` |
| `check_ip_noise` | Fragt GreyNoise nach IP-Scan-/Angriffsaktivität, Klassifizierung und zugehörigen CVEs ab | `GREYNOISE_API_KEY` | `check_ip_noise("185.220.101.34")` |
| `shodan_host_lookup` | Ermittelt offene Ports, Dienste, Banner und Schwachstellen für eine IP über Shodan | `SHODAN_API_KEY` | `shodan_host_lookup("8.8.8.8")` |
| `passive_dns_lookup` | Ruft historische DNS-Auflösungsdaten für eine Domain von CIRCL Passive DNS ab | `CIRCL_PDNS_USER` + `CIRCL_PDNS_PASSWORD` | `passive_dns_lookup("example.com")` |

### Bedrohungs-Intelligence (4 Tools)

| Tool | Beschreibung | API-Schlüssel erforderlich | Beispielverwendung |
|------|-------------|-----------------|---------------|
| `virustotal_lookup` | Analysiert Datei-Hashes, URLs, Domains oder IPs gegen 70+ Antiviren-Engines | `VIRUSTOTAL_API_KEY` | `virustotal_lookup(hash="44d88612fea8a8f36de82e1278abb02f")` |
| `search_malware` | Durchsucht MalwareBazaar nach Malware-Proben anhand von Hash, Tag oder Signatur | `ABUSECH_AUTH_KEY` (optional) | `search_malware(tag="Emotet")` |
| `search_iocs` | Fragt ThreatFox nach Kompromittierungsindikatoren ab, die mit Malware-Familien verknüpft sind | `ABUSECH_AUTH_KEY` (optional) | `search_iocs(malware="CobaltStrike")` |
| `check_ransomware` | Schlägt Ransomware-Zahlungsadressen und Transaktionsdaten von Ransomwhere nach | Kostenlos / Kein Schlüssel | `check_ransomware(address="bc1q...")` |

### DevSecOps (3 Tools)

| Tool | Beschreibung | API-Schlüssel erforderlich | Beispielverwendung |
|------|-------------|-----------------|---------------|
| `scan_dependencies` | Scannt Paketnamen und -versionen gegen OSV.dev auf bekannte Schwachstellen | Kostenlos / Kein Schlüssel | `scan_dependencies(ecosystem="PyPI", packages={"requests": "2.28.0"})` |
| `scan_github_advisories` | Durchsucht GitHub Security Advisories nach Ökosystem, Paket oder Schweregrad | `GITHUB_TOKEN` (optional) | `scan_github_advisories(ecosystem="pip", package="django")` |
| `urlscan_check` | Sendet eine URL zum Scannen ein oder ruft frühere Scan-Ergebnisse von URLScan.io ab | `URLSCAN_API_KEY` | `urlscan_check("https://suspicious-site.com")` |

---

## 📦 Installation

### Voraussetzungen

- **Python 3.10+** (3.11 oder 3.12 empfohlen)
- **pip** oder **uv**-Paketmanager
- **Git** zum Klonen des Repositorys
- Ein Terminal mit Zugriff auf Umgebungsvariablen

### Schritt-für-Schritt-Einrichtung```bash
# 1. Clone the repository
git clone https://github.com/mukul975/cve-mcp-server.git
cd cve-mcp-server

# 2. Create and activate a virtual environment
python -m venv venv

# macOS / Linux:
source venv/bin/activate

# Windows (PowerShell):
.\venv\Scripts\Activate.ps1

# Windows (CMD):
venv\Scripts\activate.bat

# 3. Install dependencies
pip install -e .

# 4. Copy and configure environment variables
cp .env.example .env
# Edit .env with your API keys (see API Keys Setup section below)

# 5. Verify the server starts
python -m cve_mcp.server

Verwendung von uv (schnellere Alternative)```bash

git clone https://github.com/mukul975/cve-mcp-server.git cd cve-mcp-server uv venv source .venv/bin/activate # or .venv\Scripts\activate on Windows uv pip install -e . cp .env.example .env

### Mit Testabhängigkeiten```bash
pip install -e ".[test]"

🔑 Einrichtung der API-Schlüssel

API-Schlüssel sind nach Priorität geordnet — hol dir zuerst die Tier-1-Schlüssel für maximale Abdeckung mit kostenlosen Tools und füge danach schrittweise Tier 2 und Tier 3 hinzu, falls nötig.

Tier 1: Hohe Priorität (kostenlos, sofortiger Zugang, maximale Abdeckung)

Tier 2: Empfohlen (kostenlose Konten, erheblicher Mehrwert)

Tier 3: Optional (erweiterte Intelligenz)

⚡ Start ohne Schlüssel: Acht Tools funktionieren ohne jeglichen API-Schlüssel — EPSS, CISA KEV, OSV.dev, MITRE ATT&CK, CWE-Abfragen, CVSS-Parsing, Ransomwhere und NVD (mit reduzierter Rate). Du kannst den Server sofort nutzen und Schlüssel nach und nach hinzufügen.

⚙️ Konfiguration

Umgebungsvariablen (.env.example)```env

NVD API key — free at https://nvd.nist.gov/developers/request-an-api-key

Without key: 5 req/30s | With key: 50 req/30s

NVD_API_KEY=

GitHub token — increases rate limit from 60/hr to 5000/hr (no scopes needed)

GITHUB_TOKEN=

Threat intelligence keys (all optional — tools degrade gracefully without them)

ABUSEIPDB_KEY= # https://www.abuseipdb.com/account/api VIRUSTOTAL_KEY= # https://www.virustotal.com/gui/join-us URLSCAN_KEY= # https://urlscan.io/user/signup SHODAN_KEY= # https://account.shodan.io/register

GreyNoise — uses /v3/ip/{ip} endpoint (NOT the deprecated /v3/community)

GREYNOISE_API_KEY= # https://viz.greynoise.io/signup

CIRCL Passive DNS — requires partner registration

CIRCL_PDNS_USER= CIRCL_PDNS_PASS=

Optional overrides

CACHE_DB_PATH= # defaults to ~/.cve-mcp/cache.db AUDIT_LOG_PATH= # defaults to ~/.cve-mcp/audit.log REQUEST_TIMEOUT=30 # HTTP timeout in seconds MAX_RETRIES=3 # retries on transient errors

### Claude Desktop-Konfiguration

**macOS:** `~/Library/Application Support/Claude/claude_desktop_config.json`
**Windows:** `%APPDATA%\Claude\claude_desktop_config.json````json
{
  "mcpServers": {
    "cve-mcp": {
      "command": "python",
      "args": ["-m", "cve_mcp.server"],
      "cwd": "/absolute/path/to/cve-mcp-server",
      "env": {
        "NVD_API_KEY": "your-key-here",
        "GITHUB_TOKEN": "ghp_xxxxxxxxxxxxxxxxxxxx",
        "ABUSEIPDB_KEY": "your-abuseipdb-key",
        "GREYNOISE_API_KEY": "your-greynoise-key",
        "SHODAN_KEY": "your-shodan-key"
      }
    }
  }
}

⚠️ Wichtig: Verwende immer absolute Pfade. Beende Claude Desktop vollständig, nachdem du die Konfiguration geändert hast (Cmd+Q / Alt+F4) — Neuladen reicht nicht aus.

Claude Code-Konfiguration```bash

Basic setup

claude mcp add cve-mcp -- python -m cve_mcp.server

With environment variables (repeat -e for each key)

claude mcp add cve-mcp -e NVD_API_KEY=your_key -e VULNCHECK_TOKEN=your_token -- python -m cve_mcp.server

Or just run from the project directory — python-dotenv auto-loads .env on startup

Verify it's connected

claude mcp list

---

## 🚀 Schnellstart

### Schritt 1: Installation (2 Minuten)```bash
git clone https://github.com/mukul975/cve-mcp-server.git
cd cve-mcp-server
python -m venv venv && source venv/bin/activate
pip install -e .

Schritt 2: Zuerst mit kostenlosen Tools testen

Keine .env-Datei erforderlich. Fügen Sie den Server zu Claude Desktop oder Claude Code hinzu und versuchen Sie:

"Was ist CVE-2021-44228? Wird es aktiv ausgenutzt?"

Claude verwendet lookup_cve (NVD), get_epss_score (EPSS) und check_kev (CISA KEV) — alle kostenlos, keine Schlüssel erforderlich.

"Scanne diese Python-Pakete auf Schwachstellen: requests 2.28.0, flask 2.2.0, django 3.2.0"

Schritt 3: Fügen Sie Ihren ersten Schlüssel für 10× Leistung hinzu```bash

echo 'NVD_API_KEY=your-key-here' > .env

Fordere einen kostenlosen NVD-Schlüssel unter [nvd.nist.gov](https://nvd.nist.gov/developers/request-an-api-key) an — sofort per E-Mail, erhöht das Rate-Limit von **5 auf 50 Anfragen pro 30 Sekunden**.

### Schritt 4: Vollleistungsmodus

Sobald du Tier-1- und Tier-2-Schlüssel hinzugefügt hast:

> **„Berechne den Risikoscore für CVE-2024-3400 und sag mir, ob wir sofort patchen sollten."**

---

## 💬 Anwendungsbeispiele

### Szenario 1: „Sollten wir Log4Shell sofort patchen?"

> **Du:** Analysiere, ob CVE-2021-44228 (Log4Shell) sofort gepatcht werden muss. Gib mir den Risikoscore und deine Empfehlung.

Claude orchestriert im Hintergrund mehrere Tools:```
→ lookup_cve("CVE-2021-44228")
  CVSS 3.1: 10.0 (CRITICAL) | AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H

→ get_epss_score("CVE-2021-44228")
  EPSS: 0.97531 (97.5%) | Percentile: 99.99%

→ check_kev("CVE-2021-44228")
  ✅ IN CISA KEV — Added 2021-12-10 | Known ransomware use: Yes

→ check_poc_exists("CVE-2021-44228")
  ✅ WEAPONIZED — 300+ public PoC repositories found

→ calculate_risk_score("CVE-2021-44228")
  Risk Score: 97/100 (CRITICAL) | Urgency: PATCH IMMEDIATELY

Claudes Antwort: "CVE-2021-44228 erreicht 97/100 (KRITISCH). Remote-Codeausführung in Apache Log4j, CVSS 10.0, 97,5% EPSS-Wahrscheinlichkeit, bestätigte aktive Ausnutzung in CISA KEV einschließlich Ransomware-Kampagnen, 300+ öffentliche Exploits. Sofort patchen."

Szenario 2: "Scanne meine Python requirements.txt"

Du: Scanne diese Abhängigkeiten: requests==2.28.0, flask==2.2.0, django==3.2.0, pillow==9.0.0, cryptography==37.0.0``` → scan_dependencies(ecosystem="PyPI", packages={...}) Found 12 vulnerabilities across 4 packages

**Claudes Antwort:** "**12 Sicherheitslücken** in deinen Paketen gefunden. **Sofortmaßnahme:** Django 3.2.0 (3 kritische CVEs, einschließlich SQL-Injection), Pillow 9.0.0 (Heap-Überlauf), cryptography 37.0.0 (OpenSSL-Kette). Aktualisiere auf: django>=4.2.16, pillow>=10.3.0, cryptography>=42.0.0."

### Szenario 3: "Verdächtige IP untersuchen"

> **Du:** Untersuche verdächtige IP 185.220.101.34 — ist sie schädlich?```
→ check_ip_reputation("185.220.101.34")
  AbuseIPDB Confidence: 100% | Reports: 4,832 | ISP: Tor Exit Node

→ check_ip_noise("185.220.101.34")
  GreyNoise: MALICIOUS | Tags: [Tor Exit Node, Web Scanner]
  CVEs targeted: CVE-2024-3400, CVE-2023-46805

→ shodan_host_lookup("185.220.101.34")
  Open ports: 22, 80, 443, 9001 | OS: Linux

Claudes Antwort: "185.220.101.34 ist ein bekannter Tor-Ausgangsknoten und wird von AbuseIPDB mit 4.832 Missbrauchsmeldungen als 100 % bösartig eingestuft. GreyNoise bestätigt aktives Scannen nach CVE-2024-3400 (Palo Alto) und CVE-2023-46805 (Ivanti). Empfehlung: In der Firewall blockieren."

Szenario 4: "Einen Executive Security Report erstellen"

Du: Erstelle einen Executive Security Report für: CVE-2024-3400, CVE-2023-44487, CVE-2023-4966, CVE-2024-21887``` → compare_cves([...]) Compiles: NVD, EPSS, KEV, PoC availability, MITRE ATT&CK mapping Generates: Ranked risk table, remediation timeline, executive summary

---

## 📊 Risikobewertung erklärt

Das Tool `calculate_risk_score` erzeugt einen **zusammengesetzten Risikowert von 0 bis 100**, indem es vier unabhängige Signale gewichtet.

### Die Formel```
Risk Score = (CVSS × 0.20) + (EPSS × 0.35) + (KEV × 0.30) + (PoC × 0.15)

Boost-Multiplikatoren

• KEV + aktiver PoC → ×1.15
• CVSS ≥ 9.0 + EPSS > 0.7 → ×1.10
• Vor weniger als 7 Tagen veröffentlicht → ×1.05

Der Score ist bei 100 gedeckelt.

Risikobewertung — v1 (2026-06)

Der numerische Bewerter ist scoring_version 1.0 (ausgegeben in triage_cve, calculate_risk_score und health_check). Die obige lineare gewichtete Summe ist der v1-Standard für den numerischen Score, mit einer harten Überschreibung:

• CISA-KEV-Hartüberschreibung: Eine in der KEV gelistete CVE ist nachweislich in freier Wildbahn ausgenutzt worden – das stärkste einzelne Ausnutzungssignal. Ihr Label kann niemals niedriger als CRITICAL sein und ihr Score ist unabhängig von CVSS/EPSS auf ≥ 76 begrenzt. (Eine KEV-CVE mit niedrigem CVSS und niedrigem EPSS liefert trotzdem CRITICAL / 76.)
• CVSS wird als Schweregrad-Signal behandelt, nicht als Signal für die Ausnutzungswahrscheinlichkeit (gemäß Allodi & Massacci 2014); EPSS und KEV tragen das Ausnutzungssignal.
• Eine experimentelle, nach SSVC v2 gestufte Entscheidung (CISA-Deployer-Modell → Act / Attend / Track* / Track) ist über triage_cve(depth="deep") als qualitative, erklärbare Alternative zur 0–100-Zahl verfügbar.

Warum diese Gewichtungen?

EPSS erhält die höchste Gewichtung (35%), weil es der beste einzelne Prädiktor für tatsächliche Ausnutzung ist – weit besser als CVSS allein. Ein CVSS 10.0 mit EPSS 0.01 ist theoretisch gefährlich, praktisch aber unwahrscheinlich. KEV mit 30% ist die Ground Truth: bestätigte Ausnutzung, keine Vorhersage. CVSS mit 20% erfasst den Schweregrad-Kontext für neue CVEs mit unzureichenden EPSS-Daten. PoC mit 15% spiegelt wider, dass öffentliche Exploits reale Angriffe erheblich beschleunigen.

🆕 Neues in v0.2.0

• triage_cve-Orchestrator — ein einziger Tool-Aufruf, der NVD + EPSS + CISA KEV (+ Suche nach öffentlichen PoCs für depth != "quick") parallel aufruft, den zusammengesetzten Risikoscore berechnet und einen sauberen Bericht zurückgibt. depth ist quick / standard (Standardwert) / deep; deep liefert zusätzlich die nach SSVC v2 gestufte Entscheidung.
• Neue Upstream-Quellen — VulnCheck NVD++ (ein transparenter NVD-Fallback, der automatisch innerhalb von triage_cve verwendet wird, wenn das NIST-NVD nicht erreichbar oder gedrosselt ist), CIRCL hashlookup und die HIBP-Pwned-Passwords-Range-API.
• KEV-Hartüberschreibungs-Scoring + scoring_version — in der KEV gelistete CVEs sind immer CRITICAL (Score ≥ 76); die Scoring-Version wird in triage_cve und health_check ausgegeben.
• HTTP-Transport — setze , um streamable-HTTP auf (Standard , zustandslos) anstelle von stdio bereitzustellen. Wird mit einem geliefert.

🌐 Datenquellen

🧪 Tests ausführen```bash

Run the full test suite

pytest tests/ -v

Run specific test files

pytest tests/test_validators.py tests/test_risk_scorer.py -v

Run with coverage

pytest tests/ -v --cov=src/cve_mcp --cov-report=term-missing

### Test mit dem MCP Inspector```bash
npx @modelcontextprotocol/inspector python -m cve_mcp.server

Öffnet unter http://localhost:6274 — interaktiv jedes Tool testen, Eingabeschemas anzeigen und Antwortformate prüfen.

Was die Tests abdecken

• Unit-Tests: Risiko-Score-Berechnung, CVSS-Vektor-Parsing, Eingabevalidierung
• Integrationstests: Tool-Registrierung, Parametervalidierung, Fehlerbehandlung für fehlende Schlüssel
• Cache-Tests: SQLite-Cache-Schreibvorgänge, TTL-Ablauf, Cache-Treffer/Fehlzugriff
• Sicherheitstests: Blockierung privater IPs, XML-Bomben-Schutz (defusedxml), Eingabebereinigung

🏛️ Architektur im Detail

Dateistruktur```

src/cve_mcp/ ├── server.py # FastMCP server — all 27 @mcp.tool() definitions ├── config.py # Environment config and API base URLs ├── models.py # Pydantic models (CVERecord, KEVEntry, EPSSScore, ...) ├── audit.py # Rotating audit log (50MB, 5 backups) ├── api/ │ ├── nvd_client.py # NVD REST API v2.0 │ ├── osv_client.py # OSV.dev package vulnerability API │ ├── epss_client.py # FIRST EPSS API │ ├── kev_client.py # CISA KEV catalog │ ├── ip_intel.py # AbuseIPDB + GreyNoise │ ├── domain_intel.py # crt.sh + CIRCL passive DNS │ ├── shodan_client.py # Shodan host intelligence │ ├── hash_intel.py # MalwareBazaar + VirusTotal │ ├── url_safety.py # URLScan.io │ ├── malware_intel.py # ThreatFox IOC lookup │ ├── ransomware_intel.py# Ransomwhere Bitcoin address lookup │ ├── exploit_intel.py # GitHub PoC/exploit search │ ├── vendor_advisory.py # MSRC + Red Hat + Ubuntu advisories │ ├── attack_mapping.py # MITRE ATT&CK STIX mapping │ ├── cve_timeline.py # CVE event timeline builder │ ├── dependency_scan.py # OSV-based dependency scanning │ ├── poc_checker.py # GitHub + Exploit-DB + Nuclei PoC search │ ├── report_generator.py# Vuln report + CVE comparison matrix │ └── rate_limiter.py # Token bucket rate limiter for NVD ├── cache/ │ └── sqlite_cache.py # Async SQLite cache with per-key TTL └── utils/ ├── validators.py # CVE ID normalization, IP/hash validation └── risk_scorer.py # Composite risk score computation

### Caching-Strategie

| Ressource | TTL |
|----------|-----|
| CVE-Datensätze (NVD) | 1 Stunde |
| EPSS-Werte | 6 Stunden |
| KEV-Katalog | 1 Stunde |
| IP-/Domain-Informationen | 1 Stunde |
| Exploit-DB-CSV | 24 Stunden |
| ATT&CK-STIX-Daten | 24 Stunden |
| Ransomware-Informationen | 24 Stunden |

### Audit-Protokoll

Jeder Tool-Aufruf wird in `~/.cve-mcp/audit.log` protokolliert:```json
{
  "timestamp": "2026-04-14T10:23:45.123Z",
  "tool": "lookup_cve",
  "parameters": {"cve_id": "CVE-2024-3400"},
  "duration_ms": 342,
  "cache_hit": false,
  "status": "ok"
}

API-Schlüssel und Antwort-Payloads werden niemals in Audit-Logs geschrieben.

🔐 Sicherheit und Datenschutz

Welche Daten Ihr Gerät verlassen

• Nur ausgehender HTTPS-Verkehr — keine eingehenden Ports geöffnet, keine Telemetrie
• CVE-IDs, IPs, Hashes, Domains und Paketnamen werden zur Abfrage an die jeweiligen APIs gesendet
• API-Antworten werden lokal in SQLite zwischengespeichert — zwischengespeicherte Daten bleiben auf Ihrem Gerät

Blockierung privater IPs

Alle Netzwerk-Intelligence-Tools blockieren private und reservierte IP-Bereiche vor jedem externen API-Aufruf:

• 10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16 (RFC 1918)
• 127.0.0.0/8 (Loopback), 169.254.0.0/16 (Link-Lokal)
• ::1, fc00::/7 (IPv6 privat)

Schutz der API-Schlüssel

• Schlüssel werden nur aus Umgebungsvariablen geladen — niemals fest codiert
• .env ist gitignored
• Schlüssel werden nie protokolliert, zwischengespeichert oder in Audit-Einträge aufgenommen

XML-Sicherheit

defusedxml wird für die gesamte XML-Analyse verwendet, um XML-Bombenangriffe (Billion Laughs, XXE-Injection) zu verhindern.

🔧 Fehlerbehebung

Server startet nicht```bash

Ensure virtual environment is activated and package is installed

pip install -e . python --version # must be 3.10+

**Claude Desktop zeigt das Hammersymbol (🔨) nicht**
- Überprüfe deine Konfiguration auf JSON-Syntaxfehler (keine nachgestellten Kommas)
- Verwende **absolute Pfade** — relative Pfade schlagen still fehl
- Beende Claude Desktop vollständig (Cmd+Q / Alt+F4) und starte es neu

### NVD-Ratenlimit erreicht```bash
# Add your free NVD API key to .env
NVD_API_KEY=your-key-here
# https://nvd.nist.gov/developers/request-an-api-key

Der Server stellt überschüssige Anfragen automatisch in die Warteschlange, aber mit einem Schlüssel erhalten Sie den 10-fachen Durchsatz.

GreyNoise 401 Unauthorized```bash

Verify your key works:

curl -H "key: YOUR_KEY" https://api.greynoise.io/v3/ip/8.8.8.8

The server uses /v3/ip/{ip} — NOT the deprecated /v3/community endpoint

### Windows-Codierungsprobleme```powershell
$env:PYTHONUTF8 = "1"
$env:PYTHONIOENCODING = "utf-8"

🗺️ Roadmap und bekannte Einschränkungen

Was der Server NICHT tut

• Kein aktives Scannen — nur Intelligence-/Lookup-Funktionen, testet Ihre Infrastruktur nicht
• Keine Schreiboperationen — liest nur aus externen APIs (außer URLScan-Übermittlungen)
• Keine CVSS-v4.0-Bewertung — der integrierte Rechner unterstützt nur v3.1; von NVD bereitgestellte v4.0-Werte werden angezeigt, aber nicht neu berechnet

Bekannte API-Einschränkungen

• NVD gibt maximal 2.000 Ergebnisse pro Abfrage zurück
• EPSS-Scores für brandneue CVEs (jünger als 24 Stunden) sind möglicherweise noch nicht vorhanden
• CISA-KEV-Updates nur an US-Werktagen
• GreyNoise-Community-Tarif: 50 Abfragen/Woche
• VirusTotal-Kostenlos-Tarif: 4 Anfragen/Minute
• CIRCL PDNS erfordert manuelle Registrierung und Freigabe
• Ransomwhere hat eine 90-Tage-Sperrfrist für neue Adressen

Geplante Verbesserungen

• Lokaler CVSS-v4.0-Rechner
• Webhook/Benachrichtigungen für KEV-Ergänzungen und EPSS-Score-Änderungen auf einer CVE-Watchlist
• STIX-2.1-Export für die SIEM-Integration
• Docker-Container mit Zero-Install-Bereitstellung
• Streambarer HTTP-Transport (MCP SSE)
• Zusätzliche Quellen: Censys, SecurityTrails, VulnCheck

🤝 Mitwirken

Beiträge sind willkommen.

Hinzufügen eines neuen Tools

1. Fügen Sie die Tool-Funktion in server.py mit dem Dekorator @mcp.tool() hinzu

2. Fügen Sie die Eingabevalidierung in utils/validators.py hinzu

3. Implementieren Sie den API-Client in api/

4. Fügen Sie Tests in tests/ hinzu

5. Aktualisieren Sie diese README```python @mcp.tool() async def my_new_tool(param: str, ctx: Context = None) -> str: """ One-line description for Claude to know when to use this tool.

   Args: param: Description of the parameter """ app = _get_app(ctx)

   validate → cache check → API call → cache write → audit → return

### Testanforderungen

- Alle neuen Tools müssen mindestens einen Offline-Test mit gemockten Antworten haben
- Risikoscore-Änderungen müssen Testfälle zur Formelverifizierung enthalten
- Netzwerk-Tools müssen einen Test enthalten, der die Blockierung privater IP-Adressen verifiziert
- Alle Tests müssen bestehen: `pytest tests/ -v`

---

## 📄 Lizenz

MIT-Lizenz — siehe [LICENSE](https://github.com/mukul975/cve-mcp-server/blob/main/LICENSE) für Details.```
Copyright (c) 2025-2026 Mahipal Jangra (mukul975)

Erstellt mit 🔐 von Mahipal Jangra · Berlin, Deutschland
Sicherheitserkenntnisse in Gespräche verwandeln.