roxxie-proxy-u-prod 0.1.0

package/source/packages/scramjet/packages/core/src/shared/rewriters/js.ts

@@ -0,0 +1,158 @@
+import { flagEnabled, ScramjetContext } from "@/shared";
+import { URLMeta } from "@rewriters/url";
+
+import { getRewriter, JsRewriterOutput } from "@rewriters/wasm";
+import {
+	Array_from,
+	TextDecoder_decode,
+	_RegExp,
+	_Uint8Array,
+	Object_keys,
+	Performance_now,
+} from "../snapshot";
+
+// eslint-disable-next-line scramjet-core/no-globals
+Error.stackTraceLimit = 50;
+
+type RewriterResult = {
+	js: string | Uint8Array;
+	map: Uint8Array | null;
+	tag: string;
+	errors: string[];
+};
+function rewriteJsWasm(
+	input: string | Uint8Array,
+	source: string | null,
+	context: ScramjetContext,
+	meta: URLMeta,
+	isModule: boolean
+): RewriterResult {
+	const [rewriter, ret] = getRewriter(context, meta);
+
+	const flagsobj = {};
+	for (const flag of Object_keys(context.config.flags)) {
+		flagsobj[flag] = flagEnabled(flag as any, context, meta.base);
+	}
+
+	try {
+		let out: JsRewriterOutput;
+		const before = Performance_now();
+		// try {
+		if (typeof input === "string") {
+			out = rewriter.rewrite_js(
+				{
+					...context.config.globals,
+					prefix: context.prefix.pathname,
+				},
+				flagsobj,
+				context.interface.codecEncode,
+				input,
+				meta.base.href,
+				source || "(unknown)",
+				isModule
+			);
+		} else {
+			out = rewriter.rewrite_js_bytes(
+				{
+					...context.config.globals,
+					prefix: context.prefix.pathname,
+				},
+				flagsobj,
+				context.interface.codecEncode,
+				input,
+				meta.base.href,
+				source || "(unknown)",
+				isModule
+			);
+		}
+		// } catch (err) {
+		// 	const err1 = err as Error;
+		// 	console.warn(
+		// 		"failed rewriting js for",
+		// 		source,
+		// 		err1.message,
+		// 		input instanceof Uint8Array ? textDecoder.decode(input) : input
+		// 	);
+
+		// 	return { js: input, tag: "", map: null };
+		// }
+		if (flagEnabled("rewriterLogs", context, meta.base)) {
+			dbg.time(meta, before, `oxc rewrite for "${source || "(unknown)"}"`);
+		}
+
+		const { js, map, scramtag, errors } = out;
+
+		return {
+			js: typeof input === "string" ? TextDecoder_decode(js) : js,
+			tag: scramtag,
+			map,
+			errors,
+		};
+	} finally {
+		ret();
+	}
+}
+
+export function rewriteJsInner(
+	js: string | Uint8Array,
+	url: string | null,
+	context: ScramjetContext,
+	meta: URLMeta,
+	isModule = false
+) {
+	return rewriteJsWasm(js, url, context, meta, isModule);
+}
+
+export function rewriteJs(
+	js: string | Uint8Array,
+	url: string | null,
+	context: ScramjetContext,
+	meta: URLMeta,
+	isModule = false
+): string | Uint8Array {
+	try {
+		const res = rewriteJsInner(js, url, context, meta, isModule);
+		let newjs = res.js;
+
+		if (flagEnabled("sourcemaps", context, meta.base)) {
+			const pushmap = globalThis[context.config.globals.pushsourcemapfn];
+			if (pushmap) {
+				pushmap(Array_from(res.map), res.tag);
+			} else {
+				// TODO: how do we check instanceof here?
+				if (typeof newjs !== "string") {
+					newjs = TextDecoder_decode(newjs);
+				}
+				const sourcemapfn = `${context.config.globals.pushsourcemapfn}([${res.map.join(",")}], "${res.tag}");`;
+
+				// don't put the sourcemap call before "use strict"
+				const strictMode = new _RegExp(/^\s*(['"])use strict\1;?/);
+				if (strictMode.test(newjs)) {
+					newjs = newjs.replace(strictMode, `$&\n${sourcemapfn}`);
+				} else {
+					newjs = `${sourcemapfn}\n${newjs}`;
+				}
+			}
+		}
+
+		if (flagEnabled("rewriterLogs", context, meta.base)) {
+			for (const error of res.errors) {
+				dbg.error("oxc parse error", error);
+			}
+		}
+
+		return newjs;
+	} catch (err) {
+		dbg.warn(
+			"failed rewriting js for",
+			url || "(unknown)",
+			err.message,
+			typeof js !== "string" ? TextDecoder_decode(js) : js
+		);
+		if (flagEnabled("allowInvalidJs", context, meta.base)) {
+			return js;
+		} else {
+			throw err;
+		}
+	}
+}

package/source/packages/scramjet/packages/core/src/shared/rewriters/url.ts

@@ -0,0 +1,248 @@
+import { ScramjetContext } from "@/shared";
+import { rewriteJs } from "@rewriters/js";
+import { QP } from "@/fetch/parse";
+
+import {
+	TextEncoder_encode,
+	_URL,
+	_URLSearchParams,
+	atob,
+	String,
+	URL_createObjectURL,
+} from "../snapshot";
+
+// user: manually triggered navigation
+// link: link clicked by the user. still user initiated, but doesn't wipe
+// location: location = ...
+export type NavigationType = "user" | "link" | "location";
+
+export type RewriteUrlOptions = {
+	referrerPolicy?: string;
+	isModule?: boolean;
+	navigateType?: NavigationType;
+	topFrame?: string;
+	parentFrame?: string;
+	isIframe?: string;
+	mode?: string;
+	credentials?: string;
+	destination?: RequestDestination;
+};
+
+export type URLMeta = {
+	origin: URL;
+	base: URL;
+	topFrameName?: string;
+	parentFrameName?: string;
+	referrerPolicy?: string;
+};
+
+function tryCanParseURL(url: string, origin?: string | URL): _URL | null {
+	try {
+		return new _URL(url, origin);
+	} catch {
+		return null;
+	}
+}
+
+export function rewriteBlob(
+	url: string,
+	context: ScramjetContext,
+	meta: URLMeta
+) {
+	const blob = new _URL(url.substring("blob:".length));
+
+	return "blob:" + meta.origin.origin + blob.pathname;
+}
+
+export function unrewriteBlob(
+	url: string,
+	context: ScramjetContext,
+	_meta: URLMeta
+) {
+	const blob = new _URL(url.substring("blob:".length));
+
+	return "blob:" + context.prefix.origin + blob.pathname;
+}
+
+function dataToBlob(url: string) {
+	const commaIndex = url.indexOf(",");
+	if (commaIndex === -1) return null;
+
+	const meta = url.slice("data:".length, commaIndex);
+	const data = url.slice(commaIndex + 1);
+
+	const metaParts = meta.split(";");
+	const mediaType = metaParts.shift() || "";
+	const isBase64 = metaParts.some((part) => part.toLowerCase() === "base64");
+	const params = metaParts.filter(
+		(part) => part && part.toLowerCase() !== "base64"
+	);
+
+	let type = mediaType || "text/plain";
+	if (!mediaType) {
+		const hasCharset = params.some((part) =>
+			part.toLowerCase().startsWith("charset=")
+		);
+		if (!hasCharset) {
+			params.push("charset=US-ASCII");
+		}
+	}
+	if (params.length) type += ";" + params.join(";");
+
+	let bytes: Uint8Array;
+	if (isBase64) {
+		let base64 = data.replace(/\s/g, "");
+		base64 = base64.replace(/-/g, "+").replace(/_/g, "/");
+		const binString = atob(base64);
+		bytes = new Uint8Array(binString.length);
+		for (let i = 0; i < binString.length; i++) {
+			bytes[i] = binString.charCodeAt(i);
+		}
+	} else {
+		let decoded = data;
+		try {
+			decoded = decodeURIComponent(data);
+		} catch {
+			// If decode fails, fall back to raw data.
+		}
+		bytes = TextEncoder_encode(decoded);
+	}
+
+	const blob = new Blob([bytes], { type });
+	const objectUrl = URL_createObjectURL(blob);
+	return { blob, objectUrl };
+}
+
+export function rewriteUrl(
+	url: string | URL,
+	context: ScramjetContext,
+	meta: URLMeta,
+	options?: RewriteUrlOptions
+) {
+	url = String(url);
+
+	if (url.startsWith("javascript:")) {
+		return (
+			"javascript:" +
+			rewriteJs(
+				url.slice("javascript:".length),
+				"(javascript: url)",
+				context,
+				meta
+			)
+		);
+	} else if (url.startsWith("blob:")) {
+		return context.prefix.href + url;
+	} else if (url.startsWith("data:")) {
+		const URL_MAX_LENGTH = 1024 * 1024 * 2;
+		const BUFFER = 1024;
+		// chrome will explode if you make a request to a service worker with a 2MB+ URL
+		// there's an okayish workaround which is just Pretending It's a Blob
+		if (url.length + context.prefix.href.length + BUFFER > URL_MAX_LENGTH) {
+			const { objectUrl } = dataToBlob(url);
+			return (
+				context.prefix.href +
+				rewriteBlob(objectUrl, context, meta) +
+				"?" +
+				QP.fakeDataURL +
+				"=1"
+			);
+		}
+
+		return context.prefix.href + url;
+	} else if (url.startsWith("mailto:") || url.startsWith("about:")) {
+		return url;
+	} else {
+		let base = meta.base.href;
+
+		if (base.startsWith("about:"))
+			base = unrewriteUrl(self.location.href, context); // jank!!!!! weird jank!!!
+		const realUrl = tryCanParseURL(url, base);
+		if (!realUrl) return url;
+
+		if (realUrl.protocol != "http:" && realUrl.protocol != "https:") {
+			// custom protocol. best thing to do is pass it through so it can open an app etc
+			// there's also extension:// pages we might need to worry about later
+			return url;
+		}
+
+		const encodedHash = context.interface.codecEncode(realUrl.hash.slice(1));
+		const realHash = encodedHash ? "#" + encodedHash : "";
+		realUrl.hash = "";
+
+		const paramsInit = new _URLSearchParams();
+
+		const referrerPolicy =
+			!options?.isModule && (options?.referrerPolicy ?? meta.referrerPolicy);
+		if (referrerPolicy) paramsInit.set(QP.referrerPolicy, referrerPolicy);
+		if (options?.isModule) paramsInit.set(QP.isModule, "module");
+		if (options?.topFrame) paramsInit.set(QP.topFrame, options.topFrame);
+		if (options?.parentFrame)
+			paramsInit.set(QP.parentFrame, options.parentFrame);
+		if (options?.isIframe) paramsInit.set(QP.isIframe, options.isIframe);
+		if (options?.mode) paramsInit.set(QP.mode, options.mode);
+		if (options?.credentials)
+			paramsInit.set(QP.credentials, options.credentials);
+		if (options?.destination)
+			paramsInit.set(QP.destination, options.destination);
+
+		// specific tracking for sec-fetch-site
+		// don't send for the top level controller calling it in go()
+		if (meta.origin.origin !== context.prefix.origin) {
+			paramsInit.set(QP.initiatorOrigin, meta.origin.origin);
+		}
+
+		let paramstring = "";
+		if (paramsInit.toString()) paramstring = "?" + paramsInit.toString();
+
+		return (
+			context.prefix.href +
+			context.interface.codecEncode(realUrl.href) +
+			paramstring +
+			realHash
+		);
+	}
+}
+
+export function unrewriteUrl(url: string | URL, context: ScramjetContext) {
+	url = String(url);
+	if (url.startsWith("javascript:")) {
+		//TODO
+		return url;
+	} else if (url.startsWith("blob:")) {
+		// realistically this shouldn't happen
+		return url;
+	} else if (url.startsWith(context.prefix.href + "blob:")) {
+		return url.substring(context.prefix.href.length);
+	} else if (url.startsWith(context.prefix.href + "data:")) {
+		return url.substring(context.prefix.href.length);
+	} else if (url.startsWith("mailto:") || url.startsWith("about:")) {
+		return url;
+	} else if (url.startsWith("http:") || url.startsWith("https:")) {
+		const realUrl = tryCanParseURL(url);
+		if (!realUrl) return url;
+		if (realUrl.protocol != "http:" && realUrl.protocol != "https:") {
+			// custom protocol
+			return url;
+		}
+		if (!realUrl.href.startsWith(context.prefix.href)) {
+			dbg.error("unrewriteurl: unexpected url", url);
+			return url;
+		}
+		const decodedHash = context.interface.codecDecode(realUrl.hash.slice(1));
+		const realHash = decodedHash ? "#" + decodedHash : "";
+		realUrl.hash = "";
+		realUrl.search = "";
+
+		return (
+			context.interface.codecDecode(
+				realUrl.href.slice(context.prefix.href.length)
+			) + realHash
+		);
+	} else if (url == "") {
+		return url;
+	} else {
+		dbg.error("unrewriteurl: unexpected url", url);
+		return url;
+	}
+}

package/source/packages/scramjet/packages/core/src/shared/rewriters/wasm.ts

@@ -0,0 +1,58 @@
+// i am a cat. i like to be petted. i like to be fed. i like to be
+import { initSync, Rewriter } from "../../../rewriter/wasm/out/wasm.js";
+import type { JsRewriterOutput } from "../../../rewriter/wasm/out/wasm.js";
+import { flagEnabled, ScramjetContext } from "@/shared";
+
+export type { JsRewriterOutput, Rewriter };
+
+import { URLMeta } from "@rewriters/url";
+import { Error, TextDecoder_decode } from "@/shared/snapshot";
+
+let wasm_u8: Uint8Array;
+export function setWasm(u8: Uint8Array | ArrayBuffer) {
+	wasm_u8 = u8 instanceof Uint8Array ? u8 : new Uint8Array(u8);
+}
+
+const MAGIC = "\0asm".split("").map((x) => x.charCodeAt(0));
+
+function initWasm() {
+	if (!(wasm_u8 instanceof Uint8Array))
+		throw new Error("rewriter wasm not found (was setWasm called?)");
+
+	if (![...wasm_u8.slice(0, 4)].every((x, i) => x === MAGIC[i]))
+		throw new Error(
+			"rewriter wasm does not have wasm magic (was it fetched correctly?)\nrewriter wasm contents: " +
+				TextDecoder_decode(wasm_u8)
+		);
+
+	initSync({
+		module: new WebAssembly.Module(wasm_u8 as unknown as BufferSource),
+	});
+}
+
+type RewriterBox = { rewriter: Rewriter; inUse: boolean };
+const rewriters: RewriterBox[] = [];
+export function getRewriter(
+	context: ScramjetContext,
+	meta: URLMeta
+): [Rewriter, () => void] {
+	initWasm();
+
+	let obj: RewriterBox;
+	const index = rewriters.findIndex((x) => !x.inUse);
+	const len = rewriters.length;
+
+	if (index === -1) {
+		if (flagEnabled("rewriterLogs", context, meta.base))
+			dbg.log(`creating new rewriter, ${len} rewriters made already`);
+
+		const rewriter = new Rewriter();
+		obj = { rewriter, inUse: false };
+		rewriters.push(obj);
+	} else {
+		obj = rewriters[index];
+	}
+	obj.inUse = true;
+
+	return [obj.rewriter, () => (obj.inUse = false)];
+}

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

@@ -0,0 +1,37 @@
+import { flagEnabled, ScramjetContext } from "@/shared";
+import { rewriteJs } from "@rewriters/js";
+import { URLMeta } from "@rewriters/url";
+import { TextDecoder_decode } from "@/shared/snapshot";
+import { base64Encode } from "@/shared/util";
+
+export function rewriteWorkers(
+	js: string | Uint8Array,
+	url: string,
+	context: ScramjetContext,
+	meta: URLMeta,
+	isModule: boolean
+) {
+	const script = (script: string) => {
+		if (isModule) {
+			return `import "${script}"\n`;
+		}
+		return `importScripts("${script}");\n`;
+	};
+	const b64 = (script: string) =>
+		`data:text/javascript;charset=utf-8;base64,${base64Encode(script)}`;
+	let str = context.interface.getWorkerInjectScripts(meta, isModule, script);
+
+	let rewritten = rewriteJs(js, url, context, meta, isModule);
+	if (typeof rewritten !== "string") {
+		rewritten = TextDecoder_decode(rewritten);
+	}
+
+	if (flagEnabled("encapsulateWorkers", context, meta.origin)) {
+		// TODO: check if there's already a sourceURL/sourcemap before appending another?
+		rewritten += `//# sourceURL=${url}`;
+		str += script(b64(rewritten as string));
+	} else {
+		str += rewritten;
+	}
+	return str;
+}

package/source/packages/scramjet/packages/core/src/shared/set-cookie-parser.ts

@@ -0,0 +1,195 @@
+// adapted from https://www.npmjs.com/package/set-cookie-parser, licensed MIT
+// we'll be forever in the shadow of node-unblocker or something
+
+type ParsedCookie = {
+	name: string;
+	value: string;
+	expires?: Date;
+	maxAge?: number;
+	secure?: boolean;
+	httpOnly?: boolean;
+	sameSite?: string;
+	partitioned?: boolean;
+	[key: string]: unknown;
+};
+
+const MAX_COOKIE_PAIR_BYTES = 4096;
+const textEncoder = new TextEncoder();
+
+function isNonEmptyString(str: unknown): str is string {
+	return typeof str === "string" && !!str.trim();
+}
+
+function hasCtlCharacters(value: string): boolean {
+	for (let i = 0; i < value.length; i++) {
+		const code = value.charCodeAt(i);
+		if (((code >= 0x00 && code <= 0x1f) || code === 0x7f) && code !== 0x09) {
+			return true;
+		}
+	}
+
+	return false;
+}
+
+function cookiePairByteLength(name: string, value: string): number {
+	// RFC length checks ignore the '=' separator.
+	return textEncoder.encode(`${name}${value}`).length;
+}
+
+function parseString(setCookieValue: string): ParsedCookie | null {
+	const parts = setCookieValue.split(";");
+
+	const nameValuePairStr = parts.shift();
+	if (!nameValuePairStr) return null;
+	if (!nameValuePairStr.trim()) return null;
+
+	const parsed = parseNameValuePair(nameValuePairStr);
+	if (!parsed) return null;
+
+	const { name } = parsed;
+	const { value } = parsed;
+
+	const cookie: ParsedCookie = {
+		name,
+		value,
+	};
+
+	for (const part of parts.filter(isNonEmptyString)) {
+		const sides = part.split("=");
+		const key = (sides.shift() || "").trimStart().toLowerCase();
+		const sideValue = sides.join("=");
+
+		if (key === "expires") {
+			cookie.expires = new Date(sideValue);
+		} else if (key === "max-age") {
+			cookie.maxAge = parseInt(sideValue, 10);
+		} else if (key === "secure") {
+			cookie.secure = true;
+		} else if (key === "httponly") {
+			cookie.httpOnly = true;
+		} else if (key === "samesite") {
+			cookie.sameSite = sideValue;
+		} else if (key === "partitioned") {
+			cookie.partitioned = true;
+		} else {
+			cookie[key] = sideValue;
+		}
+	}
+
+	return cookie;
+}
+
+function parseNameValuePair(
+	nameValuePairStr: string
+): { name: string; value: string } | null {
+	let name = "";
+	let value = "";
+	const nameValueArr = nameValuePairStr.split("=");
+
+	if (nameValueArr.length > 1) {
+		name = (nameValueArr.shift() || "").trim();
+		value = nameValueArr.join("=").trim();
+	} else {
+		value = nameValuePairStr.trim();
+	}
+
+	if (!name && !value) {
+		return null;
+	}
+
+	if (!name && /^__secure-|^__host-/i.test(value)) {
+		return null;
+	}
+
+	if (hasCtlCharacters(name) || hasCtlCharacters(value)) {
+		return null;
+	}
+
+	if (cookiePairByteLength(name, value) > MAX_COOKIE_PAIR_BYTES) {
+		return null;
+	}
+
+	return { name, value };
+}
+
+function parse(input: string | undefined): ParsedCookie[] {
+	if (!isNonEmptyString(input)) {
+		return [];
+	}
+
+	return [input]
+		.map((str) => parseString(str))
+		.filter((cookie): cookie is ParsedCookie => cookie !== null);
+}
+
+function splitCookiesString(cookiesString: unknown): string[] {
+	if (Array.isArray(cookiesString)) {
+		return cookiesString;
+	}
+	if (typeof cookiesString !== "string") {
+		return [];
+	}
+
+	const source = cookiesString;
+
+	const cookiesStrings: string[] = [];
+	let pos = 0;
+	let start = 0;
+	let ch = "";
+	let lastComma = 0;
+	let nextStart = 0;
+	let cookiesSeparatorFound = false;
+
+	function skipWhitespace() {
+		while (pos < source.length && /\s/.test(source.charAt(pos))) {
+			pos += 1;
+		}
+
+		return pos < source.length;
+	}
+
+	function notSpecialChar() {
+		ch = source.charAt(pos);
+		return ch !== "=" && ch !== ";" && ch !== ",";
+	}
+
+	while (pos < source.length) {
+		start = pos;
+		cookiesSeparatorFound = false;
+
+		while (skipWhitespace()) {
+			ch = source.charAt(pos);
+			if (ch === ",") {
+				lastComma = pos;
+				pos += 1;
+
+				skipWhitespace();
+				nextStart = pos;
+
+				while (pos < source.length && notSpecialChar()) {
+					pos += 1;
+				}
+
+				if (pos < source.length && source.charAt(pos) === "=") {
+					cookiesSeparatorFound = true;
+					pos = nextStart;
+					cookiesStrings.push(source.substring(start, lastComma));
+					start = pos;
+				} else {
+					pos = lastComma + 1;
+				}
+			} else {
+				pos += 1;
+			}
+		}
+
+		if (!cookiesSeparatorFound || pos >= source.length) {
+			cookiesStrings.push(source.substring(start, source.length));
+		}
+	}
+
+	return cookiesStrings;
+}
+
+export default parse;
+export { parse, parseNameValuePair, parseString, splitCookiesString };