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(javascript): respect HTML base URL components (#589)
Rudy Mizrahi Celekliffbde92f9ab6
diff --git a/src/application/JavaScriptArtifactPathResolution.ts b/src/application/JavaScriptArtifactPathResolution.tsindex c30c04fe7..8a165eb7b 100644--- a/src/application/JavaScriptArtifactPathResolution.ts+++ b/src/application/JavaScriptArtifactPathResolution.ts@@ -108,13 +108,19 @@ const rejectDeclaration = (return unresolvedOutcome(input, "rejected", ["NUL and backslash path syntax are not admitted for canonical artifact paths.",]);- if (/%(?:2e|2f|5c)/iu.test(declared))+ if (!admitsCanonicalPathSyntax(declared))return unresolvedOutcome(input, "rejected", ["Encoded dot or separator bytes are rejected before artifact path resolution.",]);return null;};+/** Path syntax admitted for a canonical artifact path. */+const admitsCanonicalPathSyntax = (value: string): boolean =>+ !value.includes("\0") &&+ !value.includes("\\") &&+ !/%(?:2e|2f|5c)/iu.test(value);+const contextualCandidate = (input: ResolveArtifactPathInput,): string | ArtifactPathResolution => {@@ -206,25 +212,54 @@ const htmlCandidate = (input: ResolveArtifactPathInput,): string | ArtifactPathResolution => {const declared = stripQueryAndFragment(input.declaredPath);- if (hasScheme(declared))+ if (hasScheme(declared) || declared.startsWith("//"))return unresolvedOutcome(input, "external", ["External HTML references are not mapped to local artifact assets.",]);+ const rawBase = input.htmlBaseHref;+ const base =+ rawBase === undefined || rawBase === null+ ? rawBase+ : stripQueryAndFragment(rawBase);+ if (+ base !== undefined &&+ base !== null &&+ (hasScheme(base) || base.startsWith("//"))+ )+ return unresolvedOutcome(input, "external", [+ "The document base href is external, so its script reference is not a local artifact path.",+ ]);if (declared.startsWith("/")) return declared.slice(1);- const base = input.htmlBaseHref;if (base === undefined || base === null || base === "")return posix.join(posix.dirname(input.sourcePath), declared);- if (hasScheme(base))- return unresolvedOutcome(input, "external", [- "The document base href is external, so its script reference is not a local artifact path.",+ // A local base href is a second untrusted path input; apply the same+ // admission rules a declared path gets so it cannot smuggle traversal or+ // separator syntax past canonicalization.+ if (!admitsCanonicalPathSyntax(base))+ return unresolvedOutcome(input, "rejected", [+ "The document base href uses NUL, backslash, or encoded dot and separator bytes that are not admitted for canonical artifact paths.",]);const basePath = base.startsWith("/")? base.slice(1): posix.join(posix.dirname(input.sourcePath), base);- const baseDirectory = base.endsWith("/") ? basePath : posix.dirname(basePath);- return posix.join(baseDirectory, declared);+ return posix.join(htmlBaseDirectory(base, basePath), declared);};+/**+ * The directory a relative HTML reference resolves against. A base path+ * ending in "/" or in a "." or ".." segment is already a directory, because a+ * relative reference resolves against the base URL's directory and those+ * segments are dropped rather than stepped through.+ */+const htmlBaseDirectory = (base: string, basePath: string): string =>+ base.endsWith("/") ||+ base.endsWith("/.") ||+ base.endsWith("/..") ||+ base === "." ||+ base === ".."+ ? basePath+ : posix.dirname(basePath);+const confineCandidate = (input: ResolveArtifactPathInput,candidate: string,diff --git a/src/application/JavaScriptHtmlBaseResolution.test.ts b/src/application/JavaScriptHtmlBaseResolution.test.tsnew file mode 100644index 000000000..a5a9fe93c--- /dev/null+++ b/src/application/JavaScriptHtmlBaseResolution.test.ts@@ -0,0 +1,111 @@+import { describe, expect, it } from "vitest";+import { resolveArtifactPathByContext } from "./JavaScriptArtifactPathResolution.js";+import type { JavaScriptArtifactFile } from "./JavaScriptArtifactFiles.js";+const paths = [+ "renderer/index.html",+ "assets/app.js",+ "renderer/app.js",+ "renderer/a/app.js",+ "app.js",+];+const files = new Map<string, JavaScriptArtifactFile>(+ paths.map((path) => [+ path,+ {+ path,+ container_sha256: "a".repeat(64),+ sha256: "b".repeat(64),+ bytes: 0,+ inventory_artifact_id: path,+ kind: "javascript",+ unpacked: false,+ text: { included: true, value: "" },+ },+ ]),+);+const resolve = (declaredPath: string, htmlBaseHref: string) =>+ resolveArtifactPathByContext({+ declaredPath,+ htmlBaseHref,+ sourcePath: "renderer/index.html",+ context: "html-reference",+ files,+ });+const documentUrl = "https://artifact.test/renderer/index.html";+describe("HTML base href URL components", () => {+ it.each([+ "/assets/?cache=/wrong/",+ "/assets/#/wrong/",+ "/assets/index.html?cache=/wrong/",+ ])("ignores query and fragment path-looking characters in %s", (base) => {+ expect(+ new URL(+ "app.js",+ new URL(base, "https://artifact.test/renderer/index.html"),+ ).pathname,+ ).toBe("/assets/app.js");+ expect(resolve("app.js", base)).toMatchObject({+ resolution_status: "resolved",+ resolved_path: "assets/app.js",+ });+ });+ it.each(["https://external.test/", "//external.test/"])(+ "keeps root-relative references external when their base is %s",+ (base) => {+ expect(resolve("/assets/app.js", base)).toMatchObject({+ resolution_status: "external",+ resolved_path: null,+ });+ },+ );+});+describe("HTML base href dot segments", () => {+ it.each([+ [".", "renderer/app.js"],+ ["./", "renderer/app.js"],+ ["a/.", "renderer/a/app.js"],+ ["a/..", "renderer/app.js"],+ ["..", "app.js"],+ ])(+ "resolves %s against the document directory like the URL parser",+ (base, expected) => {+ // A relative reference resolves against the base URL's directory, which+ // drops a trailing "." or ".." segment instead of stepping through it.+ expect(+ decodeURIComponent(+ new URL("app.js", new URL(base, documentUrl)).pathname,+ ).replace(/^\/+/, ""),+ ).toBe(expected);+ expect(resolve("app.js", base)).toMatchObject({+ resolution_status: "resolved",+ resolved_path: expected,+ });+ },+ );+});+describe("HTML base href path syntax", () => {+ it.each(["%2e%2e/secret/", "/a/%2e%2e/", "/a\\b/", "a\0b"])(+ "rejects base href %j with the same admission rules a declared path gets",+ (base) => {+ const outcome = resolve("app.js", base);+ expect(outcome.resolution_status).toBe("rejected");+ expect(outcome.limitations[0]).toContain(+ "not admitted for canonical artifact paths",+ );+ },+ );+ it("still confines a base href that escapes the artifact root", () => {+ expect(resolve("app.js", "/a/../../secret/")).toMatchObject({+ resolution_status: "rejected",+ limitations: [+ "The resolved candidate escapes the canonical artifact root.",+ ],+ });+ });+ it("reports an external base href as external rather than malformed", () => {+ expect(resolve("app.js", "https://external.test/%2e%2e/")).toMatchObject({+ resolution_status: "external",+ resolved_path: null,+ });+ });+});