@rog0x/mcp-crypto-tools 1.0.0

package/README.md

@@ -0,0 +1,68 @@
+# mcp-crypto-tools
+
+Cryptography and encoding tools for AI agents, served via the [Model Context Protocol (MCP)](https://modelcontextprotocol.io).
+
+## Tools
+
+### hash
+
+Hash text using MD5, SHA-1, SHA-256, SHA-512, or HMAC. Compare two hash values. Compute all algorithms at once.
+
+**Actions:** `hash`, `hmac`, `compare`, `hash_all`
+
+### encode_decode
+
+Encode and decode text using Base64, URL encoding, HTML entities, hex, or binary. Auto-detect encoding format.
+
+**Actions:** `base64_encode`, `base64_decode`, `url_encode`, `url_decode`, `html_encode`, `html_decode`, `hex_encode`, `hex_decode`, `binary_encode`, `binary_decode`, `detect`
+
+### generate_id
+
+Generate unique identifiers: UUID v4, nanoid, ULID, CUID, or random strings with configurable length and charset.
+
+**Types:** `uuid`, `nanoid`, `ulid`, `cuid`, `random`
+
+### password
+
+Generate secure passwords with configurable character sets, length, and count. Check password strength with entropy calculation and crack time estimation.
+
+**Actions:** `generate`, `check_strength`
+
+### jwt
+
+Decode JWT tokens to inspect header and payload, check expiry status, or create unsigned JWTs for testing.
+
+**Actions:** `decode`, `check_expiry`, `create_unsigned`
+
+## Setup
+
+```bash
+npm install
+npm run build
+```
+
+## MCP Configuration
+
+Add to your MCP client configuration:
+
+```json
+{
+  "mcpServers": {
+    "crypto-tools": {
+      "command": "node",
+      "args": ["D:/products/mcp-servers/mcp-crypto-tools/dist/index.js"]
+    }
+  }
+}
+```
+
+## Dependencies
+
+- `@modelcontextprotocol/sdk` - MCP server framework
+- Node.js built-in `crypto` module - all cryptographic operations
+
+No external crypto libraries required.
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,340 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const hash_js_1 = require("./tools/hash.js");
+const encode_decode_js_1 = require("./tools/encode-decode.js");
+const uuid_generator_js_1 = require("./tools/uuid-generator.js");
+const password_tools_js_1 = require("./tools/password-tools.js");
+const jwt_tools_js_1 = require("./tools/jwt-tools.js");
+const server = new index_js_1.Server({
+    name: "mcp-crypto-tools",
+    version: "1.0.0",
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+// List available tools
+server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({
+    tools: [
+        {
+            name: "hash",
+            description: "Hash text using MD5, SHA-1, SHA-256, SHA-512, or HMAC. Can also compare two hash values or compute all hash algorithms at once.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    action: {
+                        type: "string",
+                        enum: ["hash", "hmac", "compare", "hash_all"],
+                        description: "Action to perform: hash (single algorithm), hmac (keyed hash), compare (compare two hashes), hash_all (all algorithms at once)",
+                    },
+                    text: { type: "string", description: "Text to hash (for hash, hmac, hash_all actions)" },
+                    algorithm: {
+                        type: "string",
+                        enum: ["md5", "sha1", "sha256", "sha512"],
+                        description: "Hash algorithm (for hash and hmac actions). Default: sha256",
+                    },
+                    key: { type: "string", description: "Secret key (for hmac action)" },
+                    hash1: { type: "string", description: "First hash (for compare action)" },
+                    hash2: { type: "string", description: "Second hash (for compare action)" },
+                    encoding: {
+                        type: "string",
+                        enum: ["hex", "base64"],
+                        description: "Output encoding. Default: hex",
+                    },
+                },
+                required: ["action"],
+            },
+        },
+        {
+            name: "encode_decode",
+            description: "Encode or decode text using Base64, URL encoding, HTML entities, hex, or binary. Can also auto-detect the encoding format of input.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    action: {
+                        type: "string",
+                        enum: [
+                            "base64_encode", "base64_decode",
+                            "url_encode", "url_decode",
+                            "html_encode", "html_decode",
+                            "hex_encode", "hex_decode",
+                            "binary_encode", "binary_decode",
+                            "detect",
+                        ],
+                        description: "Encoding/decoding action to perform",
+                    },
+                    text: { type: "string", description: "Text to encode, decode, or detect" },
+                },
+                required: ["action", "text"],
+            },
+        },
+        {
+            name: "generate_id",
+            description: "Generate unique identifiers: UUID v4, nanoid, ULID, CUID, or random strings with configurable length and charset.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    type: {
+                        type: "string",
+                        enum: ["uuid", "nanoid", "ulid", "cuid", "random"],
+                        description: "Type of ID to generate",
+                    },
+                    count: { type: "number", description: "Number of IDs to generate (max 100). Default: 1" },
+                    length: { type: "number", description: "Length for nanoid or random string. Default: 21 for nanoid, 16 for random" },
+                    charset: {
+                        type: "string",
+                        description: "Charset for random strings: alphanumeric, alpha, numeric, hex, lowercase, uppercase, symbols, all, or a custom string of characters. Default: alphanumeric",
+                    },
+                },
+                required: ["type"],
+            },
+        },
+        {
+            name: "password",
+            description: "Generate secure passwords with configurable options, or check password strength with entropy calculation and crack time estimation.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    action: {
+                        type: "string",
+                        enum: ["generate", "check_strength"],
+                        description: "Action: generate a password or check strength of an existing one",
+                    },
+                    password: { type: "string", description: "Password to check (for check_strength action)" },
+                    length: { type: "number", description: "Password length (for generate). Default: 16" },
+                    uppercase: { type: "boolean", description: "Include uppercase letters. Default: true" },
+                    lowercase: { type: "boolean", description: "Include lowercase letters. Default: true" },
+                    digits: { type: "boolean", description: "Include digits. Default: true" },
+                    symbols: { type: "boolean", description: "Include symbols. Default: true" },
+                    exclude_ambiguous: {
+                        type: "boolean",
+                        description: "Exclude ambiguous characters (0, O, l, I, 1). Default: false",
+                    },
+                    count: { type: "number", description: "Number of passwords to generate (max 100). Default: 1" },
+                },
+                required: ["action"],
+            },
+        },
+        {
+            name: "jwt",
+            description: "Decode JWT tokens to inspect header and payload, check expiry status, or create unsigned JWTs for testing purposes. Not for production authentication.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    action: {
+                        type: "string",
+                        enum: ["decode", "check_expiry", "create_unsigned"],
+                        description: "Action: decode (full decode), check_expiry (just expiry info), create_unsigned (create test token)",
+                    },
+                    token: { type: "string", description: "JWT token string (for decode and check_expiry)" },
+                    payload: {
+                        type: "object",
+                        description: "Payload object for creating unsigned JWT (for create_unsigned)",
+                    },
+                    expires_in_seconds: {
+                        type: "number",
+                        description: "Expiration time in seconds from now (for create_unsigned)",
+                    },
+                },
+                required: ["action"],
+            },
+        },
+    ],
+}));
+// Handle tool calls
+server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+        switch (name) {
+            case "hash": {
+                const action = args?.action;
+                const encoding = args?.encoding || "hex";
+                switch (action) {
+                    case "hash": {
+                        const text = args?.text;
+                        if (!text)
+                            throw new Error("'text' is required for hash action");
+                        const algorithm = args?.algorithm || "sha256";
+                        const result = (0, hash_js_1.hashText)(text, algorithm, encoding);
+                        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+                    }
+                    case "hmac": {
+                        const text = args?.text;
+                        const key = args?.key;
+                        if (!text)
+                            throw new Error("'text' is required for hmac action");
+                        if (!key)
+                            throw new Error("'key' is required for hmac action");
+                        const algorithm = args?.algorithm || "sha256";
+                        const result = (0, hash_js_1.hmacText)(text, key, algorithm, encoding);
+                        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+                    }
+                    case "compare": {
+                        const h1 = args?.hash1;
+                        const h2 = args?.hash2;
+                        if (!h1 || !h2)
+                            throw new Error("'hash1' and 'hash2' are required for compare action");
+                        const result = (0, hash_js_1.compareHashes)(h1, h2);
+                        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+                    }
+                    case "hash_all": {
+                        const text = args?.text;
+                        if (!text)
+                            throw new Error("'text' is required for hash_all action");
+                        const result = (0, hash_js_1.hashMultiple)(text, encoding);
+                        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+                    }
+                    default:
+                        throw new Error(`Unknown hash action: ${action}`);
+                }
+            }
+            case "encode_decode": {
+                const action = args?.action;
+                const text = args?.text;
+                if (!text)
+                    throw new Error("'text' is required");
+                let result;
+                switch (action) {
+                    case "base64_encode":
+                        result = (0, encode_decode_js_1.base64Encode)(text);
+                        break;
+                    case "base64_decode":
+                        result = (0, encode_decode_js_1.base64Decode)(text);
+                        break;
+                    case "url_encode":
+                        result = (0, encode_decode_js_1.urlEncode)(text);
+                        break;
+                    case "url_decode":
+                        result = (0, encode_decode_js_1.urlDecode)(text);
+                        break;
+                    case "html_encode":
+                        result = (0, encode_decode_js_1.htmlEntitiesEncode)(text);
+                        break;
+                    case "html_decode":
+                        result = (0, encode_decode_js_1.htmlEntitiesDecode)(text);
+                        break;
+                    case "hex_encode":
+                        result = (0, encode_decode_js_1.hexEncode)(text);
+                        break;
+                    case "hex_decode":
+                        result = (0, encode_decode_js_1.hexDecode)(text);
+                        break;
+                    case "binary_encode":
+                        result = (0, encode_decode_js_1.binaryEncode)(text);
+                        break;
+                    case "binary_decode":
+                        result = (0, encode_decode_js_1.binaryDecode)(text);
+                        break;
+                    case "detect":
+                        result = (0, encode_decode_js_1.detectEncoding)(text);
+                        break;
+                    default: throw new Error(`Unknown encode_decode action: ${action}`);
+                }
+                return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+            }
+            case "generate_id": {
+                const type = args?.type;
+                const count = args?.count || 1;
+                let result;
+                switch (type) {
+                    case "uuid":
+                        result = (0, uuid_generator_js_1.generateUUIDv4)(count);
+                        break;
+                    case "nanoid": {
+                        const length = args?.length || 21;
+                        result = (0, uuid_generator_js_1.generateNanoid)(length, count);
+                        break;
+                    }
+                    case "ulid":
+                        result = (0, uuid_generator_js_1.generateULID)(count);
+                        break;
+                    case "cuid":
+                        result = (0, uuid_generator_js_1.generateCUID)(count);
+                        break;
+                    case "random": {
+                        const length = args?.length || 16;
+                        const charset = args?.charset || "alphanumeric";
+                        result = (0, uuid_generator_js_1.generateRandomString)(length, charset, count);
+                        break;
+                    }
+                    default: throw new Error(`Unknown ID type: ${type}`);
+                }
+                return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+            }
+            case "password": {
+                const action = args?.action;
+                switch (action) {
+                    case "generate": {
+                        const result = (0, password_tools_js_1.generatePassword)({
+                            length: args?.length,
+                            uppercase: args?.uppercase,
+                            lowercase: args?.lowercase,
+                            digits: args?.digits,
+                            symbols: args?.symbols,
+                            exclude_ambiguous: args?.exclude_ambiguous,
+                            count: args?.count,
+                        });
+                        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+                    }
+                    case "check_strength": {
+                        const password = args?.password;
+                        if (!password)
+                            throw new Error("'password' is required for check_strength action");
+                        const result = (0, password_tools_js_1.checkPasswordStrength)(password);
+                        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+                    }
+                    default:
+                        throw new Error(`Unknown password action: ${action}`);
+                }
+            }
+            case "jwt": {
+                const action = args?.action;
+                switch (action) {
+                    case "decode": {
+                        const token = args?.token;
+                        if (!token)
+                            throw new Error("'token' is required for decode action");
+                        const result = (0, jwt_tools_js_1.decodeJWT)(token);
+                        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+                    }
+                    case "check_expiry": {
+                        const token = args?.token;
+                        if (!token)
+                            throw new Error("'token' is required for check_expiry action");
+                        const result = (0, jwt_tools_js_1.checkJWTExpiry)(token);
+                        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+                    }
+                    case "create_unsigned": {
+                        const payload = args?.payload || {};
+                        const expiresIn = args?.expires_in_seconds;
+                        const result = (0, jwt_tools_js_1.createUnsignedJWT)(payload, expiresIn);
+                        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+                    }
+                    default:
+                        throw new Error(`Unknown jwt action: ${action}`);
+                }
+            }
+            default:
+                throw new Error(`Unknown tool: ${name}`);
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            content: [{ type: "text", text: `Error: ${message}` }],
+            isError: true,
+        };
+    }
+});
+// Start server
+async function main() {
+    const transport = new stdio_js_1.StdioServerTransport();
+    await server.connect(transport);
+    console.error("MCP Crypto Tools server running on stdio");
+}
+main().catch(console.error);
+//# sourceMappingURL=index.js.map

package/dist/tools/encode-decode.d.ts

@@ -0,0 +1,40 @@
+export declare function base64Encode(text: string): {
+    encoded: string;
+    original_length: number;
+};
+export declare function base64Decode(encoded: string): {
+    decoded: string;
+    encoded_length: number;
+};
+export declare function urlEncode(text: string): {
+    encoded: string;
+};
+export declare function urlDecode(encoded: string): {
+    decoded: string;
+};
+export declare function htmlEntitiesEncode(text: string): {
+    encoded: string;
+};
+export declare function htmlEntitiesDecode(text: string): {
+    decoded: string;
+};
+export declare function hexEncode(text: string): {
+    encoded: string;
+};
+export declare function hexDecode(hex: string): {
+    decoded: string;
+};
+export declare function binaryEncode(text: string): {
+    encoded: string;
+};
+export declare function binaryDecode(binary: string): {
+    decoded: string;
+};
+interface DetectionResult {
+    input: string;
+    detected_formats: string[];
+    analysis: Record<string, string>;
+}
+export declare function detectEncoding(text: string): DetectionResult;
+export {};
+//# sourceMappingURL=encode-decode.d.ts.map

package/dist/tools/encode-decode.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.base64Encode = base64Encode;
+exports.base64Decode = base64Decode;
+exports.urlEncode = urlEncode;
+exports.urlDecode = urlDecode;
+exports.htmlEntitiesEncode = htmlEntitiesEncode;
+exports.htmlEntitiesDecode = htmlEntitiesDecode;
+exports.hexEncode = hexEncode;
+exports.hexDecode = hexDecode;
+exports.binaryEncode = binaryEncode;
+exports.binaryDecode = binaryDecode;
+exports.detectEncoding = detectEncoding;
+const HTML_ENTITY_MAP = {
+    "&": "&",
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;",
+    "'": "&#39;",
+};
+const HTML_ENTITY_REVERSE = {};
+for (const [char, entity] of Object.entries(HTML_ENTITY_MAP)) {
+    HTML_ENTITY_REVERSE[entity] = char;
+}
+function base64Encode(text) {
+    return {
+        encoded: Buffer.from(text, "utf-8").toString("base64"),
+        original_length: text.length,
+    };
+}
+function base64Decode(encoded) {
+    return {
+        decoded: Buffer.from(encoded, "base64").toString("utf-8"),
+        encoded_length: encoded.length,
+    };
+}
+function urlEncode(text) {
+    return { encoded: encodeURIComponent(text) };
+}
+function urlDecode(encoded) {
+    return { decoded: decodeURIComponent(encoded) };
+}
+function htmlEntitiesEncode(text) {
+    const encoded = text.replace(/[&<>"']/g, (ch) => HTML_ENTITY_MAP[ch] || ch);
+    return { encoded };
+}
+function htmlEntitiesDecode(text) {
+    let decoded = text;
+    for (const [entity, char] of Object.entries(HTML_ENTITY_REVERSE)) {
+        decoded = decoded.split(entity).join(char);
+    }
+    // Handle numeric entities
+    decoded = decoded.replace(/&#(\d+);/g, (_, num) => String.fromCharCode(parseInt(num, 10)));
+    decoded = decoded.replace(/&#x([0-9a-fA-F]+);/g, (_, hex) => String.fromCharCode(parseInt(hex, 16)));
+    return { decoded };
+}
+function hexEncode(text) {
+    return { encoded: Buffer.from(text, "utf-8").toString("hex") };
+}
+function hexDecode(hex) {
+    const cleaned = hex.replace(/\s+/g, "").replace(/^0x/i, "");
+    if (!/^[0-9a-fA-F]*$/.test(cleaned) || cleaned.length % 2 !== 0) {
+        throw new Error("Invalid hex string");
+    }
+    return { decoded: Buffer.from(cleaned, "hex").toString("utf-8") };
+}
+function binaryEncode(text) {
+    const binary = Array.from(Buffer.from(text, "utf-8"))
+        .map((b) => b.toString(2).padStart(8, "0"))
+        .join(" ");
+    return { encoded: binary };
+}
+function binaryDecode(binary) {
+    const cleaned = binary.replace(/[^01\s]/g, "");
+    const bytes = cleaned.split(/\s+/).filter(Boolean);
+    for (const b of bytes) {
+        if (b.length !== 8)
+            throw new Error(`Invalid binary octet: "${b}" (must be 8 bits)`);
+    }
+    const buf = Buffer.from(bytes.map((b) => parseInt(b, 2)));
+    return { decoded: buf.toString("utf-8") };
+}
+function detectEncoding(text) {
+    const detected = [];
+    const analysis = {};
+    const trimmed = text.trim();
+    // Base64 check
+    if (/^[A-Za-z0-9+/]+=*$/.test(trimmed) && trimmed.length >= 4 && trimmed.length % 4 === 0) {
+        detected.push("base64");
+        try {
+            analysis["base64_decoded"] = Buffer.from(trimmed, "base64").toString("utf-8");
+        }
+        catch {
+            // not valid base64
+        }
+    }
+    // Hex check
+    if (/^(0x)?[0-9a-fA-F]+$/i.test(trimmed) && trimmed.replace(/^0x/i, "").length % 2 === 0) {
+        detected.push("hex");
+        try {
+            analysis["hex_decoded"] = Buffer.from(trimmed.replace(/^0x/i, ""), "hex").toString("utf-8");
+        }
+        catch {
+            // not valid hex
+        }
+    }
+    // URL encoded check
+    if (/%[0-9A-Fa-f]{2}/.test(trimmed)) {
+        detected.push("url_encoded");
+        try {
+            analysis["url_decoded"] = decodeURIComponent(trimmed);
+        }
+        catch {
+            // not valid url encoding
+        }
+    }
+    // HTML entities check
+    if (/&(?:#\d+|#x[0-9a-fA-F]+|[a-zA-Z]+);/.test(trimmed)) {
+        detected.push("html_entities");
+        analysis["html_decoded"] = htmlEntitiesDecode(trimmed).decoded;
+    }
+    // Binary check
+    if (/^[01]{8}(\s+[01]{8})*$/.test(trimmed)) {
+        detected.push("binary");
+        try {
+            analysis["binary_decoded"] = binaryDecode(trimmed).decoded;
+        }
+        catch {
+            // not valid binary
+        }
+    }
+    // JWT check
+    if (/^[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]*$/.test(trimmed)) {
+        detected.push("jwt");
+    }
+    if (detected.length === 0) {
+        detected.push("plain_text");
+    }
+    return { input: trimmed.substring(0, 100), detected_formats: detected, analysis };
+}
+//# sourceMappingURL=encode-decode.js.map

package/dist/tools/hash.d.ts

@@ -0,0 +1,19 @@
+export declare function hashText(text: string, algorithm: string, encoding?: "hex" | "base64"): {
+    algorithm: string;
+    hash: string;
+    encoding: string;
+    input_length: number;
+};
+export declare function hmacText(text: string, key: string, algorithm: string, encoding?: "hex" | "base64"): {
+    algorithm: string;
+    hmac: string;
+    encoding: string;
+    input_length: number;
+};
+export declare function compareHashes(hash1: string, hash2: string): {
+    match: boolean;
+    hash1: string;
+    hash2: string;
+};
+export declare function hashMultiple(text: string, encoding?: "hex" | "base64"): Record<string, string>;
+//# sourceMappingURL=hash.d.ts.map