@ebowwa/mcp-nm 2.1.0 → 2.2.0

package/src/handlers/patch.ts

@@ -0,0 +1,535 @@
+/**
+ * @ebowwa/mcp-nm - Binary patching handlers
+ *
+ * MCP tool handlers for binary patching operations
+ */
+
+import { execAsync, isMacOS } from "../utils/exec";
+import { hexToBytes } from "../utils/xxd";
+import { runXxd } from "../utils/xxd";
+import { convertNumber } from "../utils/convert";
+import type { McpResponse } from "../types";
+
+/**
+ * Patch bytes at offset
+ */
+export async function handlePatchBytes(args: {
+  filePath: string;
+  offset: number;
+  hexData: string;
+  createBackup?: boolean;
+}): Promise<McpResponse> {
+  const createBackup = args.createBackup !== false;
+
+  try {
+    const results: string[] = [];
+    results.push(`Patch Bytes: ${args.filePath}`);
+    results.push(`  Offset: 0x${args.offset.toString(16)} (${args.offset})`);
+    results.push(`  Data: ${args.hexData}`);
+    results.push("");
+
+    // Create backup if requested
+    if (createBackup) {
+      const backupPath = `${args.filePath}.bak`;
+      await execAsync(`cp "${args.filePath}" "${backupPath}"`);
+      results.push(`Backup created: ${backupPath}`);
+    }
+
+    // Read original bytes for verification
+    const { stdout: originalHex } = await execAsync(
+      `xxd -s ${args.offset} -l ${args.hexData.replace(/\s/g, "").length / 2} -p "${args.filePath}" | tr -d '\\n'`
+    );
+    results.push(`Original bytes: ${originalHex.trim()}`);
+
+    // Apply the patch using printf and dd
+    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`);
+
+    // Verify the patch
+    const { stdout: newHex } = await execAsync(
+      `xxd -s ${args.offset} -l ${byteCount} -p "${args.filePath}" | tr -d '\\n'`
+    );
+    results.push(`New bytes: ${newHex.trim()}`);
+
+    if (newHex.trim().toLowerCase() === hexBytes.toLowerCase()) {
+      results.push("Verification: SUCCESS");
+    } else {
+      results.push("Verification: WARNING - Bytes don't match expected value");
+    }
+
+    return { content: [{ type: "text", text: results.join("\n") }] };
+  } catch (error) {
+    return {
+      content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
+      isError: true,
+    };
+  }
+}
+
+/**
+ * Insert NOP sled at offset
+ */
+export async function handleNopSled(args: {
+  filePath: string;
+  offset: number;
+  count: number;
+  createBackup?: boolean;
+}): Promise<McpResponse> {
+  const createBackup = args.createBackup !== false;
+
+  // NOP = 0x90 on x86/x64
+  const nopHex = "90".repeat(args.count);
+
+  return handlePatchBytes({
+    filePath: args.filePath,
+    offset: args.offset,
+    hexData: nopHex,
+    createBackup,
+  });
+}
+
+/**
+ * Hex editor mode - read or modify bytes
+ */
+export async function handleHexEditor(args: {
+  filePath: string;
+  offset: number;
+  length: number;
+  newHex?: string;
+}): Promise<McpResponse> {
+  try {
+    // If newHex provided, modify; otherwise just read
+    if (args.newHex) {
+      return handlePatchBytes({
+        filePath: args.filePath,
+        offset: args.offset,
+        hexData: args.newHex,
+        createBackup: true,
+      });
+    }
+
+    // Read mode
+    const result = await runXxd(args.filePath, {
+      seek: args.offset,
+      length: args.length,
+      cols: 16,
+      groupSize: 1,
+    });
+
+    // Also get plain hex for easy copying
+    const { stdout: plainHex } = await execAsync(
+      `xxd -s ${args.offset} -l ${args.length} -p "${args.filePath}" | tr -d '\\n'`
+    );
+
+    const summary = [
+      `Hex Editor: ${args.filePath}`,
+      `Offset: 0x${args.offset.toString(16)} (${args.offset})`,
+      `Length: ${args.length} bytes`,
+      "",
+      "Hex dump:",
+      result.output,
+      "",
+      "Plain hex (for copying):",
+      plainHex.trim(),
+    ].join("\n");
+
+    return { content: [{ type: "text", text: summary }] };
+  } catch (error) {
+    return {
+      content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
+      isError: true,
+    };
+  }
+}
+
+/**
+ * Number conversion utility
+ */
+export async function handleConvertNumber(args: {
+  value: string;
+  fromFormat?: "hex" | "decimal" | "binary" | "octal" | "auto";
+  toFormat?: "all" | "hex" | "decimal" | "binary" | "octal" | "ascii";
+  byteSize?: 8 | 16 | 32 | 64;
+  signed?: boolean;
+}): Promise<McpResponse> {
+  const result = convertNumber(args.value, {
+    fromFormat: args.fromFormat ?? "auto",
+    toFormat: args.toFormat ?? "all",
+    byteSize: args.byteSize,
+    signed: args.signed,
+  });
+
+  const summary: string[] = [
+    `Number Conversion: ${args.value}`,
+    `Input format: ${args.fromFormat ?? "auto-detect"}`,
+    "",
+    "Results:",
+    `  Decimal: ${result.decimal}`,
+    `  Hex: ${result.hex}`,
+    `  Binary: ${result.binary}`,
+    `  Octal: ${result.octal}`,
+    `  ASCII: ${result.ascii}`,
+  ];
+
+  if (result.signed !== undefined) {
+    summary.push(`  Signed: ${result.signed}`);
+  }
+
+  if (result.byteBreakdown && result.byteBreakdown.length > 0) {
+    summary.push("");
+    summary.push("Byte breakdown:");
+    for (const byte of result.byteBreakdown) {
+      summary.push(`  Byte ${byte.index}: 0x${byte.hex} (${byte.decimal})`);
+    }
+  }
+
+  return { content: [{ type: "text", text: summary.join("\n") }] };
+}
+
+/**
+ * Patch manifest for persistent patches
+ */
+interface PatchEntry {
+  id: string;
+  offset: number;
+  originalBytes: string;
+  patchedBytes: string;
+  description: string;
+  applied: boolean;
+  timestamp: string;
+}
+
+const patchManifest: Map<string, PatchEntry[]> = new Map();
+
+function getPatches(filePath: string): PatchEntry[] {
+  if (!patchManifest.has(filePath)) {
+    patchManifest.set(filePath, []);
+  }
+  return patchManifest.get(filePath)!;
+}
+
+/**
+ * Register a patch for persistence
+ */
+export async function handlePatchRegister(args: {
+  filePath: string;
+  patchId: string;
+  offset: number;
+  patchedBytes: string;
+  description: string;
+  captureOriginal?: boolean;
+}): Promise<McpResponse> {
+  const patches = getPatches(args.filePath);
+
+  // Check for duplicate ID
+  if (patches.some((p) => p.id === args.patchId)) {
+    return {
+      content: [{ type: "text", text: `Error: Patch ID "${args.patchId}" already exists for this file.` }],
+      isError: true,
+    };
+  }
+
+  let originalBytes = "";
+  if (args.captureOriginal !== false) {
+    try {
+      const { stdout } = await execAsync(
+        `xxd -s ${args.offset} -l ${args.patchedBytes.replace(/\s/g, "").length / 2} -p "${args.filePath}" | tr -d '\\n'`
+      );
+      originalBytes = stdout.trim();
+    } catch {
+      originalBytes = "unknown";
+    }
+  }
+
+  const patch: PatchEntry = {
+    id: args.patchId,
+    offset: args.offset,
+    originalBytes,
+    patchedBytes: args.patchedBytes.replace(/\s/g, ""),
+    description: args.description,
+    applied: false,
+    timestamp: new Date().toISOString(),
+  };
+
+  patches.push(patch);
+
+  return {
+    content: [{
+      type: "text",
+      text: [
+        `Patch Registered: ${args.patchId}`,
+        `  File: ${args.filePath}`,
+        `  Offset: 0x${args.offset.toString(16)}`,
+        `  Original: ${originalBytes || "(not captured)"}`,
+        `  Patched: ${patch.patchedBytes}`,
+        `  Description: ${args.description}`,
+        "",
+        "Patch has been registered but not yet applied.",
+        "Use bin_patch_apply to apply all registered patches.",
+      ].join("\n"),
+    }],
+  };
+}
+
+/**
+ * List registered patches
+ */
+export async function handlePatchList(args: { filePath?: string }): Promise<McpResponse> {
+  if (args.filePath) {
+    const patches = getPatches(args.filePath);
+    if (patches.length === 0) {
+      return { content: [{ type: "text", text: `No patches registered for ${args.filePath}` }] };
+    }
+
+    return {
+      content: [{
+        type: "text",
+        text: [
+          `Patches for ${args.filePath}:`,
+          "",
+          ...patches.map(
+            (p) =>
+              `  [${p.applied ? "X" : " "}] ${p.id}: offset 0x${p.offset.toString(16)} - ${p.description}`
+          ),
+        ].join("\n"),
+      }],
+    };
+  }
+
+  // List all patches
+  const allPatches = Array.from(patchManifest.entries()).flatMap(([file, patches]) =>
+    patches.map((p) => ({ file, ...p }))
+  );
+
+  if (allPatches.length === 0) {
+    return { content: [{ type: "text", text: "No patches registered." }] };
+  }
+
+  return {
+    content: [{
+      type: "text",
+      text: [
+        "All Registered Patches:",
+        "",
+        ...allPatches.map(
+          (p) =>
+            `  [${p.applied ? "X" : " "}] ${p.file}#${p.id}: offset 0x${p.offset.toString(16)} - ${p.description}`
+        ),
+      ].join("\n"),
+    }],
+  };
+}
+
+/**
+ * Apply all registered patches
+ */
+export async function handlePatchApply(args: {
+  filePath: string;
+  resign?: boolean;
+  removeQuarantine?: boolean;
+}): Promise<McpResponse> {
+  const patches = getPatches(args.filePath);
+
+  if (patches.length === 0) {
+    return {
+      content: [{ type: "text", text: `No patches registered for ${args.filePath}` }],
+    };
+  }
+
+  const results: string[] = [];
+  results.push(`Applying Patches: ${args.filePath}`);
+  results.push("");
+
+  let appliedCount = 0;
+
+  for (const patch of patches) {
+    try {
+      const byteCount = patch.patchedBytes.length / 2;
+      const patchCmd = `printf '${patch.patchedBytes}' | dd of="${args.filePath}" bs=1 seek=${patch.offset} count=${byteCount} conv=notrunc 2>/dev/null`;
+      await execAsync(patchCmd);
+      patch.applied = true;
+      appliedCount++;
+      results.push(`[OK] ${patch.id} at 0x${patch.offset.toString(16)}`);
+    } catch (e) {
+      results.push(`[FAIL] ${patch.id}: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  }
+
+  results.push("");
+  results.push(`Applied ${appliedCount}/${patches.length} patches.`);
+
+  // macOS-specific post-processing
+  if (isMacOS() && appliedCount > 0) {
+    if (args.resign !== false) {
+      results.push("");
+      results.push("Re-signing binary...");
+      try {
+        await execAsync(`codesign --remove-signature "${args.filePath}" 2>&1 || true`);
+        await execAsync(`codesign --force --sign - "${args.filePath}"`);
+        results.push("  Ad-hoc signature applied.");
+      } catch (e) {
+        results.push(`  Warning: ${e instanceof Error ? e.message : String(e)}`);
+      }
+    }
+
+    if (args.removeQuarantine !== false) {
+      results.push("");
+      results.push("Removing quarantine...");
+      try {
+        await execAsync(`xattr -d com.apple.quarantine "${args.filePath}" 2>&1 || true`);
+        results.push("  Quarantine removed.");
+      } catch {
+        results.push("  No quarantine attribute present.");
+      }
+    }
+  }
+
+  return { content: [{ type: "text", text: results.join("\n") }] };
+}
+
+/**
+ * Restore original bytes for patches
+ */
+export async function handlePatchRestore(args: {
+  filePath: string;
+  patchId?: string;
+  resign?: boolean;
+}): Promise<McpResponse> {
+  const patches = getPatches(args.filePath);
+
+  if (patches.length === 0) {
+    return {
+      content: [{ type: "text", text: `No patches registered for ${args.filePath}` }],
+    };
+  }
+
+  const results: string[] = [];
+  results.push(`Restoring Patches: ${args.filePath}`);
+  results.push("");
+
+  const toRestore = args.patchId
+    ? patches.filter((p) => p.id === args.patchId)
+    : patches.filter((p) => p.applied);
+
+  if (toRestore.length === 0) {
+    return {
+      content: [{ type: "text", text: args.patchId ? `Patch "${args.patchId}" not found.` : "No applied patches to restore." }],
+    };
+  }
+
+  let restoredCount = 0;
+
+  for (const patch of toRestore) {
+    if (patch.originalBytes === "unknown" || !patch.originalBytes) {
+      results.push(`[SKIP] ${patch.id}: No original bytes captured`);
+      continue;
+    }
+
+    try {
+      const byteCount = patch.originalBytes.length / 2;
+      const restoreCmd = `printf '${patch.originalBytes}' | dd of="${args.filePath}" bs=1 seek=${patch.offset} count=${byteCount} conv=notrunc 2>/dev/null`;
+      await execAsync(restoreCmd);
+      patch.applied = false;
+      restoredCount++;
+      results.push(`[OK] ${patch.id} restored at 0x${patch.offset.toString(16)}`);
+    } catch (e) {
+      results.push(`[FAIL] ${patch.id}: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  }
+
+  results.push("");
+  results.push(`Restored ${restoredCount}/${toRestore.length} patches.`);
+
+  // Re-sign on macOS
+  if (isMacOS() && restoredCount > 0 && args.resign !== false) {
+    results.push("");
+    results.push("Re-signing binary...");
+    try {
+      await execAsync(`codesign --remove-signature "${args.filePath}" 2>&1 || true`);
+      await execAsync(`codesign --force --sign - "${args.filePath}"`);
+      results.push("  Ad-hoc signature applied.");
+    } catch (e) {
+      results.push(`  Warning: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  }
+
+  return { content: [{ type: "text", text: results.join("\n") }] };
+}
+
+/**
+ * Verify registered patches
+ */
+export async function handlePatchVerify(args: { filePath: string }): Promise<McpResponse> {
+  const patches = getPatches(args.filePath);
+
+  if (patches.length === 0) {
+    return {
+      content: [{ type: "text", text: `No patches registered for ${args.filePath}` }],
+    };
+  }
+
+  const results: string[] = [];
+  results.push(`Verifying Patches: ${args.filePath}`);
+  results.push("");
+
+  for (const patch of patches) {
+    try {
+      const byteCount = patch.patchedBytes.length / 2;
+      const { stdout: currentBytes } = await execAsync(
+        `xxd -s ${patch.offset} -l ${byteCount} -p "${args.filePath}" | tr -d '\\n'`
+      );
+      const current = currentBytes.trim().toLowerCase();
+      const expected = patch.patchedBytes.toLowerCase();
+
+      if (current === expected) {
+        results.push(`[APPLIED] ${patch.id}: Bytes match`);
+      } else if (patch.originalBytes && current === patch.originalBytes.toLowerCase()) {
+        results.push(`[NOT APPLIED] ${patch.id}: Original bytes detected`);
+      } else {
+        results.push(`[UNKNOWN] ${patch.id}: Unexpected bytes (${current})`);
+        results.push(`  Expected: ${expected}`);
+      }
+    } catch (e) {
+      results.push(`[ERROR] ${patch.id}: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  }
+
+  return { content: [{ type: "text", text: results.join("\n") }] };
+}
+
+/**
+ * Remove a patch from registry
+ */
+export async function handlePatchRemove(args: {
+  filePath: string;
+  patchId: string;
+}): Promise<McpResponse> {
+  const patches = getPatches(args.filePath);
+  const index = patches.findIndex((p) => p.id === args.patchId);
+
+  if (index === -1) {
+    return {
+      content: [{ type: "text", text: `Patch "${args.patchId}" not found.` }],
+      isError: true,
+    };
+  }
+
+  const removed = patches.splice(index, 1)[0];
+
+  return {
+    content: [{
+      type: "text",
+      text: [
+        `Patch Removed: ${args.patchId}`,
+        `  File: ${args.filePath}`,
+        `  Offset: 0x${removed.offset.toString(16)}`,
+        `  Description: ${removed.description}`,
+        "",
+        "Note: This only removes from registry. Binary is unchanged.",
+      ].join("\n"),
+    }],
+  };
+}