@sns-myagent/cli 0.2.0

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

@@ -0,0 +1,99 @@
+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",
+  "Hoefler Text",
+  "Menlo",
+  "Monaco",
+  "San Francisco",
+  "SF Pro Display",
+  "SF Pro Text",
+];
+
+if ("queryLocalFonts" in window) {
+  const queryLocalFonts = async function queryLocalFonts() {
+    return commonFonts.map((family) => ({
+      family,
+      fullName: family,
+      postscriptName: family.replace(/\s+/g, ""),
+      style: "Regular",
+      blob: () => Promise_resolve(new Window_Blob([])),
+    }));
+  };
+  patchToString(queryLocalFonts, "queryLocalFonts");
+  Object_defineProperty(window, "queryLocalFonts", {
+    value: queryLocalFonts,
+    writable: true,
+    configurable: true,
+    enumerable: true,
+  });
+}
+
+const originalGetContext = HTMLCanvasElement.prototype.getContext;
+const patchedGetContext = function getContext(type, options) {
+  const ctx = originalGetContext.call(this, type, options);
+  if (ctx && type === "2d") {
+    const originalFillText = ctx.fillText;
+    const patchedFillText = function fillText(text, x, y, maxWidth) {
+      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,
+      );
+    };
+    patchToString(patchedFillText, "fillText");
+    ctx.fillText = patchedFillText;
+  }
+  return ctx;
+};
+patchToString(patchedGetContext, "getContext");
+HTMLCanvasElement.prototype.getContext = patchedGetContext;

package/src/tools/puppeteer/08_stealth_audio.txt

@@ -0,0 +1,63 @@
+// Spoof AudioContext latency values to look like real hardware.
+const audioLatencyAccessors = {
+  get baseLatency() {
+    return 0.005;
+  },
+  get outputLatency() {
+    return 0.01;
+  },
+  get sampleRate() {
+    return 48000;
+  },
+};
+
+const defineAudioGetter = (proto, name) => {
+  const descriptor = Object_getOwnPropertyDescriptor(audioLatencyAccessors, name);
+  if (!descriptor || !descriptor.get) return;
+  patchToString(descriptor.get, "get " + name);
+  Object_defineProperty(proto, name, {
+    get: descriptor.get,
+    configurable: true,
+    enumerable: true,
+  });
+};
+
+const spoofLatency = (proto) => {
+  defineAudioGetter(proto, "baseLatency");
+  defineAudioGetter(proto, "outputLatency");
+};
+
+if (window.AudioContext) {
+  spoofLatency(AudioContext.prototype);
+}
+
+if (window.OfflineAudioContext) {
+  const OriginalOfflineAudioContext = window.OfflineAudioContext;
+  const PatchedOfflineAudioContext = class OfflineAudioContext extends OriginalOfflineAudioContext {
+    constructor(numberOfChannels, length, sampleRate) {
+      super(numberOfChannels, length, sampleRate);
+
+      const originalStartRendering = this.startRendering.bind(this);
+      const patchedStartRendering = async function startRendering() {
+        const buffer = await originalStartRendering();
+        for (let c = 0; c < buffer.numberOfChannels; c++) {
+          const channel = buffer.getChannelData(c);
+          for (let i = 0; i < channel.length; i++) {
+            if (Math_random() < 0.001) {
+              channel[i] += (Math_random() - 0.5) * 1e-8;
+            }
+          }
+        }
+        return buffer;
+      };
+      patchToString(patchedStartRendering, "startRendering");
+      this.startRendering = patchedStartRendering;
+    }
+  };
+  patchToString(PatchedOfflineAudioContext, "OfflineAudioContext");
+  window.OfflineAudioContext = PatchedOfflineAudioContext;
+}
+
+if (window.AudioContext) {
+  defineAudioGetter(AudioContext.prototype, "sampleRate");
+}

package/src/tools/puppeteer/09_stealth_locale.txt

@@ -0,0 +1,51 @@
+const locale = "en-US";
+const languages = [locale, "en"];
+
+const sameLanguages = (value) => {
+  if (!value || value.length !== languages.length) return false;
+  for (let index = 0; index < languages.length; index += 1) {
+    if (value[index] !== languages[index]) return false;
+  }
+  return true;
+};
+
+const navigatorProto = Object_getPrototypeOf(navigator);
+const navigatorAccessors = {
+  get language() {
+    return locale;
+  },
+  get languages() {
+    return [locale, "en"];
+  },
+};
+
+const defineNavigatorAccessor = (name) => {
+  const owner = navigatorProto || navigator;
+  const descriptor =
+    (navigatorProto && Object_getOwnPropertyDescriptor(navigatorProto, name)) ||
+    Object_getOwnPropertyDescriptor(navigator, name);
+  if (descriptor && descriptor.configurable === false) return;
+
+  const accessor = Object_getOwnPropertyDescriptor(navigatorAccessors, name);
+  if (!accessor || !accessor.get) return;
+  patchToString(accessor.get, "get " + name);
+
+  Object_defineProperty(owner, name, {
+    get: accessor.get,
+    configurable: descriptor ? descriptor.configurable : true,
+    enumerable: descriptor ? descriptor.enumerable : true,
+  });
+
+  const ownDescriptor = Object_getOwnPropertyDescriptor(navigator, name);
+  if (owner !== navigator && ownDescriptor && ownDescriptor.configurable !== false) {
+    Reflect_deleteProperty(navigator, name);
+  }
+};
+
+if (navigator.language !== locale) {
+  defineNavigatorAccessor("language");
+}
+
+if (!sameLanguages(navigator.languages)) {
+  defineNavigatorAccessor("languages");
+}

package/src/tools/puppeteer/10_stealth_plugins.txt

@@ -0,0 +1,212 @@
+const mimeTypesData = [
+	{
+		type: "application/pdf",
+		suffixes: "pdf",
+		description: "",
+		__pluginName: "Chrome PDF Viewer",
+	},
+	{
+		type: "application/x-google-chrome-pdf",
+		suffixes: "pdf",
+		description: "Portable Document Format",
+		__pluginName: "Chrome PDF Plugin",
+	},
+	{
+		type: "application/x-nacl",
+		suffixes: "",
+		description: "Native Client Executable",
+		__pluginName: "Native Client",
+	},
+	{
+		type: "application/x-pnacl",
+		suffixes: "",
+		description: "Portable Native Client Executable",
+		__pluginName: "Native Client",
+	},
+];
+
+const pluginsData = [
+	{
+		name: "Chrome PDF Plugin",
+		filename: "internal-pdf-viewer",
+		description: "Portable Document Format",
+		__mimeTypes: ["application/x-google-chrome-pdf"],
+	},
+	{
+		name: "Chrome PDF Viewer",
+		filename: "mhjfbmdgcfjbbpaeojofohoefgiehjai",
+		description: "",
+		__mimeTypes: ["application/pdf"],
+	},
+	{
+		name: "Native Client",
+		filename: "internal-nacl-plugin",
+		description: "",
+		__mimeTypes: ["application/x-nacl", "application/x-pnacl"],
+	},
+];
+
+const defineProp = (obj, prop, value) =>
+	Object_defineProperty(obj, prop, {
+		value,
+		writable: false,
+		enumerable: false,
+		configurable: true,
+	});
+
+const generateFunctionMocks = (proto, itemMainProp, dataArray) => {
+	const item = new Window_Proxy(proto.item, {
+		apply(target, ctx, args) {
+			if (!args.length) {
+				throw new TypeError(
+					`Failed to execute 'item' on '${proto[Symbol.toStringTag]}': 1 argument required, but only 0 present.`,
+				);
+			}
+			const isInteger = args[0] && Number.isInteger(Number(args[0]));
+			return (isInteger ? dataArray[Number(args[0])] : dataArray[0]) || null;
+		},
+	});
+	const namedItem = new Window_Proxy(proto.namedItem, {
+		apply(target, ctx, args) {
+			if (!args.length) {
+				throw new TypeError(
+					`Failed to execute 'namedItem' on '${proto[Symbol.toStringTag]}': 1 argument required, but only 0 present.`,
+				);
+			}
+			return dataArray.find(item => item[itemMainProp] === args[0]) || null;
+		},
+	});
+	patchToString(item, "item");
+	patchToString(namedItem, "namedItem");
+	const refresh = proto.refresh
+		? new Window_Proxy(proto.refresh, {
+				apply() {
+					return undefined;
+				},
+			})
+		: undefined;
+	patchToString(refresh, "refresh");
+	return { item, namedItem, refresh };
+};
+
+const generateMagicArray = (dataArray, proto, itemProto, itemMainProp) => {
+	const makeItem = (data) => {
+		const item = {};
+		for (const prop of Object_keys(data)) {
+			if (prop.startsWith("__")) continue;
+			defineProp(item, prop, data[prop]);
+		}
+		return patchItem(item, data);
+	};
+
+	const patchItem = (item, data) => {
+		let descriptor = Object_getOwnPropertyDescriptors(item);
+		if (itemProto === Plugin.prototype) {
+			descriptor = {
+				...descriptor,
+				length: {
+					value: data.__mimeTypes.length,
+					writable: false,
+					enumerable: false,
+					configurable: true,
+				},
+			};
+		}
+
+		const obj = Object_create(itemProto, descriptor);
+		const blacklist = [...Object_keys(data), "length", "enabledPlugin"];
+		return new Window_Proxy(obj, {
+			ownKeys(target) {
+				return [...Object_getOwnPropertyNames(target), ...Object.getOwnPropertySymbols(target)].filter(
+					key => !blacklist.includes(key),
+				);
+			},
+			getOwnPropertyDescriptor(target, prop) {
+				if (blacklist.includes(prop)) return undefined;
+				return Object_getOwnPropertyDescriptor(target, prop);
+			},
+		});
+	};
+
+	const magicArray = [];
+	dataArray.forEach(data => {
+		magicArray.push(makeItem(data));
+	});
+
+	magicArray.forEach(entry => {
+		defineProp(magicArray, entry[itemMainProp], entry);
+	});
+
+	const magicArrayObj = Object_create(proto, {
+		...Object_getOwnPropertyDescriptors(magicArray),
+		length: {
+			value: magicArray.length,
+			writable: false,
+			enumerable: false,
+			configurable: true,
+		},
+	});
+
+	const functionMocks = generateFunctionMocks(proto, itemMainProp, magicArray);
+
+	return new Window_Proxy(magicArrayObj, {
+		get(target, key = "") {
+			if (key === "item") return functionMocks.item;
+			if (key === "namedItem") return functionMocks.namedItem;
+			if (proto === PluginArray.prototype && key === "refresh") return functionMocks.refresh;
+			return Reflect_get(target, key);
+		},
+		ownKeys(target) {
+			const keys = [];
+			const typeProps = magicArray.map(entry => entry[itemMainProp]);
+			typeProps.forEach((_, index) => keys.push(`${index}`));
+			typeProps.forEach(propName => keys.push(propName));
+			return keys;
+		},
+		getOwnPropertyDescriptor(target, prop) {
+			if (prop === "length") return undefined;
+			return Object_getOwnPropertyDescriptor(target, prop);
+		},
+	});
+};
+
+const generateMimeTypeArray = (data) =>
+	generateMagicArray(data, MimeTypeArray.prototype, MimeType.prototype, "type");
+const generatePluginArray = (data) =>
+	generateMagicArray(data, PluginArray.prototype, Plugin.prototype, "name");
+
+const mimeTypes = generateMimeTypeArray(mimeTypesData);
+const plugins = generatePluginArray(pluginsData);
+
+for (const pluginData of pluginsData) {
+	pluginData.__mimeTypes.forEach((type, index) => {
+		plugins[pluginData.name][index] = mimeTypes[type];
+		Object_defineProperty(plugins[pluginData.name], type, {
+			value: mimeTypes[type],
+			writable: false,
+			enumerable: false,
+			configurable: true,
+		});
+		Object_defineProperty(mimeTypes[type], "enabledPlugin", {
+			value:
+				type === "application/x-pnacl"
+					? mimeTypes["application/x-nacl"].enabledPlugin
+					: new Window_Proxy(plugins[pluginData.name], {}),
+			writable: false,
+			enumerable: false,
+			configurable: true,
+		});
+	});
+}
+
+const patchNavigator = (name, value) =>
+	Object_defineProperty(Object_getPrototypeOf(navigator), name, {
+		get() {
+			return value;
+		},
+	});
+
+if (!("plugins" in navigator) || navigator.plugins.length === 0) {
+	patchNavigator("plugins", plugins);
+	patchNavigator("mimeTypes", mimeTypes);
+}

package/src/tools/puppeteer/11_stealth_hardware.txt

@@ -0,0 +1,59 @@
+const hardwareConcurrencyName = "hardwareConcurrency";
+let hardwareConcurrencyProto = Object_getPrototypeOf(navigator);
+let hardwareConcurrencyOwner;
+let hardwareConcurrencyDescriptor;
+
+while (hardwareConcurrencyProto && !hardwareConcurrencyDescriptor) {
+	hardwareConcurrencyDescriptor = Object_getOwnPropertyDescriptor(
+		hardwareConcurrencyProto,
+		hardwareConcurrencyName,
+	);
+	if (hardwareConcurrencyDescriptor) {
+		hardwareConcurrencyOwner = hardwareConcurrencyProto;
+	} else {
+		hardwareConcurrencyProto = Object_getPrototypeOf(hardwareConcurrencyProto);
+	}
+}
+
+const hardwareConcurrencyValue = 8;
+let shouldPatchHardwareConcurrency = false;
+
+if (
+	hardwareConcurrencyOwner &&
+	hardwareConcurrencyDescriptor &&
+	hardwareConcurrencyDescriptor.configurable &&
+	typeof hardwareConcurrencyDescriptor.get === "function"
+) {
+	shouldPatchHardwareConcurrency = true;
+	try {
+		shouldPatchHardwareConcurrency =
+			Reflect_apply(hardwareConcurrencyDescriptor.get, navigator, []) !==
+			hardwareConcurrencyValue;
+	} catch {
+		shouldPatchHardwareConcurrency = false;
+	}
+}
+
+if (shouldPatchHardwareConcurrency) {
+	const hardwareConcurrencyAccessors = {
+		get hardwareConcurrency() {
+			Reflect_apply(hardwareConcurrencyDescriptor.get, this, []);
+			return hardwareConcurrencyValue;
+		},
+	};
+	const getHardwareConcurrency = Object_getOwnPropertyDescriptor(
+		hardwareConcurrencyAccessors,
+		hardwareConcurrencyName,
+	).get;
+
+	if (typeof patchToString === "function") {
+		patchToString(getHardwareConcurrency, "get hardwareConcurrency");
+	}
+
+	Object_defineProperty(hardwareConcurrencyOwner, hardwareConcurrencyName, {
+		get: getHardwareConcurrency,
+		set: hardwareConcurrencyDescriptor.set,
+		enumerable: hardwareConcurrencyDescriptor.enumerable,
+		configurable: hardwareConcurrencyDescriptor.configurable,
+	});
+}

package/src/tools/puppeteer/12_stealth_codecs.txt

@@ -0,0 +1,42 @@
+const parseInput = (arg) => {
+	const [mime, codecStr] = arg.trim().split(";");
+	let codecs = [];
+	if (codecStr && codecStr.includes('codecs="')) {
+		codecs = codecStr
+			.trim()
+			.replace('codecs="', "")
+			.replace('"', "")
+			.trim()
+			.split(",")
+			.filter(Boolean)
+			.map(item => item.trim());
+	}
+	return { mime, codecStr, codecs };
+};
+
+const originalCanPlayType = HTMLMediaElement.prototype.canPlayType;
+const proxiedCanPlayType = new Window_Proxy(originalCanPlayType, {
+	apply(target, ctx, args) {
+		if (!args || !args.length) {
+			return Reflect_apply(target, ctx, args);
+		}
+		const { mime, codecs } = parseInput(args[0]);
+		if (mime === "video/mp4" && codecs.includes("avc1.42E01E")) {
+			return "probably";
+		}
+		if (mime === "audio/x-m4a" && !codecs.length) {
+			return "maybe";
+		}
+		if (mime === "audio/aac" && !codecs.length) {
+			return "probably";
+		}
+		return Reflect_apply(target, ctx, args);
+	},
+});
+patchToString(proxiedCanPlayType, "canPlayType");
+Object_defineProperty(HTMLMediaElement.prototype, "canPlayType", {
+	value: proxiedCanPlayType,
+	writable: true,
+	configurable: true,
+	enumerable: true,
+});