@sebastienrousseau/crypto-mcp 0.0.7 → 0.0.9

package/README.md

@@ -20,12 +20,13 @@ Instead of relying on fragile shell scripts or unverified LLM math, agents invok
 
 ## Features
 
-- **Standard MCP Protocol**: Full compliance with the Model Context Protocol JSON-RPC 2.0 specification via stdio transport.
-- **Post-Quantum Cryptography (PQC)**: Tools for NIST FIPS 203 (ML-KEM / Kyber), FIPS 204 (ML-DSA), and hybrid X25519 + ML-KEM key encapsulation.
-- **Classical Primitives**: RSA-2048/4096, ECC (P-256, P-384, P-521, secp256k1), Ed25519, OpenPGP (RFC 4880/9580), and AES-256-GCM / ChaCha20-Poly1305.
-- **Envelope Encryption**: Direct orchestration of multi-cloud Key Management Systems (AWS KMS, GCP KMS, Azure Key Vault, HashiCorp Vault).
-- **Cryptographic Bill of Materials (CBOM)**: Automated discovery and inventory of cryptographic assets for DORA Articles 9/13 and CRA compliance.
-- **Zero Runtime Dependencies**: Lightweight, secure stdio architecture operating with strict input schema validation.
+- **Standard MCP Protocol**: JSON-RPC 2.0 over stdio, with tools, resources and prompts.
+- **Key handles, not key material**: keys are generated, unwrapped or derived inside the server process. Tools return an opaque `keyHandle` (`kh_` followed by 32 hex characters) plus public metadata; no tool returns a private key, a symmetric key or a DEK, and no tool accepts one.
+- **Post-Quantum Cryptography (PQC)**: ML-KEM-768 (NIST FIPS 203) key generation, encapsulation and decapsulation.
+- **Classical Primitives**: RSA-2048/3072/4096 (RSASSA-PSS), ECDSA on P-256, P-384 and secp256k1, Ed25519, HMAC-SHA256, and AES-256-GCM / ChaCha20-Poly1305.
+- **Envelope Encryption**: wrap and unwrap DEKs under a key-encryption key. Only the `local` provider (random, in-process keys that do not survive a restart) is configured; `aws`, `gcp`, `azure` and `vault` return an error.
+- **Cryptographic Bill of Materials (CBOM)**: classify algorithm names into a CycloneDX 1.6 CBOM inventory.
+- **Validated input**: every tool call is checked against the tool's declared JSON schema before it runs.
 
 ---
 
@@ -62,18 +63,71 @@ Add the server to your `claude_desktop_config.json` or `.cursor/mcp.json`:
 
 ## Tools Exposed
 
-| Tool Name             | Description                                                   | Key Parameters                                        |
-| --------------------- | ------------------------------------------------------------- | ----------------------------------------------------- |
-| `crypto_generate_key` | Generate classical or post-quantum keypairs                   | `type` (rsa, ecc, ed25519, ml-kem-768), `passphrase`  |
-| `crypto_encrypt`      | Encrypt data with symmetric, asymmetric, or hybrid algorithms | `data`, `key`, `algorithm`, `armor`                   |
-| `crypto_decrypt`      | Decrypt encrypted ciphertexts or armored blocks               | `ciphertext`, `key`, `passphrase`                     |
-| `crypto_sign`         | Create cryptographic signatures (clearsign, detached, raw)    | `data`, `privateKey`, `passphrase`, `detached`        |
-| `crypto_verify`       | Verify digital signatures against public keys                 | `data`, `signature`, `publicKey`                      |
-| `crypto_hash`         | Compute cryptographic hashes or post-quantum signatures       | `data`, `algorithm` (sha256, sha512, blake2b, blake3) |
-| `crypto_kms_wrap`     | Wrap a local data encryption key using cloud KMS              | `provider` (aws, gcp, azure, vault), `keyId`, `dek`   |
-| `crypto_kms_unwrap`   | Unwrap a wrapped data encryption key using cloud KMS          | `provider`, `keyId`, `wrappedKey`                     |
-| `crypto_inspect_key`  | Parse armored OpenPGP keys or PEM certificates                | `keyData`                                             |
-| `crypto_audit_cbom`   | Audit a directory for cryptographic assets and produce CBOM   | `targetPath`, `format` (cyclonedx, spdx, summary)     |
+| Tool Name                | Description                                                      | Key Parameters                                                                               |
+| ------------------------ | ---------------------------------------------------------------- | -------------------------------------------------------------------------------------------- |
+| `crypto_generate_key`    | Generate a key in the server; returns its handle and public key  | `type` (rsa, ecc, ed25519, ml-kem-768, symmetric-256, hmac-sha256), `modulusLength`, `curve` |
+| `crypto_key_list`        | List held key handles with type and public metadata              | none                                                                                         |
+| `crypto_key_destroy`     | Wipe a key and invalidate its handle                             | `keyHandle`                                                                                  |
+| `crypto_key_import`      | Load a key from a file in `CRYPTO_MCP_KEY_DIR` into a handle     | `path`, `kind` (symmetric-256, hmac-sha256; raw keys only)                                   |
+| `crypto_encrypt`         | AEAD-encrypt under a key handle (a new key if none is given)     | `plaintext`, `keyHandle`, `algorithm` (aes-256-gcm, chacha20-poly1305)                       |
+| `crypto_decrypt`         | Authenticate and decrypt an AEAD ciphertext                      | `ciphertext`, `keyHandle`, `iv`, `authTag`, `algorithm`                                      |
+| `crypto_sign`            | Sign with a key handle; the algorithm follows the key            | `data`, `keyHandle`                                                                          |
+| `crypto_verify`          | Verify against a public key PEM or a key handle                  | `data`, `signature`, `publicKey` or `keyHandle`                                              |
+| `crypto_hash`            | Compute a digest                                                 | `data`, `algorithm` (sha256, sha384, sha512, sha3-256, blake2b512)                           |
+| `crypto_kem_encapsulate` | ML-KEM-768 encapsulation; the shared secret becomes a key handle | `publicKey`                                                                                  |
+| `crypto_kem_decapsulate` | ML-KEM-768 decapsulation with a key handle                       | `keyHandle`, `ciphertext`                                                                    |
+| `crypto_kms_wrap`        | Wrap the DEK behind a key handle under a KMS-held KEK            | `provider`, `keyId`, `keyHandle`                                                             |
+| `crypto_kms_unwrap`      | Unwrap a DEK into a new key handle                               | `provider`, `keyId`, `wrappedKey`                                                            |
+| `crypto_inspect_key`     | Classify a PEM or OpenPGP armored key and fingerprint it         | `keyData`                                                                                    |
+| `crypto_audit_cbom`      | Classify algorithm names into a CBOM                             | `algorithms`                                                                                 |
+
+Signature algorithms by key type: `ed25519` signs Ed25519, `rsa` signs RSASSA-PSS (SHA-256, MGF1-SHA-256, 32-byte salt), `ecc` signs ECDSA with SHA-256 (SHA-384 on P-384, DER-encoded), and `hmac-sha256` computes HMAC-SHA256.
+
+### Key handles
+
+A key handle is a capability: whoever can call the server with it can use the key, but cannot read it. Handles live only as long as the server process. The store holds at most 64 keys; adding one more destroys the least recently used key, so a client that needs a key for long should keep using it or expect to generate a new one. `crypto_key_destroy` removes a key at once.
+
+A typical session:
+
+1. `crypto_generate_key` with `type: "ed25519"` returns `keyHandle` and `publicKey`.
+2. `crypto_sign` with `data` and that `keyHandle` returns `algorithm: "ed25519"` and `signature`.
+3. Anyone can check the signature with `crypto_verify` and the `publicKey`.
+
+### Importing existing keys
+
+`crypto_key_import` brings in a key that already exists, for example to decrypt data encrypted outside the server, without the key passing through the conversation: the client names a file, and the server reads it into the key store and returns a handle.
+
+It is disabled unless the operator sets `CRYPTO_MCP_KEY_DIR` to a directory; without it the tool is still listed but every call returns `Key import is disabled`. Keeping it listed means a client sees why an import fails instead of a tool that is sometimes missing.
+
+```json
+{
+  "mcpServers": {
+    "crypto-service": {
+      "command": "npx",
+      "args": ["-y", "@sebastienrousseau/crypto-mcp"],
+      "env": { "CRYPTO_MCP_KEY_DIR": "/home/me/.config/crypto-mcp/keys" }
+    }
+  }
+}
+```
+
+Accepted files (at most 64 KiB):
+
+| File content                                                              | Imported as                                                                                               |
+| ------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------- |
+| Unencrypted PKCS#8 PEM (`BEGIN PRIVATE KEY`), Ed25519                     | `ed25519`                                                                                                 |
+| Unencrypted PKCS#8 PEM, RSA 2048, 3072 or 4096 bits                       | `rsa`                                                                                                     |
+| Unencrypted PKCS#8 PEM, EC on P-256, P-384 or secp256k1                   | `ecc`                                                                                                     |
+| Exactly 32 bytes (binary), or 64 hex digits and optional final whitespace | `symmetric-256` (AES-256-GCM / ChaCha20-Poly1305, as `crypto_encrypt` uses), or `hmac-sha256` with `kind` |
+
+The key type and public key of a PEM file come from the key itself; `kind` is refused for PEM files. Refused: encrypted PKCS#8 (decrypt it first with `openssl pkcs8 -nocrypt`), PKCS#1 and SEC1 PEM (convert with `openssl pkcs8 -topk8 -nocrypt`), and public keys, which carry nothing secret and can be passed to `crypto_verify` as `publicKey` directly.
+
+Security model:
+
+- `path` is relative to `CRYPTO_MCP_KEY_DIR`. Absolute paths, `..` segments and control characters are refused. The path is resolved with `realpath`, so a symlink is followed, but a target outside the directory is refused; the last component is then opened with `O_NOFOLLOW` where the platform has it, and the file is checked again through the open descriptor. Only regular files are read.
+- The bytes read are overwritten with zeros once parsed; hex is decoded byte by byte, never into a string. The PEM text is parsed into a `KeyObject`, which cannot be wiped (see below).
+- Results carry the handle and public metadata (`source: "crypto_key_import"`, public key, size or curve) only. Errors never contain the file's contents or its absolute path.
+- Anyone who can call the server can import any key file in the directory, so put only keys meant for this server there.
 
 ---
 
@@ -93,10 +147,9 @@ Add the server to your `claude_desktop_config.json` or `.cursor/mcp.json`:
 
 ## Security & Memory Hygiene
 
-`@sebastienrousseau/crypto-mcp` enforces strict separation of concerns:
-
-- **No Private Key Retention**: Private keys and sensitive plaintext inputs are processed in-memory and never cached across MCP requests.
-- **Input Validation**: Strict JSON schema bounds on all inputs prevent buffer overflow and injection attacks.
+- **No secret material in the conversation**: private keys, symmetric keys, DEKs and KEM shared secrets stay in the server process behind key handles. `crypto_verify` refuses a private key PEM instead of deriving its public half.
+- **Bounded key store**: at most 64 keys, least recently used evicted first. Raw secret bytes (symmetric, HMAC and ML-KEM secret keys) are overwritten with zeros when a key is evicted or destroyed. Asymmetric private keys are Node.js `KeyObject`s, which JavaScript cannot wipe; they are released for garbage collection. Transient copies (for example the hex strings `@sebastienrousseau/crypto-lib` uses for ML-KEM) are not wiped either.
+- **Input Validation**: every `tools/call` is checked against the tool's `inputSchema`: unknown properties, missing required properties, wrong types, values outside an enum and strings outside their declared length or format are rejected before the tool runs. Error messages name the property but never echo its value.
 - **Stdio Transport Isolation**: The server communicates over standard input/output with zero open network ports.
 
 ---

package/dist/protocol.d.ts

@@ -0,0 +1,18 @@
+import type { JSONRPCRequest } from "./types";
+export declare const SUPPORTED_PROTOCOL_VERSIONS: readonly ["2025-11-25", "2025-06-18", "2025-03-26", "2024-11-05"];
+export declare function negotiateProtocolVersion(requested: unknown): string;
+export declare const INVALID_PARAMS = -32602;
+export declare class McpError extends Error {
+    readonly code: number;
+    constructor(code: number, message: string);
+}
+export declare const isNotification: (request: JSONRPCRequest) => boolean;
+export declare function requireName(params: Record<string, unknown> | undefined, known: readonly {
+    name: string;
+}[], kind: string): string;
+export declare function requireArguments(params: Record<string, unknown> | undefined): Record<string, unknown>;
+export declare function requirePromptArguments(declared: readonly {
+    name: string;
+    required?: boolean;
+}[] | undefined, args: Record<string, unknown>): Record<string, string>;
+//# sourceMappingURL=protocol.d.ts.map

package/dist/protocol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol.d.ts","sourceRoot":"","sources":["../src/protocol.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAG9C,eAAO,MAAM,2BAA2B,mEAK9B,CAAC;AAOX,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,OAAO,GAAG,MAAM,CAInE;AAGD,eAAO,MAAM,cAAc,SAAS,CAAC;AAGrC,qBAAa,QAAS,SAAQ,KAAK;aAEf,IAAI,EAAE,MAAM;gBAAZ,IAAI,EAAE,MAAM,EAC5B,OAAO,EAAE,MAAM;CAKlB;AAGD,eAAO,MAAM,cAAc,GAAI,SAAS,cAAc,KAAG,OACT,CAAC;AAMjD,wBAAgB,WAAW,CACzB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,EAC3C,KAAK,EAAE,SAAS;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,EAAE,EAClC,IAAI,EAAE,MAAM,GACX,MAAM,CAeR;AAGD,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,GAC1C,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CASzB;AAGD,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,SAAS;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAE,EAAE,GAAG,SAAS,EACrE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC5B,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAoBxB"}

package/dist/protocol.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNotification = exports.McpError = exports.INVALID_PARAMS = exports.SUPPORTED_PROTOCOL_VERSIONS = void 0;
+exports.negotiateProtocolVersion = negotiateProtocolVersion;
+exports.requireName = requireName;
+exports.requireArguments = requireArguments;
+exports.requirePromptArguments = requirePromptArguments;
+exports.SUPPORTED_PROTOCOL_VERSIONS = [
+    "2025-11-25",
+    "2025-06-18",
+    "2025-03-26",
+    "2024-11-05",
+];
+function negotiateProtocolVersion(requested) {
+    return exports.SUPPORTED_PROTOCOL_VERSIONS.includes(requested)
+        ? requested
+        : exports.SUPPORTED_PROTOCOL_VERSIONS[0];
+}
+exports.INVALID_PARAMS = -32602;
+class McpError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "McpError";
+    }
+}
+exports.McpError = McpError;
+const isNotification = (request) => !("id" in request) || request.id === undefined;
+exports.isNotification = isNotification;
+function requireName(params, known, kind) {
+    const name = params?.name;
+    if (typeof name !== "string" || name === "") {
+        throw new McpError(exports.INVALID_PARAMS, `Invalid params: ${kind} name is required`);
+    }
+    if (!known.some((k) => k.name === name)) {
+        throw new McpError(exports.INVALID_PARAMS, `Invalid params: unknown ${kind}: ${name}`);
+    }
+    return name;
+}
+function requireArguments(params) {
+    const args = params?.arguments ?? {};
+    if (typeof args !== "object" || args === null || Array.isArray(args)) {
+        throw new McpError(exports.INVALID_PARAMS, "Invalid params: arguments must be an object");
+    }
+    return args;
+}
+function requirePromptArguments(declared, args) {
+    const out = {};
+    for (const [key, value] of Object.entries(args)) {
+        if (typeof value !== "string") {
+            throw new McpError(exports.INVALID_PARAMS, `Invalid params: argument ${key} must be a string`);
+        }
+        out[key] = value;
+    }
+    for (const arg of declared ?? []) {
+        if (arg.required && !out[arg.name]) {
+            throw new McpError(exports.INVALID_PARAMS, `Invalid params: missing required argument ${arg.name}`);
+        }
+    }
+    return out;
+}
+//# sourceMappingURL=protocol.js.map

package/dist/server.d.ts

@@ -1,4 +1,5 @@
 import { JSONRPCRequest, JSONRPCResponse } from "./types";
+export declare const SERVER_INSTRUCTIONS: string;
 export declare const SERVER_VERSION: string;
 export declare class CryptoMcpServer {
     private initialized;

package/dist/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,cAAc,EAAE,eAAe,EAAuB,MAAM,SAAS,CAAC;AAU/E,eAAO,MAAM,cAAc,EAAE,MAIpB,CAAC;AAEV,qBAAa,eAAe;IAC1B,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAoB;IACzC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAkB;IAKnC,aAAa,IAAI,OAAO;IAOlB,aAAa,CACxB,OAAO,EAAE,cAAc,GACtB,OAAO,CAAC,eAAe,CAAC;IAuGpB,WAAW,CAChB,KAAK,GAAE,MAAM,CAAC,cAA8B,EAC5C,MAAM,GAAE,MAAM,CAAC,cAA+B,GAC7C,IAAI;CAwBR"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,cAAc,EAAE,eAAe,EAAuB,MAAM,SAAS,CAAC;AAc/E,eAAO,MAAM,mBAAmB,QAId,CAAC;AAOnB,eAAO,MAAM,cAAc,EAAE,MAIpB,CAAC;AAEV,qBAAa,eAAe;IAC1B,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAoB;IACzC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAkB;IAKnC,aAAa,IAAI,OAAO;IAOlB,aAAa,CACxB,OAAO,EAAE,cAAc,GACtB,OAAO,CAAC,eAAe,CAAC;IAqGpB,WAAW,CAChB,KAAK,GAAE,MAAM,CAAC,cAA8B,EAC5C,MAAM,GAAE,MAAM,CAAC,cAA+B,GAC7C,IAAI;CA0BR"}

package/dist/server.js

@@ -3,13 +3,18 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CryptoMcpServer = exports.SERVER_VERSION = void 0;
+exports.CryptoMcpServer = exports.SERVER_VERSION = exports.SERVER_INSTRUCTIONS = void 0;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const node_readline_1 = __importDefault(require("node:readline"));
 const tools_1 = require("./tools");
 const resources_1 = require("./resources");
 const prompts_1 = require("./prompts");
+const protocol_1 = require("./protocol");
+exports.SERVER_INSTRUCTIONS = "Cryptographic tools that keep key material inside this server: " +
+    "generate or import a key to get a handle, then pass the handle to " +
+    "encrypt, decrypt, sign, KEM and KMS tools. No tool returns a private " +
+    "or secret key.";
 exports.SERVER_VERSION = JSON.parse(node_fs_1.default.readFileSync(node_path_1.default.join(__dirname, "..", "package.json"), "utf8")).version;
 class CryptoMcpServer {
     initialized = false;
@@ -35,7 +40,7 @@ class CryptoMcpServer {
                 case "initialize": {
                     this.initialized = true;
                     const result = {
-                        protocolVersion: "2024-11-05",
+                        protocolVersion: (0, protocol_1.negotiateProtocolVersion)(request.params?.protocolVersion),
                         capabilities: {
                             tools: {},
                             resources: {},
@@ -45,6 +50,7 @@ class CryptoMcpServer {
                             name: this.name,
                             version: this.version,
                         },
+                        instructions: exports.SERVER_INSTRUCTIONS,
                     };
                     return { jsonrpc: "2.0", id, result };
                 }
@@ -55,11 +61,8 @@ class CryptoMcpServer {
                     return { jsonrpc: "2.0", id, result: { tools: tools_1.TOOLS } };
                 }
                 case "tools/call": {
-                    const params = request.params;
-                    const toolName = params ? String(params.name) : "";
-                    const toolArgs = params && params.arguments
-                        ? params.arguments
-                        : {};
+                    const toolName = (0, protocol_1.requireName)(request.params, tools_1.TOOLS, "tool");
+                    const toolArgs = (0, protocol_1.requireArguments)(request.params);
                     const result = await (0, tools_1.executeTool)(toolName, toolArgs);
                     return { jsonrpc: "2.0", id, result };
                 }
@@ -76,11 +79,8 @@ class CryptoMcpServer {
                     return { jsonrpc: "2.0", id, result: { prompts: prompts_1.PROMPTS } };
                 }
                 case "prompts/get": {
-                    const params = request.params;
-                    const promptName = params ? String(params.name) : "";
-                    const promptArgs = params && params.arguments
-                        ? params.arguments
-                        : {};
+                    const promptName = (0, protocol_1.requireName)(request.params, prompts_1.PROMPTS, "prompt");
+                    const promptArgs = (0, protocol_1.requirePromptArguments)(prompts_1.PROMPTS.find((p) => p.name === promptName)?.arguments, (0, protocol_1.requireArguments)(request.params));
                     const result = await (0, prompts_1.getPrompt)(promptName, promptArgs);
                     return { jsonrpc: "2.0", id, result };
                 }
@@ -100,7 +100,7 @@ class CryptoMcpServer {
                 jsonrpc: "2.0",
                 id,
                 error: {
-                    code: -32603,
+                    code: err instanceof protocol_1.McpError ? err.code : -32603,
                     message: err.message,
                 },
             };
@@ -119,9 +119,11 @@ class CryptoMcpServer {
             try {
                 const req = JSON.parse(trimmed);
                 const res = await this.handleRequest(req);
+                if ((0, protocol_1.isNotification)(req))
+                    return;
                 output.write(JSON.stringify(res) + "\n");
             }
-            catch (e) {
+            catch {
                 const parseError = {
                     jsonrpc: "2.0",
                     id: null,

package/dist/tools/annotations.d.ts

@@ -0,0 +1,6 @@
+import type { MCPToolAnnotations } from "../types";
+export declare function annotationsFor(name: string): {
+    title: string;
+    annotations: MCPToolAnnotations;
+} | undefined;
+//# sourceMappingURL=annotations.d.ts.map

package/dist/tools/annotations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"annotations.d.ts","sourceRoot":"","sources":["../../src/tools/annotations.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AA8CnD,wBAAgB,cAAc,CAC5B,IAAI,EAAE,MAAM,GACX;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,kBAAkB,CAAA;CAAE,GAAG,SAAS,CAKhE"}

package/dist/tools/annotations.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.annotationsFor = annotationsFor;
+const HINTS = {
+    read: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+    add: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false,
+    },
+    destroy: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+};
+const TOOL_BEHAVIOUR = {
+    crypto_generate_key: ["Generate a key", "add"],
+    crypto_key_list: ["List key handles", "read"],
+    crypto_key_destroy: ["Destroy a key", "destroy"],
+    crypto_key_import: ["Import a key from a file", "add"],
+    crypto_inspect_key: ["Inspect a public key", "read"],
+    crypto_encrypt: ["Encrypt data", "add"],
+    crypto_decrypt: ["Decrypt data", "read"],
+    crypto_kem_encapsulate: ["Encapsulate a shared secret", "add"],
+    crypto_kem_decapsulate: ["Decapsulate a shared secret", "add"],
+    crypto_sign: ["Sign data", "read"],
+    crypto_verify: ["Verify a signature", "read"],
+    crypto_hash: ["Hash data", "read"],
+    crypto_kms_wrap: ["Wrap a key (KMS)", "add"],
+    crypto_kms_unwrap: ["Unwrap a key (KMS)", "add"],
+    crypto_audit_cbom: ["Audit a CBOM", "read"],
+};
+function annotationsFor(name) {
+    const entry = TOOL_BEHAVIOUR[name];
+    if (!entry)
+        return undefined;
+    const [title, behaviour] = entry;
+    return { title, annotations: { title, ...HINTS[behaviour] } };
+}
+//# sourceMappingURL=annotations.js.map

package/dist/tools/definitions.d.ts

@@ -2,6 +2,10 @@ import { MCPTool } from "../types";
 export declare const KEY_TYPES: string[];
 export declare const RSA_MODULUS_LENGTHS: number[];
 export declare const EC_CURVES: string[];
+export declare const KEY_DIR_ENV = "CRYPTO_MCP_KEY_DIR";
+export declare const MAX_KEY_FILE_BYTES = 65536;
 export declare const HASH_ALGORITHMS: string[];
+export declare const MAX_TEXT_LENGTH = 1048576;
+export declare const MAX_KEY_LENGTH = 16384;
 export declare const TOOLS: MCPTool[];
 //# sourceMappingURL=definitions.d.ts.map

package/dist/tools/definitions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definitions.d.ts","sourceRoot":"","sources":["../../src/tools/definitions.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AAGnC,eAAO,MAAM,SAAS,UAA0C,CAAC;AAGjE,eAAO,MAAM,mBAAmB,UAAqB,CAAC;AAGtD,eAAO,MAAM,SAAS,UAA2C,CAAC;AAGlE,eAAO,MAAM,eAAe,UAM3B,CAAC;AAGF,eAAO,MAAM,KAAK,EAAE,OAAO,EAmP1B,CAAC"}
+{"version":3,"file":"definitions.d.ts","sourceRoot":"","sources":["../../src/tools/definitions.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAA4B,MAAM,UAAU,CAAC;AAK7D,eAAO,MAAM,SAAS,UAOrB,CAAC;AAGF,eAAO,MAAM,mBAAmB,UAAqB,CAAC;AAGtD,eAAO,MAAM,SAAS,UAA2C,CAAC;AAGlE,eAAO,MAAM,WAAW,uBAAuB,CAAC;AAGhD,eAAO,MAAM,kBAAkB,QAAS,CAAC;AASzC,eAAO,MAAM,eAAe,UAM3B,CAAC;AASF,eAAO,MAAM,eAAe,UAAY,CAAC;AAGzC,eAAO,MAAM,cAAc,QAAS,CAAC;AAgVrC,eAAO,MAAM,KAAK,EAAE,OAAO,EAKiC,CAAC"}