@ebowwa/mcp-nm 2.0.2 → 2.0.3

package/dist/index.js

@@ -13643,7 +13643,7 @@ import { promisify } from "util";
 var execAsync = promisify(exec);
 var server = new Server({
   name: "@ebowwa/mcp-nm",
-  version: "2.0.0"
+  version: "2.0.3"
 }, {
   capabilities: {
     tools: {}
@@ -14977,6 +14977,517 @@ async function handleHexEditor(args) {
     throw new Error(`Hex editor failed: ${error2 instanceof Error ? error2.message : error2}`);
   }
 }
+function isMacOS() {
+  return process.platform === "darwin";
+}
+async function handleCodesignInfo(args) {
+  if (!isMacOS()) {
+    return {
+      content: [{
+        type: "text",
+        text: "Error: Code signing tools are only available on macOS. This tool requires the 'codesign' utility."
+      }],
+      isError: true
+    };
+  }
+  try {
+    const results = [];
+    results.push(`Code Signature Info: ${args.filePath}`);
+    results.push("");
+    const { stdout: fileInfo } = await execAsync(`file "${args.filePath}"`);
+    if (!fileInfo.toLowerCase().includes("mach-o")) {
+      results.push("Warning: File does not appear to be a Mach-O binary");
+      results.push(`File type: ${fileInfo.trim()}`);
+    }
+    try {
+      const { stdout: signInfo } = await execAsync(`codesign -dv "${args.filePath}" 2>&1`);
+      results.push("Signature Details:");
+      results.push(signInfo.split(`
+`).map((line) => `  ${line}`).join(`
+`));
+    } catch (e) {
+      const output = e instanceof Error ? e.message : String(e);
+      if (output.includes("no signature") || output.includes("code object is not signed")) {
+        results.push("Status: NOT SIGNED");
+        results.push("  The binary has no code signature");
+      } else {
+        results.push(`Signature check: ${output}`);
+      }
+    }
+    try {
+      await execAsync(`codesign -v "${args.filePath}" 2>&1`);
+      results.push("");
+      results.push("Validity: VALID - Signature is intact");
+    } catch (e) {
+      const output = e instanceof Error ? e.message : String(e);
+      if (output.includes("not signed")) {
+        results.push("");
+        results.push("Validity: NOT SIGNED");
+      } else {
+        results.push("");
+        results.push(`Validity: INVALID - ${output}`);
+      }
+    }
+    try {
+      const { stdout: reqs } = await execAsync(`codesign -dr - "${args.filePath}" 2>&1`);
+      if (reqs.trim() && !reqs.includes("no signature")) {
+        results.push("");
+        results.push("Designated Requirements:");
+        results.push(reqs.split(`
+`).map((line) => `  ${line}`).join(`
+`));
+      }
+    } catch {}
+    return { content: [{ type: "text", text: results.join(`
+`) }] };
+  } catch (error2) {
+    return {
+      content: [{ type: "text", text: `Error: ${error2 instanceof Error ? error2.message : String(error2)}` }],
+      isError: true
+    };
+  }
+}
+async function handleCodesignRemove(args) {
+  if (!isMacOS()) {
+    return {
+      content: [{
+        type: "text",
+        text: "Error: Code signing tools are only available on macOS."
+      }],
+      isError: true
+    };
+  }
+  const createBackup = args.createBackup !== false;
+  try {
+    const results = [];
+    results.push(`Remove Code Signature: ${args.filePath}`);
+    results.push("");
+    if (createBackup) {
+      const backupPath = `${args.filePath}.bak`;
+      await execAsync(`cp "${args.filePath}" "${backupPath}"`);
+      results.push(`Backup created: ${backupPath}`);
+    }
+    try {
+      const { stdout: signInfo } = await execAsync(`codesign -dv "${args.filePath}" 2>&1`);
+      results.push(`Previous signature: ${signInfo.split(`
+`)[0] || "signed"}`);
+    } catch {
+      results.push("Previous signature: not signed or invalid");
+    }
+    try {
+      await execAsync(`codesign --remove-signature "${args.filePath}"`);
+      results.push("Status: SUCCESS - Code signature removed");
+    } catch (e) {
+      const output = e instanceof Error ? e.message : String(e);
+      if (output.includes("no signature")) {
+        results.push("Status: NO ACTION - Binary was not signed");
+      } else {
+        throw new Error(`Failed to remove signature: ${output}`);
+      }
+    }
+    try {
+      await execAsync(`codesign -v "${args.filePath}" 2>&1`);
+      results.push("Warning: Signature still present after removal");
+    } catch (e) {
+      if (e instanceof Error && e.message.includes("not signed")) {
+        results.push("Verification: Confirmed - Binary is now unsigned");
+      }
+    }
+    return { content: [{ type: "text", text: results.join(`
+`) }] };
+  } catch (error2) {
+    return {
+      content: [{ type: "text", text: `Error: ${error2 instanceof Error ? error2.message : String(error2)}` }],
+      isError: true
+    };
+  }
+}
+async function handleCodesignSign(args) {
+  if (!isMacOS()) {
+    return {
+      content: [{
+        type: "text",
+        text: "Error: Code signing tools are only available on macOS."
+      }],
+      isError: true
+    };
+  }
+  const force = args.force !== false;
+  const createBackup = args.createBackup === true;
+  const deep = args.deep === true;
+  const certificate = args.certificate || "-";
+  try {
+    const results = [];
+    results.push(`Sign Binary: ${args.filePath}`);
+    results.push("");
+    if (createBackup) {
+      const backupPath = `${args.filePath}.bak`;
+      await execAsync(`cp "${args.filePath}" "${backupPath}"`);
+      results.push(`Backup created: ${backupPath}`);
+    }
+    const forceFlag = force ? "--force" : "";
+    const deepFlag = deep ? "--deep" : "";
+    const optionsFlag = args.options ? `--options ${args.options}` : "";
+    const cmd = `codesign -s ${certificate} ${forceFlag} ${deepFlag} ${optionsFlag} "${args.filePath}"`.replace(/\s+/g, " ").trim();
+    results.push(`Command: ${cmd}`);
+    results.push(`Signing with: ${certificate === "-" ? "ad-hoc signature" : certificate}`);
+    await execAsync(cmd);
+    results.push("Status: SUCCESS - Binary signed");
+    try {
+      await execAsync(`codesign -v "${args.filePath}" 2>&1`);
+      results.push("Verification: VALID - Signature is intact");
+    } catch (e) {
+      results.push(`Verification: WARNING - ${e instanceof Error ? e.message : String(e)}`);
+    }
+    try {
+      const { stdout: signInfo } = await execAsync(`codesign -dv "${args.filePath}" 2>&1`);
+      const infoLine = signInfo.split(`
+`).find((l) => l.includes("Identifier") || l.includes("Authority"));
+      if (infoLine) {
+        results.push(`New signature: ${infoLine.trim()}`);
+      }
+    } catch {}
+    return { content: [{ type: "text", text: results.join(`
+`) }] };
+  } catch (error2) {
+    return {
+      content: [{ type: "text", text: `Error: ${error2 instanceof Error ? error2.message : String(error2)}` }],
+      isError: true
+    };
+  }
+}
+async function handleQuarantineCheck(args) {
+  if (!isMacOS()) {
+    return {
+      content: [{
+        type: "text",
+        text: "Error: Quarantine tools are only available on macOS."
+      }],
+      isError: true
+    };
+  }
+  try {
+    const results = [];
+    results.push(`Quarantine Check: ${args.filePath}`);
+    results.push("");
+    try {
+      const { stdout: quarantine } = await execAsync(`xattr -p com.apple.quarantine "${args.filePath}" 2>&1`);
+      if (quarantine.trim()) {
+        results.push("Status: QUARANTINED");
+        results.push("");
+        results.push("Quarantine data:");
+        results.push(`  ${quarantine.trim()}`);
+        try {
+          const { stdout: details } = await execAsync(`xattr -l "${args.filePath}" 2>&1`);
+          const quarantineSection = details.split(`
+`).filter((l) => l.includes("quarantine") || l.includes("provenance"));
+          if (quarantineSection.length > 0) {
+            results.push("");
+            results.push("Extended attributes:");
+            quarantineSection.forEach((l) => results.push(`  ${l}`));
+          }
+        } catch {}
+        results.push("");
+        results.push("Note: Quarantine prevents execution of downloaded files.");
+        results.push("Use bin_quarantine_remove to allow execution.");
+      } else {
+        results.push("Status: NOT QUARANTINED");
+        results.push("The file has no quarantine attribute.");
+      }
+    } catch (e) {
+      const output = e instanceof Error ? e.message : String(e);
+      if (output.includes("No such xattr") || output.includes("not found")) {
+        results.push("Status: NOT QUARANTINED");
+        results.push("The file has no quarantine attribute.");
+      } else {
+        throw new Error(`Failed to check quarantine: ${output}`);
+      }
+    }
+    try {
+      const { stdout: provenance } = await execAsync(`xattr -p com.apple.provenance "${args.filePath}" 2>&1`);
+      if (provenance.trim()) {
+        results.push("");
+        results.push("Provenance: PRESENT");
+        results.push("  File has provenance metadata (tracks download source)");
+      }
+    } catch {}
+    return { content: [{ type: "text", text: results.join(`
+`) }] };
+  } catch (error2) {
+    return {
+      content: [{ type: "text", text: `Error: ${error2 instanceof Error ? error2.message : String(error2)}` }],
+      isError: true
+    };
+  }
+}
+async function handleQuarantineRemove(args) {
+  if (!isMacOS()) {
+    return {
+      content: [{
+        type: "text",
+        text: "Error: Quarantine tools are only available on macOS."
+      }],
+      isError: true
+    };
+  }
+  try {
+    const results = [];
+    results.push(`Remove Quarantine: ${args.filePath}`);
+    results.push("");
+    let removedAny = false;
+    try {
+      await execAsync(`xattr -d com.apple.quarantine "${args.filePath}" 2>&1`);
+      results.push("Removed: com.apple.quarantine");
+      removedAny = true;
+    } catch (e) {
+      const output = e instanceof Error ? e.message : String(e);
+      if (output.includes("No such xattr") || output.includes("not found")) {
+        results.push("Skipped: com.apple.quarantine (not present)");
+      } else {
+        results.push(`Warning: Could not remove quarantine - ${output}`);
+      }
+    }
+    try {
+      await execAsync(`xattr -d com.apple.provenance "${args.filePath}" 2>&1`);
+      results.push("Removed: com.apple.provenance");
+      removedAny = true;
+    } catch {}
+    try {
+      await execAsync(`xattr -d com.apple.metadata:kMDItemWhereFroms "${args.filePath}" 2>&1`);
+      results.push("Removed: com.apple.metadata:kMDItemWhereFroms");
+      removedAny = true;
+    } catch {}
+    if (removedAny) {
+      results.push("");
+      results.push("Status: SUCCESS - Quarantine attributes removed");
+      results.push("The file should now be able to execute without quarantine warnings.");
+    } else {
+      results.push("");
+      results.push("Status: NO ACTION - No quarantine attributes found");
+    }
+    return { content: [{ type: "text", text: results.join(`
+`) }] };
+  } catch (error2) {
+    return {
+      content: [{ type: "text", text: `Error: ${error2 instanceof Error ? error2.message : String(error2)}` }],
+      isError: true
+    };
+  }
+}
+async function handleSafePatch(args) {
+  if (!isMacOS()) {
+    return {
+      content: [{
+        type: "text",
+        text: "Error: Safe patching tools are only available on macOS."
+      }],
+      isError: true
+    };
+  }
+  const createBackup = args.createBackup !== false;
+  try {
+    const results = [];
+    results.push(`Safe Patch Workflow: ${args.filePath}`);
+    results.push(`  Offset: 0x${args.offset.toString(16)} (${args.offset})`);
+    results.push(`  Data: ${args.hexData}`);
+    results.push("");
+    if (createBackup) {
+      const backupPath = `${args.filePath}.bak`;
+      await execAsync(`cp "${args.filePath}" "${backupPath}"`);
+      results.push(`[1/4] Backup created: ${backupPath}`);
+    } else {
+      results.push("[1/4] Backup: SKIPPED (createBackup=false)");
+    }
+    results.push("[2/4] Applying binary patch...");
+    const hexBytes = args.hexData.replace(/\s+/g, "");
+    const byteCount = hexBytes.length / 2;
+    const patchCmd = `printf '${hexBytes}' | dd of="${args.filePath}" bs=1 seek=${args.offset} count=${byteCount} conv=notrunc 2>/dev/null`;
+    await execAsync(patchCmd);
+    results.push(`      Patched ${byteCount} bytes at offset 0x${args.offset.toString(16)}`);
+    results.push("[3/4] Removing old code signature...");
+    try {
+      await execAsync(`codesign --remove-signature "${args.filePath}" 2>&1`);
+      results.push("      Old signature removed");
+    } catch (e) {
+      if (e instanceof Error && e.message.includes("no signature")) {
+        results.push("      No previous signature to remove");
+      } else {
+        results.push(`      Warning: ${e instanceof Error ? e.message : String(e)}`);
+      }
+    }
+    results.push("[4/4] Applying ad-hoc signature...");
+    await execAsync(`codesign --force --sign - "${args.filePath}"`);
+    results.push("      Ad-hoc signature applied");
+    results.push("[5/5] Removing quarantine attributes...");
+    try {
+      await execAsync(`xattr -d com.apple.quarantine "${args.filePath}" 2>&1`);
+      results.push("      Quarantine attribute removed");
+    } catch {
+      results.push("      No quarantine attribute present");
+    }
+    try {
+      await execAsync(`xattr -d com.apple.provenance "${args.filePath}" 2>&1`);
+      results.push("      Provenance attribute removed");
+    } catch {}
+    results.push("");
+    results.push("Verification:");
+    try {
+      await execAsync(`codesign -v "${args.filePath}" 2>&1`);
+      results.push("  Code signature: VALID");
+    } catch (e) {
+      results.push(`  Code signature: WARNING - ${e instanceof Error ? e.message : String(e)}`);
+    }
+    try {
+      const { stdout: fileInfo } = await execAsync(`file "${args.filePath}"`);
+      if (fileInfo.includes("executable")) {
+        results.push("  File type: Executable");
+      }
+    } catch {}
+    results.push("");
+    results.push("Status: SUCCESS - Binary patched and ready to run");
+    results.push("Note: The binary is now signed with an ad-hoc signature.");
+    results.push("      Some apps may require proper code signing for full functionality.");
+    return { content: [{ type: "text", text: results.join(`
+`) }] };
+  } catch (error2) {
+    return {
+      content: [{ type: "text", text: `Error: ${error2 instanceof Error ? error2.message : String(error2)}` }],
+      isError: true
+    };
+  }
+}
+async function handleBinVerify(args) {
+  if (!isMacOS()) {
+    return {
+      content: [{
+        type: "text",
+        text: "Error: Binary verification tools are only available on macOS."
+      }],
+      isError: true
+    };
+  }
+  try {
+    const results = [];
+    const issues = [];
+    results.push(`Binary Verification: ${args.filePath}`);
+    results.push("");
+    let isMachO = false;
+    try {
+      const { stdout: fileInfo } = await execAsync(`file "${args.filePath}"`);
+      results.push(`File type: ${fileInfo.trim()}`);
+      isMachO = fileInfo.toLowerCase().includes("mach-o");
+    } catch (e) {
+      return {
+        content: [{ type: "text", text: `Error: Cannot read file - ${e instanceof Error ? e.message : String(e)}` }],
+        isError: true
+      };
+    }
+    try {
+      const { stdout: perms } = await execAsync(`ls -la "${args.filePath}"`);
+      const permLine = perms.split(`
+`).find((l) => l.includes(args.filePath.split("/").pop() || ""));
+      if (permLine) {
+        results.push(`Permissions: ${permLine.split(/\s+/)[0]}`);
+        if (!permLine.includes("x")) {
+          issues.push("File is not executable (no execute permission)");
+        }
+      }
+    } catch {
+      results.push("Permissions: Unable to check");
+    }
+    results.push("");
+    if (isMachO) {
+      results.push("Code Signature:");
+      try {
+        const { stdout: signInfo } = await execAsync(`codesign -dv "${args.filePath}" 2>&1`);
+        const authority = signInfo.split(`
+`).find((l) => l.includes("Authority"));
+        if (authority) {
+          results.push(`  Status: SIGNED (${authority.split(":")[1]?.trim() || "unknown authority"})`);
+        } else {
+          results.push("  Status: SIGNED (ad-hoc or unknown)");
+        }
+      } catch (e) {
+        const output = e instanceof Error ? e.message : String(e);
+        if (output.includes("not signed")) {
+          results.push("  Status: UNSIGNED");
+          issues.push("Binary is not code signed");
+        } else {
+          results.push(`  Status: INVALID - ${output}`);
+          issues.push("Code signature is invalid");
+        }
+      }
+      try {
+        await execAsync(`codesign -v "${args.filePath}" 2>&1`);
+        results.push("  Validity: VALID");
+      } catch (e) {
+        const output = e instanceof Error ? e.message : String(e);
+        if (!output.includes("not signed")) {
+          results.push(`  Validity: INVALID - ${output}`);
+          issues.push("Code signature verification failed");
+        }
+      }
+    }
+    results.push("");
+    results.push("Quarantine:");
+    try {
+      const { stdout: quar } = await execAsync(`xattr -p com.apple.quarantine "${args.filePath}" 2>&1`);
+      if (quar.trim()) {
+        results.push("  Status: QUARANTINED");
+        issues.push("File is quarantined and may be blocked from running");
+      } else {
+        results.push("  Status: NOT QUARANTINED");
+      }
+    } catch {
+      results.push("  Status: NOT QUARANTINED");
+    }
+    if (isMachO) {
+      results.push("");
+      results.push("Architecture:");
+      try {
+        const { stdout: arch } = await execAsync(`lipo -info "${args.filePath}" 2>&1`);
+        results.push(`  ${arch.trim()}`);
+        try {
+          const { stdout: currentArch } = await execAsync(`uname -m`);
+          if (!arch.includes(currentArch.trim()) && !arch.includes("universal")) {
+            issues.push(`Binary may not be compatible with current architecture (${currentArch.trim()})`);
+          }
+        } catch {}
+      } catch (e) {
+        results.push(`  Unable to determine: ${e instanceof Error ? e.message : String(e)}`);
+      }
+    }
+    results.push("");
+    results.push("=== SUMMARY ===");
+    if (issues.length === 0) {
+      results.push("Status: READY TO RUN");
+      results.push("The binary should execute without issues.");
+    } else {
+      results.push("Status: ISSUES DETECTED");
+      results.push("");
+      results.push("Issues:");
+      issues.forEach((issue2, i) => results.push(`  ${i + 1}. ${issue2}`));
+      results.push("");
+      results.push("Suggested fixes:");
+      if (issues.some((i) => i.includes("quarantined"))) {
+        results.push("  - Run: xattr -d com.apple.quarantine <file>");
+      }
+      if (issues.some((i) => i.includes("not code signed") || i.includes("signature"))) {
+        results.push("  - Run: codesign --force --sign - <file>");
+      }
+      if (issues.some((i) => i.includes("not executable"))) {
+        results.push("  - Run: chmod +x <file>");
+      }
+    }
+    return { content: [{ type: "text", text: results.join(`
+`) }] };
+  } catch (error2) {
+    return {
+      content: [{ type: "text", text: `Error: ${error2 instanceof Error ? error2.message : String(error2)}` }],
+      isError: true
+    };
+  }
+}
 var TOOLS = [
   {
     name: "nm_list_symbols",
@@ -15439,6 +15950,92 @@ var TOOLS = [
       },
       required: ["filePath", "offset", "length"]
     }
+  },
+  {
+    name: "bin_codesign_info",
+    description: "Show code signature details for a macOS binary (macOS only)",
+    inputSchema: {
+      type: "object",
+      properties: {
+        filePath: { type: "string", description: "Path to the binary file" }
+      },
+      required: ["filePath"]
+    }
+  },
+  {
+    name: "bin_codesign_remove",
+    description: "Remove code signature from a macOS binary (DESTRUCTIVE - macOS only)",
+    inputSchema: {
+      type: "object",
+      properties: {
+        filePath: { type: "string", description: "Path to the binary file" },
+        createBackup: { type: "boolean", description: "Create .bak backup (default: true)" }
+      },
+      required: ["filePath"]
+    }
+  },
+  {
+    name: "bin_codesign_sign",
+    description: "Apply ad-hoc or certificate signature to a macOS binary (macOS only)",
+    inputSchema: {
+      type: "object",
+      properties: {
+        filePath: { type: "string", description: "Path to the binary file" },
+        certificate: { type: "string", description: "Certificate identity (default: '-' for ad-hoc signature)" },
+        force: { type: "boolean", description: "Force replace existing signature (default: true)" },
+        createBackup: { type: "boolean", description: "Create .bak backup before signing" },
+        deep: { type: "boolean", description: "Sign all nested code" },
+        options: { type: "string", description: "Additional signing options (e.g., 'runtime' for hardened runtime)" }
+      },
+      required: ["filePath"]
+    }
+  },
+  {
+    name: "bin_quarantine_check",
+    description: "Check quarantine status of a file on macOS (macOS only)",
+    inputSchema: {
+      type: "object",
+      properties: {
+        filePath: { type: "string", description: "Path to the file" }
+      },
+      required: ["filePath"]
+    }
+  },
+  {
+    name: "bin_quarantine_remove",
+    description: "Remove quarantine attributes from a file on macOS (DESTRUCTIVE - macOS only)",
+    inputSchema: {
+      type: "object",
+      properties: {
+        filePath: { type: "string", description: "Path to the file" }
+      },
+      required: ["filePath"]
+    }
+  },
+  {
+    name: "bin_safe_patch",
+    description: "Safe binary patching workflow for macOS: patch, remove signature, re-sign, remove quarantine (DESTRUCTIVE - macOS only)",
+    inputSchema: {
+      type: "object",
+      properties: {
+        filePath: { type: "string", description: "Path to the binary file" },
+        offset: { type: "number", description: "Byte offset to patch" },
+        hexData: { type: "string", description: "Hex bytes to write (e.g., '90 90 90')" },
+        createBackup: { type: "boolean", description: "Create .bak backup (default: true)" }
+      },
+      required: ["filePath", "offset", "hexData"]
+    }
+  },
+  {
+    name: "bin_verify",
+    description: "Verify if a macOS binary will run: check signature, quarantine, architecture (macOS only)",
+    inputSchema: {
+      type: "object",
+      properties: {
+        filePath: { type: "string", description: "Path to the binary file" }
+      },
+      required: ["filePath"]
+    }
   }
 ];
 server.setRequestHandler(ListToolsRequestSchema, async () => {
@@ -15516,6 +16113,20 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         return await handleHexEditor(args);
       case "bin_convert":
         return await handleConvertNumber(args);
+      case "bin_codesign_info":
+        return await handleCodesignInfo(args);
+      case "bin_codesign_remove":
+        return await handleCodesignRemove(args);
+      case "bin_codesign_sign":
+        return await handleCodesignSign(args);
+      case "bin_quarantine_check":
+        return await handleQuarantineCheck(args);
+      case "bin_quarantine_remove":
+        return await handleQuarantineRemove(args);
+      case "bin_safe_patch":
+        return await handleSafePatch(args);
+      case "bin_verify":
+        return await handleBinVerify(args);
       default:
         throw new Error(`Unknown tool: ${name}`);
     }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ebowwa/mcp-nm",
-  "version": "2.0.2",
-  "description": "Comprehensive binary analysis MCP server - symbols (nm), hex dumps (xxd), strings, disassembly, security audit, entropy analysis, ELF/Mach-O inspection, and binary patching",
+  "version": "2.0.3",
+  "description": "Comprehensive binary analysis MCP server - symbols (nm), hex dumps (xxd), strings, disassembly, security audit, entropy analysis, ELF/Mach-O inspection, binary patching, and macOS code signing tools",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -33,7 +33,10 @@
     "binary-patching",
     "objdump",
     "readelf",
-    "otool"
+    "otool",
+    "codesign",
+    "quarantine",
+    "macos"
   ],
   "author": "ebowwa",
   "license": "MIT",