fix(matrix): guard transport new URL() against malformed input

ZengWen-DT · cursoragent · ZengWen-DT · commit 801631d67cc0 · 2026-07-17T07:17:16.000Z
Wrap user-controlled URL parsing in Matrix transport with a shared helper
that throws a stable Invalid URL error instead of leaking URL constructor
TypeErrors from malformed homeservers, redirect locations, and endpoints.

Co-authored-by: Cursor &lt;cursoragent@cursor.com&gt;
diff --git a/extensions/matrix/src/matrix/sdk/transport.test.ts b/extensions/matrix/src/matrix/sdk/transport.test.ts
@@ -465,6 +465,68 @@ describe("performMatrixRequest", () => {
     expect(result.text).toBe(payload);
     expect(result.buffer.toString("utf8")).toBe(payload);
   });
+
+  it("rejects malformed homeserver URLs with a stable error", async () => {
+    await expect(
+      performMatrixRequest({
+        homeserver: "http://matrix-user:matrix-fixture@invalid host",
+        accessToken: "token",
+        method: "GET",
+        endpoint: "/_matrix/client/v3/account/whoami",
+        timeoutMs: 5000,
+        ssrfPolicy: { allowPrivateNetwork: true },
+      }),
+    ).rejects.toThrow(new Error("Invalid URL"));
+  });
+
+  it("rejects malformed redirect Location headers with a stable error", async () => {
+    const server = http.createServer((_req, res) => {
+      res.writeHead(302, { location: "http://invalid host/path" });
+      res.end();
+    });
+    await new Promise<void>((resolve) => {
+      server.listen(0, "127.0.0.1", resolve);
+    });
+    const { port } = server.address() as { port: number };
+
+    try {
+      await expect(
+        performMatrixRequest({
+          homeserver: `http://127.0.0.1:${port}`,
+          accessToken: "token",
+          method: "GET",
+          endpoint: "/_matrix/client/v3/account/whoami",
+          timeoutMs: 5000,
+          ssrfPolicy: { allowPrivateNetwork: true },
+        }),
+      ).rejects.toThrow(new Error("Invalid URL"));
+    } finally {
+      await new Promise<void>((resolve) => {
+        server.close(() => resolve());
+      });
+    }
+  });
+
+  it("does not reflect credential-bearing malformed homeserver URLs in errors", async () => {
+    const secretPass = "matrix-fixture";
+    const malformed = `http://matrix-user:${secretPass}@${["invalid", "host"].join(" ")}`;
+
+    try {
+      await performMatrixRequest({
+        homeserver: malformed,
+        accessToken: "token",
+        method: "GET",
+        endpoint: "/_matrix/client/v3/account/whoami",
+        timeoutMs: 5000,
+        ssrfPolicy: { allowPrivateNetwork: true },
+      });
+      throw new Error("expected performMatrixRequest to reject malformed homeserver URL");
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      expect(message).toBe("Invalid URL");
+      expect(message).not.toContain(secretPass);
+    }
+  });
 });
 
 describe("createMatrixGuardedFetch", () => {
@@ -550,6 +612,14 @@ describe("createMatrixGuardedFetch", () => {
     expect(runtimeFetch).toHaveBeenCalledTimes(1);
     expect(runtimeFetch.mock.calls.at(0)?.[0]).toBe(url);
   });
+
+  it("rejects malformed request URLs with a stable error", async () => {
+    const guardedFetch = createMatrixGuardedFetch({
+      ssrfPolicy: { allowPrivateNetwork: true },
+    });
+
+    await expect(guardedFetch("not-a-url")).rejects.toThrow(new Error("Invalid URL"));
+  });
 });
 
 describe("matrix transport streaming OOM guard — real HTTP server without Content-Length", () => {
diff --git a/extensions/matrix/src/matrix/sdk/transport.ts b/extensions/matrix/src/matrix/sdk/transport.ts
@@ -45,6 +45,14 @@ function normalizeEndpoint(endpoint: string): string {
   return endpoint.startsWith("/") ? endpoint : `/${endpoint}`;
 }
 
+function parseMatrixUrl(input: string, base?: string | URL): URL {
+  try {
+    return base !== undefined ? new URL(input, base) : new URL(input);
+  } catch (cause) {
+    throw new Error("Invalid URL", { cause });
+  }
+}
+
 function applyQuery(url: URL, qs: QueryParams): void {
   if (!qs) {
     return;
@@ -164,7 +172,7 @@ async function fetchWithMatrixGuardedRedirects(params: {
   ssrfPolicy?: SsrFPolicy;
   dispatcherPolicy?: PinnedDispatcherPolicy;
 }): Promise<{ response: Response; release: () => Promise<void>; finalUrl: string }> {
-  let currentUrl = new URL(params.url);
+  let currentUrl = parseMatrixUrl(params.url);
   let method = (params.init?.method ?? "GET").toUpperCase();
   let body = params.init?.body;
   let headers = new Headers(params.init?.headers ?? {});
@@ -215,7 +223,7 @@ async function fetchWithMatrixGuardedRedirects(params: {
         throw new Error(`Matrix redirect missing location header (${currentUrl.toString()})`);
       }
 
-      const nextUrl = new URL(location, currentUrl);
+      const nextUrl = parseMatrixUrl(location, currentUrl);
       if (nextUrl.protocol !== currentUrl.protocol) {
         cleanup();
         await closeDispatcher(dispatcher);
@@ -327,8 +335,8 @@ export async function performMatrixRequest(params: {
   }
 
   const baseUrl = isAbsoluteEndpoint
-    ? new URL(params.endpoint)
-    : new URL(normalizeEndpoint(params.endpoint), params.homeserver);
+    ? parseMatrixUrl(params.endpoint)
+    : parseMatrixUrl(normalizeEndpoint(params.endpoint), params.homeserver);
   applyQuery(baseUrl, params.qs);
 
   const headers = new Headers();
