Reverse engineer anything with agents, from app behavior down to native binaries.
TypeScript agent-skillsai-agentsbinary-analysisclaude-codeclicodexcordisdecompilerdeveloper-toolsdshdsh-pluginghidrahopperllmmcpmodel-context-protocolreareverse-engineeringstatic-analysistouhou
fix(reference): stop attributing overwritten require members to Node (#3801)
Kaoru08224692bb33300c
diff --git a/src/domain/referenceSourceRequireBindings.ts b/src/domain/referenceSourceRequireBindings.tsindex f2f8d1ef5..234121a51 100644--- a/src/domain/referenceSourceRequireBindings.ts+++ b/src/domain/referenceSourceRequireBindings.ts@@ -1,5 +1,11 @@import * as t from "@babel/types";+import {+ semanticStaticPropertyKey,+ semanticWriteSiteTarget,+ semanticWriteTargets,+ unwrapJavaScriptExpression,+} from "./javascript/javascriptAstValues.js";import { analyzeParsedJavaScriptReferences } from "./javascript/javascriptSemanticAnalysis.js";import {semanticBindingId,@@ -49,6 +55,22 @@ export const unshadowedReferenceSourceRequireCalls = ((reference.resolution === "unbound" ||reference.bindingId === programRequireBinding),);+ const isLoaderReference = (identifier: t.Identifier): boolean => {+ const start = identifier.loc?.start;+ const reference =+ start === undefined+ ? undefined+ : references.get(`${start.line}:${start.column}`);+ return (+ (allowsUnboundRequire && reference?.resolution === "unbound") ||+ (reference?.resolution === "resolved" &&+ reference.bindingId === programRequireBinding)+ );+ };+ const loaderMembersIntact = requireLoaderMembersIntact(+ file.program,+ isLoaderReference,+ );const calls = new Set<t.CallExpression>();traverseJavaScriptAst(file.program, {@@ -64,6 +86,9 @@ export const unshadowedReferenceSourceRequireCalls = ())return;+ // `require.resolve` and `require.main` denote Node's members only+ // while no visible write or escape can have replaced them.+ if (!t.isIdentifier(node.callee) && !loaderMembersIntact) return;const reference = references.get(`${start.line}:${start.column}`);if ((allowsUnboundRequire &&@@ -80,6 +105,68 @@ export const unshadowedReferenceSourceRequireCalls = (return calls;};+/**+ * Whether the loader's `resolve` and `main` members keep Node's identity. A+ * write to either member or to a computed member, or `require` used as a+ * value other than a call or member read (where a mutator or alias can+ * replace members), leaves that identity unknown.+ */+const requireLoaderMembersIntact = (+ program: t.Program,+ isLoaderReference: (identifier: t.Identifier) => boolean,+): boolean => {+ let intact = true;+ const isLoaderMemberTarget = (target: t.Node): boolean => {+ if (!t.isMemberExpression(target) && !t.isOptionalMemberExpression(target))+ return false;+ const object = unwrapJavaScriptExpression(target.object).node;+ if (!t.isIdentifier(object, { name: "require" })) return false;+ if (!isLoaderReference(object)) return false;+ const key = semanticStaticPropertyKey(target.property, target.computed);+ return key === null || key === "resolve" || key === "main";+ };+ traverseJavaScriptAst(program, {+ enter: (node, parent, readAncestors) => {+ if (!intact) return;+ const site = semanticWriteSiteTarget(node);+ if (site !== null) {+ for (const target of semanticWriteTargets(site))+ if (isLoaderMemberTarget(target)) intact = false;+ return;+ }+ if (+ !t.isIdentifier(node, { name: "require" }) ||+ parent === null ||+ !isLoaderReference(node)+ )+ return;+ // Inert parentheses and TypeScript wrappers do not change how the+ // loader value is used.+ let used: t.Node = node;+ let user: t.Node | undefined = parent;+ const read = readAncestors();+ const ancestors = read.at(-1) === parent ? read : [...read, parent];+ for (let index = ancestors.length - 1; index >= 0; index -= 1) {+ user = ancestors[index];+ if (+ user === undefined ||+ unwrapJavaScriptExpression(user).node !== node+ )+ break;+ used = user;+ }+ const usedAsLoader =+ ((t.isCallExpression(user) || t.isOptionalCallExpression(user)) &&+ user.callee === used) ||+ ((t.isMemberExpression(user) || t.isOptionalMemberExpression(user)) &&+ user.object === used) ||+ t.isUnaryExpression(user, { operator: "typeof" });+ if (!usedAsLoader) intact = false;+ },+ });+ return intact;+};+const contains = (container: t.Node, node: t.Node): boolean =>typeof container.start === "number" &&typeof container.end === "number" &&diff --git a/tests/boundary/filesystem/referenceSourceShadowedRequire.test.ts b/tests/boundary/filesystem/referenceSourceShadowedRequire.test.tsindex 8c438e647..0c88a3801 100644--- a/tests/boundary/filesystem/referenceSourceShadowedRequire.test.ts+++ b/tests/boundary/filesystem/referenceSourceShadowedRequire.test.ts@@ -119,3 +119,67 @@ it("resolves require calls by lexical binding and source mode", async () => {["top-level-var.cjs", "loaded.cjs"],]);});++it("does not attribute overwritten require members to Node's resolver", async () => {+ const root = await createTestTempDirectory("rea-reference-require-member-");+ const sources: Record<string, string> = {+ "assigned.cjs":+ "require.resolve = () => 'custom';\nconsole.log(require.resolve('./loaded.cjs'));",+ "defined.cjs":+ "Object.defineProperty(require, 'resolve', { value: () => 'custom' });\nconsole.log(require.resolve('./loaded.cjs'));",+ "computed.cjs":+ "const key = 'resolve';\nrequire[key] = () => 'custom';\nconsole.log(require.resolve('./loaded.cjs'));",+ "control.cjs": "console.log(typeof require.resolve('./loaded.cjs'));",+ // A member overwrite does not change bare loader calls.+ "bare-after-overwrite.cjs":+ "require.resolve = () => 'custom';\nconsole.log(require('./loaded.cjs'));",+ // A local loader's member write does not touch Node's loader.+ "local-loader.cjs":+ "function patch(require) { require.resolve = () => 'custom'; }\npatch({});\nconsole.log(typeof require.resolve('./loaded.cjs'));",+ // Optional calls and inert wrappers do not let the loader escape.+ "optional-call.cjs":+ "require?.('./loaded.cjs');\nconsole.log(typeof (require).resolve('./loaded.cjs'));",+ "loaded.cjs": "module.exports = 'real';\n",+ };+ await Promise.all(+ Object.entries(sources).map(([path, source]) =>+ writeFile(join(root, path), source),+ ),+ );+ const runNode = promisify(execFile);+ for (const [path, stdout] of [+ ["assigned.cjs", "custom\n"],+ ["defined.cjs", "custom\n"],+ ["computed.cjs", "custom\n"],+ ["control.cjs", "string\n"],+ ["bare-after-overwrite.cjs", "real\n"],+ ["local-loader.cjs", "string\n"],+ ["optional-call.cjs", "string\n"],+ ] as const)+ expect(+ (+ await runNode(process.execPath, [join(root, path)], {+ cwd: root,+ timeout: 5_000,+ })+ ).stdout,+ ).toBe(stdout);++ const result = await importReferenceSource({+ root,+ caller: "reference-require-member-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([+ ["bare-after-overwrite.cjs", "loaded.cjs"],+ ["control.cjs", "loaded.cjs"],+ ["local-loader.cjs", "loaded.cjs"],+ ["optional-call.cjs", "loaded.cjs"],+ ]);+});