Skip to content

armgit / rea

Public Imported from GitHub
0

Reverse engineer anything with agents, from app behavior down to native binaries.

fix(javascript): retain early-return conditions in wrapped call paths

morluto503109995f9d
diff --git a/src/domain/javascript/electronWrappedCallPaths.ts b/src/domain/javascript/electronWrappedCallPaths.ts
index deb922ea6..3d38bbd48 100644
--- a/src/domain/javascript/electronWrappedCallPaths.ts
+++ b/src/domain/javascript/electronWrappedCallPaths.ts
@@ -108,6 +108,32 @@ export const collectElectronWrappedCallPaths = (
],
};
};
+ const sequentialFallthrough = (
+ statement: t.Statement,
+ env: SymbolicEnvironment,
+ context: PathContext,
+ ): { readonly continues: boolean; readonly context: PathContext } => {
+ if (symbolicDefiniteExit(statement)) return { continues: false, context };
+ if (!t.isIfStatement(statement)) return { continues: true, context };
+ const truth = symbolicTruth(resolver.evaluate(statement.test, env));
+ if (truth !== undefined)
+ return symbolicDefiniteExit(
+ truth ? statement.consequent : statement.alternate,
+ )
+ ? { continues: false, context }
+ : { continues: true, context };
+ if (symbolicDefiniteExit(statement.consequent))
+ return {
+ continues: true,
+ context: condition(context, statement.test, false),
+ };
+ if (symbolicDefiniteExit(statement.alternate))
+ return {
+ continues: true,
+ context: condition(context, statement.test),
+ };
+ return { continues: true, context };
+ };
const metadataContext = (
context: PathContext,
value: SymbolicValue,
@@ -534,21 +560,9 @@ export const collectElectronWrappedCallPaths = (
let next = context;
for (const statement of node.body) {
walk(statement, env, next);
- if (symbolicDefiniteExit(statement)) break;
- if (t.isIfStatement(statement)) {
- const truth = symbolicTruth(resolver.evaluate(statement.test, env));
- if (truth !== undefined) {
- if (
- symbolicDefiniteExit(
- truth ? statement.consequent : statement.alternate,
- )
- )
- break;
- } else if (symbolicDefiniteExit(statement.consequent))
- next = condition(next, statement.test, false);
- else if (symbolicDefiniteExit(statement.alternate))
- next = condition(next, statement.test);
- }
+ const fallthrough = sequentialFallthrough(statement, env, next);
+ if (!fallthrough.continues) break;
+ next = fallthrough.context;
}
return;
}
@@ -639,13 +653,17 @@ export const collectElectronWrappedCallPaths = (
const index = parent.body.findIndex(
(statement) => statement === child,
);
- if (
- index >= 0 &&
- parent.body
- .slice(0, index)
- .some((statement) => symbolicDefiniteExit(statement))
- )
- return;
+ if (index >= 0) {
+ for (const statement of parent.body.slice(0, index)) {
+ const fallthrough = sequentialFallthrough(
+ statement,
+ env,
+ context,
+ );
+ if (!fallthrough.continues) return;
+ context = fallthrough.context;
+ }
+ }
}
}
call(node, env, context, isolatedSeed?.callee);
diff --git a/tests/boundary/cli/electronWrappedCallPaths.test.ts b/tests/boundary/cli/electronWrappedCallPaths.test.ts
index 128b8188e..b7ed2b67c 100644
--- a/tests/boundary/cli/electronWrappedCallPaths.test.ts
+++ b/tests/boundary/cli/electronWrappedCallPaths.test.ts
@@ -9,6 +9,19 @@ import { javascriptApplicationAnalysisResultSchema } from "../../../src/domain/j
import { applicationFeatureTraceResultSchema } from "../../../src/domain/javascript/javascriptFeatureTraceSchemas.js";
import { analyzeJavaScriptDirectory } from "../../support/cli/javascriptApplication.js";
+const sourcePositionSchema = z.object({ line: z.number(), column: z.number() });
+const callPathConditionSchema = z.object({
+ expression: z.string(),
+ location: z.object({
+ start: sourcePositionSchema,
+ end: sourcePositionSchema,
+ }),
+});
+const callPathTerminalObservationSchema = z.object({
+ properties: z.object({ conditions: z.array(callPathConditionSchema) }),
+ evidence: z.object({ coverage: z.object({ status: z.string() }) }),
+});
+
const analyze = async (cli: TestCli, extra = "") => {
const root = await createTestTempDirectory("rea-electron-wrapped-paths-");
await writeFixtureFiles(root, {
@@ -123,6 +136,80 @@ cliTest(
},
);
+cliTest(
+ "preserves early-return predicates on recovered bridge paths through CLI and stdio MCP",
+ async ({ cli }) => {
+ const cases = [
+ {
+ name: "conditional early return",
+ body: 'if(x)return;e.contextBridge.exposeInMainWorld("api",{copy:()=>e.ipcRenderer.send("x")});',
+ conditions: ["!(x)"],
+ coverage: "partial",
+ },
+ {
+ name: "equivalent nested branch",
+ body: 'if(!x){e.contextBridge.exposeInMainWorld("api",{copy:()=>e.ipcRenderer.send("x")});}',
+ conditions: ["!x"],
+ coverage: "partial",
+ },
+ {
+ name: "definite early return",
+ body: 'return;e.contextBridge.exposeInMainWorld("api",{copy:()=>e.ipcRenderer.send("x")});',
+ conditions: [],
+ coverage: "complete",
+ },
+ {
+ name: "unguarded exposure",
+ body: 'e.contextBridge.exposeInMainWorld("api",{copy:()=>e.ipcRenderer.send("x")});',
+ conditions: [],
+ coverage: "complete",
+ },
+ ] as const;
+
+ for (const surface of ["CLI", "stdio MCP"] as const)
+ for (const fixture of cases) {
+ const root = await createTestTempDirectory(
+ "rea-electron-early-return-",
+ );
+ await writeFixtureFiles(root, {
+ "index.js": `const e=require("electron");function f(x){${fixture.body}}f(globalThis.blocked);`,
+ });
+ const application = await analyzeJavaScriptDirectory(
+ surface,
+ cli,
+ root,
+ );
+ const observations = application.graph.nodes.flatMap(
+ (node) => node.observations,
+ );
+ const terminal = observations.find(
+ (observation) =>
+ observation.properties.entry === "api.copy" &&
+ observation.properties.step_kind === "terminal",
+ );
+ if (fixture.name === "definite early return") {
+ expect(terminal).toBeUndefined();
+ continue;
+ }
+ const terminalEvidence =
+ callPathTerminalObservationSchema.parse(terminal);
+ expect(
+ terminalEvidence.properties.conditions.map(
+ ({ expression }) => expression,
+ ),
+ ).toEqual(fixture.conditions);
+ expect(terminalEvidence.evidence.coverage.status).toBe(
+ fixture.coverage,
+ );
+ expect(application.graph.coverage.status).toBe(fixture.coverage);
+ const source = observations.find(
+ (observation) => observation.properties.file_kind === "javascript",
+ );
+ expect(source?.properties.parse_status).toBe(fixture.coverage);
+ }
+ },
+);
+
cliTest(
"traces a nested contextBridge member through a unique IPC channel",
async ({ cli }) => {