Skip to content

armgit / rea

Public Imported from GitHub
0

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

fix(reference-source): respect require bindings

morlutof998fcb1cca9
diff --git a/src/domain/javascript/javascriptSemanticAnalysis.ts b/src/domain/javascript/javascriptSemanticAnalysis.ts
index 82f7e6244..b0e8e5ee7 100644
--- a/src/domain/javascript/javascriptSemanticAnalysis.ts
+++ b/src/domain/javascript/javascriptSemanticAnalysis.ts
@@ -29,6 +29,7 @@ import {
resolveSemanticBindingState,
semanticResolutionBlocked,
resolveSemanticBindingFromScope,
+ semanticBindingId,
semanticScopeId,
semanticVariableScope,
} from "./javascriptSemanticState.js";
@@ -105,7 +106,7 @@ export const analyzeJavaScriptSemantics = (
/** Recover lexical references, optionally for one name, without evaluating values or provenance. */
export const analyzeParsedJavaScriptReferences = (
- file: ParsedJavaScriptSource,
+ file: Pick<ParsedJavaScriptSource, "program">,
name?: string,
): readonly JavaScriptSemanticReference[] => {
const state = createState(file.program);
@@ -1101,7 +1102,7 @@ const createBinding = (
kind: JavaScriptSemanticDefinition["kind"],
mutable: boolean,
): JavaScriptSemanticBindingState => ({
- bindingId: `${scope.scopeId}:binding:${encodeURIComponent(name)}`,
+ bindingId: semanticBindingId(scope.scopeId, name),
scopeId: scope.scopeId,
name,
kind,
diff --git a/src/domain/javascript/javascriptSemanticState.ts b/src/domain/javascript/javascriptSemanticState.ts
index f7ef25319..30b787fdf 100644
--- a/src/domain/javascript/javascriptSemanticState.ts
+++ b/src/domain/javascript/javascriptSemanticState.ts
@@ -89,6 +89,10 @@ export const semanticScopeId = (
): string =>
`scope:${kind}:${String(node.start ?? -1)}:${String(node.end ?? -1)}`;
+/** Create the canonical identity used by one binding in a lexical scope. */
+export const semanticBindingId = (scopeId: string, name: string): string =>
+ `${scopeId}:binding:${encodeURIComponent(name)}`;
+
/** Resolve one lexical name from the scope containing a node. */
export const resolveSemanticBindingState = (
state: JavaScriptSemanticAnalysisState,
diff --git a/src/domain/referenceSourceImportParsing.ts b/src/domain/referenceSourceImportParsing.ts
index e89707257..62ad226dd 100644
--- a/src/domain/referenceSourceImportParsing.ts
+++ b/src/domain/referenceSourceImportParsing.ts
@@ -8,6 +8,7 @@ import type {
} from "@babel/types";
import { traverseJavaScriptAst } from "./javascript/javascriptSemanticTraversal.js";
import { parserPluginsForPath } from "./javascript/javascriptSourceParser.js";
+import { unshadowedReferenceSourceRequireCalls } from "./referenceSourceRequireBindings.js";
import {
isCallExpression,
isExportAllDeclaration,
@@ -206,6 +207,7 @@ const extractRequireAndDynamicImports = (
body: readonly Node[],
from_path: string,
relationships: ReferenceSourceImportRelationship[],
+ unshadowedRequireCalls: ReadonlySet<CallExpression>,
): void => {
// Single traversal owner: iterative, VISITOR_KEYS-gated, no recursion over
// loc/comment objects. Survives deeply nested generated member chains that
@@ -232,7 +234,11 @@ const extractRequireAndDynamicImports = (
continue;
}
const first = call.arguments[0];
- if (isRequireCallee(call.callee) && isModuleExpression(first)) {
+ if (
+ isRequireCallee(call.callee) &&
+ unshadowedRequireCalls.has(call) &&
+ isModuleExpression(first)
+ ) {
const result = moduleSpecifierFromExpression(first);
if (result !== undefined) {
appendRelationship(relationships, {
@@ -332,7 +338,12 @@ export const parseReferenceSourceImports = (
const relationships: ReferenceSourceImportRelationship[] = [];
extractImportDeclarations(ast.program.body, path, relationships);
- extractRequireAndDynamicImports(ast.program.body, path, relationships);
+ extractRequireAndDynamicImports(
+ ast.program.body,
+ path,
+ relationships,
+ unshadowedReferenceSourceRequireCalls(ast, path),
+ );
return {
relationships: relationships.map((relationship) => ({
diff --git a/src/domain/referenceSourceRequireBindings.ts b/src/domain/referenceSourceRequireBindings.ts
new file mode 100644
index 000000000..d7c8cea49
--- /dev/null
+++ b/src/domain/referenceSourceRequireBindings.ts
@@ -0,0 +1,192 @@
+import * as t from "@babel/types";
+
+import { analyzeParsedJavaScriptReferences } from "./javascript/javascriptSemanticAnalysis.js";
+import {
+ semanticBindingId,
+ semanticScopeId,
+} from "./javascript/javascriptSemanticState.js";
+import { traverseJavaScriptAst } from "./javascript/javascriptSemanticTraversal.js";
+import type { JavaScriptSemanticReference } from "./javascript/javascriptSemanticIr.js";
+import type { ParsedJavaScriptSource } from "./javascript/javascriptSourceParser.js";
+
+/**
+ * Keep calls that resolve either to Node's CommonJS wrapper loader or to a
+ * direct ESM `createRequire(import.meta.url)` binding. The shared lexical
+ * analyzer supplies binding ownership; this boundary accounts for the two
+ * Node loader bindings without evaluating arbitrary values.
+ */
+export const unshadowedReferenceSourceRequireCalls = (
+ file: Pick<ParsedJavaScriptSource, "program">,
+ path: string,
+): ReadonlySet<t.CallExpression> => {
+ const references = new Map(
+ analyzeParsedJavaScriptReferences(file).map((reference) => [
+ `${reference.location.start.line}:${reference.location.start.column}`,
+ reference,
+ ]),
+ );
+ const programRequireBinding = semanticBindingId(
+ semanticScopeId("program", file.program),
+ "require",
+ );
+ const allowsUnboundRequire = !isExplicitModuleSource(path);
+ const hasTopLevelVarRequire =
+ allowsUnboundRequire && hasUninitializedTopLevelVarRequire(file.program);
+ const createRequireBinding = directCreateRequireBinding(
+ file.program,
+ references,
+ );
+ const requireLoaderWasWritten = [...references.values()].some(
+ (reference) =>
+ reference.name === "require" &&
+ reference.role === "write" &&
+ (reference.resolution === "unbound" ||
+ reference.bindingId === programRequireBinding),
+ );
+ const calls = new Set<t.CallExpression>();
+
+ traverseJavaScriptAst(file.program, {
+ enter: (node, _parent, readAncestors) => {
+ if (!t.isCallExpression(node)) return;
+ const identifier = requireCalleeIdentifier(node.callee);
+ const start = identifier?.loc?.start;
+ if (start === undefined) return;
+ if (
+ readAncestors().some(
+ (ancestor) => t.isWithStatement(ancestor) && contains(ancestor.body, node),
+ )
+ )
+ return;
+ const reference = references.get(`${start.line}:${start.column}`);
+ if (
+ (allowsUnboundRequire &&
+ !requireLoaderWasWritten &&
+ reference?.resolution === "unbound") ||
+ (((hasTopLevelVarRequire && !requireLoaderWasWritten) ||
+ createRequireBinding) &&
+ reference?.resolution === "resolved" &&
+ reference.bindingId === programRequireBinding)
+ )
+ calls.add(node);
+ },
+ });
+ return calls;
+};
+
+const contains = (container: t.Node, node: t.Node): boolean =>
+ typeof container.start === "number" &&
+ typeof container.end === "number" &&
+ typeof node.start === "number" &&
+ typeof node.end === "number" &&
+ container.start <= node.start &&
+ node.end <= container.end;
+
+const isExplicitModuleSource = (path: string): boolean => {
+ const lower = path.toLowerCase();
+ if (lower.endsWith(".mjs") || lower.endsWith(".mts")) return true;
+ if (lower.endsWith(".cjs") || lower.endsWith(".cts")) return false;
+ // Syntax alone cannot establish Node's runtime mode: `.js` depends on its
+ // package scope, and `.ts` may be compiled with a CommonJS module target.
+ // Keep unmarked paths runtime-unknown and preserve candidate require edges.
+ return false;
+};
+
+const hasUninitializedTopLevelVarRequire = (
+ program: t.Program,
+): boolean => {
+ let found = false;
+ let initialized = false;
+ traverseJavaScriptAst(program, {
+ enter: (node, _parent, readAncestors) => {
+ if (!t.isVariableDeclaration(node, { kind: "var" })) return;
+ if (
+ readAncestors().some(
+ (ancestor) => t.isFunction(ancestor) || t.isStaticBlock(ancestor),
+ )
+ )
+ return;
+ for (const declaration of node.declarations) {
+ if (!Object.hasOwn(t.getBindingIdentifiers(declaration.id), "require"))
+ continue;
+ found = true;
+ initialized ||= declaration.init !== null;
+ }
+ },
+ });
+ return found && !initialized;
+};
+
+const directCreateRequireBinding = (
+ program: t.Program,
+ references: ReadonlyMap<string, JavaScriptSemanticReference>,
+): boolean => {
+ const programScope = semanticScopeId("program", program);
+ const importedNames = new Set<string>();
+ for (const declaration of program.body) {
+ if (
+ !t.isImportDeclaration(declaration) ||
+ (declaration.source.value !== "node:module" &&
+ declaration.source.value !== "module")
+ )
+ continue;
+ for (const specifier of declaration.specifiers) {
+ if (
+ t.isImportSpecifier(specifier) &&
+ t.isIdentifier(specifier.imported, { name: "createRequire" })
+ )
+ importedNames.add(specifier.local.name);
+ }
+ }
+
+ return program.body.some(
+ (statement) =>
+ t.isVariableDeclaration(statement, { kind: "const" }) &&
+ statement.declarations.some((declaration) => {
+ if (
+ !t.isIdentifier(declaration.id, { name: "require" }) ||
+ !t.isCallExpression(declaration.init) ||
+ !t.isIdentifier(declaration.init.callee) ||
+ !importedNames.has(declaration.init.callee.name) ||
+ !isImportMetaUrl(declaration.init.arguments[0])
+ )
+ return false;
+ const start = declaration.init.callee.loc?.start;
+ if (start === undefined) return false;
+ const reference = references.get(`${start.line}:${start.column}`);
+ return (
+ reference?.resolution === "resolved" &&
+ reference.bindingId ===
+ semanticBindingId(programScope, declaration.init.callee.name)
+ );
+ }),
+ );
+};
+
+const isImportMetaUrl = (node: t.Node | undefined): boolean =>
+ t.isMemberExpression(node) &&
+ !node.computed &&
+ t.isIdentifier(node.property, { name: "url" }) &&
+ t.isMetaProperty(node.object) &&
+ t.isIdentifier(node.object.meta, { name: "import" }) &&
+ t.isIdentifier(node.object.property, { name: "meta" });
+
+const requireCalleeIdentifier = (
+ callee: t.Node | null | undefined,
+): t.Identifier | undefined => {
+ if (t.isIdentifier(callee, { name: "require" })) return callee;
+ if (
+ !t.isMemberExpression(callee) ||
+ !t.isIdentifier(callee.object, { name: "require" }) ||
+ ((!t.isIdentifier(callee.property) || callee.computed) &&
+ !t.isStringLiteral(callee.property))
+ )
+ return undefined;
+ const propertyName = t.isIdentifier(callee.property)
+ ? callee.property.name
+ : t.isStringLiteral(callee.property)
+ ? callee.property.value
+ : undefined;
+ return propertyName === "resolve" || propertyName === "main"
+ ? callee.object
+ : undefined;
+};
diff --git a/tests/boundary/filesystem/referenceSourceShadowedRequire.test.ts b/tests/boundary/filesystem/referenceSourceShadowedRequire.test.ts
new file mode 100644
index 000000000..9ffe7ef95
--- /dev/null
+++ b/tests/boundary/filesystem/referenceSourceShadowedRequire.test.ts
@@ -0,0 +1,123 @@
+import { execFile } from "node:child_process";
+import { writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { promisify } from "node:util";
+
+import { expect, it } from "vitest";
+
+import { createTestTempDirectory } from "../../fixtures/temporaryDirectory.js";
+import { importReferenceSource } from "../../support/referenceSourceResourceScope.js";
+
+it("resolves require calls by lexical binding and source mode", async () => {
+ const root = await createTestTempDirectory("rea-reference-require-scope-");
+ const sources: Record<string, string> = {
+ "parameter.cjs": [
+ "function load(require) { return require('./throwing.cjs'); }",
+ "console.log(load(() => 'local'));",
+ ].join("\n"),
+ "destructured.cjs": [
+ "function load({ require }) { return require('./throwing.cjs'); }",
+ "console.log(load({ require: () => 'local' }));",
+ ].join("\n"),
+ "hoisted.cjs": [
+ "function load() {",
+ " console.log(require('./throwing.cjs'));",
+ " function require() { return 'local'; }",
+ "}",
+ "load();",
+ ].join("\n"),
+ "catch.cjs": [
+ "try { throw () => 'local'; }",
+ "catch (require) { console.log(require('./throwing.cjs')); }",
+ ].join("\n"),
+ "nested.cjs": [
+ "console.log(require('./loaded.cjs'));",
+ "function load(require) { return require('./throwing.cjs'); }",
+ "console.log(load(() => 'local'));",
+ ].join("\n"),
+ "dynamic-with.cjs": [
+ "with ({ require: () => 'local' }) {",
+ " console.log(require('./throwing.cjs'));",
+ "}",
+ ].join("\n"),
+ "top-level-var.cjs": [
+ "var require;",
+ "console.log(require('./loaded.cjs'));",
+ ].join("\n"),
+ "initialized-var.cjs": [
+ "var require = () => 'local';",
+ "console.log(require('./throwing.cjs'));",
+ ].join("\n"),
+ "assigned-var.cjs": [
+ "require = () => 'local';",
+ "console.log(require('./throwing.cjs'));",
+ ].join("\n"),
+ "unbound-esm.mjs": [
+ "try { require('./throwing.cjs'); }",
+ "catch (error) {",
+ " if (!(error instanceof ReferenceError)) throw error;",
+ " console.log('no-global-require');",
+ "}",
+ ].join("\n"),
+ "shadowed-esm.mjs": [
+ "const require = () => 'local';",
+ "console.log(require('./throwing.cjs'));",
+ ].join("\n"),
+ "create-require-esm.mjs": [
+ "import { createRequire as makeRequire } from 'node:module';",
+ "const require = makeRequire(import.meta.url);",
+ "console.log(require('./loaded.cjs'));",
+ ].join("\n"),
+ "loaded.cjs": "console.log('loaded');\nmodule.exports = 'real';\n",
+ "throwing.cjs": "throw new Error('A shadowed require must not load me');\n",
+ };
+
+ await Promise.all(
+ Object.entries(sources).map(([path, source]) =>
+ writeFile(join(root, path), source),
+ ),
+ );
+
+ const runNode = promisify(execFile);
+ for (const [path, stdout] of [
+ ["parameter.cjs", "local\n"],
+ ["destructured.cjs", "local\n"],
+ ["hoisted.cjs", "local\n"],
+ ["catch.cjs", "local\n"],
+ ["nested.cjs", "loaded\nreal\nlocal\n"],
+ ["dynamic-with.cjs", "local\n"],
+ ["top-level-var.cjs", "loaded\nreal\n"],
+ ["initialized-var.cjs", "local\n"],
+ ["assigned-var.cjs", "local\n"],
+ ["unbound-esm.mjs", "no-global-require\n"],
+ ["shadowed-esm.mjs", "local\n"],
+ ["create-require-esm.mjs", "loaded\nreal\n"],
+ ] as const) {
+ const executed = await runNode(process.execPath, [join(root, path)], {
+ cwd: root,
+ timeout: 5_000,
+ });
+ expect(executed.stdout).toBe(stdout);
+ expect(executed.stderr).toBe("");
+ }
+
+ const result = await importReferenceSource({
+ root,
+ caller: "reference-shadowed-require-test",
+ policy: { secretPatterns: [] },
+ });
+ if (!result.ok) throw result.error;
+
+ expect(
+ result.value.relationships
+ .filter(({ kind }) => kind === "requires")
+ .map(({ from_path, to }) => [from_path, to])
+ .sort((left, right) =>
+ (left[0] ?? "").localeCompare(right[0] ?? ""),
+ ),
+ ).toEqual([
+ ["create-require-esm.mjs", "loaded.cjs"],
+ ["nested.cjs", "loaded.cjs"],
+ ["top-level-var.cjs", "loaded.cjs"],
+ ]);
+});