roxxie-proxy-u-prod 0.1.0

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

@@ -0,0 +1,203 @@
+import {
+	Object_defineProperty,
+	Number_isSafeInteger,
+	Error,
+} from "@/shared/snapshot";
+import { SCRAMJETCLIENT, SCRAMJETCLIENTNAME } from "@/symbols";
+import { ProxyCtx, ScramjetClient } from "@client/index";
+
+enum RewriteType {
+	Insert = 0,
+	Replace = 1,
+}
+
+type Rewrite = {
+	start: number;
+} & (
+	| {
+			type: RewriteType.Insert;
+			size: number;
+	  }
+	| {
+			type: RewriteType.Replace;
+			end: number;
+			str: string;
+	  }
+);
+
+export type SourceMaps = Record<string, Rewrite[]>;
+
+function getEnd(rewrite: Rewrite): number {
+	if (rewrite.type === RewriteType.Insert) {
+		return rewrite.start + rewrite.size;
+	} else if (rewrite.type === RewriteType.Replace) {
+		return rewrite.end;
+	}
+	throw "unreachable";
+}
+
+function registerRewrites(
+	client: ScramjetClient,
+	buf: Array<number>,
+	tag: string
+) {
+	const sourcemap = Uint8Array.from(buf);
+	const view = new DataView(sourcemap.buffer);
+	const decoder = new TextDecoder("utf-8");
+
+	const rewrites: Rewrite[] = [];
+
+	const rewritelen = view.getUint32(0, true);
+	let cursor = 4;
+	for (let i = 0; i < rewritelen; i++) {
+		const start = view.getUint32(cursor, true);
+		cursor += 4;
+		const size = view.getUint32(cursor, true);
+		cursor += 4;
+
+		const type = view.getUint8(cursor) as RewriteType;
+		cursor += 1;
+
+		if (type == RewriteType.Insert) {
+			rewrites.push({ type, start, size });
+		} else if (type == RewriteType.Replace) {
+			const end = start + size;
+
+			const oldLen = view.getUint32(cursor, true);
+			cursor += 4;
+
+			const oldStr = decoder.decode(
+				sourcemap.subarray(cursor, cursor + oldLen)
+			);
+
+			rewrites.push({ type, start, end, str: oldStr });
+			cursor += oldLen;
+		}
+	}
+
+	client.box.sourcemaps[tag] = rewrites;
+}
+
+const SCRAMTAG = "/*scramtag ";
+
+function extractTag(fn: string): [string, number, number] | null {
+	// every function rewritten will have a scramtag comment
+	// it will look like this:
+	// function name()[possible whitespace]/*scramtag [index] [tag]*/[possible whitespace]{ ... }
+
+	const start = fn.indexOf(SCRAMTAG);
+	// no scramtag, probably native function or stolen from scramjet
+	if (start === -1) return null;
+
+	const end = fn.indexOf("*/", start);
+	if (end === -1) {
+		dbg.error("unreachable", fn, start, end);
+		throw new Error("unreachable");
+	}
+
+	const tag = fn.substring(start + 2, end).split(" ");
+
+	if (
+		tag.length !== 3 ||
+		tag[0] !== "scramtag" ||
+		!Number_isSafeInteger(+tag[1])
+	) {
+		dbg.error("invalid tag", fn, start, end, tag);
+		throw new Error("invalid tag");
+	}
+
+	return [tag[2], start, +tag[1]];
+}
+
+function doUnrewrite(
+	client: ScramjetClient,
+	ctx: ProxyCtx<"Function.prototype.toString", "apply">
+) {
+	const stringified: string = ctx.fn.call(ctx.this);
+
+	const extracted = extractTag(stringified);
+	if (!extracted) return ctx.return(stringified);
+	const [tag, tagOffset, tagStart] = extracted;
+
+	const fnStart = tagStart - tagOffset;
+	const fnEnd = fnStart + stringified.length;
+	const rewrites = client.box.sourcemaps[tag];
+
+	if (!rewrites) {
+		dbg.warn("failed to get rewrites for tag", tag);
+
+		return ctx.return(stringified);
+	}
+
+	let i = 0;
+	// skip all rewrites in the file before the fn
+	while (i < rewrites.length) {
+		if (rewrites[i].start < fnStart) i++;
+		else break;
+	}
+
+	let end = i;
+	while (end < rewrites.length) {
+		if (getEnd(rewrites[end]) < fnEnd) end++;
+		else break;
+	}
+	const fnrewrites = rewrites.slice(i, end);
+
+	let newString = "";
+	let lastpos = 0;
+
+	for (const rewrite of fnrewrites) {
+		newString += stringified.slice(lastpos, rewrite.start - fnStart);
+
+		if (rewrite.type === RewriteType.Insert) {
+			lastpos = rewrite.start + rewrite.size - fnStart;
+		} else if (rewrite.type === RewriteType.Replace) {
+			newString += rewrite.str;
+			lastpos = rewrite.end - fnStart;
+		} else {
+			throw "unreachable";
+		}
+	}
+
+	newString += stringified.slice(lastpos);
+	newString = newString.replace(`${SCRAMTAG}${tagStart} ${tag}*/`, "");
+
+	return ctx.return(newString);
+}
+
+export const enabled = (client: ScramjetClient) =>
+	client.flagEnabled("sourcemaps");
+
+export default function (client: ScramjetClient, self: Self) {
+	// every script will push a sourcemap
+	Object_defineProperty(self, client.config.globals.pushsourcemapfn, {
+		value: (buf: Array<number>, tag: string) => {
+			// const before = performance.now();
+			registerRewrites(client, buf, tag);
+			// if (client.flagEnabled("rewriterLogs")) {
+			// 	dbg.time(client.meta, before, `scramtag parse for ${tag}`);
+			// }
+		},
+		enumerable: false,
+		writable: false,
+		configurable: false,
+	});
+
+	// when we rewrite javascript it will make function.toString leak internals
+	// this can lead to double rewrites which is bad
+	client.Proxy("Function.prototype.toString", {
+		apply(ctx) {
+			if (client.box.unproxy.has(ctx.this)) {
+				// toString is being called on a proxy of a native function
+				// `this` will then be the proxy, which has the wrong [[SourceText]]
+				// unproxy so it passes through
+				ctx.this = client.box.unproxy.get(ctx.this)!;
+				// since we know it's a native function, no need to unrewrite
+				return;
+			}
+			// const before = performance.now();
+			doUnrewrite(client, ctx);
+			// dbg.time(client.meta, before, `scramtag unrewrite for ${ctx.fn.name}`);
+		},
+	});
+}

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

@@ -0,0 +1,72 @@
+import { ScramjetClient } from "@client/index";
+
+export default function (client: ScramjetClient, _self: GlobalThis) {
+	client.Proxy("Worker", {
+		construct(ctx) {
+			ctx.args[0] = client.rewriteUrl(ctx.args[0], {
+				destination: "worker",
+				isModule: ctx.args[1]?.type === "module",
+			});
+
+			const worker = ctx.call();
+			// const conn = new BareMuxConnection();
+
+			// (async () => {
+			// 	const port = await conn.getInnerPort();
+			// 	client.natives.call(
+			// 		"Worker.prototype.postMessage",
+			// 		worker,
+			// 		{
+			// 			$scramjet$type: "baremuxinit",
+			// 			port,
+			// 		},
+			// 		[port]
+			// 	);
+			// })();
+		},
+	});
+
+	// sharedworkers can only be constructed from window
+	client.Proxy("SharedWorker", {
+		construct(ctx) {
+			const isModule =
+				typeof ctx.args[1] === "object" && ctx.args[1]?.type === "module";
+
+			ctx.args[0] = client.rewriteUrl(ctx.args[0], {
+				destination: "sharedworker",
+				isModule,
+			});
+
+			if (ctx.args[1] && typeof ctx.args[1] === "string")
+				ctx.args[1] = `${client.url.origin}@${ctx.args[1]}`;
+
+			if (ctx.args[1] && typeof ctx.args[1] === "object") {
+				if (ctx.args[1].name) {
+					ctx.args[1].name = `${client.url.origin}@${ctx.args[1].name}`;
+				}
+			}
+
+			const worker = ctx.call();
+			// const conn = new BareMuxConnection();
+
+			// (async () => {
+			// 	const port = await conn.getInnerPort();
+			// 	client.natives.call(
+			// 		"MessagePort.prototype.postMessage",
+			// 		worker.port,
+			// 		{
+			// 			$scramjet$type: "baremuxinit",
+			// 			port,
+			// 		},
+			// 		[port]
+			// 	);
+			// })();
+		},
+	});
+
+	client.Proxy("Worklet.prototype.addModule", {
+		apply(ctx) {
+			if (ctx.args[0]) ctx.args[0] = client.rewriteUrl(ctx.args[0]);
+		},
+	});
+}

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

@@ -0,0 +1,197 @@
+import { iswindow } from "@client/entry";
+import { SCRAMJETCLIENT } from "@/symbols";
+import { ScramjetClient } from "@client/index";
+// import { argdbg } from "@client/shared/err";
+import { indirectEval } from "@client/shared/eval";
+import { Object_defineProperty } from "@/shared/snapshot";
+
+export function createWrapFn(client: ScramjetClient, self: GlobalThis) {
+	let wrappedParent: GlobalThis | null = null;
+	let wrappedTop: GlobalThis | null = null;
+	if (iswindow) {
+		try {
+			if (SCRAMJETCLIENT in self.parent) {
+				// ... then we're in a subframe, and the parent frame is also in a proxy context, so we should return its proxy
+				wrappedParent = self.parent;
+			} else {
+				// ... then we should pretend we aren't nested and return the current window
+				wrappedParent = self;
+			}
+		} catch {
+			// accessing self.parent can throw if it's cross-origin, in which case we should also pretend we aren't nested
+			wrappedParent = self;
+		}
+		// instead of returning top, we need to return the uppermost parent that's inside a scramjet context
+		let current = self;
+		for (;;) {
+			const test = current.parent.self;
+			if (test === current) break; // there is no parent, actual or emulated.
+
+			try {
+				// ... then `test` represents a window outside of the proxy context, and therefore `current` is the topmost window in the proxy context
+				if (!(SCRAMJETCLIENT in test)) break;
+			} catch {
+				// accessing test can throw if it's cross-origin, in which case we should also break
+				break;
+			}
+			// test is also insde a proxy, so we should continue up the chain
+			current = test;
+		}
+		wrappedTop = current;
+	}
+
+	return function (identifier: any, strict: boolean) {
+		if (identifier === self.location) return client.locationProxy;
+		if (identifier === self.eval) {
+			// TODO: make this per-client, don't regen every time
+			const bound = indirectEval.bind(client, strict);
+			client.box.unproxy.set(bound, self.eval);
+			return bound;
+		}
+		if (iswindow) {
+			if (identifier === self.parent) {
+				return wrappedParent;
+			} else if (identifier === self.top) {
+				return wrappedTop;
+			}
+		}
+		return identifier;
+	};
+}
+
+export const order = 4;
+export default function (client: ScramjetClient, self: GlobalThis) {
+	Object_defineProperty(self, client.config.globals.wrapfn, {
+		value: client.wrapfn,
+		writable: false,
+		configurable: false,
+		enumerable: false,
+	});
+	Object_defineProperty(self, client.config.globals.wrappropertyfn, {
+		value: function (str) {
+			if (
+				str === "location" ||
+				str === "parent" ||
+				str === "top" ||
+				str === "eval"
+			)
+				return client.config.globals.wrappropertybase + str;
+
+			return str;
+		},
+		writable: false,
+		configurable: false,
+		enumerable: false,
+	});
+	Object_defineProperty(self, client.config.globals.cleanrestfn, {
+		value: function (obj) {
+			// TODO
+		},
+		writable: false,
+		configurable: false,
+		enumerable: false,
+	});
+
+	Object_defineProperty(
+		self.Object.prototype,
+		client.config.globals.wrappropertybase + "location",
+		{
+			get: function () {
+				// if (this.location.constructor.toString().includes("Location")) {
+
+				if (this === self || this === self.document) {
+					return client.locationProxy;
+				}
+
+				return this.location;
+			},
+			set(value: any) {
+				if (this === self || this === self.document) {
+					client.url = value;
+
+					return;
+				}
+				this.location = value;
+			},
+			configurable: false,
+			enumerable: false,
+		}
+	);
+	Object_defineProperty(
+		self.Object.prototype,
+		client.config.globals.wrappropertybase + "parent",
+		{
+			get: function () {
+				return client.wrapfn(this.parent, false);
+			},
+			set(value: any) {
+				// i guess??
+				this.parent = value;
+			},
+			configurable: false,
+			enumerable: false,
+		}
+	);
+	Object_defineProperty(
+		self.Object.prototype,
+		client.config.globals.wrappropertybase + "top",
+		{
+			get: function () {
+				return client.wrapfn(this.top, false);
+			},
+			set(value: any) {
+				this.top = value;
+			},
+			configurable: false,
+			enumerable: false,
+		}
+	);
+	Object_defineProperty(
+		self.Object.prototype,
+		client.config.globals.wrappropertybase + "eval",
+		{
+			get: function () {
+				return client.wrapfn(this.eval, true);
+			},
+			set(value: any) {
+				this.eval = value;
+			},
+			configurable: false,
+			enumerable: false,
+		}
+	);
+
+	self.$scramitize = function (v) {
+		const t = typeof v;
+		if (t === "object" && v !== null) {
+			if (v === location) debugger;
+			if (iswindow) {
+				// if (v === self.parent) debugger;
+				if (v === self.top) debugger;
+			}
+		} else if (t === "string") {
+			if (v.includes("scramjet")) debugger;
+			if (v.includes("~/sj")) debugger;
+			if (v.includes(location.origin)) debugger;
+		}
+
+		return v;
+	};
+
+	// location = "..." can't be rewritten as wrapfn(location) = ..., so instead it will actually be rewritten as
+	// ((t)=>$scramjet$tryset(location,"+=",t)||location+=t)(...);
+	// it has to be a discrete function because there's always the possibility that "location" is a local variable
+	// we have to use an IIFE to avoid duplicating side-effects in the getter
+	Object_defineProperty(self, client.config.globals.trysetfn, {
+		value: function (lhs: any, op: string, rhs: any) {
+			if (client.box.locations.has(lhs)) {
+				lhs.href = rhs;
+				return true;
+			}
+
+			return false;
+		},
+		writable: false,
+		configurable: false,
+	});
+}

package/source/packages/scramjet/packages/core/src/client/singletonbox.ts

@@ -0,0 +1,52 @@
+import { IncrementalHtmlRewriter } from "@/shared";
+import { ScramjetClient } from "./client";
+import { SourceMaps } from "./shared/sourcemaps";
+import {
+	Object_getOwnPropertyNames,
+	Object_getOwnPropertyDescriptor,
+} from "@/shared/snapshot";
+
+export class SingletonBox {
+	clients: ScramjetClient[] = [];
+	globals: Map<Self, ScramjetClient> = new Map();
+	documents: Map<Document, ScramjetClient> = new Map();
+	histories: Map<History, ScramjetClient> = new Map();
+	locations: Map<Location, ScramjetClient> = new Map();
+	writeRewriters = new WeakMap<Document, IncrementalHtmlRewriter>();
+	unproxy = new Map<any, any>();
+
+	ctors: Record<string, Function[]> = {};
+
+	sourcemaps: SourceMaps = {};
+
+	constructor(public ownerclient: ScramjetClient) {}
+
+	registerClient(client: ScramjetClient, global: Self) {
+		this.clients.push(client);
+		this.globals.set(global, client);
+		this.documents.set(global.document, client);
+		this.locations.set(global.location, client);
+		this.histories.set(global.history, client);
+
+		Object_getOwnPropertyNames(global).forEach((prop) => {
+			const desc = Object_getOwnPropertyDescriptor(global, prop);
+			if (desc && typeof desc.value === "function") {
+				if (!this.ctors[prop]) this.ctors[prop] = [];
+				this.ctors[prop].push(desc.value);
+			}
+		});
+	}
+
+	instanceof(obj: any, name: string): boolean {
+		const ctors = this.ctors[name];
+		if (!ctors) {
+			dbg.error(`No constructors for ${name} found`);
+			return false;
+		}
+		for (const ctor of ctors) {
+			// eslint-disable-next-line scramjet-core/no-instanceof
+			if (obj instanceof ctor) return true;
+		}
+		return false;
+	}
+}

package/source/packages/scramjet/packages/core/src/client/worker/importScripts.ts

@@ -0,0 +1,13 @@
+import { ScramjetClient } from "@client/index";
+import { String } from "@/shared/snapshot";
+
+export default function (client: ScramjetClient) {
+	client.Proxy("importScripts", {
+		apply(ctx) {
+			for (const i in ctx.args) {
+				const url = String(ctx.args[i]);
+				ctx.args[i] = client.rewriteUrl(url);
+			}
+		},
+	});
+}

package/source/packages/scramjet/packages/core/src/fetch/body.ts

@@ -0,0 +1,93 @@
+import { BareResponse } from "@mercuryworkshop/proxy-transports";
+import {
+	BodyType,
+	ScramjetFetchHandler,
+	ScramjetFetchParsed,
+	ScramjetFetchRequest,
+} from ".";
+import {
+	flagEnabled,
+	isHtmlMimeType,
+	isJavascriptMimeType,
+	rewriteCss,
+	rewriteHtml,
+	rewriteJs,
+	rewriteWorkers,
+} from "@/shared";
+import { sniffEncoding } from "@/shared/sniffEncoding";
+import { _TextDecoder } from "@/shared/snapshot";
+
+export async function rewriteBody(
+	handler: ScramjetFetchHandler,
+	request: ScramjetFetchRequest,
+	parsed: ScramjetFetchParsed,
+	response: BareResponse
+): Promise<BodyType> {
+	switch (parsed.destination) {
+		case "iframe":
+		case "document":
+			if (isHtmlMimeType(response.headers.get("content-type") ?? "")) {
+				const buf = await response.arrayBuffer();
+				const bytes = new Uint8Array(buf);
+				const encoding = sniffEncoding(
+					bytes,
+					response.headers.get("content-type")
+				);
+				const htmlContent = new _TextDecoder(encoding).decode(bytes);
+
+				return rewriteHtml(htmlContent, handler.context, parsed.meta, {
+					loadScripts: true,
+					inline: true,
+					source: parsed.url.href,
+					headers: response.rawHeaders,
+					// reasonably confident that a document fetch is impossible without a client
+					history: parsed.trackedClient!.history,
+				});
+			} else {
+				return response.body;
+			}
+		case "script": {
+			// do not attempt to rewrite a 404 response
+			if (response.ok) {
+				const ct = response.headers.get("content-type");
+				// don't rewrite invalid module scripts when the server declares a non-JS type
+				if (parsed.isModule && ct && !isJavascriptMimeType(ct)) {
+					return response.body;
+				}
+
+				let rewritten = rewriteJs(
+					new Uint8Array(await response.arrayBuffer()),
+					response.url,
+					handler.context,
+					parsed.meta,
+					parsed.isModule
+				);
+
+				if (
+					flagEnabled("debugSourceURL", handler.context, parsed.meta.origin)
+				) {
+					if (rewritten instanceof Uint8Array) {
+						rewritten = new TextDecoder().decode(rewritten);
+					}
+					rewritten += `\n//# sourceURL=${parsed.url.href}`;
+				}
+
+				return rewritten as unknown as ArrayBuffer;
+			}
+			return response.body;
+		}
+		case "style":
+			return rewriteCss(await response.text(), handler.context, parsed.meta);
+		case "sharedworker":
+		case "worker":
+			return rewriteWorkers(
+				new Uint8Array(await response.arrayBuffer()),
+				response.url,
+				handler.context,
+				parsed.meta,
+				parsed.isModule
+			);
+		default:
+			return response.body;
+	}
+}