claudeunmask 1.0.22 → 1.0.23

package/index.js

@@ -1,4 +1,4 @@
-/* v 1.0.22 */
+/* v 1.0.23 */
 	function getMessageEncoding(message) {
 		return new TextEncoder().encode(message);
 	}
@@ -61,7 +61,7 @@
 		}
 		return "";
 	}
-	async function decryptData(inData, decryptionKey) {
+	async function unmaskData(inData, decryptionKey) {
 		var retVal = [];
 		var enc = new TextEncoder();
 		var [tmpPassword, salt, theIV] = decryptionKey.split("-");

package/index.min.js

@@ -1 +1 @@
-function getMessageEncoding(e){return new TextEncoder().encode(e)}function getMessageDecoding(e){return new TextDecoder().decode(e)}function base64ToBytes(e){let t=atob(e),r=new Uint8Array(t.length);for(let n=0;n<t.length;n++)r[n]=t.charCodeAt(n);return r}function bytesToBase64(e){let t=String.fromCharCode(...e);return btoa(t)}async function deriveKeyFromPassword(e,t){let r=getMessageEncoding(e),n=await crypto.subtle.importKey("raw",r,"PBKDF2",!1,["deriveKey"]),a=await crypto.subtle.deriveKey({name:"PBKDF2",salt:t,iterations:1e5,hash:"SHA-256"},n,{name:"AES-GCM",length:256},!0,["encrypt","decrypt"]);return a}async function decryptThisData(e,t,r){try{let n=await crypto.subtle.decrypt({name:"AES-GCM",iv:r},t,e);return getMessageDecoding(new Uint8Array(n))}catch(a){return console.log("failed",t,e),"Failed to decrypt"}return""}async function decryptData(e,t){var r=[];new TextEncoder;var[n,a,s]=t.split("-");let o=n.slice(2);for(let i of e){var c={};for(let[l,d]of Object.entries(i))try{if("string"==typeof d&&d.includes("m$k_")){var y=base64ToBytes(i.secret_column.replace("m$k_",""));let u=await deriveKeyFromPassword(o,base64ToBytes(a));c[l]=await decryptThisData(y,u,base64ToBytes(s))}else c[l]=d}catch(f){c[l]="failed"}r.push(c)}return r}
+function getMessageEncoding(e){return new TextEncoder().encode(e)}function getMessageDecoding(e){return new TextDecoder().decode(e)}function base64ToBytes(e){let t=atob(e),n=new Uint8Array(t.length);for(let r=0;r<t.length;r++)n[r]=t.charCodeAt(r);return n}function bytesToBase64(e){let t=String.fromCharCode(...e);return btoa(t)}async function deriveKeyFromPassword(e,t){let n=getMessageEncoding(e),r=await crypto.subtle.importKey("raw",n,"PBKDF2",!1,["deriveKey"]),a=await crypto.subtle.deriveKey({name:"PBKDF2",salt:t,iterations:1e5,hash:"SHA-256"},r,{name:"AES-GCM",length:256},!0,["encrypt","decrypt"]);return a}async function decryptThisData(e,t,n){try{let r=await crypto.subtle.decrypt({name:"AES-GCM",iv:n},t,e);return getMessageDecoding(new Uint8Array(r))}catch(a){return console.log("failed",t,e),"Failed to decrypt"}return""}async function unmaskData(e,t){var n=[];new TextEncoder;var[r,a,s]=t.split("-");let o=r.slice(2);for(let i of e){var c={};for(let[l,d]of Object.entries(i))try{if("string"==typeof d&&d.includes("m$k_")){var u=base64ToBytes(i.secret_column.replace("m$k_",""));let y=await deriveKeyFromPassword(o,base64ToBytes(a));c[l]=await decryptThisData(u,y,base64ToBytes(s))}else c[l]=d}catch(f){c[l]="failed"}n.push(c)}return n}

package/junk.js

@@ -0,0 +1,676 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from "@modelcontextprotocol/sdk/types.js";
+import { DefaultAzureCredential } from "@azure/identity";
+import { SqlManagementClient } from "@azure/arm-sql";
+import sql from "mssql";
+import * as fs from "fs";
+import * as path from "path";
+
+import { webcrypto } from 'crypto';
+const subtle = webcrypto.subtle;
+
+// Azure MCP Server
+class AzureMCPServer {
+  private server: Server;
+  private credential: DefaultAzureCredential;
+  private subscriptionId: string;
+  private sqlPools: Map<string, sql.ConnectionPool>;
+
+  constructor() {
+    this.server = new Server(
+      {
+        name: "azure-mcp-server",
+        version: "1.0.0",
+      },
+      {
+        capabilities: {
+          tools: {},
+        },
+      }
+    );
+
+    // Get subscription ID from environment
+    this.subscriptionId = process.env.AZURE_SUBSCRIPTION_ID || "";
+    if (!this.subscriptionId) {
+      throw new Error("AZURE_SUBSCRIPTION_ID environment variable is required");
+    }
+
+    // Initialize Azure credential
+    this.credential = new DefaultAzureCredential();
+    
+    // Initialize SQL connection pool cache
+    this.sqlPools = new Map();
+
+    this.setupHandlers();
+  }
+
+  private setupHandlers() {
+    // List available tools
+    this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
+      tools: [
+        {
+          name: "list_resource_groups",
+          description: "List all resource groups in the Azure subscription",
+          inputSchema: {
+            type: "object",
+            properties: {},
+          },
+        },
+        {
+          name: "create_resource_group",
+          description: "Create a new resource group",
+          inputSchema: {
+            type: "object",
+            properties: {
+              name: { type: "string", description: "Resource group name" },
+              location: { type: "string", description: "Azure region (e.g., eastus, westus2)" },
+            },
+            required: ["name", "location"],
+          },
+        },
+        {
+          name: "list_storage_accounts",
+          description: "List all storage accounts in a resource group",
+          inputSchema: {
+            type: "object",
+            properties: {
+              resourceGroup: { type: "string", description: "Resource group name" },
+            },
+            required: ["resourceGroup"],
+          },
+        },
+        {
+          name: "create_storage_account",
+          description: "Create a new storage account",
+          inputSchema: {
+            type: "object",
+            properties: {
+              resourceGroup: { type: "string", description: "Resource group name" },
+              accountName: { type: "string", description: "Storage account name (lowercase, alphanumeric)" },
+              location: { type: "string", description: "Azure region" },
+              sku: { type: "string", description: "SKU name (e.g., Standard_LRS, Premium_LRS)", default: "Standard_LRS" },
+            },
+            required: ["resourceGroup", "accountName", "location"],
+          },
+        },
+        {
+          name: "list_vms",
+          description: "List all virtual machines in a resource group",
+          inputSchema: {
+            type: "object",
+            properties: {
+              resourceGroup: { type: "string", description: "Resource group name" },
+            },
+            required: ["resourceGroup"],
+          },
+        },
+        {
+          name: "get_vm_status",
+          description: "Get the power state of a virtual machine",
+          inputSchema: {
+            type: "object",
+            properties: {
+              resourceGroup: { type: "string", description: "Resource group name" },
+              vmName: { type: "string", description: "Virtual machine name" },
+            },
+            required: ["resourceGroup", "vmName"],
+          },
+        },
+        {
+          name: "list_blob_containers",
+          description: "List all blob containers in a storage account",
+          inputSchema: {
+            type: "object",
+            properties: {
+              accountName: { type: "string", description: "Storage account name" },
+            },
+            required: ["accountName"],
+          },
+        },
+        {
+          name: "upload_blob",
+          description: "Upload content to a blob in Azure Storage",
+          inputSchema: {
+            type: "object",
+            properties: {
+              accountName: { type: "string", description: "Storage account name" },
+              containerName: { type: "string", description: "Container name" },
+              blobName: { type: "string", description: "Blob name/path" },
+              content: { type: "string", description: "Content to upload" },
+            },
+            required: ["accountName", "containerName", "blobName", "content"],
+          },
+        },
+        {
+          name: "list_sql_servers",
+          description: "List all SQL servers in a resource group",
+          inputSchema: {
+            type: "object",
+            properties: {
+              resourceGroup: { type: "string", description: "Resource group name" },
+            },
+            required: ["resourceGroup"],
+          },
+        },
+        {
+          name: "list_databases",
+          description: "List all databases on a SQL server",
+          inputSchema: {
+            type: "object",
+            properties: {
+              resourceGroup: { type: "string", description: "Resource group name" },
+              serverName: { type: "string", description: "SQL server name" },
+            },
+            required: ["resourceGroup", "serverName"],
+          },
+        },
+        {
+          name: "execute_query",
+          description: "Execute a SQL query on an Azure SQL Database",
+          inputSchema: {
+            type: "object",
+            properties: {
+              server: { type: "string", description: "SQL server FQDN (e.g., myserver.database.windows.net)" },
+              database: { type: "string", description: "Database name" },
+              query: { type: "string", description: "SQL query to execute" },
+              username: { type: "string", description: "Username for audit logging (required)" },
+              password: { type: "string", description: "SQL password (optional, uses Azure AD if not provided)" },
+            },
+            required: ["server", "database", "query", "username"],
+          },
+        },
+        {
+          name: "execute_stored_procedure",
+          description: "Execute a stored procedure on an Azure SQL Database",
+          inputSchema: {
+            type: "object",
+            properties: {
+              server: { type: "string", description: "SQL server FQDN" },
+              database: { type: "string", description: "Database name" },
+              procedureName: { type: "string", description: "Stored procedure name" },
+              username: { type: "string", description: "Username for audit logging (required)" },
+              parameters: { type: "object", description: "Procedure parameters as key-value pairs" },
+              password: { type: "string", description: "SQL password (optional)" },
+            },
+            required: ["server", "database", "procedureName", "username"],
+          },
+        },
+        {
+          name: "get_database_info",
+          description: "Get detailed information about a specific database",
+          inputSchema: {
+            type: "object",
+            properties: {
+              resourceGroup: { type: "string", description: "Resource group name" },
+              serverName: { type: "string", description: "SQL server name" },
+              databaseName: { type: "string", description: "Database name" },
+            },
+            required: ["resourceGroup", "serverName", "databaseName"],
+          },
+        },
+        {
+          name: "get_version",
+          description: "Get the version of the Azure MCP Server",
+          inputSchema: {
+            type: "object",
+            properties: {},
+          },
+        },
+      ],
+    }));
+
+    // Handle tool calls
+    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      try {
+        switch (request.params.name) {
+          case "list_resource_groups":
+            return await this.listResourceGroups();
+          
+          case "create_resource_group":
+            return await this.createResourceGroup(
+              request.params.arguments as { name: string; location: string }
+            );
+          
+          case "list_storage_accounts":
+            return await this.listStorageAccounts(
+              request.params.arguments as { resourceGroup: string }
+            );
+          
+          case "create_storage_account":
+            return await this.createStorageAccount(
+              request.params.arguments as { resourceGroup: string; accountName: string; location: string; sku?: string }
+            );
+          
+          case "list_vms":
+            return await this.listVMs(
+              request.params.arguments as { resourceGroup: string }
+            );
+          
+          case "get_vm_status":
+            return await this.getVMStatus(
+              request.params.arguments as { resourceGroup: string; vmName: string }
+            );
+          
+          case "list_blob_containers":
+            return await this.listBlobContainers(
+              request.params.arguments as { accountName: string }
+            );
+          
+          case "upload_blob":
+            return await this.uploadBlob(
+              request.params.arguments as { accountName: string; containerName: string; blobName: string; content: string }
+            );
+          
+          case "list_sql_servers":
+            return await this.listSqlServers(
+              request.params.arguments as { resourceGroup: string }
+            );
+          
+          case "list_databases":
+            return await this.listDatabases(
+              request.params.arguments as { resourceGroup: string; serverName: string }
+            );
+          
+          case "execute_query":
+            return await this.executeQuery(
+              request.params.arguments as { server: string; database: string; query: string; username: string; password?: string }
+            );
+          
+          case "execute_stored_procedure":
+            return await this.executeStoredProcedure(
+              request.params.arguments as { server: string; database: string; procedureName: string; username: string; parameters?: any; password?: string }
+            );
+          
+          case "get_database_info":
+            return await this.getDatabaseInfo(
+              request.params.arguments as { resourceGroup: string; serverName: string; databaseName: string }
+            );
+          
+          case "get_version":
+            return await this.getVersion();
+
+          default:
+            throw new Error(`Unknown tool: ${request.params.name}`);
+        }
+      } catch (error: any) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${error.message}`,
+            },
+          ],
+        };
+      }
+    });
+  }
+
+  private async listSqlServers(args: { resourceGroup: string }) {
+    const client = new SqlManagementClient(this.credential, this.subscriptionId);
+    const servers = [];
+
+    for await (const server of client.servers.listByResourceGroup(args.resourceGroup)) {
+      servers.push({
+        name: server.name,
+        location: server.location,
+        fullyQualifiedDomainName: server.fullyQualifiedDomainName,
+        version: server.version,
+        administratorLogin: server.administratorLogin,
+      });
+    }
+
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(servers, null, 2),
+        },
+      ],
+    };
+  }
+
+  private async listDatabases(args: { resourceGroup: string; serverName: string }) {
+    const client = new SqlManagementClient(this.credential, this.subscriptionId);
+    const databases = [];
+
+    for await (const db of client.databases.listByServer(args.resourceGroup, args.serverName)) {
+      databases.push({
+        name: db.name,
+        location: db.location,
+        status: db.status,
+        sku: db.sku,
+        maxSizeBytes: db.maxSizeBytes,
+        creationDate: db.creationDate,
+      });
+    }
+
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(databases, null, 2),
+        },
+      ],
+    };
+  }
+
+  private async getDatabaseInfo(args: { resourceGroup: string; serverName: string; databaseName: string }) {
+    const client = new SqlManagementClient(this.credential, this.subscriptionId);
+    
+    const database = await client.databases.get(
+      args.resourceGroup,
+      args.serverName,
+      args.databaseName
+    );
+
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            name: database.name,
+            location: database.location,
+            status: database.status,
+            sku: database.sku,
+            maxSizeBytes: database.maxSizeBytes,
+            collation: database.collation,
+            creationDate: database.creationDate,
+            earliestRestoreDate: database.earliestRestoreDate,
+            elasticPoolId: database.elasticPoolId,
+            kind: database.kind,
+          }, null, 2),
+        },
+      ],
+    };
+  }
+
+  private async getSqlPool(server: string, database: string, username: string, password?: string): Promise<sql.ConnectionPool> {
+    const poolKey = `${server}:${database}`;
+    
+    // Return existing pool if available
+    if (this.sqlPools.has(poolKey)) {
+      const pool = this.sqlPools.get(poolKey)!;
+      if (pool.connected) {
+        return pool;
+      }
+    }
+
+const DBusername = "pprappdevusermcp";
+password = "ZuX?c5%+=6!c?}5z)n73"
+
+
+    // Create new connection pool
+    let config: sql.config;
+
+    // Use SQL auth if credentials provided, otherwise use Azure AD
+    if (DBusername && password) {
+      config = {
+        server: server,
+        database: database,
+        user: DBusername,
+        password: password,
+        options: {
+          encrypt: true,
+          trustServerCertificate: false,
+        },
+        pool: {
+          max: 10,
+          min: 0,
+          idleTimeoutMillis: 30000,
+        },
+      };
+    } else {
+      // Use Azure AD authentication with managed identity or DefaultAzureCredential
+      const token = await this.credential.getToken("https://database.windows.net/.default");
+      config = {
+        server: server,
+        database: database,
+        options: {
+          encrypt: true,
+          trustServerCertificate: false,
+        },
+        pool: {
+          max: 10,
+          min: 0,
+          idleTimeoutMillis: 30000,
+        },
+        authentication: {
+          type: 'azure-active-directory-access-token',
+          options: {
+            token: token.token,
+          },
+        } as any,
+      };
+    }
+
+    const pool = await sql.connect(config);
+    this.sqlPools.set(poolKey, pool);
+    
+    return pool;
+  }
+
+  private async logRequest(queryString: string, server: string, username: string) {
+    const homeDir = process.env.USERPROFILE || process.env.HOME || '';
+    const logDir = path.join(homeDir, 'source', 'repos', 'mcp_server');
+    
+    // Create directory if it doesn't exist
+    if (!fs.existsSync(logDir)) {
+      fs.mkdirSync(logDir, { recursive: true });
+    }
+    
+    const logFile = path.join(logDir, 'sql_query_log.txt');
+    const logEntry = `[${new Date().toISOString()}] Server: ${server}\tUsername: ${username}\tQuery:\n ${queryString}\n`;
+    fs.appendFileSync(logFile, logEntry);
+
+  }
+
+  private getMessageEncoding(message: string): Uint8Array {
+    return new TextEncoder().encode(message);
+  }
+
+  private getMessageDecoding(message: Uint8Array): string {
+    return new TextDecoder().decode(message);
+  }
+
+private bytesToBase64(bytes: Uint8Array): string {
+  const binary = String.fromCharCode(...bytes);
+  return btoa(binary);
+}
+private base64ToBytes(base64: string): Uint8Array {
+  const binary = atob(base64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+
+	private async deriveKeyFromPassword(password: string, salt: Uint8Array): Promise<CryptoKey> {
+	  const pwUtf8 = this.getMessageEncoding(password);
+  // Use PBKDF2 for key derivation from a password
+
+//    importKey(format, keyData, algorithm, extractable, keyUsages)
+	  const keyMaterial = await crypto.subtle.importKey(
+		'raw',
+		pwUtf8 as BufferSource,
+		'PBKDF2',
+		false,
+		['deriveKey']
+	  );
+
+	  const derivedKey = await crypto.subtle.deriveKey(
+		{
+		  name: 'PBKDF2',
+		  salt: salt as BufferSource,
+		  iterations: 100000, // High iterations make it more secure
+		  hash: 'SHA-256',
+		},
+		keyMaterial,
+		{ name: 'AES-GCM', length: 256 }, // Use AES-GCM for encryption
+		true, // Key can be extracted if needed
+		['encrypt', 'decrypt']
+	  );
+
+	  return derivedKey;
+	}
+
+  private async encryptData(plaintext: string, key: CryptoKey, iv: BufferSource): Promise<{ ciphertext: string, iv: string }> {
+    const encoded = this.getMessageEncoding(plaintext);
+
+    const ciphertextBuffer = await crypto.subtle.encrypt(
+      { name: 'AES-GCM', iv},
+      key,
+      encoded as BufferSource
+    );
+    const cipherBase64 = this.bytesToBase64(new Uint8Array(ciphertextBuffer));
+    const ivBase64 = this.bytesToBase64(new Uint8Array(iv as ArrayBuffer));
+
+    return {
+      ciphertext: cipherBase64,
+      iv: ivBase64
+    };
+  }
+
+  private async findDataToEncrypt(theData: any[], secretKey: string, salt:Uint8Array, ivIn: BufferSource): Promise<any[]> {
+    const retVal: any[] = [];
+    const algorithm: string = 'SHA-256';
+
+    const server: string = "no server v1";
+    const username: string = "no username";
+
+	  const encryptionKey = await this.deriveKeyFromPassword(secretKey, salt);
+
+    for (const curRow of theData) {
+      const retRow: any = {};
+      
+      for (const [key, value] of Object.entries(curRow)) {
+        let newValue: string = <any>value;
+        
+        if (typeof newValue === 'string' && newValue.startsWith("m$k_")) {
+          this.logRequest(`\t in encrypt -> encrypting ${JSON.stringify(newValue)}`, server, username);
+          var tmpValue: any = newValue.replace("m$k_", "");
+
+          const { ciphertext, iv } = await this.encryptData(tmpValue, encryptionKey, ivIn);
+//          newValue = "m$k_" + ciphertext + "-" + iv + "-" + this.bytesToBase64(salt) + "-" + this.bytesToBase64(ivIn as Uint8Array);
+          newValue = "m$k_" + ciphertext;
+          this.logRequest(`\tin encrypt -> result ${JSON.stringify(newValue)}`, server, username);
+        }
+        
+        retRow[key] = newValue;
+      }
+      
+      retVal.push(retRow);
+    }
+    
+    return retVal;
+  }
+
+  private async executeQuery(args: { server: string; database: string; query: string; username: string; password?: string }) {
+    try {
+      const pool = await this.getSqlPool(args.server, args.database, args.username, args.password);
+      
+      this.logRequest(args.query, args.server, args.username);
+      
+      const result = await pool.request().query(args.query);
+      const resultCount = result.recordset ? result.recordset.length : 0;
+      this.logRequest(`\t-> Query returned ${JSON.stringify(result.recordset)} rows`, args.server, args.username);
+      const secretKey = this.bytesToBase64(crypto.getRandomValues(new Uint8Array(16)));
+      const salt = crypto.getRandomValues(new Uint8Array(16));
+      const ivIn = crypto.getRandomValues(new Uint8Array(16));
+
+      var retval: any = await this.findDataToEncrypt(result.recordset, secretKey, salt, ivIn);
+      const junkBits = new Date().getSeconds().toString(16).padStart(2, 'P');
+      const secretKey_modified = junkBits + secretKey;
+      this.logRequest(`\t-> encryption returned ${JSON.stringify(retval)}`, args.server, args.username);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              rowsAffected: result.rowsAffected,
+              key: secretKey_modified + "-" + this.bytesToBase64(salt) + "-" + this.bytesToBase64(ivIn as Uint8Array),
+              recordset: retval,
+            }, null, 2),
+          },
+        ],
+      };
+    } catch (error: any) {
+      this.logRequest(`\t**** error occurred: ${error.message}`, args.server, args.username);
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Query execution failed: ${error.message}`,
+          },
+        ],
+      };
+    }
+  }
+
+  private getVersion() {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            version: "1.0.4",
+            name: "azure-mcp-server",
+          }, null, 2),
+        },
+      ],
+    };
+  }
+
+  private async executeStoredProcedure(args: { server: string; database: string; procedureName: string; username: string; parameters?: any; password?: string }) {
+    try {
+      const pool = await this.getSqlPool(args.server, args.database, args.username, args.password);
+      const request = pool.request();
+
+      // Add parameters if provided
+      if (args.parameters) {
+        for (const [key, value] of Object.entries(args.parameters)) {
+          request.input(key, value);
+        }
+      }
+
+      const result = await request.execute(args.procedureName);
+
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              rowsAffected: result.rowsAffected,
+              recordset: result.recordset,
+              recordsets: result.recordsets,
+              returnValue: result.returnValue,
+            }, null, 2),
+          },
+        ],
+      };
+    } catch (error: any) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Stored procedure execution failed: ${error.message}`,
+          },
+        ],
+      };
+    }
+  }
+
+  async run() {
+    const transport = new StdioServerTransport();
+    await this.server.connect(transport);
+    console.error("Azure MCP Server running on stdio");
+  }
+}
+
+// Start the server
+const server = new AzureMCPServer();
+server.run().catch(console.error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudeunmask",
-  "version": "1.0.22",
+  "version": "1.0.23",
   "description": "claude unmask test",
   "main": "index.js",
   "scripts": {