roxxie-proxy-u-prod 0.1.0

package/source/packages/scramjet/packages/core/src/shared/cookie.ts

@@ -0,0 +1,199 @@
+// thnank you node unblocker guy
+import { JSON_parse, JSON_stringify } from "@/shared/snapshot";
+import { _Date } from "./snapshot";
+import parse from "./set-cookie-parser";
+
+export type Cookie = {
+	name: string;
+	value: string;
+	path?: string;
+	expires?: number;
+	maxAge?: number;
+	domain?: string;
+	hostOnly?: boolean;
+	secure?: boolean;
+	httpOnly?: boolean;
+	sameSite?: string; // "strict"|"lax"|"none" or titlecase variants from parsers
+};
+
+export class CookieJar {
+	private cookies: Record<string, Cookie> = {};
+	// Index by domain (without leading dot)
+	private byDomain: Map<string, Cookie[]> = new Map();
+
+	private defaultPath(url: URL): string {
+		const pathname = url.pathname;
+		if (!pathname || !pathname.startsWith("/")) return "/";
+		const lastSlash = pathname.lastIndexOf("/");
+		if (lastSlash <= 0) return "/";
+		return pathname.slice(0, lastSlash);
+	}
+
+	private pathMatches(requestPath: string, cookiePath: string): boolean {
+		if (requestPath === cookiePath) return true;
+		if (!requestPath.startsWith(cookiePath)) return false;
+		if (cookiePath.endsWith("/")) return true;
+		return requestPath.charAt(cookiePath.length) === "/";
+	}
+
+	private indexCookie(c: Cookie) {
+		const key = c.domain!.slice(1);
+		let bucket = this.byDomain.get(key);
+		if (!bucket) {
+			bucket = [];
+			this.byDomain.set(key, bucket);
+		}
+		bucket.push(c);
+	}
+
+	private unindexCookie(c: Cookie) {
+		const key = c.domain!.slice(1);
+		const bucket = this.byDomain.get(key);
+		if (!bucket) return;
+		const i = bucket.indexOf(c);
+		if (i >= 0) bucket.splice(i, 1);
+		if (bucket.length === 0) this.byDomain.delete(key);
+	}
+
+	private removeById(id: string) {
+		const prev = this.cookies[id];
+		if (prev) this.unindexCookie(prev);
+		delete this.cookies[id];
+	}
+
+	setCookies(cookieString: string, url: URL) {
+		const parsedCookies = parse(cookieString);
+
+		for (const parsedCookie of parsedCookies) {
+			const lowerName = parsedCookie.name.toLowerCase();
+
+			if (lowerName.startsWith("__secure-")) {
+				if (!parsedCookie.secure) continue;
+			} else if (lowerName.startsWith("__host-")) {
+				if (!parsedCookie.secure) continue;
+				if (parsedCookie.domain) continue;
+				if (parsedCookie.path !== "/") continue;
+			}
+
+			const hostOnly = !parsedCookie.domain;
+			const expiresTime = parsedCookie.expires?.getTime();
+			const expires = Number.isFinite(expiresTime) ? expiresTime : undefined;
+			const cookie: Cookie = {
+				...parsedCookie,
+				hostOnly,
+				expires,
+			};
+
+			if (!cookie.domain) cookie.domain = url.hostname;
+			if (!cookie.domain.startsWith(".")) cookie.domain = "." + cookie.domain;
+			if (!cookie.path || !cookie.path.startsWith("/")) {
+				cookie.path = this.defaultPath(url);
+			}
+			if (!cookie.sameSite) cookie.sameSite = "lax";
+
+			const id = `${cookie.domain}@${cookie.path}@${cookie.name}`;
+
+			if (typeof cookie.maxAge === "number") {
+				if (!Number.isFinite(cookie.maxAge)) {
+					delete cookie.maxAge;
+				} else if (cookie.maxAge <= 0) {
+					this.removeById(id);
+					continue;
+				} else {
+					cookie.expires = _Date.now() + cookie.maxAge * 1000;
+				}
+			}
+
+			const prev = this.cookies[id];
+			if (prev) this.unindexCookie(prev);
+			this.cookies[id] = cookie;
+			this.indexCookie(cookie);
+		}
+	}
+
+	// SameSite enforcement context passed to getCookies.
+	// "strict"     – same-site request; all cookies allowed
+	// "lax"        – cross-site top-level GET/HEAD navigation; Strict blocked, Lax+None allowed
+	// "cross-site" – cross-site subresource or non-GET navigation; only None allowed
+	getCookies(
+		url: URL,
+		fromJs: boolean,
+		sameSiteContext: "strict" | "lax" | "cross-site" = "strict"
+	): string {
+		const now = _Date.now();
+		const hostname = url.hostname;
+		const pathname = url.pathname;
+		const validCookies: Cookie[] = [];
+
+		// Walk the hostname's domain suffix chain
+		let key: string | undefined = hostname;
+		while (key !== undefined) {
+			const bucket = this.byDomain.get(key);
+			if (bucket) {
+				for (const cookie of bucket) {
+					if (cookie.expires !== undefined && cookie.expires < now) continue;
+
+					if (cookie.hostOnly && key !== hostname) continue;
+
+					// Scramjet proxies all origins as HTTPS (including those served over HTTP),
+					// so we don't enforce the Secure attribute based on protocol here.
+					// if (cookie.secure && url.protocol !== "https:") continue;
+					if (cookie.httpOnly && fromJs) continue;
+					if (!this.pathMatches(pathname, cookie.path!)) continue;
+
+					// SameSite enforcement — compare case-insensitively since parsers may
+					// return "Strict"/"Lax"/"None" (titlecase) or "strict"/"lax"/"none".
+					const cs = (cookie.sameSite ?? "lax").toLowerCase();
+					if (sameSiteContext === "cross-site") {
+						// Only SameSite=None cookies are sent cross-site
+						if (cs !== "none") continue;
+					} else if (sameSiteContext === "lax") {
+						// Lax top-level navigation: block Strict, allow Lax and None
+						if (cs === "strict") continue;
+					}
+					// "strict" context: all cookies allowed (no filtering)
+
+					validCookies.push(cookie);
+				}
+			}
+			const dot = key.indexOf(".");
+			key = dot === -1 ? undefined : key.slice(dot + 1);
+		}
+
+		return validCookies
+			.map((cookie) =>
+				cookie.name ? `${cookie.name}=${cookie.value}` : cookie.value
+			)
+			.join("; ");
+	}
+
+	load(cookies: string | Record<string, Cookie>) {
+		if (typeof cookies === "object") {
+			console.error("??");
+			return;
+		}
+		const parsed: Record<string, Cookie> = JSON_parse(cookies);
+		this.cookies = {};
+		this.byDomain.clear();
+		const ids = Object.keys(parsed);
+		for (let i = 0; i < ids.length; i++) {
+			const id = ids[i];
+			const c = parsed[id];
+			if (typeof c.expires === "string") {
+				const t = Date.parse(c.expires as unknown as string);
+				c.expires = Number.isFinite(t) ? t : undefined;
+			}
+			this.cookies[id] = c;
+			this.indexCookie(c);
+		}
+	}
+
+	clear() {
+		this.cookies = {};
+		this.byDomain.clear();
+	}
+
+	dump(): string {
+		return JSON_stringify(this.cookies);
+	}
+}

package/source/packages/scramjet/packages/core/src/shared/headers.ts

@@ -0,0 +1,76 @@
+import { RawHeaders } from "@mercuryworkshop/proxy-transports";
+
+export class ScramjetHeaders {
+	headers = {};
+
+	set(key: string, v: string) {
+		this.headers[key.toLowerCase()] = v;
+	}
+
+	get(key: string): string | null {
+		const lk = key.toLowerCase();
+		if (lk in this.headers) {
+			return this.headers[lk];
+		}
+
+		return null;
+	}
+
+	delete(key: string) {
+		delete this.headers[key.toLowerCase()];
+	}
+
+	has(key: string): boolean {
+		return key.toLowerCase() in this.headers;
+	}
+
+	toRawHeaders(): RawHeaders {
+		const raw: RawHeaders = [];
+		for (const k in this.headers) {
+			raw.push([k, this.headers[k]]);
+		}
+
+		return raw;
+	}
+
+	toNativeHeaders(): Headers {
+		const native = new Headers();
+		for (const k in this.headers) {
+			native.set(k, this.headers[k]);
+		}
+
+		return native;
+	}
+
+	static fromRawHeaders(raw: RawHeaders): ScramjetHeaders {
+		const h = new ScramjetHeaders();
+		for (const [k, v] of raw) {
+			if (h.has(k)) {
+				// console.debug(
+				// 	`Duplicate header "${k}" found in raw headers, overwriting previous value.`
+				// );
+			}
+			h.set(k, v);
+		}
+
+		return h;
+	}
+
+	static fromNativeHeaders(native: Headers): ScramjetHeaders {
+		const h = new ScramjetHeaders();
+		for (const [k, v] of native.entries()) {
+			h.set(k, v);
+		}
+
+		return h;
+	}
+
+	clone(): ScramjetHeaders {
+		const newh = new ScramjetHeaders();
+		for (const k in this.headers) {
+			newh.set(k, this.headers[k]);
+		}
+
+		return newh;
+	}
+}

package/source/packages/scramjet/packages/core/src/shared/htmlRules.ts

@@ -0,0 +1,154 @@
+import { rewriteCss } from "@rewriters/css";
+import { rewriteHtml, rewriteSrcset } from "@rewriters/html";
+import { rewriteUrl, unrewriteBlob, URLMeta } from "@rewriters/url";
+import { ScramjetContext } from "@/shared";
+import { _URL } from "./snapshot";
+
+export const htmlRules: {
+	[key: string]: "*" | string[] | ((...any: any[]) => string | null);
+	fn: (
+		value: string,
+		context: ScramjetContext,
+		meta: URLMeta,
+		attrs?: Record<string, string | undefined>
+	) => string | null;
+}[] = [
+	{
+		fn: (value, context, meta) =>
+			rewriteUrl(value, context, meta, { navigateType: "location" }),
+
+		// url rewrites
+		src: ["embed", "img", "frame", "input", "track"],
+		href: ["a", "area", "image"],
+		data: ["object"],
+		action: ["form"],
+		formaction: ["button", "input", "textarea", "submit"],
+		poster: ["video"],
+		"xlink:href": ["image"],
+	},
+	{
+		fn: (value, context, meta, attrs) => {
+			const isModule =
+				attrs?.type?.toLowerCase() === "module" ||
+				attrs?.rel?.toLowerCase() === "modulepreload";
+
+			return rewriteUrl(value, context, meta, {
+				isModule,
+			});
+		},
+
+		src: ["script"],
+		href: ["link"],
+	},
+	{
+		fn: (value, context, meta) => {
+			const url = rewriteUrl(value, context, meta, {
+				topFrame: meta.topFrameName,
+				parentFrame: meta.parentFrameName,
+				isIframe: "1",
+			});
+
+			return url;
+		},
+		src: ["iframe"],
+	},
+	{
+		// is this a good idea?
+		fn: (_value, _context, _meta) => {
+			return null;
+		},
+		sandbox: ["iframe"],
+	},
+	{
+		fn: (value, context, meta) => {
+			if (value.startsWith("blob:")) {
+				// for media elements specifically they must take the original blob
+				// because they can't be fetch'd
+				return unrewriteBlob(value, context, meta);
+			}
+
+			return rewriteUrl(value, context, meta);
+		},
+		src: ["video", "audio", "source"],
+	},
+	{
+		fn: () => "",
+
+		integrity: ["script", "link"],
+	},
+	{
+		fn: () => null,
+
+		// csp stuff that must be deleted
+		nonce: "*",
+		csp: ["iframe"],
+		credentialless: ["iframe"],
+	},
+	{
+		fn: (value, context, meta) => rewriteSrcset(value, context, meta),
+
+		// srcset
+		srcset: ["img", "source"],
+		imagesrcset: ["link"],
+	},
+	{
+		fn: (value, context, meta) =>
+			rewriteHtml(
+				value,
+				context,
+				{
+					// for srcdoc origin is the origin of the page that the iframe is on. base and path get dropped
+					origin: new _URL(meta.origin.origin),
+					base: new _URL(meta.origin.origin),
+					topFrameName: meta.topFrameName,
+					parentFrameName: meta.parentFrameName,
+					referrerPolicy: meta.referrerPolicy,
+				},
+				{
+					loadScripts: true,
+					inline: true,
+					source: meta.origin.href,
+					apisource: "set HTMLIFrameElement.prototype.srcdoc",
+				}
+			),
+
+		// srcdoc
+		srcdoc: ["iframe"],
+	},
+	{
+		fn: (value, context, meta) => rewriteCss(value, context, meta),
+		style: "*",
+	},
+	{
+		fn: (value, context, meta) => {
+			if (value === "_top" || value === "_unfencedTop")
+				return meta.topFrameName;
+			else if (value === "_parent") return meta.parentFrameName;
+			else return value;
+		},
+		target: ["a", "base"],
+	},
+	{
+		// svg elements with an href property
+		fn: (value, context, meta) => {
+			// #id values are not rewritten
+			if (value.startsWith("#")) return value;
+			return rewriteUrl(value, context, meta);
+		},
+		href: [
+			"use",
+			"textPath",
+			"mpath",
+			"feImage",
+			"animate",
+			"animateMotion",
+			"animateTransform",
+			"set",
+			"discard",
+			"linearGradient",
+			"radialGradient",
+			"pattern",
+			"filter",
+		],
+	},
+];

package/source/packages/scramjet/packages/core/src/shared/index.ts

@@ -0,0 +1,79 @@
+import { ScramjetConfig, ScramjetFlags, ScramjetVersionInfo } from "@/types";
+import DomHandler, { Element } from "domhandler";
+import { URLMeta } from "@rewriters/url";
+import { CookieJar } from "./cookie";
+import { TapInstance } from "@/Tap";
+import { HtmlContext } from "@/shared/rewriters/html";
+import { _RegExp } from "./snapshot";
+
+export * from "./cookie";
+export * from "./headers";
+export * from "./htmlRules";
+export * from "./mime";
+export * from "./rewriters";
+
+export function flagEnabled(
+	flag: keyof ScramjetFlags,
+	context: ScramjetContext,
+	url: URL
+): boolean {
+	const value = context.config.flags[flag];
+	for (const regex in context.config.siteFlags) {
+		const partialflags = context.config.siteFlags[regex];
+		if (new _RegExp(regex).test(url.href) && flag in partialflags) {
+			return partialflags[flag];
+		}
+	}
+
+	return value;
+}
+export type ScramjetInterface = {
+	codecEncode: (input: string) => string;
+	codecDecode: (input: string) => string;
+
+	getInjectScripts(
+		meta: URLMeta,
+		handler: DomHandler,
+		htmlcontext: HtmlContext,
+		script: (src: string) => Element
+	): Element[];
+	getWorkerInjectScripts?(
+		meta: URLMeta,
+		isModule: boolean,
+		script: (src: string) => string
+	): string;
+};
+
+export type ScramjetContext = {
+	config: ScramjetConfig;
+	prefix: URL;
+	interface: ScramjetInterface;
+	cookieJar: CookieJar;
+	hooks?: {
+		rewriter: {
+			html: TapInstance<HtmlRewriterHooks>;
+		};
+	};
+};
+
+export type HtmlRewriterHooks = {
+	pre: {
+		context: {
+			handler: DomHandler;
+			meta: URLMeta;
+			origHtml: string;
+			htmlcontext: HtmlContext;
+		};
+	};
+	post: {
+		context: {
+			handler: DomHandler;
+			meta: URLMeta;
+			origHtml: string;
+			htmlcontext: HtmlContext;
+		};
+		props: {
+			setRawHtml?: string;
+		};
+	};
+};