Servidor MCP de Criptografía Post-Cuántica

Solo para investigación y prototipado. Este servidor utiliza liboqs, el cual no se recomienda explícitamente para uso en producción o para proteger datos sensibles. Al usar el modo store_as (recomendado), las claves secretas se redactan de la salida de la herramienta y se mantienen en un llavero con ámbito de sesión. Sin store_as, las claves secretas y los secretos compartidos aparecen en la salida de la herramienta, lo que podría entrar en el contexto del modelo, registros del cliente o transcripciones. Establezca PQC_REQUIRE_KEY_HANDLES=1 para forzar el modo de solo identificadores (handles) para todas las operaciones con claves secretas. Adecuado para experimentación, educación y pruebas de interoperabilidad.

Un servidor del Protocolo de Contexto de Modelo (MCP) que proporciona operaciones criptográficas post-cuánticas utilizando liboqs de Open Quantum Safe. Permite a asistentes de IA como Claude realizar operaciones criptográficas resistentes a la computación cuántica, incluyendo generación de claves, cifrado, firma y verificación.

¿Por qué la Criptografía Post-Cuántica?

Los sistemas criptográficos actuales (RSA, ECC, ECDSA) serán vulnerados por computadoras cuánticas que ejecuten el algoritmo de Shor. El NIST ha estandarizado nuevos algoritmos resistentes a la computación cuántica:

Este servidor MCP hace que estos algoritmos sean accesibles para agentes de IA para investigación, desarrollo e integración.

Características

• Mecanismos de Encapsulación de Claves (KEMs) disponibles vía liboqs: ML-KEM, FrodoKEM, HQC, BIKE, Classic McEliece

• Algoritmos de firma disponibles vía liboqs: ML-DSA, Falcon, SLH-DSA, MAYO, CROSS, UOV

• Integración completa con MCP: Funciona con Claude Desktop, Claude Code, Cursor y cualquier cliente MCP

• Soporta algoritmos estandarizados por el NIST: Implementa algoritmos FIPS 203, 204 y 205

• Análisis de seguridad: Compara niveles de seguridad clásica frente a cuántica

Inicio rápido

Requisitos previos

• Python 3.10+

• Biblioteca compartida liboqs

• uv (recomendado) o pip

Instalación

1. Instalar liboqs

macOS (Homebrew con biblioteca compartida):

# Homebrew only provides static library, build from source for shared:
git clone --depth 1 --branch 0.15.0 https://github.com/open-quantum-safe/liboqs.git
cd liboqs && mkdir build && cd build
cmake -DBUILD_SHARED_LIBS=ON -DCMAKE_INSTALL_PREFIX=$HOME/.local ..
make -j4 && make install

Ubuntu/Debian:

sudo apt-get install liboqs-dev

Alternativa: Use el script de instalación incluido que automatiza lo anterior:

bash scripts/install-liboqs.sh

2. Clonar e instalar

git clone https://github.com/scottdhughes/post-quantum-mcp.git
cd post-quantum-mcp

# Install all dependencies (creates .venv automatically)
uv sync --all-extras

3. Configurar Claude Code / Claude Desktop

Añada a su configuración de MCP:

Claude Code (~/.claude.json):

{
  "mcpServers": {
    "pqc": {
      "type": "stdio",
      "command": "/path/to/post-quantum-mcp/run.sh",
      "args": [],
      "env": {}
    }
  }
}

Claude Desktop (claude_desktop_config.json):

{
  "mcpServers": {
    "pqc": {
      "command": "/path/to/post-quantum-mcp/run.sh"
    }
  }
}

El servidor también puede ejecutarse directamente mediante python -m pqc_mcp_server.

Herramientas disponibles

pqc_list_algorithms

Lista todos los algoritmos post-cuánticos disponibles.

Input: { "type": "kem" | "sig" | "all" }
Output: List of available algorithms with NIST standard mappings

pqc_algorithm_info

Obtiene información detallada sobre un algoritmo específico.

Input: { "algorithm": "ML-KEM-768" }
Output: Key sizes, security level, performance characteristics

pqc_generate_keypair

Genera un par de claves resistente a la computación cuántica.

Input: { "algorithm": "ML-DSA-65" }
Output: Base64-encoded public and secret keys

pqc_encapsulate

Realiza la encapsulación de claves (crea un secreto compartido).

Input: { "algorithm": "ML-KEM-768", "public_key": "<base64>" }
Output: Ciphertext and shared secret

pqc_decapsulate

Recupera el secreto compartido a partir del texto cifrado.

Input: { "algorithm": "ML-KEM-768", "secret_key": "<base64>", "ciphertext": "<base64>" }
Output: Shared secret

pqc_sign

Firma un mensaje con una firma post-cuántica.

Input: { "algorithm": "ML-DSA-65", "secret_key": "<base64>", "message": "Hello, quantum world!" }
Output: Base64-encoded signature

pqc_verify

Verifica una firma post-cuántica.

Input: { "algorithm": "ML-DSA-65", "public_key": "<base64>", "message": "...", "signature": "<base64>" }
Output: { "valid": true/false }

pqc_hash

Calcula el hash de un mensaje usando funciones hash resistentes a la computación cuántica.

Input: { "message": "data", "algorithm": "SHA3-256" | "SHA3-512" | "SHAKE128" | "SHAKE256" }
Output: Digest in hex and base64

pqc_security_analysis

Analiza las propiedades de seguridad de un algoritmo.

Input: { "algorithm": "ML-KEM-768" }
Output: NIST level, classical/quantum security equivalents, Grover/Shor resistance

Intercambio de claves híbrido (X25519 + ML-KEM-768)

Suite: mlkem768-x25519-sha3-256 — toma prestado el combinador KEM del borrador compuesto ML-KEM de LAMPS (id-MLKEM768-X25519-SHA3-256). El sha3-256 en el nombre de la suite se refiere al hash del combinador KEM; la derivación de claves HKDF utiliza SHA-256 (vía cryptography HKDF). La capa de sobre sellado es el protocolo propio de este proyecto construido sobre ese combinador.

Esta es una construcción de caja sellada anónima que proporciona confidencialidad híbrida con integridad de texto cifrado. No tiene secreto directo (forward-secret) contra el compromiso de la clave del destinatario, y no está autenticada por el remitente.

pqc_hybrid_keygen

Genera un paquete de par de claves híbrido.

Recomendado: con store_as (claves secretas redactadas)

// Input
{"store_as": "alice"}

// Output — no secret keys
{
  "suite": "mlkem768-x25519-sha3-256",
  "handle": "alice",
  "classical": {"algorithm": "X25519", "public_key": "DeRN3xLbEglMdXKO7P98cAvc...", "fingerprint": "a1b2c3d4..."},
  "pqc": {"algorithm": "ML-KEM-768", "public_key": "gDsL8UgEVcMeJgUOQgSlAotx...", "fingerprint": "e5f6a7b8..."}
}

Sin store_as (se devuelven claves sin procesar — no recomendado):

// Input
{}

// Output — secret keys exposed in tool output
{
  "suite": "mlkem768-x25519-sha3-256",
  "classical": {
    "algorithm": "X25519",
    "public_key": "DeRN3xLbEglMdXKO7P98cAvc...",
    "secret_key": "YEYD9j5c2hpTei0ferXWbAFb..."
  },
  "pqc": {
    "algorithm": "ML-KEM-768",
    "public_key": "gDsL8UgEVcMeJgUOQgSlAotx...",
    "secret_key": "MQB2U0EzNGmloLuiTYG3BTcr..."
  }
}

pqc_hybrid_encap / pqc_hybrid_decap

Bloque de construcción de encapsulación de claves. Devuelve un secreto compartido combinado derivado mediante el combinador SHA3-256 de la suite.

pqc_hybrid_seal / pqc_hybrid_open

Cifra/descifra texto plano usando encapsulación híbrida + AES-256-GCM. Vinculación AAD de cabecera completa. Nonce determinista (no transmitido en el sobre).

// Seal input
{
  "plaintext": "Hello, quantum world!",
  "recipient_classical_public_key": "<base64 X25519 public key>",
  "recipient_pqc_public_key": "<base64 ML-KEM-768 public key>"
}

// Seal output
{
  "envelope": {
    "version": "pqc-mcp-v3",
    "mode": "anon-seal",
    "suite": "mlkem768-x25519-sha3-256",
    "x25519_ephemeral_public_key": "6+b1Y8AkgEycKL5wL2cIeSMv...",
    "pqc_ciphertext": "DF+PYy4zx+OmnW8wLD3EL+4M...",
    "ciphertext": "NnEap2fDq5+xTCwvHdKfy5Xj..."
  }
}

// Open input
{
  "envelope": { "...envelope from seal..." },
  "classical_secret_key": "<base64 X25519 secret key>",
  "pqc_secret_key": "<base64 ML-KEM-768 secret key>"
}

// Open output
{
  "suite": "mlkem768-x25519-sha3-256",
  "plaintext": "Hello, quantum world!",
  "plaintext_base64": "SGVsbG8sIHF1YW50dW0gd29ybGQh"
}

Ejemplos de prompts híbridos

"Genera un par de claves híbrido y sella un mensaje para mí"

"Realiza un intercambio de claves híbrido y muéstrame el secreto compartido"

"Cifra 'datos clasificados' usando PQC híbrido y luego descífralos"

Sobres híbridos autenticados

Añade autenticación del remitente a la capa de confidencialidad híbrida usando firmas ML-DSA-65 (FIPS 204). El remitente firma una transcripción binaria canónica que cubre todo el sobre. El destinatario verifica la identidad del remitente antes del descifrado.

Esta es una construcción de sobre sellado autenticado por el remitente. Todavía no tiene secreto directo contra el compromiso futuro de la clave a largo plazo del destinatario. La capa de sobre sellado es el protocolo propio de este proyecto.

pqc_hybrid_auth_seal

Cifrar + firmar. Requiere claves de firma ML-DSA-65 del remitente + claves híbridas del destinatario.

Recomendado: con identificadores de clave (key handles)

// Input
{
  "plaintext": "Authenticated message",
  "recipient_key_store_name": "bob",
  "sender_key_store_name": "alice-signing"
}

// Output
{
  "envelope": {
    "version": "pqc-mcp-v3",
    "mode": "auth-seal",
    "suite": "mlkem768-x25519-sha3-256",
    
    "sender_signature_algorithm": "ML-DSA-65",
    "sender_public_key": "0ji6POTItnZUX8rELwVwWSOV...",
    "sender_key_fingerprint": "0f617ece2f1d04c0...",
    "recipient_classical_key_fingerprint": "c1deade4a5300a9a...",
    "recipient_pqc_key_fingerprint": "bb0e084213d6ac74...",
    "x25519_ephemeral_public_key": "5LEikNANeJNhZSiq...",
    "pqc_ciphertext": "ybgWc3ruG3JwXmr4...",
    "ciphertext": "6OYdADdh0eH/LviD...",
    "signature": "BOniPALs1kfhWcRh..."
  }
}

Alternativa: con claves sin procesar (no recomendado)

// Input
{
  "plaintext": "Authenticated message",
  "recipient_classical_public_key": "<base64 X25519 public key>",
  "recipient_pqc_public_key": "<base64 ML-KEM-768 public key>",
  "sender_secret_key": "<base64 ML-DSA-65 secret key>",
  "sender_public_key": "<base64 ML-DSA-65 public key>"
}

pqc_hybrid_auth_open

Verificar remitente + descifrar. Requiere expected_sender_public_key o expected_sender_fingerprint. La firma se verifica antes del descifrado; los fallos de autenticación son distintos de los fallos de descifrado.

// Open with expected sender public key
{
  "envelope": { "...envelope from auth_seal..." },
  "classical_secret_key": "<base64 X25519 secret key>",
  "pqc_secret_key": "<base64 ML-KEM-768 secret key>",
  "expected_sender_public_key": "<base64 ML-DSA-65 public key>"
}

// Or open with expected sender fingerprint
{
  "envelope": { "...envelope from auth_seal..." },
  "classical_secret_key": "...",
  "pqc_secret_key": "...",
  "expected_sender_fingerprint": "0f617ece2f1d04c0481aa0fe..."
}

// Output
{
  "suite": "mlkem768-x25519-sha3-256",
  "plaintext": "Authenticated message",
  "plaintext_base64": "QXV0aGVudGljYXRlZCBtZXNzYWdl",
  "sender_key_fingerprint": "0f617ece2f1d04c0481aa0fe...",
  "sender_signature_algorithm": "ML-DSA-65",
  "authenticated": true
}

pqc_hybrid_auth_verify

Verifica la firma del remitente en un sobre autenticado SIN descifrar. No se necesitan claves secretas. Comprueba la vinculación del remitente, la consistencia de la huella digital, la firma ML-DSA-65 y la frescura de la marca de tiempo.

// Input
{
  "envelope": { "...envelope from auth_seal..." },
  "expected_sender_fingerprint": "0f617ece2f1d04c0..."
}

// Output
{
  "verified": true,
  "sender_key_fingerprint": "0f617ece2f1d04c0...",
  "sender_signature_algorithm": "ML-DSA-65",
  "version": "pqc-mcp-v3",
  "mode": "auth-seal",
  "replay_seen": false,
  "timestamp": "1711929600"
}

pqc_envelope_inspect

Inspecciona los metadatos del sobre sin descifrar. No se necesitan claves secretas. Devuelve la versión, la suite, las huellas digitales y los tamaños de los campos.

// Input
{"envelope": { "...any sealed or authenticated envelope..." }}

// Output
{
  "version": "pqc-mcp-v3",
  "mode": "auth-seal",
  "suite": "mlkem768-x25519-sha3-256",
  "authenticated": true,
  "sender_key_fingerprint": "0f617ece2f1d04c0...",
  
  
  "ciphertext_size": 1234,
  "plaintext_size_approx": 1218,
  "pqc_ciphertext_size": 1088,
  "signature_size": 3309
}

pqc_fingerprint

Calcula la huella digital SHA3-256 de una clave pública. Devuelve hexadecimal en minúsculas.

// Input
{"public_key": "<base64-encoded public key>"}

// Output
{"fingerprint": "a1b2c3d4e5f6...", "algorithm": "SHA3-256"}

pqc_benchmark

Realiza un benchmark de un algoritmo PQC: tiempos de generación de claves, encapsulación/firma, decapsulación/verificación, y tamaños de clave/texto cifrado/firma.

// Input
{"algorithm": "ML-KEM-768", "iterations": 10}

// Output — timing and size measurements

Flujo de generación de claves

1. Sender: generate ML-DSA-65 signing keys via pqc_generate_keypair
2. Recipient: generate hybrid keys via pqc_hybrid_keygen
3. Exchange public keys out-of-band
4. Sender: pqc_hybrid_auth_seal with both key sets
5. Recipient: pqc_hybrid_auth_open with expected sender identity

Ejemplos de prompts autenticados

"Genera un par de claves de firma ML-DSA-65 y un par de claves de destinatario híbrido, luego envía un mensaje cifrado autenticado"

"Abre este sobre autenticado y verifica que provenga del remitente esperado"

"Sella un mensaje para Bob y fírmalo con mi clave ML-DSA, luego haz que Bob lo abra usando mi huella digital"

Identificadores de clave (Redacción de secretos)

Modo opcional donde las claves secretas se almacenan localmente en el proceso y nunca aparecen en la salida de la herramienta. Los identificadores (handles) son globales al proceso y se pierden al reiniciar el servidor.

Generación con identificadores

// pqc_hybrid_keygen with store_as
{"store_as": "alice"}

// Output — no secret keys
{
  "suite": "mlkem768-x25519-sha3-256",
  "handle": "alice",
  "classical": {"algorithm": "X25519", "public_key": "...", "fingerprint": "..."},
  "pqc": {"algorithm": "ML-KEM-768", "public_key": "...", "fingerprint": "..."}
}

Uso de identificadores en herramientas posteriores

// pqc_hybrid_seal with store name instead of raw keys
{
  "plaintext": "Hello via handle!",
  "recipient_key_store_name": "alice"
}

// pqc_hybrid_auth_seal with two store names
{
  "plaintext": "Authenticated via handles",
  "recipient_key_store_name": "alice",
  "sender_key_store_name": "bob-signing"
}

Las herramientas PQC genéricas (pqc_sign, pqc_verify, pqc_encapsulate, pqc_decapsulate) también aceptan key_store_name.

Proporcionar tanto un nombre de almacén como claves sin procesar para el mismo rol es un error.

Gestión del almacén de claves

• pqc_key_store_save: Guarda una salida de generación de claves por nombre para una referencia conveniente. Ámbito de sesión, sin persistencia.

• pqc_key_store_load: Carga una clave almacenada por nombre. Devuelve solo material público para entradas de identificadores.

• pqc_key_store_list: Lista todas las claves almacenadas con metadatos (nombres, tipos, huellas digitales). No se muestra material secreto.

• pqc_key_store_delete: Elimina una clave almacenada por nombre.

Características de seguridad

Protocolo de sobre v3

Los sobres v3 están vinculados al modo: cada sobre lleva un campo mode explícito (anon-seal o auth-seal) que está vinculado a la información HKDF, AAD y la transcripción de autenticación. Esto proporciona una verdadera separación entre modos: el texto cifrado producido por un modo no puede ser descifrado por el otro, bloqueando ataques de degradación de eliminación de autenticación en la capa AEAD. AAD utiliza marcos con prefijo de longitud (autodelimitados) en v3. Los sobres autenticados incluyen un campo timestamp firmado en la transcripción canónica; al verificar/abrir, el servidor comprueba la frescura (predeterminado: 24 horas, configurable mediante max_age_seconds). La tolerancia a la desviación del reloj es de 5 minutos.

Protección contra repetición

El servidor mantiene una caché de resúmenes de firmas (SHA3-256 de los bytes de la firma del sobre) con TTL. pqc_hybrid_auth_verify realiza una comprobación de repetición de solo lectura. pqc_hybrid_auth_open realiza una comprobación antes del descifrado y marca después del éxito. La caché persiste en ~/.pqc/state/replay-cache.json y sobrevive a los reinicios del servidor. Máximo 50,000 entradas con desalojo de las más antiguas primero.

Validación del tamaño del sobre

Todos los sobres se validan antes de cualquier procesamiento criptográfico: máximo 1 MB por campo base64 (ciphertext, pqc_ciphertext, signature, sender_public_key, x25519_ephemeral_public_key), máximo 50 campos en total. Previene bombas de memoria y agotamiento de recursos.

Política de seguridad del servidor

Establezca PQC_REQUIRE_KEY_HANDLES=1 para forzar el modo de solo identificadores: el servidor rechaza cualquier llamada a herramienta que pase claves secretas sin procesar, forzando el uso de store_as/key_store_name para todas las operaciones con claves secretas (generación de claves, firma, decapsulación y operaciones de sobre híbrido). Esta es una comprobación del lado del servidor que no puede ser eludida por un agente que se comporte mal.

Compatibilidad con versiones anteriores v1/v2

Los sobres v1 (pqc-mcp-v1) se aceptan al abrir/verificar por compatibilidad con versiones anteriores, pero producen una advertencia sonora. Los sobres v1 carecen de marcas de tiempo firmadas y, por lo tanto, omiten las comprobaciones de frescura y no proporcionan protección contra repetición. Los sobres v2 (pqc-mcp-v2) se aceptan pero carecen de vinculación de modo; se incluye una advertencia de obsolescencia en la respuesta.

Transporte de retransmisión (Relay)

El proyecto incluye un relay de Cloudflare Worker para mensajería A2A entre máquinas.

En vivo: https://quantum-seal-relay.novoamorx1.workers.dev

El relay es un buzón de sobres opaco: almacena y reenvía blobs JSON sin realizar operaciones criptográficas ni acceder a claves privadas.

Límites: 50 KB máximo por sobre, 1000 mensajes/buzón, 24h TTL, limitación de tasa (60 POST/min, 120 GET/min por IP).

Seguridad: El relay nunca ve texto plano. La confid