pre-compute URLPatterns

Author: lipsumar

src/server/http-combo-server.ts

@@ -381,8 +381,8 @@ function analyzeAndMaybePassThroughTls(
     if (passthroughList && interceptOnlyList){
         throw new Error('Cannot use both tlsPassthrough and tlsInterceptOnly options at the same time.');
     }
-    const passThroughHostnames = passthroughList?.map(({ hostname }) => hostname) ?? [];
-    const interceptOnlyHostnames = interceptOnlyList?.map(({ hostname }) => hostname);
+    const passThroughPatterns = passthroughList?.map(({ hostname }) => new URLPattern(`https://${hostname}`)) ?? [];
+    const interceptOnlyPatterns = interceptOnlyList?.map(({ hostname }) => new URLPattern(`https://${hostname}`));
 
     const tlsConnectionListener = server.listeners('connection')[0] as (socket: net.Socket) => {};
     server.removeListener('connection', tlsConnectionListener);
@@ -401,11 +401,11 @@ function analyzeAndMaybePassThroughTls(
                 ja3Fingerprint: calculateJa3FromFingerprintData(helloData.fingerprintData)
             };
 
-            if (shouldPassThrough(connectHostname, passThroughHostnames, interceptOnlyHostnames)) {
+            if (shouldPassThrough(connectHostname, passThroughPatterns, interceptOnlyPatterns)) {
                 const upstreamPort = connectPort ? parseInt(connectPort, 10) : undefined;
                 passthroughListener(socket, connectHostname, upstreamPort);
                 return; // Do not continue with TLS
-            } else if (shouldPassThrough(sniHostname, passThroughHostnames, interceptOnlyHostnames)) {
+            } else if (shouldPassThrough(sniHostname, passThroughPatterns, interceptOnlyPatterns)) {
                 passthroughListener(socket, sniHostname!); // Can't guess the port - not included in SNI
                 return; // Do not continue with TLS
             }
@@ -425,18 +425,18 @@ function analyzeAndMaybePassThroughTls(
 export function shouldPassThrough(
     hostname: string | undefined,
     // Only one of these two should have values (validated above):
-    passThroughHostnames: string[],
-    interceptOnlyHostnames: string[] | undefined
+    passThroughPatterns: URLPattern[],
+    interceptOnlyPatterns: URLPattern[] | undefined
   ): boolean {
     if (!hostname) return false;
 
-    if (interceptOnlyHostnames) {
-      return !interceptOnlyHostnames.some((hn) =>
-        new URLPattern(`https://${hn}`).test(`https://${hostname}`)
+    if (interceptOnlyPatterns) {
+      return !interceptOnlyPatterns.some((pattern) =>
+        pattern.test(`https://${hostname}`)
       );
     }
 
-    return passThroughHostnames.some((hn) =>
-      new URLPattern(`https://${hn}`).test(`https://${hostname}`)
+    return passThroughPatterns.some((pattern) =>
+        pattern.test(`https://${hostname}`)
     );
   }

test/http-combo-server.spec.ts

@@ -1,3 +1,4 @@
+import { URLPattern } from "urlpattern-polyfill";
 import { shouldPassThrough } from "../src/server/http-combo-server";
 import { expect } from "./test-utils";
 
@@ -21,7 +22,7 @@ describe("shouldPassThrough", () => {
     it("should return true when hostname is in passThroughHostnames", () => {
       const should = shouldPassThrough(
         "example.org",
-        ["example.org"],
+        [new URLPattern("https://example.org")],
         undefined
       );
       expect(should).to.be.true;
@@ -30,30 +31,46 @@ describe("shouldPassThrough", () => {
     it("should return false when hostname is not in passThroughHostnames", () => {
       const should = shouldPassThrough(
         "example.org",
-        ["example.com"],
+        [new URLPattern("https://example.com")],
         undefined
       );
       expect(should).to.be.false;
     });
 
     it("should return true when hostname match a wildcard", () => {
-      const should = shouldPassThrough("example.org", ["*.org"], undefined);
+      const should = shouldPassThrough(
+        "example.org",
+        [new URLPattern("https://*.org")],
+        undefined
+      );
       expect(should).to.be.true;
     });
   });
   describe("interceptOnlyHostnames", () => {
     it("should return false when hostname is in interceptOnlyHostnames", () => {
-      const should = shouldPassThrough("example.org", [], ["example.org"]);
+      const should = shouldPassThrough(
+        "example.org",
+        [],
+        [new URLPattern("https://example.org")]
+      );
       expect(should).to.be.false;
     });
 
     it("should return true when hostname is not in interceptOnlyHostnames", () => {
-      const should = shouldPassThrough("example.org", [], ["example.com"]);
+      const should = shouldPassThrough(
+        "example.org",
+        [],
+        [new URLPattern("https://example.com")]
+      );
       expect(should).to.be.true;
     });
 
     it("should return false when hostname match a wildcard", () => {
-      const should = shouldPassThrough("example.org", [], ["*.org"]);
+      const should = shouldPassThrough(
+        "example.org",
+        [],
+        [new URLPattern("https://*.org")]
+      );
       expect(should).to.be.false;
     });
   });