Skip to content

armgit / rea

Public Imported from GitHub
0

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

fix(javascript): project decoded file URL paths (#810)

Rudy Mizrahi Celekli2572e1eb2f85
diff --git a/src/application/JavaScriptFileUrlPaths.test.ts b/src/application/JavaScriptFileUrlPaths.test.ts
new file mode 100644
index 000000000..0a4a5cdd8
--- /dev/null
+++ b/src/application/JavaScriptFileUrlPaths.test.ts
@@ -0,0 +1,95 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join, relative } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+import { parseExpression } from "@babel/parser";
+import { describe, expect, it } from "vitest";
+
+import { createTestTempDirectory } from "../../tests/fixtures/temporaryDirectory.js";
+import { javascriptApplicationAnalysisResultSchema } from "../domain/javascriptApplicationAnalysis.js";
+import { staticPath } from "../domain/javascriptStaticAnalysisHelpers.js";
+import { analyzeJavaScriptApplication } from "./JavaScriptApplicationService.js";
+
+const urlCases = [
+ ["./preload%20name.cjs", "preload name.cjs", "main.mjs"],
+ ["./pr%C3%A9load.cjs", "préload.cjs", "main.mjs"],
+ ["./preload%3F%23.cjs", "preload?#.cjs", "main.mjs"],
+ ["./preload.cjs?cache=1#v2", "preload.cjs", "main.mjs"],
+ ["../preload.cjs?cache=1", "preload.cjs", "src/main.mjs"],
+ ["./sub/../preload.cjs", "preload.cjs", "main.mjs"],
+ ["./preload.cjs", "preload.cjs", "main.mjs"],
+] as const;
+
+const unknownExpressions = [
+ 'fileURLToPath(new URL("./invalid%.cjs", import.meta.url))',
+ 'fileURLToPath(new URL("./preload%2fname.cjs", import.meta.url))',
+ 'fileURLToPath(new URL("./preload%5cname.cjs", import.meta.url))',
+ 'fileURLToPath(new URL("./%2e/preload.cjs", import.meta.url))',
+ 'fileURLToPath(new URL("https://example.test/preload.cjs", import.meta.url))',
+ 'fileURLToPath(new URL("//example.test/preload.cjs", import.meta.url))',
+ 'fileURLToPath(new URL("#fragment", import.meta.url))',
+ 'fileURLToPath(new URL("?cache=1", import.meta.url))',
+ 'fileURLToPath(new URL("./preload.cjs", runtimeBase))',
+ "fileURLToPath(new URL(runtimePath, import.meta.url))",
+ 'convertFileURLToPath(new URL("./preload.cjs", import.meta.url))',
+];
+
+describe("source-relative file URL paths", () => {
+ it.each(urlCases)(
+ "resolves %s to the file read by Node",
+ async (reference, target, sourcePath) => {
+ const root = await createTestTempDirectory("rea-file-url-path-");
+ const sourceFile = join(root, sourcePath);
+ await mkdir(dirname(sourceFile), { recursive: true });
+ await writeFile(join(root, target), 'module.exports = "real preload";\n');
+ if (reference.includes("%") && sourcePath === "main.mjs")
+ await writeFile(
+ join(root, reference),
+ 'module.exports = "encoded-name decoy";\n',
+ );
+ const nativePath = fileURLToPath(
+ new URL(reference, pathToFileURL(sourceFile)),
+ );
+ expect(relative(root, nativePath)).toBe(target);
+ expect(await readFile(nativePath, "utf8")).toContain("real preload");
+ await writeFile(
+ sourceFile,
+ `import { fileURLToPath } from "node:url";\nnew BrowserWindow({ webPreferences: { preload: fileURLToPath(new URL(${JSON.stringify(reference)}, import.meta.url)) } });\n`,
+ );
+
+ const result = await analyzeJavaScriptApplication({
+ input_path: root,
+ format: "directory",
+ });
+ expect(result.ok).toBe(true);
+ if (!result.ok) throw result.error;
+ const { graph } = javascriptApplicationAnalysisResultSchema.parse(
+ result.value.normalized_result,
+ );
+ const preloads = graph.nodes.filter(
+ ({ kind }) => kind === "electron-preload",
+ );
+ expect(preloads).toHaveLength(1);
+ expect(preloads[0]?.observations).not.toHaveLength(0);
+ for (const observation of preloads[0]?.observations ?? [])
+ expect(observation.properties).toMatchObject({
+ resolved_path: target,
+ resolution_status: "resolved",
+ resolution_context: "filesystem-expression",
+ });
+ },
+ );
+
+ it.each(unknownExpressions)("leaves unsupported %s unknown", (expression) => {
+ expect(
+ staticPath(parseExpression(expression, { sourceType: "module" })),
+ ).toBeUndefined();
+ });
+
+ it("does not URL-decode literal filesystem punctuation", () => {
+ const expression = 'path.join(__dirname, "preload%20?#.cjs")';
+ expect(
+ staticPath(parseExpression(expression, { sourceType: "module" })),
+ ).toBe("preload%20?#.cjs");
+ });
+});
diff --git a/src/domain/javascriptStaticAnalysisHelpers.ts b/src/domain/javascriptStaticAnalysisHelpers.ts
index 1f1c3a959..a1353690a 100644
--- a/src/domain/javascriptStaticAnalysisHelpers.ts
+++ b/src/domain/javascriptStaticAnalysisHelpers.ts
@@ -1,5 +1,6 @@
import { createHash } from "node:crypto";
import { posix } from "node:path";
+import { fileURLToPath } from "node:url";
import * as t from "@babel/types";
@@ -184,8 +185,7 @@ const staticCallPath = (
? stringValue(node.arguments[0])
: undefined;
if (name === "fileURLToPath" || name.endsWith(".fileURLToPath")) {
- const argument = argumentNode(node.arguments[0]);
- return argument === undefined ? undefined : staticPathAt(argument);
+ return staticFileUrlPath(argumentNode(node.arguments[0]));
}
if (
(name === "dirname" || name.endsWith(".dirname")) &&
@@ -207,6 +207,59 @@ const staticCallPath = (
return parts.length === 0 ? undefined : posix.join(...parts);
};
+const staticFileUrlPath = (
+ argument: t.Node | undefined,
+): string | undefined => {
+ if (argument === undefined) return undefined;
+ return isSourceFileUrl(argument)
+ ? sourceRelativeFileUrlPath(argument)
+ : staticPathAt(argument);
+};
+
+/** Project a known source-relative URL through the actual file URL decoder. */
+const sourceRelativeFileUrlPath = (node: t.Node): string | undefined => {
+ if (!isSourceFileUrl(node)) return undefined;
+ const value = stringValue(node.arguments[0]);
+ if (
+ value === undefined ||
+ (value.split(/[?#]/u, 1)[0] ?? "") === "" ||
+ value !== value.trim() ||
+ value.includes("\\") ||
+ [...value].some((character) => character.charCodeAt(0) < 32) ||
+ /^[a-z][a-z0-9+.-]*:/iu.test(value) ||
+ value.startsWith("//") ||
+ /%(?:2e|2f|5c)/iu.test(value.split(/[?#]/u, 1)[0] ?? "")
+ )
+ return undefined;
+ // A sufficiently deep inert anchor preserves any leading parent segments
+ // without using this host's cwd or inventing the application's directory.
+ const directory = `/${"source/".repeat(value.split("/").length + 1)}`;
+ try {
+ const resolved = new URL(value, `file://${directory}entry.js`);
+ const path = fileURLToPath(resolved, { windows: false });
+ if (value.startsWith("/")) return path;
+ const relative = posix.relative(directory, path) || ".";
+ // Keep the established explicit source-directory observation spelling.
+ return value.startsWith("./") &&
+ relative !== "." &&
+ !relative.startsWith("../")
+ ? `./${relative}`
+ : relative;
+ } catch (cause: unknown) {
+ // Malformed escapes and non-file URL forms remain unknown.
+ void cause;
+ return undefined;
+ }
+};
+
+const isSourceFileUrl = (
+ node: t.Node,
+): node is t.CallExpression | t.NewExpression =>
+ (t.isCallExpression(node) || t.isNewExpression(node)) &&
+ (calleeName(node.callee) === "URL" ||
+ calleeName(node.callee).endsWith(".URL")) &&
+ isFileIdentity(argumentNode(node.arguments[1]));
+
const staticResolvedPath = (
node: t.CallExpression | t.NewExpression,
): string | undefined => {