claudeunmask 1.0.28 → 1.0.29

package/index.js

@@ -1,4 +1,4 @@
-/* v 1.0.28 */
+/* v 1.0.29 */
 	function getMessageEncoding(message) {
 		return new TextEncoder().encode(message);
 	}
@@ -56,33 +56,27 @@
 			);
 			return getMessageDecoding(new Uint8Array(plaintextBuffer));
 		} catch (error) {
-console.log ("failed", key, bytesToBase64(ciphertext), error);
 			throw Error ("Failed to decrypt");
 		}
 		return "";
 	}
 	async function decrypt(inData, decryptionKey) {
 		var dailyKey = await window.prompt("Enter the daily key","crazy_string");
-console.log ("decrypt: daily key", dailyKey);
 		var retVal = [];
 		var enc = new TextEncoder();
 		var [tmpPassword, salt, theIV] = decryptionKey.split("-");
-console.log ("from MCP", decryptionKey, tmpPassword, salt, theIV);
 		const dailyKeyBinary = await deriveKeyFromPassword(dailyKey, base64ToBytes(salt));
 		try {
 			tmpPassword = await decryptThisData (base64ToBytes(tmpPassword), dailyKeyBinary, base64ToBytes(theIV));
 		} catch (error) {
-console.log ("failed to decrypt the key");
 			throw Error ("Failed to decrypt the key");
 		}
-console.log ("secret:", tmpPassword);
 		const password = tmpPassword;
 		for (const curRec of inData) {
 			var tmpRec = {};
 			for (const [key, value] of Object.entries(curRec)) {
 				try {
 					if (typeof value === "string" && value.includes("m$k_")) {
-console.log ("masked", value, curRec[key]);
 						var theData = base64ToBytes(curRec[key].replace ("m$k_", ""));
 						const encryptionKey = await deriveKeyFromPassword(password, base64ToBytes(salt));
 						tmpRec[key] = await decryptThisData (theData, encryptionKey, base64ToBytes(theIV));
@@ -90,7 +84,6 @@ console.log ("masked", value, curRec[key]);
 						tmpRec[key] = value;
 					}
 				} catch (error) {
-console.log ("error", error);
 					tmpRec[key] = "failed";
 				}
 			}
@@ -99,17 +92,14 @@ console.log ("error", error);
 		return retVal;
 	}
 	async function unmaskData (inData, decryptionKey, dailyKey) {
-console.log ("unmask: daily key", dailyKey);
 		var retVal = {};
 		retVal.data = [];
 		retVal.errorCount = 0;
 		retVal.unmaskCount = 0;
 		var enc = new TextEncoder();
 		var [tmpPassword, salt, theIV] = decryptionKey.split("-");
-console.log ("from MCP", decryptionKey, tmpPassword, salt, theIV);
 		var haveError = 0;
 		for (var ii= 0; ii<=2; ii++) {		// try to decrypt the daily key and the add = until it works or we've added 2
-console.log ("testing daily key: ", dailyKey);
 			const dailyKeyBinary = await deriveKeyFromPassword(dailyKey, base64ToBytes(salt));
 			try {
 				tmpPassword = await decryptThisData (base64ToBytes(tmpPassword), dailyKeyBinary, base64ToBytes(theIV));
@@ -124,7 +114,6 @@ console.log ("testing daily key: ", dailyKey);
 		if (haveError) {
 			throw Error ("Failed to decrypt the key");
 		}
-console.log ("secret:", tmpPassword);
 		const password = tmpPassword;
 		const encryptionKey = await deriveKeyFromPassword(password, base64ToBytes(salt));
 		for (const curRec of inData) {
@@ -132,7 +121,6 @@ console.log ("secret:", tmpPassword);
 			for (const [key, value] of Object.entries(curRec)) {
 				try {
 					if (typeof value === "string" && value.includes("m$k_")) {
-console.log ("masked", value, curRec[key]);
 						retVal.unmaskCount++;
 						var theData = base64ToBytes(curRec[key].replace ("m$k_", ""));
 						tmpRec[key] = await decryptThisData (theData, encryptionKey, base64ToBytes(theIV));
@@ -140,7 +128,6 @@ console.log ("masked", value, curRec[key]);
 						tmpRec[key] = value;
 					}
 				} catch (error) {
-console.log ("error", error);
 					tmpRec[key] = "failed";
 					retVal.errorCount++;
 				}
@@ -149,8 +136,7 @@ console.log ("error", error);
 		}
 		
 		if (retVal.errorCount) {
-console.log ("an error happened", (100 * retVal.errorCount / retVal.unmaskCount));
-			
+			console.log ("an error happened", (100 * retVal.errorCount / retVal.unmaskCount));
 		}
 		return retVal;
 	}

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),a=new Uint8Array(t.length);for(let r=0;r<t.length;r++)a[r]=t.charCodeAt(r);return a}function bytesToBase64(e){let t=String.fromCharCode(...e);return btoa(t)}async function deriveKeyFromPassword(e,t){let a=getMessageEncoding(e),r=await crypto.subtle.importKey("raw",a,"PBKDF2",!1,["deriveKey"]),o=await crypto.subtle.deriveKey({name:"PBKDF2",salt:t,iterations:1e5,hash:"SHA-256"},r,{name:"AES-GCM",length:256},!0,["encrypt","decrypt"]);return o}async function decryptThisData(e,t,a){try{let r=await crypto.subtle.decrypt({name:"AES-GCM",iv:a},t,e);return getMessageDecoding(new Uint8Array(r))}catch(o){throw console.log("failed",t,bytesToBase64(e),o),Error("Failed to decrypt")}return""}async function decrypt(e,t){var a=await window.prompt("Enter the daily key","crazy_string");console.log("decrypt: daily key",a);var r=[];new TextEncoder;var[o,s,n]=t.split("-");console.log("from MCP",t,o,s,n);let i=await deriveKeyFromPassword(a,base64ToBytes(s));try{o=await decryptThisData(base64ToBytes(o),i,base64ToBytes(n))}catch(y){throw console.log("failed to decrypt the key"),Error("Failed to decrypt the key")}console.log("secret:",o);let l=o;for(let d of e){var c={};for(let[u,g]of Object.entries(d))try{if("string"==typeof g&&g.includes("m$k_")){console.log("masked",g,d[u]);var f=base64ToBytes(d[u].replace("m$k_",""));let h=await deriveKeyFromPassword(l,base64ToBytes(s));c[u]=await decryptThisData(f,h,base64ToBytes(n))}else c[u]=g}catch(p){console.log("error",p),c[u]="failed"}r.push(c)}return r}async function unmaskData(e,t,a){console.log("unmask: daily key",a);var r={};r.data=[],r.errorCount=0,r.unmaskCount=0,new TextEncoder;var[o,s,n]=t.split("-");console.log("from MCP",t,o,s,n);let i=await deriveKeyFromPassword(a,base64ToBytes(s));try{o=await decryptThisData(base64ToBytes(o),i,base64ToBytes(n))}catch(y){throw console.log("failed to decrypt the key"),Error("Failed to decrypt the key")}console.log("secret:",o);let l=o,d=await deriveKeyFromPassword(l,base64ToBytes(s));for(let c of e){var u={};for(let[g,f]of Object.entries(c))try{if("string"==typeof f&&f.includes("m$k_")){console.log("masked",f,c[g]),r.unmaskCount++;var h=base64ToBytes(c[g].replace("m$k_",""));u[g]=await decryptThisData(h,d,base64ToBytes(n))}else u[g]=f}catch(p){console.log("error",p),u[g]="failed",r.errorCount++}r.data.push(u)}return r.errorCount&&console.log("an error happened",100*r.errorCount/r.unmaskCount),r}
+function getMessageEncoding(e){return new TextEncoder().encode(e)}function getMessageDecoding(e){return new TextDecoder().decode(e)}function base64ToBytes(e){let t=atob(e),a=new Uint8Array(t.length);for(let r=0;r<t.length;r++)a[r]=t.charCodeAt(r);return a}function bytesToBase64(e){let t=String.fromCharCode(...e);return btoa(t)}async function deriveKeyFromPassword(e,t){let a=getMessageEncoding(e),r=await crypto.subtle.importKey("raw",a,"PBKDF2",!1,["deriveKey"]),s=await crypto.subtle.deriveKey({name:"PBKDF2",salt:t,iterations:1e5,hash:"SHA-256"},r,{name:"AES-GCM",length:256},!0,["encrypt","decrypt"]);return s}async function decryptThisData(e,t,a){try{let r=await crypto.subtle.decrypt({name:"AES-GCM",iv:a},t,e);return getMessageDecoding(new Uint8Array(r))}catch(s){throw Error("Failed to decrypt")}return""}async function decrypt(e,t){var a=await window.prompt("Enter the daily key","crazy_string"),r=[];new TextEncoder;var[s,o,n]=t.split("-");let i=await deriveKeyFromPassword(a,base64ToBytes(o));try{s=await decryptThisData(base64ToBytes(s),i,base64ToBytes(n))}catch(y){throw Error("Failed to decrypt the key")}let c=s;for(let d of e){var l={};for(let[u,w]of Object.entries(d))try{if("string"==typeof w&&w.includes("m$k_")){var f=base64ToBytes(d[u].replace("m$k_",""));let h=await deriveKeyFromPassword(c,base64ToBytes(o));l[u]=await decryptThisData(f,h,base64ToBytes(n))}else l[u]=w}catch(p){l[u]="failed"}r.push(l)}return r}async function unmaskData(e,t,a){var r={};r.data=[],r.errorCount=0,r.unmaskCount=0,new TextEncoder;for(var[s,o,n]=t.split("-"),i=0,y=0;y<=2;y++){let c=await deriveKeyFromPassword(a,base64ToBytes(o));try{s=await decryptThisData(base64ToBytes(s),c,base64ToBytes(n)),i=0;break}catch(d){i=1,a+="="}}if(i)throw Error("Failed to decrypt the key");let l=s,u=await deriveKeyFromPassword(l,base64ToBytes(o));for(let w of e){var f={};for(let[h,p]of Object.entries(w))try{if("string"==typeof p&&p.includes("m$k_")){r.unmaskCount++;var g=base64ToBytes(w[h].replace("m$k_",""));f[h]=await decryptThisData(g,u,base64ToBytes(n))}else f[h]=p}catch(m){f[h]="failed",r.errorCount++}r.data.push(f)}return r.errorCount&&console.log("an error happened",100*r.errorCount/r.unmaskCount),r}

package/package.json

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

package/index - Copy.js

@@ -1,19 +0,0 @@
-
-	function unmask (theData) {
-		var retVal = [];
-		for (curRow of theData) {
-			var retRow = {};
-			for (const [key, value] of Object.entries(curRow)) {
-				let newValue = value;
-				
-				if (newValue.startsWith ("m$k_")) {
-					newValue = newValue.replace ("m$k_","");
-					newValue = newValue.split('').reverse().join('');
-				}
-				retRow[key] = newValue;
-			}
-			retVal.push (retRow);
-		}
-console.log ("hello from unmask", retVal);
-		return retVal;
-	}

package/junk.js

@@ -1,676 +0,0 @@
-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);