Files
reverse-engineering-anything/tests/boundary/cli/electronScopedIpc.test.ts
T
Kaoru0822 e66a27c2f2 fix(electron): resolve exact local IPC channel values (#13005)
* fix(electron): resolve exact local IPC channel values

* test(electron): cover ESM IPC channel overwrites

* fix(electron): reconcile wrapper registrations before resolving channels

* test(electron): require inference evidence for resolved handler channels

* fix(electron): preserve inferred channels on handler evidence
2026-11-20 22:32:13 -08:00

369 lines
15 KiB
TypeScript

import { createHash } from "node:crypto";
import { expect } from "vitest";
import { createTestTempDirectory } from "../../fixtures/temporaryDirectory.js";
import { writeFixtureFiles } from "../../support/javascriptApplicationFixture.js";
import { cliTest } from "../../support/cli/cliFixture.js";
import { analyzeJavaScriptDirectory } from "../../support/cli/javascriptApplication.js";
cliTest.for(["CLI", "stdio MCP"] as const)(
"preserves scoped IPC allocations without global dispatch pairing through %s",
async (surface, { cli }) => {
const root = await createTestTempDirectory("rea-scoped-ipc-");
const copy = `const {BrowserWindow}=require("electron"); const window=new BrowserWindow(); window.webContents.ipc.handle("copied",()=>{});`;
await writeFixtureFiles(root, {
"copy-one.cjs": copy,
"copy-two.cjs": copy,
"main.cjs": `const { BrowserWindow, ipcMain } = require("electron");
const first = new BrowserWindow();
const second = new BrowserWindow();
first.webContents.mainFrame.ipc.handle("shared", () => "first");
second.webContents.mainFrame.ipc.handle("shared", () => "second");
ipcMain.handle("shared", () => "global");
const dynamicWindow = new BrowserWindow();
dynamicWindow.webContents.ipc.handle(dynamicChannel, () => "dynamic");
ipcMain.handle("dynamic-shadow", () => "global");
const fake = { webContents: { ipc: { handle() {} } } };
fake.webContents.ipc.handle("fake", () => {});`,
"preload.cjs": `const { ipcRenderer } = require("electron");
ipcRenderer.invoke("shared");
ipcRenderer.invoke("dynamic-shadow");`,
});
const application = await analyzeJavaScriptDirectory(surface, cli, root);
expect(application.statistics.parse_failures).toBe(0);
expect(application.summary.ipc).toMatchObject({
operations: 9,
main_handlers: 7,
renderer_transmissions: 2,
paired_renderer_transmissions: 0,
ambiguous_renderer_transmissions: 2,
});
const channels = application.graph.nodes.filter(
({ kind }) => kind === "ipc-channel",
);
const copies = application.graph.nodes.filter(
({ kind, observations }) =>
kind === "ipc-handler" &&
observations.some(({ properties }) => properties.channel === "copied"),
);
expect(copies).toHaveLength(2);
expect(
channels.filter(({ observations }) =>
observations.some(({ properties }) => properties.channel === "copied"),
),
).toHaveLength(2);
const shared = channels.filter(({ observations }) =>
observations.some(({ properties }) => properties.channel === "shared"),
);
expect(shared).toHaveLength(3);
const scoped = shared.filter(({ observations }) =>
observations.some(({ properties }) => properties.receiver !== undefined),
);
expect(scoped).toHaveLength(2);
const owners = scoped.flatMap(({ observations }) =>
observations.map(({ properties }) => properties.receiver),
);
expect(new Set(owners.map((owner) => JSON.stringify(owner))).size).toBe(2);
expect(
channels.some(({ observations }) =>
observations.some(({ properties }) => properties.channel === "fake"),
),
).toBe(false);
expect(
application.graph.edges.filter(
({ evidence }) =>
evidence.extractor.operation === "pair-ipc-literal-channel",
),
).toEqual([]);
},
);
cliTest.for(["CLI", "stdio MCP"] as const)(
"does not uniquely pair a renderer with exactly one scoped literal handler through %s",
async (surface, { cli }) => {
const root = await createTestTempDirectory("rea-single-scoped-ipc-");
await writeFixtureFiles(root, {
"main.cjs": `const { BrowserWindow } = require("electron");
const window = new BrowserWindow();
window.webContents.mainFrame.ipc.handle("only-scoped", () => "result");`,
"preload.cjs": `const { ipcRenderer } = require("electron");
ipcRenderer.invoke("only-scoped");`,
});
const application = await analyzeJavaScriptDirectory(surface, cli, root);
expect(application.summary.ipc).toMatchObject({
operations: 2,
main_handlers: 1,
renderer_transmissions: 1,
dynamic_channel_operations: 0,
paired_renderer_transmissions: 0,
ambiguous_renderer_transmissions: 1,
});
const handlers = application.graph.nodes.filter(
({ kind }) => kind === "ipc-handler",
);
expect(handlers).toHaveLength(1);
expect(handlers[0]?.observations[0]?.properties.receiver).toMatchObject({
kind: "main-frame",
});
expect(
application.graph.edges.filter(
({ evidence }) =>
evidence.extractor.operation === "pair-ipc-literal-channel",
),
).toEqual([]);
},
);
cliTest.for(["CLI", "stdio MCP"] as const)(
"pairs literal IPC within proven application owners through %s",
async (surface, { cli }) => {
const root = await createTestTempDirectory("rea-application-ipc-");
await writeFixtureFiles(root, {
"a/package.json": JSON.stringify({ name: "a", main: "main.cjs" }),
"a/main.cjs": `const { ipcMain, clipboard } = require("electron");
ipcMain.handle("shared", (event, value) => clipboard.writeText(value));`,
"a/preload.cjs": `const { ipcRenderer, contextBridge } = require("electron");
contextBridge.exposeInMainWorld("api", { read: (value) => ipcRenderer.invoke("shared", value) });`,
"b/package.json": JSON.stringify({ name: "b", main: "main.cjs" }),
"b/main.cjs": `const { ipcMain, clipboard } = require("electron");
ipcMain.handle("shared", (event, value) => clipboard.writeText(value));`,
"b/preload.cjs": `const { ipcRenderer, contextBridge } = require("electron");
contextBridge.exposeInMainWorld("api", { read: (value) => ipcRenderer.invoke("shared", value) });`,
});
const application = await analyzeJavaScriptDirectory(surface, cli, root);
expect(application.summary.ipc).toMatchObject({
operations: 4,
paired_renderer_transmissions: 2,
ambiguous_renderer_transmissions: 0,
});
const pairs = application.graph.edges.filter(
({ evidence }) =>
evidence.extractor.operation === "pair-ipc-literal-channel",
);
const joins = application.graph.edges.filter(
({ evidence }) =>
evidence.extractor.operation === "join-electron-wrapper-paths",
);
expect(joins).toHaveLength(2);
expect(
new Set(joins.map(({ target_node_id }) => target_node_id)).size,
).toBe(2);
const nodes = new Map(
application.graph.nodes.map((node) => [node.node_id, node]),
);
for (const join of joins) {
const target = nodes.get(join.target_node_id);
expect(target?.observations).toEqual(
expect.arrayContaining([
expect.objectContaining({
evidence: expect.objectContaining({
location: expect.objectContaining({
available: true,
value: expect.objectContaining({
source: join.properties.handler_path,
}),
}),
}),
}),
]),
);
}
expect(pairs).toHaveLength(2);
expect(
new Set(pairs.map(({ target_node_id }) => target_node_id)).size,
).toBe(2);
expect(
application.graph.nodes.filter(({ kind }) => kind === "ipc-handler"),
).toHaveLength(2);
for (const edge of pairs) {
expect(edge.evidence.location.available).toBe(true);
const location = edge.evidence.location;
if (!location.available || location.value.kind !== "source-range")
throw new Error("IPC pairing omitted its authored source location");
expect(edge.properties.handler_path).toBe(
location.value.source.startsWith("a/") ? "a/main.cjs" : "b/main.cjs",
);
}
expect(
application.graph.nodes.filter(({ kind }) => kind === "ipc-channel"),
).toHaveLength(2);
},
);
cliTest.for(["CLI", "stdio MCP"] as const)(
"retains unknown IPC applicability across distinct or shared application owners through %s",
async (surface, { cli }) => {
for (const sharedSource of [false, true]) {
const root = await createTestTempDirectory(
"rea-unknown-application-ipc-",
);
await writeFixtureFiles(root, {
"a/package.json": JSON.stringify({ name: "a", main: "main.cjs" }),
"a/main.cjs": sharedSource
? `require("../shared.cjs");`
: `module.exports = {};`,
"b/package.json": JSON.stringify({ name: "b", main: "main.cjs" }),
"b/main.cjs": `const { ipcMain } = require("electron");
${sharedSource ? 'require("../shared.cjs");' : ""}
ipcMain.handle("shared", () => "result");`,
[sharedSource ? "shared.cjs" : "a/preload.cjs"]:
`const { ipcRenderer } = require("electron"); ipcRenderer.invoke("shared");`,
});
const application = await analyzeJavaScriptDirectory(surface, cli, root);
expect(application.summary.ipc).toMatchObject({
operations: 2,
paired_renderer_transmissions: 0,
ambiguous_renderer_transmissions: 1,
unpaired_literal_renderer_transmissions: 0,
});
expect(
application.graph.edges.filter(({ evidence }) =>
["pair-ipc-literal-channel", "join-electron-wrapper-paths"].includes(
evidence.extractor.operation,
),
),
).toEqual([]);
expect(
application.graph.nodes.filter(({ kind }) => kind === "ipc-handler"),
).toHaveLength(1);
}
},
);
cliTest.for(["CLI", "stdio MCP"] as const)(
"keeps unexamined external package effects unknown without obscuring builtins through %s",
async (surface, { cli }) => {
for (const [label, extra, expected] of [
["builtins", `require("node:path");`, "paired"],
["external", `require("unobserved-package");`, "ambiguous"],
["dynamic", `require(unknownName);`, "ambiguous"],
["native", `require("./addon.node");`, "ambiguous"],
] as const) {
const root = await createTestTempDirectory("rea-external-ipc-owner-");
await writeFixtureFiles(root, {
"package.json": JSON.stringify({ name: "app", main: "main.cjs" }),
"main.cjs": `const {ipcMain}=require("electron"); ${extra} ipcMain.handle("known",()=>1);`,
"preload.cjs": `const {ipcRenderer}=require("electron"); ipcRenderer.invoke("known");`,
...(label === "native" ? { "addon.node": "fixture" } : {}),
});
const application = await analyzeJavaScriptDirectory(surface, cli, root);
expect(application.summary.ipc, label).toMatchObject({
paired_renderer_transmissions: expected === "paired" ? 1 : 0,
ambiguous_renderer_transmissions: expected === "ambiguous" ? 1 : 0,
});
}
},
);
cliTest.for(["CLI", "stdio MCP"] as const)(
"resolves selected local IPC channel values while retaining opaque writes through %s",
async (surface, { cli }) => {
const root = await createTestTempDirectory("rea-ipc-local-values-");
const source = [
'const { ipcRenderer } = require("electron");',
'const channels = { listen: "autofill.listen", other: "original" };',
"const captured = channels.listen;",
'const stable = { listen: "autofill.stable" };',
"const subscribe = () => ipcRenderer.on(stable.listen, () => {});",
"channels.other = unknown;",
"ipcRenderer.on(channels.other, () => {});",
"channels.listen = unknown;",
"ipcRenderer.send(captured);",
].join("\n");
await writeFixtureFiles(root, { "preload.cjs": source });
const application = await analyzeJavaScriptDirectory(surface, cli, root);
const observations = application.graph.nodes
.filter(({ kind }) => kind === "ipc-channel")
.flatMap(({ observations }) => observations);
expect(observations).toEqual(
expect.arrayContaining([
expect.objectContaining({
properties: expect.objectContaining({ channel: "autofill.listen" }),
evidence: expect.objectContaining({
state: "inferred",
artifact: expect.objectContaining({
available: true,
sha256: createHash("sha256").update(source).digest("hex"),
}),
location: expect.objectContaining({
available: true,
value: expect.objectContaining({
source: "preload.cjs",
start: expect.objectContaining({ line: 9 }),
}),
}),
}),
}),
expect.objectContaining({
properties: expect.objectContaining({
channel: "autofill.stable",
operation: "on",
}),
}),
expect.objectContaining({
properties: expect.objectContaining({
channel: null,
channel_expression: "channels.other",
}),
}),
]),
);
const handlers = application.graph.nodes
.filter(({ kind }) => kind === "ipc-handler")
.flatMap(({ observations }) => observations);
expect(handlers).toContainEqual(
expect.objectContaining({
properties: expect.objectContaining({ channel: "autofill.stable" }),
evidence: expect.objectContaining({
state: "inferred",
artifact: expect.objectContaining({
available: true,
sha256: createHash("sha256").update(source).digest("hex"),
}),
location: expect.objectContaining({
available: true,
value: expect.objectContaining({
source: "preload.cjs",
start: expect.objectContaining({ line: 5 }),
}),
}),
}),
}),
);
},
);
cliTest.for(["CLI", "stdio MCP"] as const)(
"keeps an ESM channel unknown after its property is overwritten through %s",
async (surface, { cli }) => {
const root = await createTestTempDirectory("rea-ipc-mutated-channel-");
await writeFixtureFiles(root, {
"preload.mjs": [
'import { ipcRenderer } from "electron";',
'const channels = { send: "old" };',
"const alias = channels;",
"alias.send = unknown;",
"ipcRenderer.send(channels.send);",
].join("\n"),
});
const application = await analyzeJavaScriptDirectory(surface, cli, root);
expect(application.summary.ipc).toMatchObject({
operations: 1,
literal_channels: 0,
dynamic_channel_operations: 1,
});
expect(
application.graph.nodes
.filter(({ kind }) => kind === "ipc-channel")
.flatMap(({ observations }) =>
observations.map(({ properties }) => properties),
),
).toEqual([
expect.objectContaining({
channel: null,
channel_expression: "channels.send",
}),
]);
},
);