roxxie-proxy-u-prod 0.1.0

package/source/packages/scramjet/packages/core/src/client/shared/requests/fetch.ts

@@ -0,0 +1,67 @@
+import { ScramjetClient } from "@client/index";
+import { unrewriteLinkHeader } from "./xmlhttprequest";
+import { String } from "@/shared/snapshot";
+
+/**
+ * Capture the page's intended `init.mode` / `init.credentials` and forward
+ * them to `rewriteUrl` so they get stamped onto the proxy URL as `sj$mode` /
+ * `sj$cred`. The service-side handler reads those back when computing
+ * Sec-Fetch-Mode / Sec-Fetch-Storage-Access, since `event.request.mode` and
+ * `event.request.credentials` from the SW are derived against the rewritten
+ * same-origin URL and don't reflect the page's actual intent.
+ */
+function rewriteUrlOptionsForFetch(init: RequestInit | undefined) {
+	return {
+		// `fetch()` and `new Request()` both default mode to "cors" per spec.
+		mode: init?.mode ?? "cors",
+		credentials: init?.credentials === "include" ? "include" : undefined,
+	};
+}
+
+export default function (client: ScramjetClient) {
+	client.Proxy("fetch", {
+		apply(ctx) {
+			if (client.box.instanceof(ctx.args[0], "Request")) return;
+			const url = String(ctx.args[0]);
+			ctx.args[0] = client.rewriteUrl(
+				url,
+				rewriteUrlOptionsForFetch(ctx.args[1] as RequestInit | undefined)
+			);
+		},
+	});
+
+	client.Proxy("Request", {
+		construct(ctx) {
+			if (client.box.instanceof(ctx.args[0], "Request")) return;
+			const url = String(ctx.args[0]);
+			ctx.args[0] = client.rewriteUrl(
+				url,
+				rewriteUrlOptionsForFetch(ctx.args[1] as RequestInit | undefined)
+			);
+		},
+	});
+
+	client.Trap(["Request.prototype.url", "Response.prototype.url"], {
+		get(ctx) {
+			return client.unrewriteUrl(ctx.get() as string);
+		},
+	});
+
+	// TODO: this needs to be only for response objects created from a fetch
+	client.Trap("Response.prototype.headers", {
+		get(ctx) {
+			const headers = ctx.get() as Headers;
+			const newHeaders = new Headers();
+
+			for (const [key, value] of headers.entries()) {
+				if (key.toLowerCase() === "link") {
+					newHeaders.append(key, unrewriteLinkHeader(value, client.context));
+				} else {
+					newHeaders.append(key, value);
+				}
+			}
+
+			return newHeaders;
+		},
+	});
+}

package/source/packages/scramjet/packages/core/src/client/shared/requests/websocket.ts

@@ -0,0 +1,389 @@
+import { type BareCompatibleWebSocket } from "@mercuryworkshop/proxy-transports";
+import { ScramjetClient } from "@client/index";
+import {
+	Object_setPrototypeOf,
+	Reflect_get,
+	_URL,
+	_WeakMap,
+} from "@/shared/snapshot";
+
+type FakeWebSocketState = {
+	protocol: string;
+	extensions: string;
+	url: string;
+	binaryType: string;
+	barews: BareCompatibleWebSocket;
+
+	onopen: (ev: Event) => any | null;
+	onmessage: (ev: MessageEvent) => any | null;
+	onclose: (ev: CloseEvent) => any | null;
+	onerror: (ev: Event) => any | null;
+};
+type FakeWebSocketStreamState = {
+	protocol: string;
+	extensions: string;
+	url: string;
+	barews: BareCompatibleWebSocket;
+
+	opened: any;
+	closed: any;
+	readable: ReadableStream;
+	writable: WritableStream;
+};
+export default function (client: ScramjetClient, self: GlobalThis) {
+	const socketmap: WeakMap<WebSocket, FakeWebSocketState> =
+		new _WeakMap() as WeakMap<WebSocket, FakeWebSocketState>;
+	const socketstreammap: WeakMap<WebSocketStream, FakeWebSocketStreamState> =
+		new _WeakMap() as WeakMap<WebSocketStream, FakeWebSocketStreamState>;
+	client.Proxy("WebSocket", {
+		construct(ctx) {
+			const fakeWebSocket = new EventTarget() as WebSocket;
+			Object_setPrototypeOf(fakeWebSocket, ctx.fn.prototype);
+			fakeWebSocket.constructor = ctx.fn;
+
+			// websockets can take relative URLs
+			let rawurl = new _URL(ctx.args[0], client.url.href);
+			if (rawurl.protocol === "http:") {
+				rawurl = new _URL(
+					"ws:" + rawurl.href.substring(rawurl.protocol.length)
+				);
+			} else if (rawurl.protocol === "https:") {
+				rawurl = new _URL(
+					"wss:" + rawurl.href.substring(rawurl.protocol.length)
+				);
+			}
+			const url = rawurl.href;
+
+			const trustEvent = (ev: Event) =>
+				new Proxy(ev, {
+					get(target, prop) {
+						if (prop === "isTrusted") return true;
+
+						return Reflect_get(target, prop);
+					},
+				});
+
+			const barews = client.bare.createWebSocket(url, ctx.args[1], [
+				["User-Agent", self.navigator.userAgent],
+				["Origin", client.url.origin],
+				["Cookie", client.context.cookieJar.getCookies(client.url, false)],
+			]);
+
+			const state: FakeWebSocketState = {
+				protocol: "",
+				extensions: "",
+				url,
+				binaryType: "blob",
+				barews,
+
+				onopen: null,
+				onmessage: null,
+				onclose: null,
+				onerror: null,
+			};
+
+			function fakeEventSend(fakeev: Event) {
+				state["on" + fakeev.type]?.(trustEvent(fakeev));
+				fakeWebSocket.dispatchEvent(fakeev);
+			}
+
+			barews.addEventListener("open", () => {
+				fakeEventSend(new Event("open"));
+			});
+			barews.addEventListener("close", (ev) => {
+				fakeEventSend(new CloseEvent("close", ev));
+			});
+			barews.addEventListener("message", async (ev) => {
+				let payload = ev.data;
+				if (typeof payload === "string") {
+					// DO NOTHING
+				} else if ("byteLength" in payload) {
+					// arraybuffer, convert to blob if needed or set the proper prototype
+					if (state.binaryType === "blob") {
+						payload = new Blob([payload]);
+					} else {
+						Object_setPrototypeOf(payload, ArrayBuffer.prototype);
+					}
+				} else if ("arrayBuffer" in payload) {
+					// blob, convert to arraybuffer if neccesary.
+					if (state.binaryType === "arraybuffer") {
+						payload = await payload.arrayBuffer();
+						Object_setPrototypeOf(payload, ArrayBuffer.prototype);
+					}
+				}
+
+				const fakeev = new MessageEvent("message", {
+					data: payload,
+					origin: ev.origin,
+					lastEventId: ev.lastEventId,
+					source: ev.source,
+					ports: ev.ports,
+				});
+
+				fakeEventSend(fakeev);
+			});
+			barews.addEventListener("error", () => {
+				fakeEventSend(new Event("error"));
+			});
+
+			socketmap.set(fakeWebSocket, state);
+			ctx.return(fakeWebSocket);
+		},
+	});
+	client.Trap("WebSocket.prototype.binaryType", {
+		get(ctx) {
+			const ws = socketmap.get(ctx.this);
+			if (!ws) return ctx.get();
+
+			return ws.binaryType;
+		},
+		set(ctx, v: string) {
+			const ws = socketmap.get(ctx.this);
+			if (!ws) return ctx.set(v);
+			if (v === "blob" || v === "arraybuffer") ws.binaryType = v;
+		},
+	});
+
+	client.Trap("WebSocket.prototype.bufferedAmount", {
+		get(ctx) {
+			const ws = socketmap.get(ctx.this);
+			if (!ws) return ctx.get();
+
+			return 0;
+		},
+	});
+
+	client.Trap("WebSocket.prototype.extensions", {
+		get(ctx) {
+			const ws = socketmap.get(ctx.this);
+			if (!ws) return ctx.get();
+
+			return ws.extensions;
+		},
+	});
+
+	client.Trap("WebSocket.prototype.onopen", {
+		get(ctx) {
+			const ws = socketmap.get(ctx.this);
+			if (!ws) return ctx.get();
+
+			return ws.onopen;
+		},
+		set(ctx, v: (ev: Event) => any) {
+			const ws = socketmap.get(ctx.this);
+			if (!ws) return ctx.set(v);
+
+			ws.onopen = v;
+		},
+	});
+
+	client.Trap("WebSocket.prototype.onmessage", {
+		get(ctx) {
+			const ws = socketmap.get(ctx.this);
+			if (!ws) return ctx.get();
+
+			return ws.onmessage;
+		},
+		set(ctx, v: (ev: MessageEvent) => any) {
+			const ws = socketmap.get(ctx.this);
+			if (!ws) return ctx.set(v);
+
+			ws.onmessage = v;
+		},
+	});
+
+	client.Trap("WebSocket.prototype.onclose", {
+		get(ctx) {
+			const ws = socketmap.get(ctx.this);
+			if (!ws) return ctx.get();
+
+			return ws.onclose;
+		},
+		set(ctx, v: (ev: CloseEvent) => any) {
+			const ws = socketmap.get(ctx.this);
+			if (!ws) return ctx.set(v);
+
+			ws.onclose = v;
+		},
+	});
+
+	client.Trap("WebSocket.prototype.onerror", {
+		get(ctx) {
+			const ws = socketmap.get(ctx.this);
+			if (!ws) return ctx.get();
+
+			return ws.onerror;
+		},
+		set(ctx, v: (ev: Event) => any) {
+			const ws = socketmap.get(ctx.this);
+			if (!ws) return ctx.set(v);
+
+			ws.onerror = v;
+		},
+	});
+
+	client.Trap("WebSocket.prototype.url", {
+		get(ctx) {
+			const ws = socketmap.get(ctx.this);
+			if (!ws) return ctx.get();
+
+			return ws.url;
+		},
+	});
+
+	client.Trap("WebSocket.prototype.protocol", {
+		get(ctx) {
+			const ws = socketmap.get(ctx.this);
+			if (!ws) return ctx.get();
+
+			return ws.protocol;
+		},
+	});
+
+	client.Trap("WebSocket.prototype.readyState", {
+		get(ctx) {
+			const ws = socketmap.get(ctx.this);
+			if (!ws) return ctx.get();
+
+			return ws.barews.readyState;
+		},
+	});
+
+	client.Proxy("WebSocket.prototype.send", {
+		apply(ctx) {
+			const ws = socketmap.get(ctx.this);
+			if (!ws) return;
+
+			ctx.return(ws.barews.send(ctx.args[0]));
+		},
+	});
+
+	client.Proxy("WebSocket.prototype.close", {
+		apply(ctx) {
+			const ws = socketmap.get(ctx.this);
+			if (!ws) return;
+
+			if (ctx.args[0] === undefined) ctx.args[0] = 1000;
+			if (ctx.args[1] === undefined) ctx.args[1] = "";
+			ctx.return(ws.barews.close(ctx.args[0], ctx.args[1]));
+		},
+	});
+
+	client.Proxy("WebSocketStream", {
+		construct(ctx) {
+			const fakeWebSocket = {};
+			Object_setPrototypeOf(fakeWebSocket, ctx.fn.prototype);
+			fakeWebSocket.constructor = ctx.fn;
+
+			const barews = client.bare.createWebSocket(ctx.args[0], ctx.args[1], [
+				["User-Agent", self.navigator.userAgent],
+				["Origin", client.url.origin],
+			]);
+			ctx.args[1]?.signal.addEventListener("abort", () => {
+				barews.close(1000, "");
+			});
+			const state: FakeWebSocketStreamState = {
+				protocol: "",
+				extensions: "",
+				url: ctx.args[0],
+				barews,
+
+				opened: new Promise((resolve, reject) => {
+					barews.addEventListener("open", () => {
+						resolve({
+							readable: state.readable,
+							writable: state.writable,
+							protocol: state.protocol,
+							extensions: state.extensions,
+						});
+					});
+					barews.addEventListener("error", (ev: Event) => {
+						reject(ev);
+					});
+				}),
+				closed: new Promise((resolve) => {
+					barews.addEventListener("close", (ev: CloseEvent) => {
+						resolve({ closeCode: ev.code, reason: ev.reason });
+					});
+				}),
+				readable: new ReadableStream({
+					start(controller) {
+						barews.addEventListener("message", async (ev: MessageEvent) => {
+							let payload = ev.data;
+							// TODO: this needs to be changed to uint8array later
+							// chrome isnt following spec though so we are just going to do this
+							if (typeof payload === "string") {
+								// DO NOTHING
+							} else if ("byteLength" in payload) {
+								// arraybuffer, set the realms prototype so its recognized
+								Object.setPrototypeOf(payload, ArrayBuffer.prototype);
+							} else if ("arrayBuffer" in payload) {
+								// blob, convert to arraybuffer
+								payload = await payload.arrayBuffer();
+								Object.setPrototypeOf(payload, ArrayBuffer.prototype);
+							}
+							controller.enqueue(payload);
+						});
+					},
+					cancel(info) {
+						barews.close(info?.closeCode ?? 1000, info?.reason ?? "");
+					},
+				}),
+				writable: new WritableStream({
+					write(chunk) {
+						barews.send(chunk);
+					},
+					abort() {
+						barews.close(1000, "");
+					},
+					close(info) {
+						barews.close(info?.closeCode ?? 1000, info?.reason ?? "");
+					},
+				}),
+			};
+
+			socketstreammap.set(fakeWebSocket, state);
+			ctx.return(fakeWebSocket);
+		},
+	});
+
+	client.Trap("WebSocketStream.prototype.opened", {
+		get(ctx) {
+			const ws = socketstreammap.get(ctx.this);
+
+			return ws.opened;
+		},
+	});
+
+	client.Trap("WebSocketStream.prototype.closed", {
+		get(ctx) {
+			const ws = socketstreammap.get(ctx.this);
+
+			return ws.closed;
+		},
+	});
+
+	client.Trap("WebSocketStream.prototype.url", {
+		get(ctx) {
+			const ws = socketstreammap.get(ctx.this);
+
+			return ws.url;
+		},
+	});
+
+	client.Proxy("WebSocketStream.prototype.close", {
+		apply(ctx) {
+			const ws = socketstreammap.get(ctx.this);
+			if (ctx.args[0]) {
+				if (ctx.args[0].closeCode === undefined) ctx.args[0].closeCode = 1000;
+				if (ctx.args[0].reason === undefined) ctx.args[0].reason = "";
+
+				return ctx.return(
+					ws.barews.close(ctx.args[0].closeCode, ctx.args[0].reason)
+				);
+			}
+
+			return ctx.return(ws.barews.close(1000, ""));
+		},
+	});
+}

package/source/packages/scramjet/packages/core/src/client/shared/requests/xmlhttprequest.ts

@@ -0,0 +1,163 @@
+import { getFlag, ScramjetContext } from "@/shared";
+import { rewriteUrl, unrewriteUrl, URLMeta } from "@rewriters/url";
+import { ScramjetClient } from "@client/index";
+
+export default function (client: ScramjetClient, self: Self) {
+	let worker;
+	// if (self.Worker && flagEnabled("syncxhr", client.url)) {
+	// 	worker = client.natives.construct("Worker", config.files.sync);
+	// }
+	const ARGS = Symbol("xhr original args");
+	const HEADERS = Symbol("xhr headers");
+
+	client.Proxy("XMLHttpRequest.prototype.open", {
+		apply(ctx) {
+			if (ctx.args[1]) ctx.args[1] = client.rewriteUrl(ctx.args[1]);
+			if (ctx.args[2] === undefined) ctx.args[2] = true;
+			ctx.this[ARGS] = ctx.args;
+		},
+	});
+
+	client.Proxy("XMLHttpRequest.prototype.setRequestHeader", {
+		apply(ctx) {
+			const headers = ctx.this[HEADERS] || (ctx.this[HEADERS] = {});
+			headers[ctx.args[0]] = ctx.args[1];
+		},
+	});
+
+	client.Proxy("XMLHttpRequest.prototype.send", {
+		apply(ctx) {
+			const args = ctx.this[ARGS];
+			if (!args || args[2]) return;
+
+			if (!client.getFlag("syncxhr")) {
+				console.warn("ignoring request - sync xhr disabled in flags");
+
+				return ctx.return(undefined);
+			}
+
+			// it's a sync request
+			// sync xhr to service worker is not supported
+			// there's a nice way of polyfilling this though, we can spin on an atomic using sharedarraybuffer. this will maintain the sync behavior
+
+			//@ts-ignore
+			const sab = new SharedArrayBuffer(1024, { maxByteLength: 2147483647 });
+			const view = new DataView(sab);
+
+			client.natives.call("Worker.prototype.postMessage", worker, {
+				sab,
+				args,
+				headers: ctx.this[HEADERS],
+				body: ctx.args[0],
+			});
+
+			const now = performance.now();
+			while (view.getUint8(0) === 0) {
+				if (performance.now() - now > 1000) {
+					throw new Error("xhr timeout");
+				}
+				/* spin */
+			}
+
+			const status = view.getUint16(1);
+			const headersLength = view.getUint32(3);
+
+			const headersab = new Uint8Array(headersLength);
+			headersab.set(new Uint8Array(sab.slice(7, 7 + headersLength)));
+			const headers = new TextDecoder().decode(headersab);
+
+			const bodyLength = view.getUint32(7 + headersLength);
+			const bodyab = new Uint8Array(bodyLength);
+			bodyab.set(
+				new Uint8Array(
+					sab.slice(11 + headersLength, 11 + headersLength + bodyLength)
+				)
+			);
+			const body = new TextDecoder().decode(bodyab);
+
+			// these should be using proxies to not leak scram strings but who cares
+			client.RawTrap(ctx.this, "status", {
+				get() {
+					return status;
+				},
+			});
+			client.RawTrap(ctx.this, "responseText", {
+				get() {
+					return body;
+				},
+			});
+			client.RawTrap(ctx.this, "response", {
+				get() {
+					if (ctx.this.responseType === "arraybuffer") return bodyab.buffer;
+
+					return body;
+				},
+			});
+			client.RawTrap(ctx.this, "responseXML", {
+				get() {
+					const parser = new DOMParser();
+
+					return parser.parseFromString(body, "text/xml");
+				},
+			});
+			client.RawTrap(ctx.this, "getAllResponseHeaders", {
+				get() {
+					return () => headers;
+				},
+			});
+			client.RawTrap(ctx.this, "getResponseHeader", {
+				get() {
+					return (header: string) => {
+						const re = new RegExp(`^${header}: (.*)$`, "m");
+						const match = re.exec(headers);
+
+						return match ? match[1] : null;
+					};
+				},
+			});
+
+			ctx.return(undefined);
+		},
+	});
+
+	client.Trap("XMLHttpRequest.prototype.responseURL", {
+		get(ctx) {
+			return client.unrewriteUrl(ctx.get() as string);
+		},
+	});
+
+	client.Proxy("XMLHttpRequest.prototype.getAllResponseHeaders", {
+		apply(ctx) {
+			const headerstring = ctx.fn.call(ctx.this) as string;
+			if (!headerstring) return headerstring;
+			const headers = headerstring.split("\r\n");
+
+			for (const [i, header] of headers.entries()) {
+				if (header.toLowerCase().startsWith("link:")) {
+					headers[i] = `Link: ${unrewriteLinkHeader(
+						header.slice(5).trim(),
+						client.context
+					)}`;
+				}
+			}
+
+			ctx.return(headers.join("\r\n"));
+		},
+	});
+	client.Proxy("XMLHttpRequest.prototype.getResponseHeader", {
+		apply(ctx) {
+			const header = ctx.fn.call(ctx.this, ctx.args[0]) as string | null;
+			if (!header) return header;
+			if (ctx.args[0].toLowerCase() === "link") {
+				ctx.return(unrewriteLinkHeader(header, client.context));
+			}
+		},
+	});
+}
+
+export function unrewriteLinkHeader(header: string, context: ScramjetContext) {
+	return header.replace(
+		/<([^>]+)>/gi,
+		(_match, p1) => `<${unrewriteUrl(p1, context)}>`
+	);
+}

package/source/packages/scramjet/packages/core/src/client/shared/settimeout.ts

@@ -0,0 +1,20 @@
+import { rewriteJs } from "@rewriters/js";
+import { ScramjetClient } from "@client/index";
+import { String } from "@/shared/snapshot";
+
+export default function (client: ScramjetClient, self: Self) {
+	client.Proxy(["setTimeout", "setInterval"], {
+		apply(ctx) {
+			if (typeof ctx.args[0] !== "function") {
+				const code = String(ctx.args[0]);
+				// @ts-expect-error - for some reason it doesn't recognize setTimeout(string, number)
+				ctx.args[0] = rewriteJs(
+					code,
+					"(setTimeout string eval)",
+					client.context,
+					client.meta
+				);
+			}
+		},
+	});
+}