@swf2es/desktop 0.1.16 → 0.1.18

package/src/main/main.ts

@@ -6,6 +6,7 @@
 //   electron apps/desktop [--trace] app.xml [root-dir] [-- arguments...]
 //
 // --ignore-certificate-errors[=host,...] leaves HTTPS and WSS certificates unchecked.
+// --proxy=socks5://[user:pass@]host:port (or http://...) sends the SWF's network through a proxy.
 //
 // The second runs an AIR application by its descriptor, as adl does.
 import { statSync } from "node:fs";
@@ -49,14 +50,23 @@ import {
   statOf,
   writeOf,
 } from "./air.ts";
+import { resolveCase } from "./case-paths.ts";
 import { bridgeFiles } from "./files.ts";
 import { failureLine, requestLine } from "./netlog.ts";
 import { type Movie, Network, Refused, unverifiedHosts } from "./network.ts";
 import { APP_ORIGIN, registerScheme, serve } from "./protocol.ts";
+import { describeProxy, proxyArgument, sameProxy } from "./proxy.ts";
 import { Sandbox } from "./sandbox.ts";
 import { SettingsFile } from "./settings.ts";
 import { bridgeSockets } from "./sockets.ts";
-import { hasWebSocket, unverifiedDispatcher, webSocketOpener } from "./websocket-connections.ts";
+import {
+  dispatchedOpener,
+  hasWebSocket,
+  type Opener,
+  proxiedDispatcher,
+  unverifiedDispatcher,
+  webSocketOpener,
+} from "./websocket-connections.ts";
 import { bridgeWebSockets } from "./websockets.ts";
 
 const preload = fileURLToPath(new URL("../preload/preload.cjs", import.meta.url));
@@ -106,16 +116,54 @@ if (unverified) {
 
 const unverifiedHost = (host: string) =>
   !!unverified && (unverified.all || unverified.hosts.includes(host.toLowerCase()));
-const network = new Network({ unverified: unverifiedHost });
+
+/**
+ * --proxy=<url>: what the SWF's requests, sockets and WebSockets go
+ * through. For this run alone, never kept, and said aloud, without its
+ * credentials. One that does not parse stops the app rather than letting
+ * it run without.
+ */
+const proxied = proxyArgument(process.argv.slice(1));
+if (proxied && "error" in proxied) {
+  process.stderr.write(`swf2es: ${proxied.error}\n`);
+  process.exit(2);
+}
+
+const proxy = proxied?.proxy ?? null;
+if (proxy) {
+  process.stderr.write(
+    `swf2es: --proxy: the SWF's requests, sockets and WebSockets go through ${describeProxy(proxy)}\n`,
+  );
+}
+
+/** What --log-network adds to a line of a connection that went through the proxy. */
+const via = proxy ? " via proxy" : "";
+const warn = (message: string) => process.stderr.write(`swf2es: ${message}\n`);
+const network = new Network({ unverified: unverifiedHost, proxy });
 // What opens an AIR application's WebSockets: the global's client, a wss: server's certificate
-// unchecked where the switch names its host.
-const insecureWebSockets = unverified ? unverifiedDispatcher() : null;
-if (unverified && !insecureWebSockets) {
+// unchecked where the switch names its host; or every one through the proxy.
+const insecureWebSockets = unverified && !proxy ? unverifiedDispatcher() : null;
+if (unverified && !proxy && !insecureWebSockets) {
   process.stderr.write(
     "swf2es: --ignore-certificate-errors: a WebSocket's certificate is verified all the same\n",
   );
 }
 
+const proxiedWebSockets = proxy ? proxiedDispatcher(proxy, unverifiedHost, warn) : null;
+// Never past the proxy: where none can be made, no WebSocket opens.
+const webSocketOpen: Opener | undefined = proxy
+  ? proxiedWebSockets
+    ? dispatchedOpener(proxiedWebSockets)
+    : () => {
+        throw new Error("no WebSocket through the proxy");
+      }
+  : insecureWebSockets
+    ? webSocketOpener(unverifiedHost, insecureWebSockets)
+    : undefined;
+if (proxy && !proxiedWebSockets) {
+  process.stderr.write("swf2es: --proxy: this Electron's WebSocket cannot go through a proxy\n");
+}
+
 /** What the page's requests under way abort with, by the preload's number. */
 const requests = new Map<number, AbortController>();
 let settings: SettingsFile;
@@ -584,13 +632,15 @@ async function askForSocket(name: string, swf: string, endpoint: string): Promis
  * sockets do here. air.net.WebSocket is AIR's alone, so nothing else has one.
  */
 function permitWebSocket(url: string): boolean {
-  if (sandbox.application && hasWebSocket()) {
+  if (sandbox.application && hasWebSocket() && (!proxy || proxiedWebSockets)) {
     return true;
   }
 
-  const why = sandbox.application
-    ? "this Electron has no WebSocket client"
-    : "only an AIR application has one";
+  const why = !sandbox.application
+    ? "only an AIR application has one"
+    : !hasWebSocket()
+      ? "this Electron has no WebSocket client"
+      : "this Electron's WebSocket cannot go through the proxy";
   process.stderr.write(`swf2es: no WebSocket to ${url.slice(0, 2048)}: ${why}\n`);
   return false;
 }
@@ -643,10 +693,22 @@ async function chooseLibrary(name: LibraryName): Promise<void> {
     refuse("The settings could not be saved.", `swf2es uses ${path} until it quits.`);
   }
 
+  buildMenu();
+
   // The page fetched the libraries once; a fresh page fetches the new one.
   window.webContents.reload();
 }
 
+/** Play on the library the app ships again, in place of one the user chose. */
+function resetLibrary(name: LibraryName): void {
+  if (!settings.clearLibrary(name)) {
+    refuse("The settings could not be saved.", `swf2es uses its own ${name} until it quits.`);
+  }
+
+  buildMenu();
+  window?.webContents.reload();
+}
+
 function buildMenu(): void {
   const recent = settings.settings.recent;
   const template: MenuItemConstructorOptions[] = [
@@ -681,6 +743,11 @@ function buildMenu(): void {
         },
         { type: "separator" },
         { label: "Choose playerglobal.abc…", click: () => void chooseLibrary("playerglobal") },
+        {
+          label: "Use the App's playerglobal",
+          enabled: !!settings.settings.playerglobal,
+          click: () => resetLibrary("playerglobal"),
+        },
         { type: "separator" },
         { role: "quit" },
       ],
@@ -913,14 +980,8 @@ function listen(): void {
       void chooseLibrary(name);
     }
   });
-  bridgeSockets(trusted, permitSocket, netLog, logSockets);
-  bridgeWebSockets(
-    trusted,
-    permitWebSocket,
-    insecureWebSockets ? webSocketOpener(unverifiedHost, insecureWebSockets) : undefined,
-    netLog,
-    logSockets,
-  );
+  bridgeSockets(trusted, permitSocket, netLog, logSockets, { proxy, warn });
+  bridgeWebSockets(trusted, permitWebSocket, webSocketOpen, netLog, logSockets, via);
   ipcMain.handle("net:fetch", (event, id: unknown, request: unknown) => {
     if (!trusted(event) || typeof id !== "number") {
       throw new Error("not the app's page");
@@ -1052,7 +1113,7 @@ function listenForAir(): void {
     }
 
     try {
-      const real = await realpath(path);
+      const real = await realpath(resolveCase(path));
       return sandbox.startApplication(real) ? new Uint8Array(await readFile(real)) : null;
     } catch {
       return null;
@@ -1155,7 +1216,7 @@ async function fetchForPage(
         response.status,
         response.bytes?.length ?? null,
         performance.now() - started,
-      ),
+      ) + via,
     );
     return response;
   } catch (error) {
@@ -1164,7 +1225,7 @@ async function fetchForPage(
       const why = error instanceof Refused ? error.message : `failed: ${error}`;
       process.stderr.write(`swf2es: not loading ${shown}: ${why}\n`);
     } else {
-      netLog?.(failureLine(method, url, "aborted", performance.now() - started));
+      netLog?.(failureLine(method, url, "aborted", performance.now() - started) + via);
     }
 
     throw error;
@@ -1178,10 +1239,25 @@ async function fetchForPage(
 // One app to a user data directory: a second start hands its SWF to the first and quits.
 const first = app.requestSingleInstanceLock();
 if (!first) {
+  if (proxied) {
+    process.stderr.write(
+      "swf2es: handed to the app already open, which opens it only if started with the same --proxy\n",
+    );
+  }
+
   app.quit();
 }
 
 app.on("second-instance", (_event, argv, workingDirectory) => {
+  // What it names would go through another proxy than this app's, or past it.
+  const asked = proxyArgument(argv.slice(1));
+  if (asked && !("proxy" in asked && sameProxy(asked.proxy, proxy))) {
+    process.stderr.write(
+      "swf2es: not opening what a second start named: its --proxy is not this app's\n",
+    );
+    return;
+  }
+
   if (window) {
     if (window.isMinimized()) {
       window.restore();
@@ -1231,6 +1307,15 @@ void app.whenReady().then(() => {
   }
 
   settings = new SettingsFile(app.getPath("userData"));
+  // A playerglobal chosen once is kept across versions of the app: said at each start, as a
+  // library older or newer than the app's own makes SWFs fail in ways nothing else explains.
+  const chosen = settings.libraries().playerglobal;
+  if (chosen) {
+    process.stderr.write(
+      `swf2es: playing on the playerglobal chosen in File, ${chosen}, not the app's own\n`,
+    );
+  }
+
   serve(session.defaultSession, sandbox, () => settings.libraries());
   // The page never goes to the network itself: a SWF's requests go through
   // the main process (network.ts), which sends them without this session.

package/src/main/network.ts

@@ -21,12 +21,17 @@
 //   that changes its answer (rebinding) changes nothing.
 // - Requests are bounded: methods, headers, sizes, redirects, time, and
 //   how many run at once; and each movie's are aborted as the next opens.
+// - Through a proxy (--proxy, proxy.ts), each connection is a tunnel to
+//   the address its host was pinned to, judged as without one: the proxy
+//   is asked for that address, not the name, so a proxy's DNS that answers
+//   otherwise than this machine's reaches nothing the judgement did not.
 //
 // Without Electron, so that node tests it (tests/desktop/network.test.ts).
 import { lookup } from "node:dns/promises";
 import { type ClientRequest, request as httpRequest, type IncomingMessage } from "node:http";
 import { request as httpsRequest } from "node:https";
-import { connect, isIP, isIPv4 } from "node:net";
+import { connect, isIP, isIPv4, type Socket } from "node:net";
+import type { Duplex } from "node:stream";
 import * as tls from "node:tls";
 import { type AddressClass, addressClass, badPort, RANK } from "./addresses.ts";
 import { DECODED, Decompressor } from "./decompress.ts";
@@ -44,6 +49,7 @@ import {
   urlMetaPolicy,
   usablePolicies,
 } from "./policy.ts";
+import { connectThrough, type ProxyConfig, ProxyError } from "./proxy.ts";
 
 export type Purpose = "movie" | "content" | "data" | "send";
 
@@ -145,6 +151,8 @@ export interface NetworkOptions {
   limits?: Partial<Limits>;
   /** Where a socket server keeps its master policy: 843. */
   socketPolicyPort?: number;
+  /** What every connection goes through (--proxy); none by default. */
+  proxy?: ProxyConfig | null;
 }
 
 /** What Flash Player 32 reported, sent as it sent it. */
@@ -239,6 +247,7 @@ export class Network {
   private readonly ca: string | string[] | undefined;
   private readonly unverified: (host: string) => boolean;
   private readonly socketPolicyPort: number;
+  private readonly proxy: ProxyConfig | null;
   private session: Session | null = null;
   private running = 0;
   private readonly waiting: (() => void)[] = [];
@@ -253,6 +262,7 @@ export class Network {
     this.ca = options.ca ?? defaultCa();
     this.unverified = options.unverified ?? (() => false);
     this.socketPolicyPort = options.socketPolicyPort ?? 843;
+    this.proxy = options.proxy ?? null;
   }
 
   /**
@@ -753,7 +763,13 @@ export class Network {
         timeout: this.limits.policyTimeout,
         deadline: this.limits.policyTimeout,
       });
-    } catch {
+    } catch (error) {
+      // A proxy that failed is said, as the request that needed the policy fails;
+      // a server the proxy did not reach has no policy, as one that is not there.
+      if (proxyFault(error)) {
+        throw error;
+      }
+
       return null;
     }
 
@@ -790,15 +806,27 @@ export class Network {
     timeout: number,
     signal: AbortSignal,
   ): Promise<SocketPolicy | null> {
-    return new Promise((answer) => {
+    return new Promise((answer, fail) => {
       const chunks: Buffer[] = [];
       let length = 0;
-      const socket = connect({ host: address, port });
-      const finish = (policy: SocketPolicy | null) => {
+      let socket: Socket | null = null;
+      let finished = false;
+      const opening = new AbortController();
+      const finish = (policy: SocketPolicy | null, error?: Error) => {
+        if (finished) {
+          return;
+        }
+
+        finished = true;
         clearTimeout(timer);
         signal.removeEventListener("abort", abort);
-        socket.destroy();
-        answer(policy);
+        opening.abort();
+        socket?.destroy();
+        if (error) {
+          fail(error);
+        } else {
+          answer(policy);
+        }
       };
       const read = () => {
         const text = Buffer.concat(chunks).toString("utf8");
@@ -808,24 +836,70 @@ export class Network {
       const abort = () => finish(null);
       const timer = setTimeout(abort, timeout);
       signal.addEventListener("abort", abort, { once: true });
-      socket.on("connect", () => socket.write("<policy-file-request/>\0"));
-      socket.on("data", (chunk: Buffer) => {
-        length += chunk.length;
-        if (length > this.limits.policy) {
-          finish(null);
-          return;
-        }
+      const talk = (connected: Socket) => {
+        socket = connected;
+        connected.on("data", (chunk: Buffer) => {
+          length += chunk.length;
+          if (length > this.limits.policy) {
+            finish(null);
+            return;
+          }
 
-        chunks.push(chunk);
-        if (chunk.includes(0)) {
-          read();
-        }
-      });
-      socket.on("end", read);
-      socket.on("error", () => finish(null));
+          chunks.push(chunk);
+          if (chunk.includes(0)) {
+            read();
+          }
+        });
+        connected.on("end", read);
+        connected.on("error", () => finish(null));
+      };
+
+      if (!this.proxy) {
+        const direct = connect({ host: address, port });
+        talk(direct);
+        direct.on("connect", () => direct.write("<policy-file-request/>\0"));
+        return;
+      }
+
+      connectThrough(this.proxy, address, port, { signal: opening.signal }).then(
+        (tunnel) => {
+          if (finished) {
+            tunnel.destroy();
+            return;
+          }
+
+          talk(tunnel);
+          tunnel.write("<policy-file-request/>\0");
+        },
+        (error: ProxyError) =>
+          // A server the proxy did not reach has no policy; a proxy that failed is said.
+          finish(null, error.fault ? new Refused(error.message, { cause: error }) : undefined),
+      );
     });
   }
 
+  /**
+   * A request's createConnection: a tunnel through `proxy` to `address`,
+   * with TLS over it where `secure` says how, as Node's callback form takes
+   * it. A proxy's failure is a refusal saying why, the ProxyError its cause.
+   */
+  private tunnel(
+    proxy: ProxyConfig,
+    address: string,
+    port: number,
+    secure: tls.ConnectionOptions | false,
+    signal: AbortSignal,
+  ) {
+    return (_options: unknown, done: (error: Error | null, socket: Duplex) => void) => {
+      connectThrough(proxy, address, port, { signal }).then(
+        (tunnel) => done(null, secure ? tls.connect({ ...secure, socket: tunnel }) : tunnel),
+        (error: ProxyError) =>
+          done(new Refused(error.message, { cause: error }), undefined as unknown as Duplex),
+      );
+      return undefined;
+    };
+  }
+
   /**
    * One HTTP exchange with `address`, the URL's host pinned to it: its
    * status and headers, and its body if `read` and the status is a
@@ -877,28 +951,41 @@ export class Network {
 
       const https = url.protocol === "https:";
       const family = isIP(address);
+      const port = Number(url.port || (https ? 443 : 80));
+      const secure: tls.ConnectionOptions = {
+        servername: isIP(host) ? undefined : host,
+        ca: this.ca,
+        // Only where the user asked for this host: its certificate goes unchecked.
+        ...(this.unverified(host) ? { rejectUnauthorized: false } : {}),
+      };
       let request: ClientRequest;
       try {
         request = (https ? httpsRequest : httpRequest)({
           host,
-          port: url.port || (https ? 443 : 80),
+          port,
           path: `${url.pathname}${url.search}`,
           method,
           headers: outgoing,
-          agent: false,
-          // The address pinned for this request, whatever the resolver would say now.
-          lookup: (_name, opts, callback) => {
-            if ((opts as { all?: boolean }).all) {
-              (callback as (e: null, a: { address: string; family: number }[]) => void)(null, [
-                { address, family },
-              ]);
-            } else {
-              (callback as (e: null, a: string, f: number) => void)(null, address, family);
-            }
-          },
-          ...(https ? { servername: isIP(host) ? undefined : host, ca: this.ca } : {}),
-          // Only where the user asked for this host: its certificate goes unchecked.
-          ...(https && this.unverified(host) ? { rejectUnauthorized: false } : {}),
+          ...(this.proxy
+            ? // Through the proxy to the pinned address, TLS over the tunnel for https; the
+              // request's own timers and signal bound the proxy's part too. No agent: the
+              // connection is this one's.
+              { createConnection: this.tunnel(this.proxy, address, port, https && secure, signal) }
+            : {
+                agent: false,
+                // The address pinned for this request, whatever the resolver would say now.
+                lookup: (_name, opts, callback) => {
+                  if ((opts as { all?: boolean }).all) {
+                    (callback as (e: null, a: { address: string; family: number }[]) => void)(
+                      null,
+                      [{ address, family }],
+                    );
+                  } else {
+                    (callback as (e: null, a: string, f: number) => void)(null, address, family);
+                  }
+                },
+                ...(https ? secure : {}),
+              }),
         });
       } catch (error) {
         // What check() let through and Node still refuses: a refusal like any other.
@@ -931,7 +1018,10 @@ export class Network {
       const abort = () => stop(new Refused("aborted"));
       signal.addEventListener("abort", abort, { once: true });
       arm();
-      request.on("error", (error) => stop(new Refused(error.message)));
+      // A proxy's refusal comes as it was made, with its cause.
+      request.on("error", (error) =>
+        stop(error instanceof Refused ? error : new Refused(error.message)),
+      );
       request.on("response", (response: IncomingMessage) => {
         const status = response.statusCode ?? 0;
         const received: [string, string][] = [];
@@ -1195,11 +1285,24 @@ function cached<T>(
 
     value = make();
     cache.set(key, value);
+    // A failure, a proxy's, is not kept: the next request asks again.
+    const made = value;
+    made.catch(() => {
+      if (cache.get(key) === made) {
+        cache.delete(key);
+      }
+    });
   }
 
   return value;
 }
 
+/** Whether `error` is a refusal for a proxy that failed, not a server it did not reach. */
+function proxyFault(error: unknown): boolean {
+  const cause = (error as Error | null)?.cause;
+  return cause instanceof ProxyError && cause.fault;
+}
+
 function describe(requester: Requester): string {
   return requester.host === null ? 'a local SWF (domain="*")' : requester.host;
 }