ciphersuite-mcp

Ein MCP (Model Context Protocol)-Server, der AES-256-CBC-Verschlüsselungs- und -Entschlüsselungstools, Ressourcen, die jeden Algorithmus beschreiben, und sofort einsatzbereite Prompts bereitstellt — alles direkt in VS Code Copilot Chat ausführbar.

Related MCP server: Secret Vault MCP Server

Was es tut

So funktioniert die Verschlüsselung

• Algorithmus: AES-256-CBC

• Schlüsselableitung: scrypt(passphrase, fixedSalt, 32) — Sie übergeben eine beliebige Passphrase als String; der Server leitet daraus automatisch einen starken 32-Byte-Schlüssel ab

• Ausgabeformat: <IV in hex>:<ciphertext in hex> — bewahren Sie den vollständigen String auf, um später entschlüsseln zu können

• IV: Bei jedem Verschlüsselungsaufruf wird ein neuer, zufälliger 16-Byte-IV generiert, sodass dieselbe Nachricht bei zweimaliger Verschlüsselung unterschiedliche Ausgaben erzeugt

Voraussetzungen

• Node.js v24+ (siehe engines in package.json)

Installation

npm install

Es ist kein Build-Schritt erforderlich — der Server führt TypeScript direkt über die native TypeScript-Unterstützung von Node.js aus.

Verwendung in VS Code

1. MCP-Serverkonfiguration hinzufügen

Erstellen Sie (oder öffnen Sie) .vscode/mcp.json in Ihrem Arbeitsbereich und fügen Sie Folgendes hinzu:

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

oder über npm:

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

Tipp: Sie können diesen Server auch zur MCP-Konfiguration auf Benutzerebene unter ~/.vscode/mcp.json hinzufügen, um ihn in jedem Arbeitsbereich verfügbar zu machen.

2. VS Code neu laden

Öffnen Sie die Befehlspalette (Cmd+Shift+P) und führen Sie Developer: Reload Window aus (oder starten Sie VS Code einfach neu).

3. In Copilot Chat verwenden

Öffnen Sie Copilot Chat (Agent-Modus) und probieren Sie Folgendes aus:

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

Der Agent ruft automatisch das passende Tool auf und gibt das Ergebnis zurück.

Den MCP Inspector ausführen

Mit dem MCP Inspector können Sie alle Tools, Ressourcen und Prompts interaktiv in einer Browser-UI erkunden und testen:

npm run mcp:inspect

Dadurch wird der Inspector unter http://localhost:5173 geöffnet und mit dem laufenden Server verbunden.

Tests ausführen

# Run all tests once
npm test

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

Die Testsuite umfasst:

• Verschlüsseln einer Nachricht

• Entschlüsseln einer Nachricht mit der korrekten Passphrase

• Auflisten und Lesen der Ressource encryption://info

• Abrufen beider Prompts

• Fehler: Entschlüsseln mit falscher Passphrase

• Fehler: Entschlüsseln eines fehlerhaften Chiffrats

Projektstruktur

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

Verfügbare Skripte

Von Grund auf erstellen

Dieser Abschnitt dokumentiert Schritt für Schritt, wie dieser MCP-Server aufgebaut wurde — nützlich für die zukünftige Erstellung neuer MCP-Server.

MCP-Transporttypen

Es gibt 3 Arten von MCP-Transport:

Abhängigkeiten

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

1. Einstiegspunkt — src/index.ts

Der Einstiegspunkt erstellt einen StdioServerTransport und verbindet den MCP-Server damit:

// 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. Server-Einrichtung — src/mcp.ts

Erstellen Sie die MCP-Serverinstanz mit einem Namen und einer Version:

// 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. Tools registrieren

Tools sind Funktionen, die das LLM aufrufen kann, um Aktionen auszuführen. Verwenden Sie server.registerTool, das 3 Argumente benötigt:

1. Name des Tools (String)

2. Konfigurationsobjekt mit:

   • description — was das Tool tut; das LLM verwendet dies, um zu entscheiden, wann es aufgerufen wird

   • inputSchema — entspricht dem Request-Body, definiert mit Zod

   • outputSchema — entspricht dem Response-Body, definiert mit Zod

3. Asynchrone Handler-Funktion — die eigentliche Implementierung

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)}`
                }]
            }
        }
    }
)

Dasselbe Muster gilt für decrypt_message — tauschen Sie einfach die Felder des Eingabe-/Ausgabeschemas aus und rufen Sie stattdessen decrypt() auf.

4. Ressourcen registrieren

Ressourcen stellen statische oder berechnete Informationen bereit, die dem LLM helfen, den Kontext rund um ein Tool zu verstehen. Verwenden Sie server.registerResource, das 4 Argumente benötigt:

1. Name der Ressource

2. URI-Vorlage (normalerweise identisch mit dem Namen)

3. Konfigurationsobjekt, das eine description enthält

4. Handler-Funktion, die contents zurückgibt — ein Array von Objekten mit uri, mimeType und 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(),
            },
        ]
    })
)

Die Ressource decryption://info folgt demselben Muster und beschreibt das erwartete Eingabeformat, die Passphrasenanforderungen und häufige Fehlerszenarien für das Entschlüsselungs-Tool.

5. Prompts registrieren

Prompts sind vorgefertigte Nachrichtenvorlagen, mit denen das LLM Tools auf geführte Weise aufrufen kann. Verwenden Sie server.registerPrompt, das 3 Argumente benötigt:

1. Name des Prompts

2. Konfigurationsobjekt mit:

   • description — was der Prompt tut

   • argsSchema — die Eingabeparameter, definiert mit Zod

3. Handler-Funktion, die messages zurückgibt — ein Array von Objekten mit role (user oder assistant) und 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}`,
                }
            }
        ]
    })
)

Der Prompt decrypt_message_prompt folgt demselben Muster — er nimmt encryptedMessage und encryptionKey als Argumente entgegen und weist das LLM an, decrypt_message aufzurufen.

6. Verbinden des MCP-Servers mit einer IDE

VS Code (automatisch)

Erstellen Sie .vscode/mcp.json im Projektstammverzeichnis. VS Code erkennt es automatisch:

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

Andere IDEs / Andere Projekte

Kopieren Sie den Servereintrag von ciphersuite-mcp in die MCP-Konfigurationsdatei des Zielprojekts oder der Ziel-IDE. Der Server läuft als Unterprozess über stdio, sodass sich jeder MCP-kompatible Client damit verbinden kann.