🛡️ CVE MCP Server

Inteligencia de seguridad impulsada por IA a tu alcance: 28 herramientas + un orquestador triage_cve de una sola llamada, 24 fuentes de datos, un protocolo.

Un servidor Model Context Protocol (MCP) de nivel de producción que convierte a Claude en un analista de seguridad de espectro completo. En lugar de alternar entre más de 15 pestañas del navegador en NVD, EPSS, CISA KEV, Shodan, VirusTotal y GreyNoise, haz una pregunta a Claude y obtén inteligencia correlacionada en segundos. Construido con Python, FastMCP, httpx, aiosqlite, Pydantic v2 y defusedxml.

El problema: Clasificar un solo CVE implica consultar NVD para obtener puntuaciones CVSS, EPSS para la probabilidad de explotación, CISA KEV para el estado de explotación activa, GitHub para los parches y VirusTotal para las asociaciones con malware; luego hay que correlacionar todo mentalmente. Para 50 CVEs, eso es un día entero perdido.

La solución: CVE MCP Server le da a Claude acceso directo a 28 herramientas de seguridad de 24 APIs, con el orquestador de una sola llamada triage_cve como interfaz. Pregunta "¿Deberíamos aplicar el parche para CVE-2024-3400?" y Claude se despliega en paralelo hacia todas las fuentes relevantes, calcula una puntuación de riesgo compuesta (con una anulación estricta de CISA KEV) y entrega una recomendación priorizada con evidencia.

🌍 GARS-2026 — Encuesta global de preparación para IA agéntica

Estoy llevando a cabo un estudio académico global que mide qué tan preparados están realmente los profesionales de seguridad, los desarrolladores y los equipos empresariales para la IA agéntica: servidores MCP, llamadas a herramientas, gobernanza y flujos de trabajo con supervisión humana.

Si usas este repositorio, tu respuesta sería un punto de datos genuinamente valioso.

📋 Realiza la encuesta (10 min): Encuesta

• 60 preguntas · Anónima · Supervisada por SRH Berlin
• Recibes 50 Casky Tokens por acceso anticipado a casky.ai
• Resultados publicados en acceso abierto bajo CC-BY 4.0

📑 Tabla de contenidos

• Arquitectura
• Catálogo de herramientas
• Instalación
• Configuración de claves de API
• Configuración
• Inicio rápido
• Ejemplos de uso
• Explicación de la puntuación de riesgo
• Fuentes de datos
• Ejecución de pruebas
• Análisis profundo de la arquitectura
• Seguridad y privacidad
• Solución de problemas
• Hoja de ruta y limitaciones conocidas
• Contribuciones
• Licencia

🏗️ Arquitectura```

┌─────────────────────────────────────────────────────────────────────┐ │ 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 │ └──────────────┘ └──────────────┘ └──────────────┘

Todo el tráfico es **solo HTTPS saliente** — no se abren puertos de entrada. Las claves de API se cargan desde variables de entorno y nunca se registran. Las direcciones IP privadas/internas están bloqueadas en todas las herramientas de búsqueda.

---

## 🔍 Catálogo de herramientas (28 herramientas)

### ⭐ Orquestación (v0.2.0) — empieza aquí

| Tool | Description | API Key Required | Example Usage |
|------|-------------|-----------------|---------------|
| `triage_cve` | Triaje de una sola llamada que despliega NVD + EPSS + CISA KEV (+ PoC público para `depth != "quick"`) de forma concurrente, calcula la puntuación de riesgo compuesta con una anulación dura de KEV, recurre a VulnCheck NVD++ cuando NIST NVD está limitado y, con `depth="deep"`, emite la decisión condicionada de SSVC v2 | Gratis / Sin clave (se recomienda clave) | `triage_cve("CVE-2021-44228", depth="deep")` |

> **También se expone a través de primitivas MCP** — Recursos: `kev://catalog`, `epss://scores/{cve_id}`, `manifest://tool-hash` (SHA-256 sobre la superficie de herramientas registrada, para la detección de manipulación). Prompts: `patch_decision`, `compare_and_prioritize`, `dependency_triage`.

### Inteligencia principal de vulnerabilidades (8 herramientas)

| Tool | Description | API Key Required | Example Usage |
|------|-------------|-----------------|---------------|
| `lookup_cve` | Obtener el registro detallado de CVE de NVD, incluyendo puntuaciones CVSS, CWEs, productos afectados, referencias y cronología | Gratis / Sin clave (se recomienda clave) | `lookup_cve("CVE-2024-3400")` |
| `search_cves` | Buscar CVEs en NVD por palabra clave, nombre de producto, severidad o rango de fechas | Gratis / Sin clave (se recomienda clave) | `search_cves(keyword="Apache Log4j", severity="CRITICAL")` |
| `get_epss_score` | Obtener la probabilidad de explotación EPSS (0–1) y el percentil para una o más CVEs | Gratis / Sin clave | `get_epss_score("CVE-2024-3400")` |
| `check_kev_status` | Comprobar si una CVE aparece en el catálogo de Vulnerabilidades Explotadas Conocidas de CISA | Gratis / Sin clave | `check_kev_status("CVE-2021-44228")` |
| `get_cvss_details` | Interpretar y explicar una cadena de vector CVSS v3.1 con desglose por métrica | Gratis / Sin clave | `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` | Consultar los detalles de Common Weakness Enumeration por ID de CWE en la base de datos integrada | Gratis / Sin clave | `get_cwe_info("CWE-79")` |
| `get_cve_references` | Extraer y categorizar todos los enlaces de referencia de una CVE (parches, avisos, exploits) | Gratis / Sin clave (se recomienda clave) | `get_cve_references("CVE-2023-44487")` |
| `bulk_cve_lookup` | Recuperar en lote los detalles de hasta 20 CVEs en una sola llamada con enriquecimiento paralelo | Gratis / Sin clave (se recomienda clave) | `bulk_cve_lookup(["CVE-2024-3400", "CVE-2023-44487"])` |

### Inteligencia de exploits y ataques (4 herramientas)

| Tool | Description | API Key Required | Example Usage |
|------|-------------|-----------------|---------------|
| `search_exploits` | Buscar en GitHub exploits de prueba de concepto públicos y repositorios de código de exploits | `GITHUB_TOKEN` (opcional) | `search_exploits("CVE-2024-3400")` |
| `get_mitre_techniques` | Mapear una CVE o CWE a las técnicas, tácticas y mitigaciones relevantes de MITRE ATT&CK | Gratis / Sin clave | `get_mitre_techniques("CVE-2021-44228")` |
| `check_poc_availability` | Determinar si existe código de prueba de concepto conocido para una CVE en múltiples fuentes | `GITHUB_TOKEN` (opcional) | `check_poc_availability("CVE-2024-3400")` |
| `get_attack_patterns` | Obtener los detalles de patrones de ataque CAPEC asociados con una CWE o CVE | Gratis / Sin clave | `get_attack_patterns("CWE-89")` |

### Fase 3: Riesgo avanzado e informes (4 herramientas)

| Tool | Description | API Key Required | Example Usage |
|------|-------------|-----------------|---------------|
| `calculate_risk_score` | Calcular una puntuación de riesgo compuesta de 0 a 100 usando CVSS, EPSS, estado de KEV y disponibilidad de PoC | Gratis / Sin clave (se recomienda clave) | `calculate_risk_score("CVE-2024-3400")` |
| `generate_risk_report` | Generar un informe de seguridad ejecutivo formateado para una o más CVEs con recomendaciones | Gratis / Sin clave (se recomienda clave) | `generate_risk_report(["CVE-2024-3400", "CVE-2023-44487"])` |
| `prioritize_cves` | Clasificar una lista de CVEs por puntuación de riesgo compuesta para la priorización del triaje | Gratis / Sin clave (se recomienda clave) | `prioritize_cves(["CVE-2024-3400", "CVE-2023-4966", "CVE-2023-44487"])` |
| `get_trending_cves` | Obtener CVEs en tendencia basándose en puntuaciones EPSS altas y adiciones recientes a KEV | Gratis / Sin clave | `get_trending_cves(days=7, min_epss=0.5)` |

### Inteligencia de red (4 herramientas)

| Tool | Description | API Key Required | Example Usage |
|------|-------------|-----------------|---------------|
| `lookup_ip_reputation` | Consultar el historial de abuso de una dirección IP y la puntuación de confianza a través de AbuseIPDB | `ABUSEIPDB_API_KEY` | `lookup_ip_reputation("185.220.101.34")` |
| `check_ip_noise` | Consultar GreyNoise para actividad de escaneo/ataque de IP, clasificación y CVEs asociadas | `GREYNOISE_API_KEY` | `check_ip_noise("185.220.101.34")` |
| `shodan_host_lookup` | Obtener puertos abiertos, servicios, banners y vulnerabilidades de una IP a través de Shodan | `SHODAN_API_KEY` | `shodan_host_lookup("8.8.8.8")` |
| `passive_dns_lookup` | Obtener los datos históricos de resolución DNS de un dominio desde CIRCL Passive DNS | `CIRCL_PDNS_USER` + `CIRCL_PDNS_PASSWORD` | `passive_dns_lookup("example.com")` |

### Inteligencia de amenazas (4 herramientas)

| Tool | Description | API Key Required | Example Usage |
|------|-------------|-----------------|---------------|
| `virustotal_lookup` | Analizar hashes de archivos, URLs, dominios o IPs contra más de 70 motores antivirus | `VIRUSTOTAL_API_KEY` | `virustotal_lookup(hash="44d88612fea8a8f36de82e1278abb02f")` |
| `search_malware` | Buscar muestras de malware en MalwareBazaar por hash, etiqueta o firma | `ABUSECH_AUTH_KEY` (opcional) | `search_malware(tag="Emotet")` |
| `search_iocs` | Consultar ThreatFox para obtener Indicadores de Compromiso vinculados a familias de malware | `ABUSECH_AUTH_KEY` (opcional) | `search_iocs(malware="CobaltStrike")` |
| `check_ransomware` | Consultar direcciones de pago de ransomware y datos de transacciones desde Ransomwhere | Gratis / Sin clave | `check_ransomware(address="bc1q...")` |

### DevSecOps (3 herramientas)

| Tool | Description | API Key Required | Example Usage |
|------|-------------|-----------------|---------------|
| `scan_dependencies` | Escanear nombres y versiones de paquetes contra OSV.dev para detectar vulnerabilidades conocidas | Gratis / Sin clave | `scan_dependencies(ecosystem="PyPI", packages={"requests": "2.28.0"})` |
| `scan_github_advisories` | Buscar avisos de seguridad de GitHub por ecosistema, paquete o severidad | `GITHUB_TOKEN` (opcional) | `scan_github_advisories(ecosystem="pip", package="django")` |
| `urlscan_check` | Enviar una URL para escaneo u obtener resultados de escaneo anteriores de URLScan.io | `URLSCAN_API_KEY` | `urlscan_check("https://suspicious-site.com")` |

---

## 📦 Instalación

### Requisitos previos

- **Python 3.10+** (se recomienda 3.11 o 3.12)
- **pip** o **uv** como gestor de paquetes
- **Git** para clonar el repositorio
- Un terminal con acceso a las variables de entorno

### Configuración paso a paso```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

Usando uv (alternativa más rápida)```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

### Con dependencias de prueba```bash
pip install -e ".[test]"

🔑 Configuración de claves API

Las claves API están organizadas por prioridad — obtén primero las claves del Nivel 1 para una cobertura máxima con herramientas gratuitas, y luego agrega progresivamente el Nivel 2 y el Nivel 3 según sea necesario.

Nivel 1: Prioridad alta (gratuito, acceso inmediato, máxima cobertura)

Nivel 2: Recomendado (cuentas gratuitas, valor significativo)

Nivel 3: Opcional (inteligencia ampliada)

⚡ Inicio sin claves: Ocho herramientas funcionan sin ninguna clave API — EPSS, CISA KEV, OSV.dev, MITRE ATT&CK, consultas CWE, análisis CVSS, Ransomwhere y NVD (a una tasa reducida). Puedes empezar a usar el servidor de inmediato e ir añadiendo claves progresivamente.

⚙️ Configuración

Variables de entorno (.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

### Configuración de Claude Desktop

**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"
      }
    }
  }
}

⚠️ Importante: Utiliza siempre rutas absolutas. Sal por completo de Claude Desktop (Cmd+Q / Alt+F4) después de cambiar la configuración — recargar no es suficiente.

Configuración de Claude Code```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

---

## 🚀 Inicio rápido

### Paso 1: Instalar (2 minutos)```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 .

Step 2: Prueba primero con herramientas gratuitas

No se necesita archivo .env. Añade el servidor a Claude Desktop o Claude Code y prueba:

"¿Qué es CVE-2021-44228? ¿Se explota activamente?"

Claude usará lookup_cve (NVD), get_epss_score (EPSS) y check_kev (CISA KEV), todos gratuitos y sin necesidad de claves.

"Analiza estos paquetes de Python en busca de vulnerabilidades: requests 2.28.0, flask 2.2.0, django 3.2.0"

Paso 3: Añade tu primera clave para un rendimiento 10×```bash

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

Solicita una clave NVD gratuita en [nvd.nist.gov](https://nvd.nist.gov/developers/request-an-api-key) — instantánea por correo electrónico, aumenta el límite de frecuencia de **5 a 50 solicitudes por 30 segundos**.

### Paso 4: Modo de máxima potencia

Una vez que hayas añadido las claves de Nivel 1 y Nivel 2:

> **"Calcula la puntuación de riesgo para CVE-2024-3400 y dime si deberíamos aplicar el parche de inmediato."**

---

## 💬 Ejemplos de uso

### Escenario 1: "¿Deberíamos parchear Log4Shell de inmediato?"

> **Tú:** Analiza si CVE-2021-44228 (Log4Shell) necesita un parche inmediato. Dame la puntuación de riesgo y tu recomendación.

Claude orquesta múltiples herramientas entre bastidores:```
→ 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

Respuesta de Claude: "CVE-2021-44228 obtiene 97/100 (CRÍTICO). Ejecución remota de código en Apache Log4j, CVSS 10.0, probabilidad EPSS del 97.5%, explotación activa confirmada en CISA KEV, incluidas campañas de ransomware, más de 300 exploits públicos. Parchea inmediatamente."

Escenario 2: "Escanea mi requirements.txt de Python"

Tú: Escanea estas dependencias: 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

**La respuesta de Claude:** "Encontré **12 vulnerabilidades** en tus paquetes. **Acción inmediata:** Django 3.2.0 (3 CVEs críticos, incluyendo inyección SQL), Pillow 9.0.0 (desbordamiento de montón), cryptography 37.0.0 (cadena OpenSSL). Actualiza a: django>=4.2.16, pillow>=10.3.0, cryptography>=42.0.0."

### Escenario 3: "Investigar una IP sospechosa"

> **Tú:** Investiga la IP sospechosa 185.220.101.34 — ¿es maliciosa?```
→ 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

Respuesta de Claude: "185.220.101.34 es un nodo de salida Tor conocido clasificado como 100% malicioso por AbuseIPDB con 4,832 informes de abuso. GreyNoise confirma escaneo activo de CVE-2024-3400 (Palo Alto) y CVE-2023-46805 (Ivanti). Recomendación: bloquear en el cortafuegos."

Escenario 4: "Generar un informe de seguridad ejecutivo"

Tú: Genera un informe de seguridad ejecutivo para: 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

---

## 📊 Explicación de la puntuación de riesgo

La herramienta `calculate_risk_score` produce una **puntuación de riesgo compuesta de 0 a 100** al ponderar cuatro señales independientes.

### La fórmula```
Risk Score = (CVSS × 0.20) + (EPSS × 0.35) + (KEV × 0.30) + (PoC × 0.15)

Multiplicadores de refuerzo

• KEV + PoC activo → ×1.15
• CVSS ≥ 9.0 + EPSS > 0.7 → ×1.10
• Publicado hace menos de 7 días → ×1.05

La puntuación se limita a un máximo de 100.

Puntuación de riesgo — v1 (2026-06)

El puntuador numérico es scoring_version 1.0 (expuesto en triage_cve, calculate_risk_score y health_check). La suma ponderada lineal anterior es el valor predeterminado de v1 para la puntuación numérica, con una anulación estricta:

• Anulación estricta de CISA KEV: un CVE incluido en KEV tiene explotación confirmada en la naturaleza, la señal de explotación más fuerte. Su etiqueta nunca puede ser inferior a CRITICAL y su puntuación se fija en ≥ 76, independientemente de CVSS/EPSS. (Un CVE en KEV con CVSS bajo y EPSS bajo sigue devolviendo CRITICAL / 76.)
• CVSS se trata como una señal de gravedad, no como una señal de probabilidad de explotación (según Allodi & Massacci 2014); EPSS y KEV son los que aportan la señal de explotación.
• Una decisión experimental con compuertas SSVC v2 (modelo CISA Deployer → Act / Attend / Track* / Track) está disponible mediante triage_cve(depth="deep") como alternativa cualitativa y explicable al número de 0–100.

¿Por qué estos pesos?

EPSS recibe el mayor peso (35 %) porque es el mejor predictor individual de la explotación real — mucho mejor que CVSS por sí solo. Un CVSS 10.0 con EPSS 0.01 es teóricamente peligroso, pero prácticamente improbable. KEV con 30 % es la verdad de referencia: explotación confirmada, no una predicción. CVSS con 20 % captura el contexto de gravedad para CVEs nuevos con datos de EPSS insuficientes. PoC con 15 % refleja que los exploits públicos aceleran drásticamente los ataques en el mundo real.

🆕 Novedades en v0.2.0

• Orquestador triage_cve — una única llamada de herramienta que lanza en paralelo NVD + EPSS + CISA KEV (+ descubrimiento público de PoC para depth != "quick"), calcula la puntuación de riesgo compuesta y devuelve un informe claro. depth puede ser quick / standard (predeterminado) / deep; deep además emite la decisión con compuertas SSVC v2.
• Nuevas fuentes upstream — VulnCheck NVD++ (un respaldo transparente de NVD que triage_cve usa automáticamente cuando el NVD de NIST es inaccesible o está limitado), CIRCL hashlookup y la API de rangos de HIBP Pwned Passwords.
• Puntuación con anulación estricta por KEV + scoring_version — los CVE incluidos en KEV son siempre CRITICAL (puntuación ≥ 76); la versión de puntuación se informa en triage_cve y health_check.
• Transporte HTTP — establezca para servir streamable-HTTP en (predeterminado , sin estado) en lugar de stdio. Incluye un .

🌐 Fuentes de datos

🧪 Ejecución de pruebas```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

### Prueba con el MCP Inspector```bash
npx @modelcontextprotocol/inspector python -m cve_mcp.server

Se abre en http://localhost:6274 — prueba interactivamente cada herramienta, consulta los esquemas de entrada e inspecciona los formatos de respuesta.

Qué cubren las pruebas

• Pruebas unitarias: Cálculo de puntuación de riesgo, análisis de vectores CVSS, validación de entrada
• Pruebas de integración: Registro de herramientas, validación de parámetros, manejo de errores para claves faltantes
• Pruebas de caché: Escrituras de caché SQLite, caducidad TTL, aciertos/fallos de caché
• Pruebas de seguridad: Bloqueo de IP privadas, protección contra bombas XML (defusedxml), saneamiento de entradas

🏛️ Arquitectura en profundidad

Estructura de archivos```

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

### Estrategia de caché

| Recurso | TTL |
|----------|-----|
| Registros CVE (NVD) | 1 hora |
| Puntuaciones EPSS | 6 horas |
| Catálogo KEV | 1 hora |
| Inteligencia de IP / dominio | 1 hora |
| CSV de Exploit-DB | 24 horas |
| Datos STIX de ATT&CK | 24 horas |
| Inteligencia de ransomware | 24 horas |

### Registro de auditoría

Cada invocación de la herramienta se registra en `~/.cve-mcp/audit.log`:

``````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"
}

Las claves de API y los payloads de respuesta nunca se escriben en los registros de auditoría.

🔐 Seguridad y privacidad

Qué datos salen de tu máquina

• Solo HTTPS saliente — no se abren puertos entrantes, sin telemetría
• Los IDs de CVE, IPs, hashes, dominios y nombres de paquetes se envían a las respectivas API para su consulta
• Las respuestas de la API se almacenan en caché localmente en SQLite — los datos en caché permanecen en tu máquina

Bloqueo de IPs privadas

Todas las herramientas de inteligencia de red bloquean los rangos de IP privados y reservados antes de cualquier llamada a una API externa:

• 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 (enlace local)
• ::1, fc00::/7 (IPv6 privada)

Protección de claves de API

• Las claves se cargan solo desde variables de entorno — nunca fijas en el código
• .env está en gitignore
• Las claves nunca se registran, almacenan en caché ni se incluyen en las entradas de auditoría

Seguridad XML

defusedxml se utiliza para todo el análisis XML para prevenir ataques de bomba XML (billion laughs, inyección XXE).

🔧 Solución de problemas

El servidor no se inicia```bash

Ensure virtual environment is activated and package is installed

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

**Claude Desktop no muestra el icono de martillo (🔨)**
- Comprueba si hay errores de sintaxis JSON (sin comas finales) en tu configuración
- Usa **rutas absolutas** — las rutas relativas fallan silenciosamente
- Cierra por completo Claude Desktop (Cmd+Q / Alt+F4) y reinícialo

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

El servidor encola automáticamente las solicitudes en exceso, pero con una clave obtienes 10× más de rendimiento.

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

### Problemas de codificación de Windows```powershell
$env:PYTHONUTF8 = "1"
$env:PYTHONIOENCODING = "utf-8"

🗺️ Hoja de ruta y limitaciones conocidas

Lo que el servidor NO hace

• Sin escaneo activo — solo inteligencia/consulta, no sondea tu infraestructura
• Sin operaciones de escritura — solo lectura de APIs externas (excepto envíos a URLScan)
• Sin puntuación CVSS v4.0 — la calculadora integrada solo maneja v3.1; las puntuaciones v4.0 proporcionadas por NVD se muestran pero no se recalculan

Limitaciones de API conocidas

• NVD devuelve un máximo de 2,000 resultados por consulta
• Las puntuaciones EPSS para CVEs nuevos (< 24 horas) pueden no existir todavía
• CISA KEV se actualiza solo en días hábiles de EE. UU.
• Nivel comunitario de GreyNoise: 50 consultas/semana
• Plan gratuito de VirusTotal: 4 solicitudes/minuto
• CIRCL PDNS requiere registro y aprobación manuales
• Ransomwhere tiene un embargo de 90 días sobre nuevas direcciones

Mejoras planificadas

• Calculadora local CVSS v4.0
• Webhook/alertas para adiciones a KEV y cambios en las puntuaciones EPSS en una lista de seguimiento de CVEs
• Exportación STIX 2.1 para integración con SIEM
• Contenedor Docker con despliegue sin instalación
• Streamable HTTP transport (MCP SSE)
• Fuentes adicionales: Censys, SecurityTrails, VulnCheck

🤝 Contribuciones

Las contribuciones son bienvenidas.

Cómo añadir una nueva herramienta

1. Añade la función de la herramienta en server.py con el decorador @mcp.tool()

2. Añade la validación de entrada en utils/validators.py

3. Implementa el cliente de API en api/

4. Añade pruebas en tests/

5. Actualiza este 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

### Requisitos de prueba

- Todas las herramientas nuevas deben tener al menos una prueba offline con respuestas simuladas
- Los cambios en la puntuación de riesgo deben incluir casos de prueba de verificación de fórmulas
- Las herramientas de red deben incluir una prueba que verifique el bloqueo de IP privadas
- Todas las pruebas deben pasar: `pytest tests/ -v`

---

## 📄 Licencia

Licencia MIT — consulte [LICENSE](https://github.com/mukul975/cve-mcp-server/blob/HEAD/LICENSE) para obtener detalles.```
Copyright (c) 2025-2026 Mahipal Jangra (mukul975)

Construido con 🔐 por Mahipal Jangra · Berlín, Alemania
Convirtiendo la inteligencia de seguridad en conversación.