ciphersuite-mcp

Un servidor MCP (Model Context Protocol) que proporciona herramientas de cifrado y descifrado AES-256-CBC, recursos que describen cada algoritmo y prompts listos para usar, todo ello ejecutable directamente en VS Code Copilot Chat.

Related MCP server: Secret Vault MCP Server

Qué hace

Cómo funciona el cifrado

• Algoritmo: AES-256-CBC

• Derivación de la clave: scrypt(passphrase, fixedSalt, 32) — puedes pasar cualquier cadena como frase de contraseña; el servidor deriva automáticamente una clave fuerte de 32 bytes

• Formato de salida: <IV in hex>:<ciphertext in hex> — conserva la cadena completa para descifrarla más tarde

• IV: se genera un IV aleatorio nuevo de 16 bytes en cada llamada de cifrado, por lo que el mismo mensaje cifrado dos veces produce una salida diferente

Requisitos previos

• Node.js v24+ (consulta engines en package.json)

Instalación

npm install

No se necesita ningún paso de compilación: el servidor ejecuta TypeScript directamente mediante el soporte nativo de TypeScript de Node.js.

Uso en VS Code

1. Añadir la configuración del servidor MCP

Crea (o abre) .vscode/mcp.json en tu espacio de trabajo y añade:

{
  "servers": {
    "ciphersuite-mcp": {
      "command": "node",
      "args": ["--experimental-strip-types", "ABSOLUTE_PATH_TO_PROJECT/src/index.ts"]
    }
  }
}

o mediante npm:

{
  "servers": {
    "ciphersuite-mcp": {
      "command": "npx",
      "args": ["-y", "@igorromero/ciphersuite-mcp"]
    }
  }
}

Consejo: También puedes añadir este servidor a tu configuración de MCP a nivel de usuario en ~/.vscode/mcp.json para que esté disponible en todos los espacios de trabajo.

2. Recargar VS Code

Abre la paleta de comandos (Cmd+Shift+P) y ejecuta Developer: Reload Window (o simplemente reinicia VS Code).

3. Usarlo en Copilot Chat

Abre Copilot Chat (modo agente) y prueba:

Encrypt the message "Hello, World!" using the passphrase "my-secret-key"

Decrypt this message: a3f1...:<ciphertext> using the passphrase "my-secret-key"

Show me the encryption://info resource

El agente llamará automáticamente a la herramienta adecuada y devolverá el resultado.

Ejecutar el MCP Inspector

El MCP Inspector te permite explorar y probar todas las herramientas, recursos y prompts de forma interactiva en una interfaz de navegador:

npm run mcp:inspect

Esto abre el inspector en http://localhost:5173 y lo conecta al servidor en ejecución.

Ejecutar las pruebas

# Run all tests once
npm test

# Run tests in watch mode (with debugger)
npm run test:dev

La suite de pruebas cubre:

• Cifrar un mensaje

• Descifrar un mensaje con la frase de contraseña correcta

• Listar y leer el recurso encryption://info

• Obtener ambos prompts

• Error: descifrar con la frase de contraseña incorrecta

• Error: descifrar un texto cifrado malformado

Estructura del proyecto

src/
  index.ts   # Entry point — connects the server to stdio transport
  mcp.ts     # All tools, resources, and prompts are registered here
tests/
  mcp.test.ts

Scripts disponibles

Creación desde cero

Esta sección documenta cómo se construyó este servidor MCP paso a paso — algo útil para crear nuevos servidores MCP en el futuro.

Tipos de transporte de MCP

Existen 3 tipos de transporte de MCP:

Dependencias

// package.json
"dependencies": {
  "@modelcontextprotocol/sdk": "^1.27.1",
  "@types/node": "^24.11.0",
  "zod": "^3.25.76"
}

1. Punto de entrada — src/index.ts

El punto de entrada crea un StdioServerTransport y conecta el servidor MCP a él:

// src/index.ts
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { server } from "./mcp.ts";

async function main() {
    const transport = new StdioServerTransport()
    await server.connect(transport)
    console.error('Encrypt MCP Server running on stdio')
}

main().catch((error) => {
    console.error("Fatal error in main():", error);
    process.exit(1);
});

2. Configuración del servidor — src/mcp.ts

Crea la instancia del servidor MCP con un nombre y una versión:

// src/mcp.ts
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";

export const server = new McpServer({
    name: '@igorromero/ciphersuite-mcp',
    version: '0.0.1'
})

3. Registrar herramientas

Las herramientas son funciones que el LLM puede llamar para realizar acciones. Usa server.registerTool, que recibe 3 argumentos:

1. Nombre de la herramienta (cadena)

2. Objeto de configuración que contiene:

   • description — qué hace la herramienta; el LLM usa esto para decidir cuándo llamarla

   • inputSchema — equivalente al cuerpo de la solicitud, definido con Zod

   • outputSchema — equivalente al cuerpo de la respuesta, definido con Zod

3. Función de controlador asíncrona — la implementación real

server.registerTool(
    'encrypt_message',
    {
        description: 'Encrypt a message',
        inputSchema: {
            message: z.string().describe("The message to encrypt"),
            encryptionKey: z.string().describe(
                "Any passphrase to use for encryption — the server derives a strong key from it automatically"
            )
        },
        outputSchema: {
            encryptedMessage: z.string().describe(
                "The encrypted message (format: iv:ciphertext)"
            )
        }
    },
    async ({ message, encryptionKey }) => {
        try {
            const encryptedMessage = encrypt(message, encryptionKey)
            return {
                content: [{ type: "text", text: encryptedMessage }],
                structuredContent: { encryptedMessage }
            }
        } catch (error) {
            return {
                isError: true,
                content: [{
                    type: 'text',
                    text: `Failed to encrypt message! Error: ${error instanceof Error ? error.message : String(error)}`
                }]
            }
        }
    }
)

El mismo patrón se aplica a decrypt_message — solo tienes que intercambiar los campos del esquema de entrada/salida y llamar a decrypt().

4. Registrar recursos

Los recursos proporcionan información estática o calculada que ayuda al LLM a comprender el contexto de una herramienta. Usa server.registerResource, que recibe 4 argumentos:

1. Nombre del recurso

2. Plantilla de URI (normalmente igual al nombre)

3. Objeto de configuración que contiene una description

4. Función de controlador que devuelve contents — un array de objetos con uri, mimeType y text

server.registerResource(
    'encryption://info',
    'encryption://info',
    {
        description: 'Describes the encryption algorithm, key requirements, and output format used by this server',
    },
    () => ({
        contents: [
            {
                uri: "encryption://info",
                mimeType: "text/plain",
                text: `
Algorithm : AES-256-CBC
Key derivation: scrypt (passphrase + fixed server salt → 32-byte key)
Output format: <16-byte IV in hex>:<ciphertext in hex>  (separated by ":")
Notes:
  - Users pass any passphrase — the server derives a strong 32-byte key automatically using scrypt.
  - A random IV is generated for every encryption — the same message encrypted twice will produce different output.
  - Use the exact same passphrase to decrypt.
  - Keep the full "iv:ciphertext" string to decrypt later.
                `.trim(),
            },
        ]
    })
)

El recurso decryption://info sigue el mismo patrón y describe el formato de entrada esperado, los requisitos de la frase de contraseña y los escenarios de error comunes para la herramienta de descifrado.

5. Registrar prompts

Los prompts son plantillas de mensajes predefinidas que el LLM puede usar para invocar herramientas de forma guiada. Usa server.registerPrompt, que recibe 3 argumentos:

1. Nombre del prompt

2. Objeto de configuración que contiene:

   • description — qué hace el prompt

   • argsSchema — los parámetros de entrada, definidos con Zod

3. Función de controlador que devuelve messages — un array de objetos con role (user o assistant) y content

server.registerPrompt(
    "encrypt_message_prompt",
    {
        description: "Prompt to encrypt a plain-text message using the encrypt_message tool",
        argsSchema: {
            message: z.string().describe("The message to encrypt"),
            encryptionKey: z.string().describe(
                "Any passphrase to use for encryption — the server derives a strong key from it automatically"
            )
        }
    },
    ({ message, encryptionKey }) => ({
        messages: [
            {
                role: 'user',
                content: {
                    type: "text",
                    text: `Please encrypt the following message using the encrypt_message tool.\nMessage: ${message}\nEncryption key: ${encryptionKey}`,
                }
            }
        ]
    })
)

El decrypt_message_prompt sigue el mismo patrón — toma encryptedMessage y encryptionKey como argumentos e indica al LLM que llame a decrypt_message.

6. Conexión del servidor MCP a un IDE

VS Code (automático)

Crea .vscode/mcp.json en la raíz del proyecto. VS Code lo detectará automáticamente:

{
    "servers": {
        "ciphersuite-mcp": {
            "command": "node",
            "args": [
                "--experimental-strip-types",
                "src/index.ts"
            ]
        }
    }
}

Otros IDEs / Otros proyectos

Copia la entrada del servidor ciphersuite-mcp en el archivo de configuración de MCP del proyecto o IDE de destino. El servidor se ejecuta como un subproceso mediante stdio, por lo que cualquier cliente compatible con MCP puede conectarse a él.