@zorilla/puppeteer-extra-plugin-stealth 1.0.0

package/test/evasions/webgl.vendor/index.test.js

@@ -0,0 +1,220 @@
+import { expect, test } from 'vitest';
+import Plugin from '../../../src/evasions/webgl.vendor/index.js';
+import {
+  addExtra,
+  getStealthFingerPrint,
+  getVanillaFingerPrint,
+  vanillaPuppeteer,
+} from '../../util.js';
+
+// FIXME: This changed in more recent chrome versions
+// test('vanilla: videoCard is Google Inc', async () => {
+//   const pageFn = async page => await page.evaluate(() => window.chrome) // eslint-disable-line
+//   const { videoCard } = await getVanillaFingerPrint(pageFn)
+//   expect(videoCard).toEqual(['Google Inc.', 'Google SwiftShader'])
+// })
+
+test.skip('stealth: videoCard is Intel Inc (requires fpcollect)', async () => {
+  const pageFn = async page => await page.evaluate(() => window.chrome); // eslint-disable-line
+  const { videoCard } = await getStealthFingerPrint(Plugin, pageFn);
+  expect(videoCard).toEqual(['Intel Inc.', 'Intel Iris OpenGL Engine']);
+});
+
+test.skip('stealth: customized values (requires fpcollect)', async () => {
+  const pageFn = async page => await page.evaluate(() => window.chrome); // eslint-disable-line
+  const { videoCard } = await getStealthFingerPrint(Plugin, pageFn, {
+    vendor: 'foo',
+    renderer: 'bar',
+  });
+  expect(videoCard).toEqual(['foo', 'bar']);
+});
+
+/* global WebGLRenderingContext */
+async function extendedTests() {
+  const results = {};
+
+  async function test(name, fn) {
+    const detectionPassed = await fn();
+    if (detectionPassed) console.log(`Chrome headless detected via ${name}`);
+    results[name] = detectionPassed;
+  }
+
+  const canvas = document.createElement('canvas');
+  const context = canvas.getContext('webgl');
+
+  await test('descriptorsOK', _ => {
+    const descriptors = Object.getOwnPropertyDescriptors(
+      WebGLRenderingContext.prototype
+    );
+    const str = descriptors.getParameter.toString();
+    return str === `[object Object]`;
+  });
+
+  await test('toStringOK', _ => {
+    const str = context.getParameter.toString();
+    return str === `function getParameter() { [native code] }`;
+  });
+
+  await test('toStringOK2', _ => {
+    const str = WebGLRenderingContext.prototype.getParameter.toString();
+    return str === `function getParameter() { [native code] }`;
+  });
+
+  // Make sure we not reveal our proxy through errors
+  await test('errorOK', _ => {
+    try {
+      return context.getParameter();
+    } catch (err) {
+      return !err.stack.includes(`at Object.apply`);
+    }
+  });
+
+  // Should not throw (that was old stealth behavior)
+  await test('elementOK', _ => {
+    try {
+      return context.getParameter(123) === null;
+    } catch (_) {
+      return false;
+    }
+  });
+
+  return results;
+}
+
+test.skip('vanilla: webgl is native (requires fpcollect)', async () => {
+  const pageFn = async page => {
+    // page.on('console', msg => {
+    //   console.log('Page console: ', msg.text())
+    // })
+    return await page.evaluate(extendedTests); // eslint-disable-line
+  };
+  const { pageFnResult: result } = await getVanillaFingerPrint(pageFn);
+
+  const wasHeadlessDetected = Object.values(result).some(e => e === false);
+  if (wasHeadlessDetected) {
+    console.log(result);
+  }
+  expect(wasHeadlessDetected).toBe(false);
+});
+
+test.skip('stealth: webgl is native (requires fpcollect)', async () => {
+  const pageFn = async page => await page.evaluate(extendedTests); // eslint-disable-line
+  const { pageFnResult: result } = await getStealthFingerPrint(Plugin, pageFn);
+
+  const wasHeadlessDetected = Object.values(result).some(e => e === false);
+  if (wasHeadlessDetected) {
+    console.log(result);
+  }
+  expect(wasHeadlessDetected).toBe(false);
+});
+
+/**
+ * A very simple method to retrieve the name of the default videocard of the system
+ * using webgl.
+ *
+ * Example (Apple Retina MBP 13): {vendor: "Intel Inc.", renderer: "Intel(R) Iris(TM) Graphics 6100"}
+ *
+ * @see https://stackoverflow.com/questions/49267764/how-to-get-the-video-card-driver-name-using-javascript-browser-side
+ * @returns {Object}
+ */
+function getVideoCardInfo(context = 'webgl') {
+  const gl = document.createElement('canvas').getContext(context);
+  if (!gl) {
+    return {
+      error: 'no webgl',
+    };
+  }
+  const debugInfo = gl.getExtension('WEBGL_debug_renderer_info');
+  if (debugInfo) {
+    return {
+      vendor: gl.getParameter(debugInfo.UNMASKED_VENDOR_WEBGL),
+      renderer: gl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL),
+    };
+  }
+  return {
+    error: 'no WEBGL_debug_renderer_info',
+  };
+}
+
+test('stealth: handles WebGLRenderingContext', async () => {
+  const puppeteer = addExtra(vanillaPuppeteer).use(Plugin());
+  const browser = await puppeteer.launch({ headless: true });
+  const page = await browser.newPage();
+
+  const videoCardInfo = await page.evaluate(getVideoCardInfo, 'webgl');
+  expect(videoCardInfo.error).toBe(undefined);
+  expect(videoCardInfo.vendor).toBe('Intel Inc.');
+  expect(videoCardInfo.renderer).toBe('Intel Iris OpenGL Engine');
+});
+
+test('stealth: handles WebGL2RenderingContext', async () => {
+  const puppeteer = addExtra(vanillaPuppeteer).use(Plugin());
+  const browser = await puppeteer.launch({ headless: true });
+  const page = await browser.newPage();
+
+  const videoCardInfo = await page.evaluate(getVideoCardInfo, 'webgl2');
+  expect(videoCardInfo.error).toBe(undefined);
+  expect(videoCardInfo.vendor).toBe('Intel Inc.');
+  expect(videoCardInfo.renderer).toBe('Intel Iris OpenGL Engine');
+});
+
+test('vanilla: normal toString stuff', async () => {
+  const browser = await vanillaPuppeteer.launch({ headless: true });
+  const page = await browser.newPage();
+
+  const test1 = await page.evaluate(() => {
+    return WebGLRenderingContext.prototype.getParameter.toString + '';
+  });
+  expect(test1).toBe('function toString() { [native code] }');
+
+  const test2 = await page.evaluate(() => {
+    return WebGLRenderingContext.prototype.getParameter.toString();
+  });
+  expect(test2).toBe('function getParameter() { [native code] }');
+});
+
+test('stealth: will not leak toString stuff', async () => {
+  const puppeteer = addExtra(vanillaPuppeteer).use(Plugin());
+  const browser = await puppeteer.launch({ headless: true });
+  const page = await browser.newPage();
+
+  const test1 = await page.evaluate(() => {
+    return WebGLRenderingContext.prototype.getParameter.toString + '';
+  });
+  expect(test1).toBe('function toString() { [native code] }'); // returns function () { [native code] }
+
+  const test2 = await page.evaluate(() => {
+    return WebGLRenderingContext.prototype.getParameter.toString();
+  });
+  expect(test2).toBe('function getParameter() { [native code] }');
+});
+
+test('stealth: sets user opts correctly', async () => {
+  const puppeteer = addExtra(vanillaPuppeteer).use(
+    Plugin({ vendor: 'alice', renderer: 'bob' })
+  );
+  const browser = await puppeteer.launch({ headless: true });
+  const page = await browser.newPage();
+
+  const videoCardInfo = await page.evaluate(getVideoCardInfo, 'webgl');
+  expect(videoCardInfo.error).toBe(undefined);
+  expect(videoCardInfo.vendor).toBe('alice');
+  expect(videoCardInfo.renderer).toBe('bob');
+});
+
+test('stealth: does not affect protoype', async () => {
+  const puppeteer = addExtra(vanillaPuppeteer).use(
+    Plugin({ vendor: 'alice', renderer: 'bob' })
+  );
+  const browser = await puppeteer.launch({ headless: true });
+  const page = await browser.newPage();
+
+  const result = await page.evaluate(() => {
+    try {
+      return WebGLRenderingContext.prototype.getParameter(37445);
+    } catch (err) {
+      return err.message;
+    }
+  });
+  expect(result).toBe('Illegal invocation');
+});

package/test/fixtures/dummy-with-service-worker.html

@@ -0,0 +1,22 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <title>title foo</title>
+    <!-- Testing evasions with a real html page makes things easier -->
+    <script>
+      if ('serviceWorker' in navigator) {
+        window.addEventListener('load', () => {
+          navigator.serviceWorker.register('/sw.js').then((registration) => {
+            console.log('ServiceWorker registration successful with scope: ', registration.scope);
+          }, (err) => {
+            console.log('ServiceWorker registration failed: ', err);
+          });
+        });
+      }
+    </script>
+  </head>
+  <body>
+    <h1>Test page with service worker</h1>
+  </body>
+</html>

package/test/fixtures/dummy.html

@@ -0,0 +1,11 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <title>title foo</title>
+    <!-- Testing evasions with a real html page makes things easier -->
+  </head>
+  <body>
+    <h1>Test page</h1>
+  </body>
+</html>

package/test/fixtures/sw.js

@@ -0,0 +1 @@
+// Left empty

package/test/fpscanner.test.ts

@@ -0,0 +1,54 @@
+import fpscanner from 'fpscanner';
+import { expect, test } from 'vitest';
+import Plugin from '../dist/index.js';
+import {
+  compareLooseVersionStrings,
+  getStealthFingerPrint,
+  getVanillaFingerPrint,
+} from './util.js';
+
+// Fix CI issues with old versions
+const isOldPuppeteerVersion = () => {
+  const version = process.env.PUPPETEER_VERSION;
+  if (!version) {
+    return false;
+  }
+  if (version === '1.9.0' || version === '1.6.2') {
+    return true;
+  }
+  return false;
+};
+
+test.skip('vanilla: will fail multiple fpscanner tests (requires fpcollect build)', async () => {
+  const fingerPrint = await getVanillaFingerPrint();
+  const testedFingerPrints = fpscanner.analyseFingerprint(fingerPrint);
+  const failedChecks = Object.values(testedFingerPrints).filter(
+    val => val.consistent < 3
+  );
+
+  if (isOldPuppeteerVersion()) {
+    expect(failedChecks.length).toBe(8);
+  } else {
+    expect(failedChecks.length).toBe(7);
+  }
+});
+
+test.skip('stealth: will not fail a single fpscanner test (requires fpcollect build)', async () => {
+  const fingerPrint = await getStealthFingerPrint(Plugin);
+  const testedFingerPrints = fpscanner.analyseFingerprint(fingerPrint);
+  const failedChecks = Object.values(testedFingerPrints).filter(
+    val => val.consistent < 3
+  );
+
+  if (failedChecks.length) {
+    console.warn('The following fingerprints failed:', failedChecks);
+  }
+
+  if (compareLooseVersionStrings(fingerPrint.userAgent, '89.0.4339.0') >= 0) {
+    // Updated navigator.webdriver behavior breaks the fpscanner tests.
+    expect(failedChecks.length).toBe(1);
+    expect(failedChecks[0].name).toBe('WEBDRIVER');
+  } else {
+    expect(failedChecks.length).toBe(0);
+  }
+});

package/test/index.test.ts

@@ -0,0 +1,51 @@
+const PLUGIN_NAME = 'stealth';
+
+import { expect, test } from 'vitest';
+
+import Plugin from '../dist/index.js';
+
+test('is a function', async () => {
+  expect(typeof Plugin).toBe('function');
+});
+
+test('should have the basic class members', async () => {
+  const instance = Plugin();
+  expect(instance.name).toBe(PLUGIN_NAME);
+  expect(instance._isPuppeteerExtraPlugin).toBe(true);
+});
+
+test('should have the public child class members', async () => {
+  const instance = Plugin();
+  const prototype = Object.getPrototypeOf(instance);
+  const childClassMembers = Object.getOwnPropertyNames(prototype);
+
+  expect(childClassMembers.includes('constructor')).toBe(true);
+  expect(childClassMembers.includes('name')).toBe(true);
+  expect(childClassMembers.includes('name')).toBe(true);
+  expect(childClassMembers.includes('defaults')).toBe(true);
+  expect(childClassMembers.includes('availableEvasions')).toBe(true);
+  expect(childClassMembers.includes('enabledEvasions')).toBe(true);
+  expect(childClassMembers.length).toBe(7);
+});
+
+test('should have opts with default values', async () => {
+  const instance = Plugin();
+  expect(instance.opts.enabledEvasions).toEqual(instance.availableEvasions);
+});
+
+test('should add all dependencies dynamically', async () => {
+  const instance = Plugin();
+  const deps = new Set(
+    [...instance.opts.enabledEvasions].map(e => `${PLUGIN_NAME}/evasions/${e}`)
+  );
+  expect(instance.dependencies).toEqual(deps);
+});
+
+test('should add all dependencies dynamically including changes', async () => {
+  const instance = Plugin();
+  const fakeDep = 'foobar';
+  instance.enabledEvasions = new Set([fakeDep]);
+  expect(instance.dependencies).toEqual(
+    new Set([`${PLUGIN_NAME}/evasions/${fakeDep}`])
+  );
+});

package/test/service-worker.test.ts

@@ -0,0 +1,112 @@
+import fs from 'node:fs';
+import http from 'node:http';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { afterAll, beforeAll, expect, test } from 'vitest';
+import Plugin from '../dist/index.js';
+import { addExtra, vanillaPuppeteer } from './util.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Create a simple HTTP server. Service Workers cannot be served from file:// URIs
+const httpServer = async () => {
+  const server = await http
+    .createServer((req, res) => {
+      let contents, type;
+
+      if (req.url === '/sw.js') {
+        contents = fs.readFileSync(path.join(__dirname, './fixtures/sw.js'));
+        type = 'application/javascript';
+      } else {
+        contents = fs.readFileSync(
+          path.join(__dirname, './fixtures/dummy-with-service-worker.html')
+        );
+        type = 'text/html';
+      }
+
+      res.setHeader('Content-Type', type);
+      res.writeHead(200);
+      res.end(contents);
+    })
+    .listen(0); // random free port
+
+  return `http://127.0.0.1:${server.address().port}/`;
+};
+
+let browser, page, worker;
+
+beforeAll(async () => {
+  const address = await httpServer();
+  console.log(`Server is running on port ${address}`);
+
+  browser = await addExtra(vanillaPuppeteer)
+    .use(Plugin())
+    .launch({ headless: true });
+  page = await browser.newPage();
+
+  worker = new Promise(resolve => {
+    browser.on('targetcreated', async target => {
+      if (target.type() === 'service_worker') {
+        resolve(target.worker());
+      }
+    });
+  });
+
+  await page.goto(address);
+  worker = await worker;
+});
+
+afterAll(async () => {
+  await browser.close();
+});
+
+test.skip('stealth: inconsistencies between page and worker', async () => {
+  const pageFP = await page.evaluate(detectFingerprint);
+  const workerFP = await worker.evaluate(detectFingerprint);
+
+  expect(pageFP).toEqual(workerFP);
+});
+
+test.skip('stealth: creepjs has good trust score', async () => {
+  page.goto('https://abrahamjuliot.github.io/creepjs/');
+
+  const score = await (
+    await (
+      await page.waitForSelector('#fingerprint-data .unblurred')
+    ).getProperty('textContent')
+  ).jsonValue();
+
+  expect(parseInt(score, 10) > 80).toBe(true);
+});
+
+/* global OffscreenCanvas */
+function detectFingerprint() {
+  const results = {};
+
+  const props = [
+    'userAgent',
+    'language',
+    'hardwareConcurrency',
+    'deviceMemory',
+    'languages',
+    'platform',
+  ];
+  props.forEach(el => {
+    results[el] = navigator[el].toString();
+  });
+
+  const canvasOffscreenWebgl = new OffscreenCanvas(256, 256);
+  const contextWebgl = canvasOffscreenWebgl.getContext('webgl');
+  const rendererInfo = contextWebgl.getExtension('WEBGL_debug_renderer_info');
+  results.webglVendor = contextWebgl.getParameter(
+    rendererInfo.UNMASKED_VENDOR_WEBGL
+  );
+  results.webglRenderer = contextWebgl.getParameter(
+    rendererInfo.UNMASKED_RENDERER_WEBGL
+  );
+
+  results.timeZone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+
+  return results;
+}

package/test/stealth/headful-chrome-stealth.js

@@ -0,0 +1,25 @@
+const path = require('node:path');
+const scriptName = path.basename(__filename);
+const screenshotPath = path.join(__dirname, '_results', `${scriptName}.png`);
+
+const puppeteer = require('@zorilla/puppeteer-extra');
+const pluginStealth = require('@zorilla/puppeteer-extra-plugin-stealth')();
+puppeteer.use(pluginStealth);
+
+async function main() {
+  console.log('start', scriptName);
+  const browser = await puppeteer.launch({
+    headless: false,
+    executablePath: `/Applications/Google Chrome.app/Contents/MacOS/Google Chrome`, // MacOS
+  });
+
+  const page = await browser.newPage();
+  await page.setViewport({ width: 800, height: 600 });
+  await page.goto('https://bot.sannysoft.com/');
+  await page.waitForTimeout(5000);
+  await page.screenshot({ path: screenshotPath, fullPage: true });
+
+  await browser.close();
+  console.log('end', screenshotPath);
+}
+main();

package/test/stealth/headful-chrome-vanilla.js

@@ -0,0 +1,23 @@
+const path = require('node:path');
+const scriptName = path.basename(__filename);
+const screenshotPath = path.join(__dirname, '_results', `${scriptName}.png`);
+
+const puppeteer = require('puppeteer');
+
+async function main() {
+  console.log('start', scriptName);
+  const browser = await puppeteer.launch({
+    headless: false,
+    executablePath: `/Applications/Google Chrome.app/Contents/MacOS/Google Chrome`, // MacOS
+  });
+
+  const page = await browser.newPage();
+  await page.setViewport({ width: 800, height: 600 });
+  await page.goto('https://bot.sannysoft.com/');
+  await page.waitForTimeout(5000);
+  await page.screenshot({ path: screenshotPath, fullPage: true });
+
+  await browser.close();
+  console.log('end', screenshotPath);
+}
+main();

package/test/stealth/headful-chromium-stealth.js

@@ -0,0 +1,22 @@
+const path = require('node:path');
+const scriptName = path.basename(__filename);
+const screenshotPath = path.join(__dirname, '_results', `${scriptName}.png`);
+
+const puppeteer = require('@zorilla/puppeteer-extra');
+const pluginStealth = require('@zorilla/puppeteer-extra-plugin-stealth');
+
+async function main() {
+  puppeteer.use(pluginStealth());
+  console.log('start', scriptName);
+  const browser = await puppeteer.launch({ headless: false });
+
+  const page = await browser.newPage();
+  await page.setViewport({ width: 800, height: 600 });
+  await page.goto('https://bot.sannysoft.com/');
+  await page.waitForTimeout(5000);
+  await page.screenshot({ path: screenshotPath, fullPage: true });
+
+  await browser.close();
+  console.log('end', screenshotPath);
+}
+main();

package/test/stealth/headful-chromium-vanilla.js

@@ -0,0 +1,20 @@
+const path = require('node:path');
+const scriptName = path.basename(__filename);
+const screenshotPath = path.join(__dirname, '_results', `${scriptName}.png`);
+
+const puppeteer = require('puppeteer');
+
+async function main() {
+  console.log('start', scriptName);
+  const browser = await puppeteer.launch({ headless: false });
+
+  const page = await browser.newPage();
+  await page.setViewport({ width: 800, height: 600 });
+  await page.goto('https://bot.sannysoft.com/');
+  await page.waitForTimeout(5000);
+  await page.screenshot({ path: screenshotPath, fullPage: true });
+
+  await browser.close();
+  console.log('end', screenshotPath);
+}
+main();

package/test/stealth/headless-chrome-stealth.js

@@ -0,0 +1,25 @@
+const path = require('node:path');
+const scriptName = path.basename(__filename);
+const screenshotPath = path.join(__dirname, '_results', `${scriptName}.png`);
+
+const puppeteer = require('@zorilla/puppeteer-extra');
+const pluginStealth = require('@zorilla/puppeteer-extra-plugin-stealth')();
+puppeteer.use(pluginStealth);
+
+async function main() {
+  console.log('start', scriptName);
+  const browser = await puppeteer.launch({
+    headless: true,
+    executablePath: `/Applications/Google Chrome.app/Contents/MacOS/Google Chrome`, // MacOS
+  });
+
+  const page = await browser.newPage();
+  await page.setViewport({ width: 800, height: 600 });
+  await page.goto('https://bot.sannysoft.com/');
+  await page.waitForTimeout(5000);
+  await page.screenshot({ path: screenshotPath, fullPage: true });
+
+  await browser.close();
+  console.log('end', screenshotPath);
+}
+main();

package/test/stealth/headless-chrome-vanilla.js

@@ -0,0 +1,23 @@
+const path = require('node:path');
+const scriptName = path.basename(__filename);
+const screenshotPath = path.join(__dirname, '_results', `${scriptName}.png`);
+
+const puppeteer = require('puppeteer');
+
+async function main() {
+  console.log('start', scriptName);
+  const browser = await puppeteer.launch({
+    headless: true,
+    executablePath: `/Applications/Google Chrome.app/Contents/MacOS/Google Chrome`, // MacOS
+  });
+
+  const page = await browser.newPage();
+  await page.setViewport({ width: 800, height: 600 });
+  await page.goto('https://bot.sannysoft.com/');
+  await page.waitForTimeout(5000);
+  await page.screenshot({ path: screenshotPath, fullPage: true });
+
+  await browser.close();
+  console.log('end', screenshotPath);
+}
+main();