@f5xc-salesdemos/xcsh 2.2.0 → 14.0.2

package/src/tools/puppeteer/03_stealth_botd.txt

@@ -0,0 +1,384 @@
+const makeNativeString = (name) => "function " + (name || "") + "() { [native code] }";
+const patchToString = (fn, name) => {
+	if (typeof fn !== "function") return;
+	Object_defineProperty(fn, "toString", {
+		value: function toString() {
+			return makeNativeString(name);
+		},
+		writable: false,
+		configurable: true,
+		enumerable: false,
+	});
+};
+
+// Ensure navigator.webdriver behaves like real Chrome
+if (navigator.webdriver !== false && navigator.webdriver !== undefined) {
+	const proto = Object_getPrototypeOf(navigator);
+	if (proto && "webdriver" in proto) {
+		delete proto.webdriver;
+	}
+}
+
+// Ensure window.chrome exists and is populated with standard Chrome APIs
+if (!window.chrome) {
+	Object_defineProperty(window, "chrome", {
+		writable: true,
+		enumerable: true,
+		configurable: false,
+		value: {},
+	});
+}
+
+if (window.chrome && !("app" in window.chrome)) {
+	const STATIC_DATA = {
+		isInstalled: false,
+		InstallState: {
+			DISABLED: "disabled",
+			INSTALLED: "installed",
+			NOT_INSTALLED: "not_installed",
+		},
+		RunningState: {
+			CANNOT_RUN: "cannot_run",
+			READY_TO_RUN: "ready_to_run",
+			RUNNING: "running",
+		},
+	};
+
+	const makeError = (fn) => new TypeError(`Error in invocation of app.${fn}()`);
+
+	window.chrome.app = {
+		...STATIC_DATA,
+		get isInstalled() {
+			return false;
+		},
+		getDetails: function getDetails() {
+			if (arguments.length) throw makeError("getDetails");
+			return null;
+		},
+		getIsInstalled: function getIsInstalled() {
+			if (arguments.length) throw makeError("getIsInstalled");
+			return false;
+		},
+		runningState: function runningState() {
+			if (arguments.length) throw makeError("runningState");
+			return "cannot_run";
+		},
+	};
+
+	patchToString(window.chrome.app.getDetails, "getDetails");
+	patchToString(window.chrome.app.getIsInstalled, "getIsInstalled");
+	patchToString(window.chrome.app.runningState, "runningState");
+}
+
+if (window.chrome && !("csi" in window.chrome) && window.performance?.timing) {
+	window.chrome.csi = function csi() {
+		const { timing } = window.performance;
+		return {
+			onloadT: timing.domContentLoadedEventEnd,
+			startE: timing.navigationStart,
+			pageT: Date.now() - timing.navigationStart,
+			tran: 15,
+		};
+	};
+	patchToString(window.chrome.csi, "csi");
+}
+
+if (
+	window.chrome &&
+	!("loadTimes" in window.chrome) &&
+	window.performance?.timing &&
+	window.PerformancePaintTiming
+) {
+	const { performance } = window;
+	const ntEntryFallback = {
+		nextHopProtocol: "h2",
+		type: "other",
+	};
+
+	const protocolInfo = {
+		get connectionInfo() {
+			const ntEntry = performance.getEntriesByType("navigation")[0] || ntEntryFallback;
+			return ntEntry.nextHopProtocol;
+		},
+		get npnNegotiatedProtocol() {
+			const ntEntry = performance.getEntriesByType("navigation")[0] || ntEntryFallback;
+			return ["h2", "hq"].includes(ntEntry.nextHopProtocol) ? ntEntry.nextHopProtocol : "unknown";
+		},
+		get navigationType() {
+			const ntEntry = performance.getEntriesByType("navigation")[0] || ntEntryFallback;
+			return ntEntry.type;
+		},
+		get wasAlternateProtocolAvailable() {
+			return false;
+		},
+		get wasFetchedViaSpdy() {
+			const ntEntry = performance.getEntriesByType("navigation")[0] || ntEntryFallback;
+			return ["h2", "hq"].includes(ntEntry.nextHopProtocol);
+		},
+		get wasNpnNegotiated() {
+			const ntEntry = performance.getEntriesByType("navigation")[0] || ntEntryFallback;
+			return ["h2", "hq"].includes(ntEntry.nextHopProtocol);
+		},
+	};
+
+	const { timing } = window.performance;
+
+	const toFixed = (num, fixed) => {
+		const re = new RegExp("^-?\\d+(?:.\\d{0," + (fixed || -1) + "})?");
+		return num.toString().match(re)[0];
+	};
+
+	const timingInfo = {
+		get firstPaintAfterLoadTime() {
+			return 0;
+		},
+		get requestTime() {
+			return timing.navigationStart / 1000;
+		},
+		get startLoadTime() {
+			return timing.navigationStart / 1000;
+		},
+		get commitLoadTime() {
+			return timing.responseStart / 1000;
+		},
+		get finishDocumentLoadTime() {
+			return timing.domContentLoadedEventEnd / 1000;
+		},
+		get finishLoadTime() {
+			return timing.loadEventEnd / 1000;
+		},
+		get firstPaintTime() {
+			const fpEntry = performance.getEntriesByType("paint")[0] || {
+				startTime: timing.loadEventEnd / 1000,
+			};
+			return toFixed((fpEntry.startTime + performance.timeOrigin) / 1000, 3);
+		},
+	};
+
+	window.chrome.loadTimes = function loadTimes() {
+		return { ...protocolInfo, ...timingInfo };
+	};
+	patchToString(window.chrome.loadTimes, "loadTimes");
+}
+
+const isSecureOrigin = document.location.protocol.startsWith("https");
+if (window.chrome && !("runtime" in window.chrome) && isSecureOrigin) {
+	const STATIC_DATA = {
+		OnInstalledReason: {
+			CHROME_UPDATE: "chrome_update",
+			INSTALL: "install",
+			SHARED_MODULE_UPDATE: "shared_module_update",
+			UPDATE: "update",
+		},
+		OnRestartRequiredReason: {
+			APP_UPDATE: "app_update",
+			OS_UPDATE: "os_update",
+			PERIODIC: "periodic",
+		},
+		PlatformArch: {
+			ARM: "arm",
+			ARM64: "arm64",
+			MIPS: "mips",
+			MIPS64: "mips64",
+			X86_32: "x86-32",
+			X86_64: "x86-64",
+		},
+		PlatformNaclArch: {
+			ARM: "arm",
+			MIPS: "mips",
+			MIPS64: "mips64",
+			X86_32: "x86-32",
+			X86_64: "x86-64",
+		},
+		PlatformOs: {
+			ANDROID: "android",
+			CROS: "cros",
+			LINUX: "linux",
+			MAC: "mac",
+			OPENBSD: "openbsd",
+			WIN: "win",
+		},
+		RequestUpdateCheckStatus: {
+			NO_UPDATE: "no_update",
+			THROTTLED: "throttled",
+			UPDATE_AVAILABLE: "update_available",
+		},
+	};
+
+	const makeCustomRuntimeErrors = (preamble, method, extensionId) => ({
+		NoMatchingSignature: new TypeError(preamble + "No matching signature."),
+		MustSpecifyExtensionID: new TypeError(
+			preamble +
+				`${method} called from a webpage must specify an Extension ID (string) for its first argument.`,
+		),
+		InvalidExtensionID: new TypeError(preamble + `Invalid extension id: '${extensionId}'`),
+	});
+
+	const isValidExtensionId = (value) => value.length === 32 && value.toLowerCase().match(/^[a-p]+$/);
+
+	const sendMessageHandler = {
+		apply(target, _ctx, args) {
+			const [extensionId, options, responseCallback] = args || [];
+			const errorPreamble =
+				"Error in invocation of runtime.sendMessage(optional string extensionId, any message, optional object options, optional function responseCallback): ";
+			const Errors = makeCustomRuntimeErrors(errorPreamble, "chrome.runtime.sendMessage()", extensionId);
+
+			const noArguments = args.length === 0;
+			const tooManyArguments = args.length > 4;
+			const incorrectOptions = options && typeof options !== "object";
+			const incorrectResponseCallback = responseCallback && typeof responseCallback !== "function";
+
+			if (noArguments || tooManyArguments || incorrectOptions || incorrectResponseCallback) {
+				throw Errors.NoMatchingSignature;
+			}
+
+			if (args.length < 2) {
+				throw Errors.MustSpecifyExtensionID;
+			}
+
+			if (typeof extensionId !== "string") {
+				throw Errors.NoMatchingSignature;
+			}
+
+			if (!isValidExtensionId(extensionId)) {
+				throw Errors.InvalidExtensionID;
+			}
+
+			return undefined;
+		},
+	};
+
+	const connectHandler = {
+		apply(target, _ctx, args) {
+			const [extensionId, connectInfo] = args || [];
+			const errorPreamble =
+				"Error in invocation of runtime.connect(optional string extensionId, optional object connectInfo): ";
+			const Errors = makeCustomRuntimeErrors(errorPreamble, "chrome.runtime.connect()", extensionId);
+
+			const noArguments = args.length === 0;
+			const emptyStringArgument = args.length === 1 && extensionId === "";
+			if (noArguments || emptyStringArgument) {
+				throw Errors.MustSpecifyExtensionID;
+			}
+
+			const tooManyArguments = args.length > 2;
+			const incorrectConnectInfoType = connectInfo && typeof connectInfo !== "object";
+			if (tooManyArguments || incorrectConnectInfoType) {
+				throw Errors.NoMatchingSignature;
+			}
+
+			const extensionIdIsString = typeof extensionId === "string";
+			if (extensionIdIsString && extensionId === "") {
+				throw Errors.MustSpecifyExtensionID;
+			}
+			if (extensionIdIsString && !isValidExtensionId(extensionId)) {
+				throw Errors.InvalidExtensionID;
+			}
+
+			const validateConnectInfo = (info) => {
+				if (args.length > 1) {
+					throw Errors.NoMatchingSignature;
+				}
+				if (Object_keys(info).length === 0) {
+					throw Errors.MustSpecifyExtensionID;
+				}
+				Object_entries(info).forEach(([key, value]) => {
+					const isExpected = ["name", "includeTlsChannelId"].includes(key);
+					if (!isExpected) {
+						throw new TypeError(errorPreamble + `Unexpected property: '${key}'.`);
+					}
+					const mismatch = (propName, expected, found) =>
+						TypeError(
+							errorPreamble +
+								`Error at property '${propName}': Invalid type: expected ${expected}, found ${found}.`,
+						);
+					if (key === "name" && typeof value !== "string") {
+						throw mismatch(key, "string", typeof value);
+					}
+					if (key === "includeTlsChannelId" && typeof value !== "boolean") {
+						throw mismatch(key, "boolean", typeof value);
+					}
+				});
+			};
+
+			if (typeof extensionId === "object") {
+				validateConnectInfo(extensionId);
+				throw Errors.MustSpecifyExtensionID;
+			}
+
+			const makeConnectResponse = () => {
+				const onSomething = () => ({
+					addListener: function addListener() {},
+					dispatch: function dispatch() {},
+					hasListener: function hasListener() {},
+					hasListeners: function hasListeners() {
+						return false;
+					},
+					removeListener: function removeListener() {},
+				});
+
+				return {
+					name: "",
+					sender: undefined,
+					disconnect: function disconnect() {},
+					onDisconnect: onSomething(),
+					onMessage: onSomething(),
+					postMessage: function postMessage() {
+						if (!arguments.length) {
+							throw new TypeError("Insufficient number of arguments.");
+						}
+						throw new Error("Attempting to use a disconnected port object");
+					},
+				};
+			};
+
+			return makeConnectResponse();
+		},
+	};
+
+	window.chrome.runtime = {
+		...STATIC_DATA,
+		get id() {
+			return undefined;
+		},
+		connect: null,
+		sendMessage: null,
+	};
+
+	const sendMessageProxy = new Window_Proxy(function sendMessage() {}, sendMessageHandler);
+	const connectProxy = new Window_Proxy(function connect() {}, connectHandler);
+	patchToString(sendMessageProxy, "sendMessage");
+	patchToString(connectProxy, "connect");
+	window.chrome.runtime.sendMessage = sendMessageProxy;
+	window.chrome.runtime.connect = connectProxy;
+}
+
+// Suppress Permission.query for automation-controlled
+if (navigator.permissions?.query) {
+	if (isSecureOrigin && "Notification" in window) {
+		Object_defineProperty(Notification, "permission", {
+			get: () => "default",
+			configurable: true,
+		});
+	} else if (!isSecureOrigin) {
+		const originalQuery = navigator.permissions.query;
+		navigator.permissions.query = function (parameters) {
+			if (parameters?.name === "notifications") {
+			const status = { state: "denied", onchange: null };
+			if (typeof PermissionStatus !== "undefined") {
+				Object_setPrototypeOf(status, PermissionStatus.prototype);
+			}
+			return Promise_resolve(status);
+			}
+			return originalQuery.call(this, parameters);
+		};
+	}
+}
+
+// Remove CDC_ markers from document
+const documentProps = Object_getOwnPropertyNames(document);
+for (const prop of documentProps) {
+	if (prop.startsWith("cdc_")) {
+		delete document[prop];
+	}
+}

package/src/tools/puppeteer/04_stealth_iframe.txt

@@ -0,0 +1,81 @@
+const addContentWindowProxy = (iframe) => {
+	const contentWindowProxy = {
+		get(target, key) {
+			if (key === "self") return this;
+			if (key === "frameElement") return iframe;
+			if (key === "0") return undefined;
+			return Reflect.get(target, key);
+		},
+	};
+
+	if (!iframe.contentWindow) {
+		const proxy = new Window_Proxy(window, contentWindowProxy);
+		Object_defineProperty(iframe, "contentWindow", {
+			get() {
+				return proxy;
+			},
+			set(newValue) {
+				return newValue;
+			},
+			enumerable: true,
+			configurable: false,
+		});
+	}
+};
+
+const handleIframeCreation = (target, thisArg, args) => {
+	const iframe = target.apply(thisArg, args);
+	const originalIframe = iframe;
+	const originalSrcdoc = originalIframe.srcdoc;
+
+	Object_defineProperty(iframe, "srcdoc", {
+		configurable: true,
+		get() {
+			return originalSrcdoc;
+		},
+		set(newValue) {
+			addContentWindowProxy(this);
+			Object_defineProperty(iframe, "srcdoc", {
+				configurable: false,
+				writable: false,
+				value: originalSrcdoc,
+			});
+			originalIframe.srcdoc = newValue;
+		},
+	});
+
+	return iframe;
+};
+
+const addIframeCreationSniffer = () => {
+	const originalCreateElement = document.createElement;
+	const handler = {
+		apply(target, thisArg, args) {
+			const isIframe = args && args.length && `${args[0]}`.toLowerCase() === "iframe";
+			if (!isIframe) {
+				return target.apply(thisArg, args);
+			}
+			return handleIframeCreation(target, thisArg, args);
+		},
+		get(target, key) {
+			return Reflect.get(target, key);
+		},
+	};
+
+	const proxied = new Window_Proxy(originalCreateElement, handler);
+	Object_defineProperty(document, "createElement", {
+		value: proxied,
+		writable: true,
+		configurable: true,
+	});
+	Object_defineProperty(document.createElement, "toString", {
+		value: Function_toString.bind(originalCreateElement),
+		writable: false,
+		configurable: true,
+		enumerable: false,
+	});
+};
+
+try {
+	addIframeCreationSniffer();
+} catch {}

package/src/tools/puppeteer/05_stealth_webgl.txt

@@ -0,0 +1,75 @@
+const vendors = ["Intel Inc.", "NVIDIA Corporation", "AMD"];
+const renderers = [
+  "Intel(R) Iris(TM) Plus Graphics 640",
+  "Intel(R) HD Graphics 630",
+  "NVIDIA GeForce GTX 1050 Ti",
+  "NVIDIA GeForce GTX 1060",
+  "NVIDIA GeForce RTX 3060",
+  "AMD Radeon RX 580",
+  "AMD Radeon Pro 560",
+];
+const vendor = vendors[Math_floor(Math_random() * vendors.length)];
+const renderer = renderers[Math_floor(Math_random() * renderers.length)];
+
+const getParameterProxyHandler = {
+  apply(target, thisArg, args) {
+    const param = args[0];
+    // VENDOR = 0x1F00
+    if (param === 0x1F00) return vendor;
+    // RENDERER = 0x1F01
+    if (param === 0x1F01) return renderer;
+    // UNMASKED_VENDOR_WEBGL = 0x9245
+    if (param === 0x9245) return vendor;
+    // UNMASKED_RENDERER_WEBGL = 0x9246
+    if (param === 0x9246) return renderer;
+    return target.apply(thisArg, args);
+  },
+};
+
+// Hook WebGL contexts
+const hookWebGL = (proto) => {
+  const originalGetParameter = proto.getParameter;
+  Object_defineProperty(proto, "getParameter", {
+    value: new Window_Proxy(originalGetParameter, getParameterProxyHandler),
+    writable: true,
+    configurable: true,
+    enumerable: true,
+  });
+};
+
+if (window.WebGLRenderingContext) {
+  hookWebGL(WebGLRenderingContext.prototype);
+}
+if (window.WebGL2RenderingContext) {
+  hookWebGL(WebGL2RenderingContext.prototype);
+}
+
+// Also mask getShaderPrecisionFormat for software rendering detection
+const precisionMask = (proto) => {
+  const original = proto.getShaderPrecisionFormat;
+  if (!original) return;
+  Object_defineProperty(proto, "getShaderPrecisionFormat", {
+    value: function (shaderType, precisionType) {
+      const result = original.call(this, shaderType, precisionType);
+      if (result) {
+        // Hardware typically has higher precision than SwiftShader defaults
+        return {
+          precision: Math_max(result.precision, 23),
+          rangeMin: Math_min(result.rangeMin, 127),
+          rangeMax: Math_max(result.rangeMax, 127),
+        };
+      }
+      return result;
+    },
+    writable: true,
+    configurable: true,
+    enumerable: true,
+  });
+};
+
+if (window.WebGLRenderingContext) {
+  precisionMask(WebGLRenderingContext.prototype);
+}
+if (window.WebGL2RenderingContext) {
+  precisionMask(WebGL2RenderingContext.prototype);
+}

package/src/tools/puppeteer/06_stealth_screen.txt

@@ -0,0 +1,72 @@
+// Generate consistent "real" screen dimensions based on viewport
+const width = window.innerWidth;
+const height = window.innerHeight;
+const availWidth = width;
+const availHeight = Math_max(height - 40, 0); // Account for taskbar
+const colorDepth = 24;
+const pixelDepth = 24;
+const devicePixelRatio = window.devicePixelRatio && window.devicePixelRatio > 1 ? window.devicePixelRatio : 1.25;
+
+const defineScreenProp = (prop, value) => {
+  try {
+    Object_defineProperty(window.Screen?.prototype ?? window.screen, prop, {
+      get: () => value,
+      configurable: true,
+      enumerable: true,
+    });
+  } catch {}
+};
+
+// Override screen properties
+for (const [prop, descriptor] of Object_entries({
+  width,
+  height,
+  availWidth,
+  availHeight,
+  availLeft: 0,
+  availTop: 0,
+  colorDepth,
+  pixelDepth,
+})) {
+  defineScreenProp(prop, descriptor);
+}
+
+// Ensure outer dimensions match screen for consistency
+const chromeFrameHeight = 85;
+Object_defineProperty(window, "outerWidth", {
+  get: () => window.innerWidth,
+  configurable: true,
+  enumerable: true,
+});
+Object_defineProperty(window, "outerHeight", {
+  get: () => window.innerHeight + chromeFrameHeight,
+  configurable: true,
+  enumerable: true,
+});
+
+if (window.visualViewport) {
+  const defineVvpProp = (prop, value) => {
+    try {
+      Object_defineProperty(window.visualViewport, prop, {
+        get: () => value,
+        configurable: true,
+        enumerable: true,
+      });
+    } catch {}
+  };
+
+  defineVvpProp("width", width);
+  defineVvpProp("height", height);
+  defineVvpProp("scale", 1);
+  defineVvpProp("offsetLeft", 0);
+  defineVvpProp("offsetTop", 0);
+  defineVvpProp("pageLeft", 0);
+  defineVvpProp("pageTop", 0);
+}
+
+// Consistent devicePixelRatio
+Object_defineProperty(window, "devicePixelRatio", {
+  get: () => devicePixelRatio,
+  configurable: true,
+  enumerable: true,
+});

package/src/tools/puppeteer/07_stealth_fonts.txt

@@ -0,0 +1,97 @@
+const commonFonts = [
+  "Arial",
+  "Arial Black",
+  "Arial Narrow",
+  "Arial Rounded MT Bold",
+  "Book Antiqua",
+  "Bookman Old Style",
+  "Calibri",
+  "Cambria",
+  "Cambria Math",
+  "Century",
+  "Century Gothic",
+  "Century Schoolbook",
+  "Comic Sans MS",
+  "Consolas",
+  "Courier",
+  "Courier New",
+  "Garamond",
+  "Geneva",
+  "Georgia",
+  "Gill Sans",
+  "Gill Sans MT",
+  "Helvetica",
+  "Helvetica Neue",
+  "Impact",
+  "Lucida Console",
+  "Lucida Grande",
+  "Lucida Sans Unicode",
+  "MS Gothic",
+  "MS PGothic",
+  "MS Sans Serif",
+  "MS Serif",
+  "Palatino",
+  "Palatino Linotype",
+  "Segoe Print",
+  "Segoe Script",
+  "Segoe UI",
+  "Segoe UI Emoji",
+  "Segoe UI Symbol",
+  "Tahoma",
+  "Times",
+  "Times New Roman",
+  "Trebuchet MS",
+  "Verdana",
+  "Wingdings",
+  "Wingdings 2",
+  "Wingdings 3",
+  "Apple Color Emoji",
+  "Apple SD Gothic Neo",
+  "Helvetica Neue",
+  "Hoefler Text",
+  "Menlo",
+  "Monaco",
+  "San Francisco",
+  "SF Pro Display",
+  "SF Pro Text",
+];
+
+// Override queryLocalFonts if present (Local Font Access API)
+if ("queryLocalFonts" in window) {
+  Object_defineProperty(window, "queryLocalFonts", {
+    value: async () => {
+      return commonFonts.map((family) => ({
+        family,
+        fullName: family,
+        postscriptName: family.replace(/\s+/g, ""),
+        style: "Regular",
+        blob: () => Promise_resolve(new Window_Blob([])),
+      }));
+    },
+    writable: true,
+    configurable: true,
+    enumerable: true,
+  });
+}
+
+// Hide fonts-unique tracking via canvas
+const originalGetContext = HTMLCanvasElement.prototype.getContext;
+HTMLCanvasElement.prototype.getContext = function (type, options) {
+  const ctx = originalGetContext.call(this, type, options);
+  if (ctx && type === "2d") {
+    const originalFillText = ctx.fillText;
+    ctx.fillText = function (text, x, y, maxWidth) {
+      // Add tiny imperceptible noise to text rendering
+      const noiseX = (Math_random() - 0.5) * 0.02;
+      const noiseY = (Math_random() - 0.5) * 0.02;
+      return originalFillText.call(
+        this,
+        text,
+        x + noiseX,
+        y + noiseY,
+        maxWidth,
+      );
+    };
+  }
+  return ctx;
+};