fpscanner 0.2.0 → 0.9.2

package/src/signals/plugins.ts

@@ -0,0 +1,70 @@
+import { SignalValue } from "../types";
+import { INIT, NA, hashCode, ERROR, setObjectValues} from "./utils";
+
+function isValidPluginArray() {
+    if (!navigator.plugins) return false;
+    const str = typeof navigator.plugins.toString === "function" 
+      ? navigator.plugins.toString() 
+      : navigator.plugins.constructor && typeof navigator.plugins.constructor.toString === "function"
+        ? navigator.plugins.constructor.toString()
+        : typeof navigator.plugins;
+    return str === "[object PluginArray]" || 
+           str === "[object MSPluginsCollection]" || 
+           str === "[object HTMLPluginsCollection]";
+  }
+
+  function getPluginNamesHash() {
+    if (!navigator.plugins) return NA;
+
+    const pluginNames = [];
+    for (let i = 0; i < navigator.plugins.length; i++) {
+      pluginNames.push(navigator.plugins[i].name);
+    }
+    return hashCode(pluginNames.join(","));
+  }
+
+
+  function getPluginCount() {
+    if (!navigator.plugins) return NA;
+    return navigator.plugins.length;
+  }
+
+  function getPluginConsistency1() {
+    if (!navigator.plugins) return NA;
+    try {
+        return navigator.plugins[0] === navigator.plugins[0][0].enabledPlugin;
+    } catch (e) {
+        return ERROR;
+    }
+  }
+
+  function getPluginOverflow() {
+    if (!navigator.plugins) return NA;
+
+    try {
+        return navigator.plugins.item(4294967296) !== navigator.plugins[0];
+    } catch (e) {
+        return ERROR;
+    }
+  }
+
+export function plugins() {
+    const pluginsData = {
+        isValidPluginArray: INIT as SignalValue<boolean>,
+        pluginCount: INIT as SignalValue<number>,
+        pluginNamesHash: INIT as SignalValue<string>,
+        pluginConsistency1: INIT as SignalValue<boolean>,
+        pluginOverflow: INIT as SignalValue<boolean>,
+    }
+    
+    try {
+        pluginsData.isValidPluginArray = isValidPluginArray();
+        pluginsData.pluginCount = getPluginCount();
+        pluginsData.pluginNamesHash = getPluginNamesHash();
+        pluginsData.pluginConsistency1 = getPluginConsistency1();
+        pluginsData.pluginOverflow = getPluginOverflow();
+    } catch (e) {
+        setObjectValues(pluginsData, ERROR);
+    }
+    return pluginsData;
+}

package/src/signals/screenResolution.ts

@@ -0,0 +1,15 @@
+import { NA } from './utils';
+
+export function screenResolution() {
+    return {
+        width: window.screen.width,
+        height: window.screen.height,
+        pixelDepth: window.screen.pixelDepth,
+        colorDepth: window.screen.colorDepth,
+        availableWidth: window.screen.availWidth,
+        availableHeight: window.screen.availHeight,
+        innerWidth: window.innerWidth,
+        innerHeight: window.innerHeight,
+        hasMultipleDisplays: typeof (screen as any).isExtended !== 'undefined' ? (screen as any).isExtended : NA,
+    };
+}

package/src/signals/seleniumProperties.ts

@@ -0,0 +1,40 @@
+export function hasSeleniumProperties() {
+    const seleniumProps = [
+        "__driver_evaluate",
+        "__webdriver_evaluate", 
+        "__selenium_evaluate",
+        "__fxdriver_evaluate",
+        "__driver_unwrapped",
+        "__webdriver_unwrapped",
+        "__selenium_unwrapped", 
+        "__fxdriver_unwrapped",
+        "_Selenium_IDE_Recorder",
+        "_selenium",
+        "calledSelenium",
+        "$cdc_asdjflasutopfhvcZLmcfl_",
+        "$chrome_asyncScriptInfo",
+        "__$webdriverAsyncExecutor",
+        "webdriver",
+        "__webdriverFunc",
+        "domAutomation",
+        "domAutomationController",
+        "__lastWatirAlert",
+        "__lastWatirConfirm",
+        "__lastWatirPrompt",
+        "__webdriver_script_fn",
+        "_WEBDRIVER_ELEM_CACHE"
+      ];
+
+      let hasSeleniumProperty = false;
+
+      for (let i = 0; i < seleniumProps.length; i++) {
+        if (seleniumProps[i] in window) {
+          hasSeleniumProperty = true;
+          break;
+        }
+      }
+
+      hasSeleniumProperty = hasSeleniumProperty || !!(document as any).__webdriver_script_fn || !!(window as any).domAutomation || !!(window as any).domAutomationController
+      
+      return hasSeleniumProperty;
+}

package/src/signals/time.ts

@@ -0,0 +1,3 @@
+export function time() {
+    return new Date().getTime();
+}

package/src/signals/toSourceError.ts

@@ -0,0 +1,27 @@
+import { INIT } from './utils';
+
+export function toSourceError() {
+    const toSourceErrorData = {
+        toSourceError: INIT,
+        hasToSource: false,
+    };
+
+    try {
+        (null as any).usdfsh;
+    } catch (e) {
+        toSourceErrorData.toSourceError = (e as Error).toString();
+    }
+
+    try {
+        throw "xyz";
+    } catch (e: any) {
+        try {
+            e.toSource();
+            toSourceErrorData.hasToSource = true;
+        } catch (e2) {
+            toSourceErrorData.hasToSource = false;
+        }
+    }
+
+    return toSourceErrorData;
+}

package/src/signals/url.ts

@@ -0,0 +1,3 @@
+export function pageURL() {
+    return window.location.href;
+}

package/src/signals/userAgent.ts

@@ -0,0 +1,3 @@
+export function userAgent() {
+    return navigator.userAgent;
+}

package/src/signals/utils.ts

@@ -0,0 +1,29 @@
+export const ERROR = 'ERROR';
+export const INIT = 'INIT';
+export const NA = 'NA';
+export const SKIPPED = 'SKIPPED';
+export const HIGH = 'high'
+export const LOW = 'low'
+export const MEDIUM = 'medium'
+
+
+export function hashCode(str: string) {
+    let hash = 0;
+    for (let i = 0, len = str.length; i < len; i++) {
+        let chr = str.charCodeAt(i);
+        hash = (hash << 5) - hash + chr;
+        hash |= 0;
+    }
+    return hash.toString(16).padStart(8, "0");
+}
+
+export function setObjectValues(object: any, value: any) {
+    for (const key in object) {
+        object[key] = value;
+    }
+}
+
+
+export function isFirefox() {
+    return (navigator as any).buildID === "20181001000000";
+}

package/src/signals/webGL.ts

@@ -0,0 +1,28 @@
+import { ERROR, INIT, NA, isFirefox, setObjectValues } from './utils';
+
+export function webGL() {
+    const webGLData = {
+        vendor: INIT,
+        renderer: INIT,
+    };
+
+    if (isFirefox()) {
+        setObjectValues(webGLData, NA);
+        return webGLData;
+    }
+
+    try {
+        var canvas = document.createElement('canvas');
+        var ctx = (canvas.getContext("webgl") || canvas.getContext("experimental-webgl")) as any;
+        if (ctx.getSupportedExtensions().indexOf("WEBGL_debug_renderer_info") >= 0) {
+            webGLData.vendor = ctx.getParameter(ctx.getExtension('WEBGL_debug_renderer_info').UNMASKED_VENDOR_WEBGL);
+            webGLData.renderer = ctx.getParameter(ctx.getExtension('WEBGL_debug_renderer_info').UNMASKED_RENDERER_WEBGL);
+        } else {
+            setObjectValues(webGLData, NA);
+        }
+    } catch (e) {
+        setObjectValues(webGLData, ERROR);
+    }
+
+    return webGLData;
+}

package/src/signals/webdriver.ts

@@ -0,0 +1,3 @@
+export function webdriver() {
+    return navigator.webdriver;
+};

package/src/signals/webdriverWritable.ts

@@ -0,0 +1,15 @@
+export function webdriverWritable() {
+    try {
+        const prop = "webdriver";
+        const navigator = window.navigator as any;
+        if (!navigator[prop] && !navigator.hasOwnProperty(prop)) {
+            navigator[prop] = 1;
+            const writable = navigator[prop] === 1;
+            delete navigator[prop];
+            return writable;
+        }
+        return true;
+    } catch (e) {
+        return false;
+    }
+}

package/src/signals/webgpu.ts

@@ -0,0 +1,28 @@
+import { ERROR, INIT, NA, setObjectValues } from "./utils";
+
+export async function webgpu() {
+    const webGPUData = {
+        vendor: INIT,
+        architecture: INIT,
+        device: INIT,
+        description: INIT,
+    };
+
+    if ('gpu' in navigator) {
+        try {
+            const adapter = await (navigator as any).gpu.requestAdapter();
+            if (adapter) {
+                webGPUData.vendor = adapter.info.vendor;
+                webGPUData.architecture = adapter.info.architecture;
+                webGPUData.device = adapter.info.device;
+                webGPUData.description = adapter.info.description;
+            }
+        } catch (e) {
+            setObjectValues(webGPUData, ERROR);
+        }
+    } else {
+        setObjectValues(webGPUData, NA);
+    }
+
+    return webGPUData;
+}

package/src/signals/worker.ts

@@ -0,0 +1,77 @@
+import { ERROR, INIT, setObjectValues } from './utils';
+
+export async function worker() {
+    return new Promise((resolve) => {
+        const workerData = {
+            vendor: INIT,
+            renderer: INIT,
+            userAgent: INIT,
+            language: INIT,
+            platform: INIT,
+            memory: INIT,
+            cpuCount: INIT,
+        };
+
+        try {
+            const workerCode = `try {
+                var fingerprintWorker = {};
+
+                fingerprintWorker.userAgent = navigator.userAgent;
+                fingerprintWorker.language = navigator.language;
+                fingerprintWorker.cpuCount = navigator.hardwareConcurrency;
+                fingerprintWorker.platform = navigator.platform;
+                fingerprintWorker.memory = navigator.deviceMemory;
+                
+
+                var canvas = new OffscreenCanvas(1, 1);
+                fingerprintWorker.vendor = 'INIT';
+                fingerprintWorker.renderer = 'INIT';
+                var gl = canvas.getContext('webgl');
+                try {
+                    if (gl) {
+                        var glExt = gl.getExtension('WEBGL_debug_renderer_info');
+                        fingerprintWorker.vendor = gl.getParameter(glExt.UNMASKED_VENDOR_WEBGL);
+                        fingerprintWorker.renderer = gl.getParameter(glExt.UNMASKED_RENDERER_WEBGL);
+                    } else {
+                        fingerprintWorker.vendor = 'NA';
+                        fingerprintWorker.renderer = 'NA';
+                    }
+                } catch (_) {
+                    fingerprintWorker.vendor = 'ERROR';
+                    fingerprintWorker.renderer = 'ERROR';
+                }
+                self.postMessage(fingerprintWorker);
+            } catch (e) {
+                self.postMessage(fingerprintWorker);
+            }`
+
+            
+            const blob = new Blob([workerCode], { type: 'application/javascript' });
+            const workerUrl = URL.createObjectURL(blob);
+            const worker = new Worker(workerUrl);
+
+            worker.onmessage = function (e) {
+                try {
+                    workerData.vendor = e.data.vendor;
+                    workerData.renderer = e.data.renderer;
+                    workerData.userAgent = e.data.userAgent;
+                    workerData.language = e.data.language;
+                    workerData.platform = e.data.platform;
+                    workerData.memory = e.data.memory;
+                    workerData.cpuCount = e.data.cpuCount;
+
+                    return resolve(workerData);
+                } catch (_) {
+                    setObjectValues(workerData, ERROR);
+                    return resolve(workerData);
+                }
+            }
+        } catch (e) {
+            setObjectValues(workerData, ERROR);
+
+            return resolve(workerData);
+        }
+
+    });
+
+}

package/src/types.ts

@@ -0,0 +1,237 @@
+import { ERROR, INIT, NA, SKIPPED } from './signals/utils';
+
+export type SignalValue<T> = T | typeof ERROR | typeof INIT | typeof NA | typeof SKIPPED;
+
+export interface WebGLSignal {
+    vendor: SignalValue<string>;
+    renderer: SignalValue<string>;
+}
+
+export interface InternationalizationSignal {
+    timezone: SignalValue<string>;
+    localeLanguage: SignalValue<string>;
+}
+
+export interface ScreenResolutionSignal {
+    width: SignalValue<number>;
+    height: SignalValue<number>;
+    pixelDepth: SignalValue<number>;
+    colorDepth: SignalValue<number>;
+    availableWidth: SignalValue<number>;
+    availableHeight: SignalValue<number>;
+    innerWidth: SignalValue<number>;
+    innerHeight: SignalValue<number>;
+    hasMultipleDisplays: SignalValue<boolean>;
+}
+
+export interface LanguagesSignal {
+    languages: SignalValue<string[]>;
+    language: SignalValue<string>;
+}
+
+export interface WebGPUSignal {
+    vendor: SignalValue<string>;
+    architecture: SignalValue<string>;
+    device: SignalValue<string>;
+    description: SignalValue<string>;
+}
+
+export interface IframeSignal {
+    webdriver: SignalValue<boolean>;
+    userAgent: SignalValue<string>;
+    platform: SignalValue<string>;
+    memory: SignalValue<number>;
+    cpuCount: SignalValue<number>;
+    language: SignalValue<string>;
+}
+
+export interface WebWorkerSignal {
+    webdriver: SignalValue<boolean>;
+    userAgent: SignalValue<string>;
+    platform: SignalValue<string>;
+    memory: SignalValue<number>;
+    cpuCount: SignalValue<number>;
+    language: SignalValue<string>;
+    vendor: SignalValue<string>;
+    renderer: SignalValue<string>;
+}
+
+export interface BrowserExtensionsSignal {
+    bitmask: SignalValue<string>;
+    extensions: SignalValue<string[]>;
+}
+
+export interface BrowserFeaturesSignal {
+    bitmask: SignalValue<string>;
+    chrome: SignalValue<boolean>;
+    brave: SignalValue<boolean>;
+    applePaySupport: SignalValue<boolean>;
+    opera: SignalValue<boolean>;
+    serial: SignalValue<boolean>;
+    attachShadow: SignalValue<boolean>;
+    caches: SignalValue<boolean>;
+    webAssembly: SignalValue<boolean>;
+    buffer: SignalValue<boolean>;
+    showModalDialog: SignalValue<boolean>;
+}
+
+export interface MediaQueriesSignal {
+    prefersColorScheme: SignalValue<string | null>;
+    prefersReducedMotion: SignalValue<boolean>;
+    prefersReducedTransparency: SignalValue<boolean>;
+    colorGamut: SignalValue<string | null>;
+    pointer: SignalValue<string | null>;
+    anyPointer: SignalValue<string | null>;
+    hover: SignalValue<boolean>;
+    anyHover: SignalValue<boolean>;
+    colorDepth: SignalValue<number>;
+}
+
+export interface ToSourceErrorSignal {
+    toSourceError: SignalValue<string>;
+    hasToSource: SignalValue<boolean>;
+}
+
+export interface CanvasSignal {
+    hasModifiedCanvas: SignalValue<boolean>;
+    canvasFingerprint: SignalValue<string>;
+}
+
+export interface HighEntropyValuesSignal {
+    architecture: SignalValue<string>;
+    bitness: SignalValue<string>;
+    brands: SignalValue<string[]>;
+    mobile: SignalValue<boolean>;
+    model: SignalValue<string>;
+    platform: SignalValue<string>;
+    platformVersion: SignalValue<string>;
+    uaFullVersion: SignalValue<string>;
+}
+
+export interface PluginsSignal {
+    isValidPluginArray: SignalValue<boolean>;
+    pluginCount: SignalValue<number>;
+    pluginNamesHash: SignalValue<string>;
+    pluginConsistency1: SignalValue<boolean>;
+    pluginOverflow: SignalValue<boolean>;
+}
+
+export interface MultimediaDevicesSignal {
+    speakers: SignalValue<number>;
+    microphones: SignalValue<number>;
+    webcams: SignalValue<number>;
+}
+
+export interface MediaCodecsSignal {
+    audioCanPlayTypeHash: SignalValue<string>;
+    videoCanPlayTypeHash: SignalValue<string>;
+    audioMediaSourceHash: SignalValue<string>;
+    videoMediaSourceHash: SignalValue<string>;
+    rtcAudioCapabilitiesHash: SignalValue<string>;
+    rtcVideoCapabilitiesHash: SignalValue<string>;
+    hasMediaSource: SignalValue<boolean>;
+}
+
+// Grouped signal interfaces
+export interface AutomationSignals {
+    webdriver: SignalValue<boolean>;
+    webdriverWritable: SignalValue<boolean>;
+    selenium: SignalValue<boolean>;
+    cdp: SignalValue<boolean>;
+    playwright: SignalValue<boolean>;
+    navigatorPropertyDescriptors: SignalValue<string>;
+}
+
+export interface DeviceSignals {
+    cpuCount: SignalValue<number>;
+    memory: SignalValue<number>;
+    platform: SignalValue<string>;
+    screenResolution: ScreenResolutionSignal;
+    multimediaDevices: MultimediaDevicesSignal;
+    mediaQueries: MediaQueriesSignal;
+}
+
+export interface BrowserSignals {
+    userAgent: SignalValue<string>;
+    features: BrowserFeaturesSignal;
+    plugins: PluginsSignal;
+    extensions: BrowserExtensionsSignal;
+    highEntropyValues: HighEntropyValuesSignal;
+    etsl: SignalValue<number>;
+    maths: SignalValue<string>;
+    toSourceError: ToSourceErrorSignal;
+}
+
+export interface GraphicsSignals {
+    webGL: WebGLSignal;
+    webgpu: WebGPUSignal;
+    canvas: CanvasSignal;
+}
+
+export interface LocaleSignals {
+    internationalization: InternationalizationSignal;
+    languages: LanguagesSignal;
+}
+
+export interface ContextsSignals {
+    iframe: IframeSignal;
+    webWorker: WebWorkerSignal;
+}
+
+export interface FingerprintSignals {
+    automation: AutomationSignals;
+    device: DeviceSignals;
+    browser: BrowserSignals;
+    graphics: GraphicsSignals;
+    codecs: MediaCodecsSignal;
+    locale: LocaleSignals;
+    contexts: ContextsSignals;
+}
+
+export interface FastBotDetectionDetails {
+    headlessChromeScreenResolution: DetectionRuleResult;
+    hasWebdriver: DetectionRuleResult;
+    hasWebdriverWritable: DetectionRuleResult;
+    hasSeleniumProperty: DetectionRuleResult;
+    hasCDP: DetectionRuleResult;
+    hasPlaywright: DetectionRuleResult;
+    hasImpossibleDeviceMemory: DetectionRuleResult;
+    hasHighCPUCount: DetectionRuleResult;
+    hasMissingChromeObject: DetectionRuleResult;
+    hasWebdriverIframe: DetectionRuleResult;
+    hasWebdriverWorker: DetectionRuleResult;
+    hasMismatchWebGLInWorker: DetectionRuleResult;
+    hasMismatchPlatformIframe: DetectionRuleResult;
+    hasMismatchPlatformWorker: DetectionRuleResult;
+    hasSwiftshaderRenderer: DetectionRuleResult;
+    hasUTCTimezone: DetectionRuleResult;
+}
+export interface Fingerprint {
+    signals: FingerprintSignals;
+    fsid: string;
+    nonce: string;
+    time: SignalValue<number>;
+    url: string;
+    fastBotDetection: boolean;
+    fastBotDetectionDetails: FastBotDetectionDetails;
+}
+
+export type DetectionSeverity = 'low' | 'medium' | 'high';
+
+export interface DetectionRuleResult {
+    detected: boolean;
+    severity: DetectionSeverity;
+}
+
+export interface DetectionRule {
+    name: string;
+    severity: DetectionSeverity;
+    test: (fingerprint: Fingerprint) => boolean;
+}
+
+export interface CollectFingerprintOptions {
+    encrypt?: boolean;
+    timeout?: number;
+    skipWorker?: boolean;
+}
+

package/.babelrc

@@ -1,3 +0,0 @@
-{
-  "presets": ["es2015"]
-}

package/.travis.yml

@@ -1,17 +0,0 @@
-language: node_js
-node_js:
-  - "node"
-dist: trusty # needs Ubuntu Trusty
-# Note: if you switch to sudo: false, you'll need to launch chrome with --no-sandbox.
-# See https://github.com/travis-ci/travis-ci/issues/8836
-sudo: required
-addons:
-  chrome: stable # have Travis install chrome stable.
-cache:
-  npm: true
-  directories:
-    - node_modules
-install:
-  - npm install
-script:
-  - npm test