@swf2es/desktop 0.1.19 → 0.1.21

package/src/main/permissions.ts

@@ -0,0 +1,135 @@
+// Whether the SWF playing may open a socket or a WebSocket, and where to:
+// the user asked once a server, and a remote SWF's socket policy.
+import { dialog } from "electron";
+import { allowedOnce, current, deniedOnce, networkMovie } from "./open.ts";
+import { sandbox, settings, window } from "./state.ts";
+import { network, proxiedWebSockets, proxy } from "./switches.ts";
+import { hasWebSocket } from "./websocket-connections.ts";
+
+/** The prompts on screen, by "host:port": a second connection there waits on the first's answer. */
+const asking = new Map<string, Promise<boolean>>();
+
+/**
+ * Whether the SWF playing may connect a socket to `host`:`port`, and where
+ * to: only with the network, and only as the user allows, once or always
+ * for that SWF, when it first asks for that server; and for a remote SWF,
+ * as that server's socket policy allows, at the address it came from.
+ * Denied where no one can be asked.
+ */
+export async function permitSocket(
+  host: string,
+  port: number,
+): Promise<{ address?: string } | null> {
+  // AIR's application sandbox connects where it likes, unasked, with no socket policy.
+  if (sandbox.application) {
+    return {};
+  }
+
+  const playing = current;
+  const swf = sandbox.swf;
+  const endpoint = `${host}:${port}`;
+  if (!playing || !swf || !sandbox.networkAllowed()) {
+    process.stderr.write(`swf2es: no socket to ${endpoint}: the SWF has no network\n`);
+    return null;
+  }
+
+  if (!(await allowedByUser(playing, swf, endpoint))) {
+    return null;
+  }
+
+  if (networkMovie?.kind !== "remote") {
+    return {};
+  }
+
+  try {
+    return { address: await network.socketAddress(host, port) };
+  } catch (error) {
+    process.stderr.write(`swf2es: no socket to ${endpoint}: ${(error as Error).message}\n`);
+    return null;
+  }
+}
+
+/** Whether the user allows the SWF playing a socket to `endpoint`, asked once a server. */
+async function allowedByUser(
+  playing: NonNullable<typeof current>,
+  swf: string,
+  endpoint: string,
+): Promise<boolean> {
+  if (settings.socketAllowed(swf, endpoint) || allowedOnce.has(endpoint)) {
+    return true;
+  }
+
+  if (deniedOnce.has(endpoint)) {
+    return false;
+  }
+
+  let answer = asking.get(endpoint);
+  if (!answer) {
+    answer = askForSocket(playing.movie.name, swf, endpoint).finally(() => asking.delete(endpoint));
+    asking.set(endpoint, answer);
+  }
+
+  return (await answer) && current === playing;
+}
+
+async function askForSocket(name: string, swf: string, endpoint: string): Promise<boolean> {
+  if (!window) {
+    return false;
+  }
+
+  const playing = current;
+  let response: number;
+  try {
+    ({ response } = await dialog.showMessageBox(window, {
+      type: "question",
+      message: `${name} asks to connect to ${endpoint}.`,
+      detail:
+        "A socket lets the SWF send that server whatever it has. " +
+        "Allow it only for a server you trust.",
+      buttons: ["Allow Once", "Always Allow for This SWF", "Deny"],
+      defaultId: 2,
+      cancelId: 2,
+      noLink: true,
+    }));
+  } catch {
+    return false;
+  }
+
+  if (current !== playing) {
+    return false;
+  }
+
+  switch (response) {
+    case 0:
+      allowedOnce.add(endpoint);
+      return true;
+    case 1:
+      if (!settings.allowSocket(swf, endpoint)) {
+        allowedOnce.add(endpoint);
+      }
+
+      return true;
+    default:
+      deniedOnce.add(endpoint);
+      return false;
+  }
+}
+
+/**
+ * Whether what plays may open a WebSocket to `url`: an AIR application,
+ * unasked and anywhere, as AIR's application sandbox connects and as its
+ * sockets do here. air.net.WebSocket is AIR's alone, so nothing else has one.
+ */
+export function permitWebSocket(url: string): boolean {
+  if (sandbox.application && hasWebSocket() && (!proxy || proxiedWebSockets)) {
+    return true;
+  }
+
+  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;
+}

package/src/main/settings.ts

@@ -1,12 +1,18 @@
 // What the app remembers between runs, in settings.json under its user
-// data: a playerglobal.abc the user chose, and the SWFs opened last.
+// data: a playerglobal.abc the user chose, the SWFs opened last, and
+// Stage3D turned off or on from the View menu.
 import { randomUUID } from "node:crypto";
 import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import type { LibraryName, LibraryState } from "../shared/api.js";
 
 export interface Settings {
-  stage3D: boolean;
+  /**
+   * Stage3D as the View menu last set it; absent until it does, which is on. Not `stage3D`, the
+   * key of the opt-in this replaced: every write saved that one, its `false` along with any other
+   * change, so a stored `false` there does not tell a user's choice from the old default.
+   */
+  stage3DChoice?: boolean;
   playerglobal?: string;
   /** Most recent first. */
   recent: string[];
@@ -49,8 +55,13 @@ export class SettingsFile {
     return this.update({ [name]: undefined });
   }
 
+  /** Whether SWFs get a Context3D: on unless the user turned it off. */
+  get stage3D(): boolean {
+    return this.current.stage3DChoice ?? true;
+  }
+
   setStage3D(enabled: boolean): boolean {
-    return this.update({ stage3D: enabled });
+    return this.update({ stage3DChoice: enabled });
   }
 
   /** `path` opened: first in the recent list. */
@@ -84,7 +95,7 @@ export class SettingsFile {
       const read = JSON.parse(readFileSync(this.path, "utf8"));
       const text = (value: unknown) => (typeof value === "string" ? value : undefined);
       return {
-        stage3D: read.stage3D === true,
+        stage3DChoice: typeof read.stage3DChoice === "boolean" ? read.stage3DChoice : undefined,
         playerglobal: text(read.playerglobal),
         recent: strings(read.recent),
         sockets: Object.fromEntries(
@@ -95,7 +106,7 @@ export class SettingsFile {
       };
     } catch {
       // None yet, or unreadable: start again rather than refuse to start.
-      return { stage3D: false, recent: [], sockets: {} };
+      return { recent: [], sockets: {} };
     }
   }
 

package/src/main/state.ts

@@ -0,0 +1,44 @@
+// What the main process's modules share: the window, its page, the
+// settings and the sandbox of what plays. main.ts alone changes the
+// window, the settings and whether the page listens, through the setters
+// here, since a module cannot assign another's bindings; the rest read
+// them as they are now.
+import type { BrowserWindow, IpcMainEvent, IpcMainInvokeEvent } from "electron";
+import { APP_ORIGIN } from "./protocol.ts";
+import { Sandbox } from "./sandbox.ts";
+import type { SettingsFile } from "./settings.ts";
+
+export const TITLE = "swf2es";
+
+export const sandbox = new Sandbox();
+export let settings: SettingsFile;
+export let window: BrowserWindow | null = null;
+/**
+ * The page has asked to start and listens for what opens: until then, start() hands it the movie.
+ */
+export let listening = false;
+
+export function setWindow(created: BrowserWindow | null): void {
+  window = created;
+}
+
+export function setSettings(read: SettingsFile): void {
+  settings = read;
+}
+
+export function setListening(now: boolean): void {
+  listening = now;
+}
+
+/** Whether a message comes from the window's own page, on swf2es://app/. */
+export function trusted(event: IpcMainEvent | IpcMainInvokeEvent): boolean {
+  const frame = event.senderFrame;
+  return (
+    window !== null &&
+    event.sender === window.webContents &&
+    frame !== null &&
+    frame.parent === null &&
+    // Node's URL gives a scheme it does not know no origin: compare the text.
+    frame.url.startsWith(`${APP_ORIGIN}/`)
+  );
+}

package/src/main/switches.ts

@@ -0,0 +1,87 @@
+// The command line's switches for this run alone, and what they make:
+// --trace and the network's logs, --ignore-certificate-errors and --proxy,
+// the network judged through them and what opens an AIR application's
+// WebSockets. Each said on stderr as the app starts.
+import { Network } from "./network.ts";
+import { unverifiedHosts } from "./network-rules.ts";
+import { describeProxy, proxyArgument } from "./proxy.ts";
+import {
+  dispatchedOpener,
+  type Opener,
+  proxiedDispatcher,
+  unverifiedDispatcher,
+  webSocketOpener,
+} from "./websocket-connections.ts";
+
+/** --trace: what the page logs, a SWF's trace() among it, goes to the terminal. */
+export const trace = process.argv.includes("--trace");
+// Each request and socket of the SWF's said on stderr: the page's DevTools show none of them.
+// --log-sockets says what each socket sends and receives as well, and so the rest too.
+export const logSockets = process.argv.includes("--log-sockets");
+const logNetwork = logSockets || process.argv.includes("--log-network");
+export const netLog = logNetwork ? (line: string) => process.stderr.write(`${line}\n`) : null;
+/** The SWF's http and https requests, judged as Flash's sandboxes had them. */
+/**
+ * --ignore-certificate-errors[=host,...]: HTTPS servers whose certificates go
+ * unchecked, for one's own with a certificate it signed itself. For this
+ * run alone, never kept, and said aloud: anyone on the way to such a host
+ * can read and change what the SWF loads from it.
+ */
+const unverified = unverifiedHosts(process.argv.slice(1));
+if (unverified) {
+  process.stderr.write(
+    unverified.all
+      ? "swf2es: --ignore-certificate-errors: no HTTPS or WSS server's certificate is verified\n"
+      : `swf2es: --ignore-certificate-errors: certificates are not verified for ${unverified.hosts.join(", ") || "no host"}\n`,
+  );
+}
+
+const unverifiedHost = (host: string) =>
+  !!unverified && (unverified.all || unverified.hosts.includes(host.toLowerCase()));
+
+/**
+ * --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.
+ */
+export const proxied = proxyArgument(process.argv.slice(1));
+if (proxied && "error" in proxied) {
+  process.stderr.write(`swf2es: ${proxied.error}\n`);
+  process.exit(2);
+}
+
+export 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. */
+export const via = proxy ? " via proxy" : "";
+export const warn = (message: string) => process.stderr.write(`swf2es: ${message}\n`);
+export 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; 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",
+  );
+}
+
+export const proxiedWebSockets = proxy ? proxiedDispatcher(proxy, unverifiedHost, warn) : null;
+// Never past the proxy: where none can be made, no WebSocket opens.
+export 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");
+}

package/src/renderer/index.ts

@@ -113,7 +113,7 @@ document.addEventListener("drop", (event) => {
   }
 });
 
-// An open or close during optional backend loading takes precedence over the startup snapshot.
+// An open or close while the page starts takes precedence over the startup snapshot.
 let started = false;
 let pending: OpenedMovie | null | undefined;
 desktop.onOpen((movie) => {
@@ -133,12 +133,23 @@ desktop.onClose(() => {
 const state = await desktop.start();
 configure({ build: state.build ?? undefined });
 if (state.stage3D) {
-  try {
-    const { createStage3D } = await import("./stage3d.js");
-    configure({ stage3D: createStage3D });
-  } catch (error) {
-    console.warn("swf2es: Stage3D backend could not be loaded; using default playback.", error);
-  }
+  // The WebGL2 backend loads when a SWF first asks for a context, so that one that never does
+  // starts without waiting for it.
+  configure({
+    stage3D: {
+      load: () =>
+        import("./stage3d.js").then(
+          (backend) => backend.createStage3D,
+          (error) => {
+            console.warn(
+              "swf2es: Stage3D backend could not be loaded; Context3D unavailable.",
+              error,
+            );
+            throw error;
+          },
+        ),
+    },
+  });
 }
 
 useLibraries(state.libraries);