fpscanner 0.2.0 → 0.9.2

package/src/signals/browserExtensions.ts

@@ -0,0 +1,57 @@
+import { INIT } from "./utils";
+
+export function browserExtensions() {
+    const browserExtensionsData = {
+        bitmask: INIT,
+        extensions: [] as string[],
+    };
+
+    const hasGrammarly = document.body.hasAttribute('data-gr-ext-installed');
+    const hasMetamask = typeof (window as any).ethereum !=='undefined';
+    const hasCouponBirds = document.getElementById('coupon-birds-drop-div') !== null;
+    const hasDeepL = document.querySelector('deepl-input-controller') !== null;
+    const hasMonicaAI = document.getElementById('monica-content-root') !== null;
+    const hasSiderAI = document.querySelector('chatgpt-sidebar') !== null;
+    const hasRequestly = typeof (window as any).__REQUESTLY__ !== 'undefined';
+    const hasVeepn = Array.from(document.querySelectorAll('*'))
+    .filter(el => el.tagName.toLowerCase().startsWith('veepn-')).length > 0;
+
+    browserExtensionsData.bitmask = [
+        hasGrammarly ? '1' : '0',
+        hasMetamask ? '1' : '0',
+        hasCouponBirds ? '1' : '0',
+        hasDeepL ? '1' : '0',
+        hasMonicaAI ? '1' : '0',
+        hasSiderAI ? '1' : '0',
+        hasRequestly ? '1' : '0',
+        hasVeepn ? '1' : '0',
+    ].join('');
+
+
+    if (hasGrammarly) {
+        browserExtensionsData.extensions.push('grammarly');
+    }
+    if (hasMetamask) {
+        browserExtensionsData.extensions.push('metamask');
+    }
+    if (hasCouponBirds) {
+        browserExtensionsData.extensions.push('coupon-birds');
+    }
+    if (hasDeepL) {
+        browserExtensionsData.extensions.push('deepl');
+    }
+    if (hasMonicaAI) {
+        browserExtensionsData.extensions.push('monica-ai');
+    }
+    if (hasSiderAI) {
+        browserExtensionsData.extensions.push('sider-ai');
+    }
+    if (hasRequestly) {
+        browserExtensionsData.extensions.push('requestly');
+    }
+    if (hasVeepn) {
+        browserExtensionsData.extensions.push('veepn');
+    }
+    
+    return browserExtensionsData;
+}

package/src/signals/browserFeatures.ts

@@ -0,0 +1,24 @@
+import { INIT } from "./utils";
+
+export function browserFeatures() {
+    const browserFeaturesData = {
+        bitmask: INIT,
+        chrome: 'chrome' in window,
+        brave: 'brave' in navigator,
+        applePaySupport: 'ApplePaySetup' in window,
+        opera: (typeof (window as any).opr !== "undefined") || 
+        (typeof (window as any).onoperadetachedviewchange === "object"),
+        serial: (window.navigator as any).serial !== undefined,
+        attachShadow: !!Element.prototype.attachShadow,
+        caches: !!window.caches,
+        webAssembly: !!window.WebAssembly && !!window.WebAssembly.instantiate,
+        buffer: 'Buffer' in window,
+        showModalDialog: 'showModalDialog' in window,
+    };
+
+    // set bitmask to 0/1 string based on browserFeaturesData, exclude bitmask property itself (you need to filter on the key)
+    // use the filter function to exclude the bitmask property itself
+    const bitmask = Object.keys(browserFeaturesData).filter((key) => key !== 'bitmask').map(key => (browserFeaturesData as any)[key] ? '1' : '0').join('');
+    browserFeaturesData.bitmask = bitmask;
+    return browserFeaturesData;
+}

package/src/signals/canvas.ts

@@ -0,0 +1,84 @@
+import { ERROR, INIT, hashCode } from './utils';
+import { SignalValue } from '../types';
+
+async function hasModifiedCanvas(): Promise<SignalValue<boolean>> {
+    return new Promise((resolve) => {
+
+        try {
+            const img = new Image();
+            const ctx = document.createElement('canvas').getContext('2d') as CanvasRenderingContext2D;
+            img.onload = () => {
+                ctx.drawImage(img, 0, 0);
+                resolve(ctx.getImageData(0, 0, 1, 1).data.filter(x => x === 0).length != 4);
+            };
+
+            img.onerror = () => {
+                resolve(ERROR);
+            };
+            img.src = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAAC0lEQVQYV2NgAAIAAAUAAarVyFEAAAAASUVORK5CYII=';
+        } catch (e) {
+            resolve(ERROR);
+        }
+    });
+}
+
+
+function getCanvasFingerprint(): SignalValue<string> {
+    var canvas = document.createElement('canvas');
+    canvas.width = 400;
+    canvas.height = 200;
+    canvas.style.display = "inline";
+    var context = canvas.getContext("2d") as CanvasRenderingContext2D;
+
+    try {
+        context.rect(0, 0, 10, 10);
+        context.rect(2, 2, 6, 6);
+        context.textBaseline = "alphabetic";
+        context.fillStyle = "#f60";
+        context.fillRect(125, 1, 62, 20);
+        context.fillStyle = "#069";
+        context.font = "11pt no-real-font-123";
+        context.fillText("Cwm fjordbank glyphs vext quiz, 😃", 2, 15);
+        context.fillStyle = "rgba(102, 204, 0, 0.2)";
+        context.font = "18pt Arial";
+        context.fillText("Cwm fjordbank glyphs vext quiz, 😃", 4, 45);
+
+        context.globalCompositeOperation = "multiply";
+        context.fillStyle = "rgb(255,0,255)";
+        context.beginPath();
+        context.arc(50, 50, 50, 0, 2 * Math.PI, !0);
+        context.closePath();
+        context.fill();
+        context.fillStyle = "rgb(0,255,255)";
+        context.beginPath();
+        context.arc(100, 50, 50, 0, 2 * Math.PI, !0);
+        context.closePath();
+        context.fill();
+        context.fillStyle = "rgb(255,255,0)";
+        context.beginPath();
+        context.arc(75, 100, 50, 0, 2 * Math.PI, !0);
+        context.closePath();
+        context.fill();
+        context.fillStyle = "rgb(255,0,255)";
+        context.arc(75, 75, 75, 0, 2 * Math.PI, !0);
+        context.arc(75, 75, 25, 0, 2 * Math.PI, !0);
+        context.fill("evenodd");
+        return hashCode(canvas.toDataURL());
+
+    } catch (e) {
+        return ERROR;
+    }
+}
+
+export async function canvas() {
+    const canvasData = {
+        hasModifiedCanvas: INIT as SignalValue<boolean>,
+        canvasFingerprint: INIT as SignalValue<string>,
+    };
+
+    canvasData.hasModifiedCanvas = await hasModifiedCanvas();
+
+    canvasData.canvasFingerprint = getCanvasFingerprint();
+
+    return canvasData;
+}

package/src/signals/cdp.ts

@@ -0,0 +1,18 @@
+import { ERROR } from './utils';
+
+export function cdp() {
+    try {
+        let wasAccessed = false;
+        const originalPrepareStackTrace = (Error as any).prepareStackTrace;
+        (Error as any).prepareStackTrace = function () {
+            wasAccessed = true;
+            return originalPrepareStackTrace;
+        };
+        const err = new Error('');
+        console.log(err);
+
+        return wasAccessed;
+    } catch (e) {
+        return ERROR;
+    }
+}

package/src/signals/cpuCount.ts

@@ -0,0 +1,5 @@
+import { NA } from './utils';
+
+export function cpuCount() {
+    return navigator.hardwareConcurrency || NA;
+}

package/src/signals/etsl.ts

@@ -0,0 +1,3 @@
+export function etsl() {
+    return eval.toString().length;
+}

package/src/signals/highEntropyValues.ts

@@ -0,0 +1,48 @@
+import { ERROR, INIT, NA, setObjectValues } from "./utils";
+
+export async function highEntropyValues() {
+    const navigator = window.navigator as any;
+    const highEntropyValues = {
+        architecture: INIT,
+        bitness: INIT,
+        brands: INIT,
+        mobile: INIT,
+        model: INIT,
+        platform: INIT,
+        platformVersion: INIT,
+        uaFullVersion: INIT,
+    };
+
+    if ('userAgentData' in navigator) {
+        try {
+            const ua = await navigator.userAgentData.getHighEntropyValues([
+                "architecture",
+                "bitness",
+                "brands",
+                "mobile",
+                "model",
+                "platform",
+                "platformVersion",
+                "uaFullVersion"
+            ]);
+
+            highEntropyValues.architecture = ua.architecture;
+            highEntropyValues.bitness = ua.bitness;
+            highEntropyValues.brands = ua.brands;
+            highEntropyValues.mobile = ua.mobile;
+            highEntropyValues.model = ua.model;
+            highEntropyValues.platform = ua.platform;
+            highEntropyValues.platformVersion = ua.platformVersion;
+            highEntropyValues.uaFullVersion = ua.uaFullVersion;
+
+
+        } catch (e) {
+            setObjectValues(highEntropyValues, ERROR);
+        }
+
+    } else {
+        setObjectValues(highEntropyValues, NA);
+    }
+
+    return highEntropyValues;
+}

package/src/signals/iframe.ts

@@ -0,0 +1,34 @@
+import { ERROR, INIT, NA, setObjectValues } from './utils';
+
+export function iframe() {
+    const iframeData = {
+        webdriver: INIT,
+        userAgent: INIT,
+        platform: INIT,
+        memory: INIT,
+        cpuCount: INIT,
+        language: INIT,
+    };
+    const iframe = document.createElement('iframe');
+
+    try {
+        iframe.style.display = 'none';
+        iframe.src = 'about:blank';
+        document.body.appendChild(iframe);
+
+        const iframeWindowNavigator = (iframe.contentWindow?.navigator as any);
+
+        iframeData.webdriver = iframeWindowNavigator.webdriver ?? false;
+        iframeData.userAgent = iframeWindowNavigator.userAgent ?? NA;
+        iframeData.platform = iframeWindowNavigator.platform ?? NA;
+        iframeData.memory = iframeWindowNavigator.deviceMemory ?? NA;
+        iframeData.cpuCount = iframeWindowNavigator.hardwareConcurrency ?? NA;
+        iframeData.language = iframeWindowNavigator.language ?? NA;
+    } catch (e) {
+        setObjectValues(iframeData, ERROR);
+    } finally {
+        document.body.removeChild(iframe);
+    }
+
+    return iframeData;
+}

package/src/signals/internationalization.ts

@@ -0,0 +1,24 @@
+import { INIT, ERROR, NA } from "./utils";
+
+export function internationalization() {
+    const internationalizationData = {
+        timezone: INIT,
+        localeLanguage: INIT,
+    };
+
+    try {
+        if (typeof Intl !== 'undefined' && typeof Intl.DateTimeFormat !== 'undefined') {
+            const dtfOptions = Intl.DateTimeFormat().resolvedOptions();
+            internationalizationData.timezone = dtfOptions.timeZone;
+            internationalizationData.localeLanguage = dtfOptions.locale;
+        } else {
+            internationalizationData.timezone = NA;
+            internationalizationData.localeLanguage = NA;
+        }
+    } catch (e) {
+        internationalizationData.timezone = ERROR;
+        internationalizationData.localeLanguage = ERROR;
+    }
+
+    return internationalizationData;
+}

package/src/signals/languages.ts

@@ -0,0 +1,6 @@
+export function languages() {
+    return {
+        languages: navigator.languages,
+        language: navigator.language,
+    }
+}

package/src/signals/maths.ts

@@ -0,0 +1,30 @@
+import { hashCode } from './utils';
+
+export function maths() {
+    const results: number[] = [];
+    const testValue = 0.123456789;
+
+    // Math constants
+    const constants = ["E", "LN10", "LN2", "LOG10E", "LOG2E", "PI", "SQRT1_2", "SQRT2"];
+    constants.forEach(function (name) {
+        try {
+            results.push((Math as any)[name]);
+        } catch (e) {
+            results.push(-1);
+        }
+    });
+
+    // Math functions (can reveal VM/browser differences)
+    const mathFunctions = ["tan", "sin", "exp", "atan", "acosh", "asinh", "atanh", "expm1", "log1p", "sinh"];
+
+
+    mathFunctions.forEach(function (name) {
+        try {
+            results.push((Math as any)[name](testValue));
+        } catch (e) {
+            results.push(-1);
+        }
+    });
+
+    return hashCode(results.map(String).join(","));
+}

package/src/signals/mediaCodecs.ts

@@ -0,0 +1,120 @@
+import { ERROR, NA, hashCode, setObjectValues } from './utils';
+
+
+const AUDIO_CODECS = [
+    'audio/mp4; codecs="mp4a.40.2"',
+    'audio/mpeg;',
+    'audio/webm; codecs="vorbis"',
+    'audio/ogg; codecs="vorbis"',
+    'audio/wav; codecs="1"',
+    'audio/ogg; codecs="speex"',
+    'audio/ogg; codecs="flac"',
+    'audio/3gpp; codecs="samr"',
+];
+
+const VIDEO_CODECS = [
+    'video/mp4; codecs="avc1.42E01E, mp4a.40.2"',
+    'video/mp4; codecs="avc1.42E01E"',
+    'video/mp4; codecs="avc1.58A01E"',
+    'video/mp4; codecs="avc1.4D401E"',
+    'video/mp4; codecs="avc1.64001E"',
+    'video/mp4; codecs="mp4v.20.8"',
+    'video/mp4; codecs="mp4v.20.240"',
+    'video/webm; codecs="vp8"',
+    'video/ogg; codecs="theora"',
+    'video/ogg; codecs="dirac"',
+    'video/3gpp; codecs="mp4v.20.8"',
+    'video/x-matroska; codecs="theora"',
+];
+
+
+function getCanPlayTypeSupport(codecs: string[], mediaType: 'audio' | 'video'): Record<string, string | null> {
+    const result: Record<string, string | null> = {};
+    try {
+        const element = document.createElement(mediaType);
+        for (const codec of codecs) {
+            try {
+                result[codec] = element.canPlayType(codec) || null;
+            } catch {
+                result[codec] = null;
+            }
+        }
+    } catch {
+        for (const codec of codecs) {
+            result[codec] = null;
+        }
+    }
+    return result;
+}
+
+function getMediaSourceSupport(codecs: string[]): Record<string, boolean | null> {
+    const result: Record<string, boolean | null> = {};
+    const MediaSource = window.MediaSource;
+    
+    if (!MediaSource || typeof MediaSource.isTypeSupported !== 'function') {
+        for (const codec of codecs) {
+            result[codec] = null;
+        }
+        return result;
+    }
+    
+    for (const codec of codecs) {
+        try {
+            result[codec] = MediaSource.isTypeSupported(codec);
+        } catch {
+            result[codec] = null;
+        }
+    }
+    return result;
+}
+
+function getRtcCapabilities(kind: 'audio' | 'video'): string | typeof NA | typeof ERROR {
+    try {
+        const RTCRtpReceiver = window.RTCRtpReceiver;
+        if (RTCRtpReceiver && typeof RTCRtpReceiver.getCapabilities === 'function') {
+            const capabilities = RTCRtpReceiver.getCapabilities(kind);
+            return hashCode(JSON.stringify(capabilities));
+        }
+        return NA;
+    } catch (e) {
+        return ERROR;
+    }
+}
+
+export function mediaCodecs() {
+    const mediaCodecsData = {
+        audioCanPlayTypeHash: NA as string | typeof NA | typeof ERROR,
+        videoCanPlayTypeHash: NA as string | typeof NA | typeof ERROR,
+        audioMediaSourceHash: NA as string | typeof NA | typeof ERROR,
+        videoMediaSourceHash: NA as string | typeof NA | typeof ERROR,
+        rtcAudioCapabilitiesHash: NA as string | typeof NA | typeof ERROR,
+        rtcVideoCapabilitiesHash: NA as string | typeof NA | typeof ERROR,
+        hasMediaSource: false,
+    };
+
+    try {
+        // Check MediaSource availability
+        mediaCodecsData.hasMediaSource = !!window.MediaSource;
+
+        // canPlayType support - hash the results
+        const audioCanPlayType = getCanPlayTypeSupport(AUDIO_CODECS, 'audio');
+        const videoCanPlayType = getCanPlayTypeSupport(VIDEO_CODECS, 'video');
+        mediaCodecsData.audioCanPlayTypeHash = hashCode(JSON.stringify(audioCanPlayType));
+        mediaCodecsData.videoCanPlayTypeHash = hashCode(JSON.stringify(videoCanPlayType));
+
+        // MediaSource.isTypeSupported - hash the results
+        const audioMediaSource = getMediaSourceSupport(AUDIO_CODECS);
+        const videoMediaSource = getMediaSourceSupport(VIDEO_CODECS);
+        mediaCodecsData.audioMediaSourceHash = hashCode(JSON.stringify(audioMediaSource));
+        mediaCodecsData.videoMediaSourceHash = hashCode(JSON.stringify(videoMediaSource));
+
+        // RTCRtpReceiver.getCapabilities - already returns hash
+        mediaCodecsData.rtcAudioCapabilitiesHash = getRtcCapabilities('audio');
+        mediaCodecsData.rtcVideoCapabilitiesHash = getRtcCapabilities('video');
+
+    } catch (e) {
+        setObjectValues(mediaCodecsData, ERROR);
+    }
+
+    return mediaCodecsData;
+}

package/src/signals/mediaQueries.ts

@@ -0,0 +1,85 @@
+import { ERROR, INIT, setObjectValues } from './utils';
+
+export function mediaQueries() {
+    const mediaQueriesData = {
+        prefersColorScheme: INIT as string | null | typeof INIT | typeof ERROR,
+        prefersReducedMotion: INIT as boolean | typeof INIT | typeof ERROR,
+        prefersReducedTransparency: INIT as boolean | typeof INIT | typeof ERROR,
+        colorGamut: INIT as string | null | typeof INIT | typeof ERROR,
+        pointer: INIT as string | null | typeof INIT | typeof ERROR,
+        anyPointer: INIT as string | null | typeof INIT | typeof ERROR,
+        hover: INIT as boolean | typeof INIT | typeof ERROR,
+        anyHover: INIT as boolean | typeof INIT | typeof ERROR,
+        colorDepth: INIT as number | typeof INIT | typeof ERROR,
+    };
+
+    try {
+        // Prefers color scheme
+        if (window.matchMedia('(prefers-color-scheme: dark)').matches) {
+            mediaQueriesData.prefersColorScheme = 'dark';
+        } else if (window.matchMedia('(prefers-color-scheme: light)').matches) {
+            mediaQueriesData.prefersColorScheme = 'light';
+        } else {
+            mediaQueriesData.prefersColorScheme = null;
+        }
+
+        // Prefers reduced motion
+        mediaQueriesData.prefersReducedMotion = window.matchMedia('(prefers-reduced-motion: reduce)').matches;
+
+        // Prefers reduced transparency
+        mediaQueriesData.prefersReducedTransparency = window.matchMedia('(prefers-reduced-transparency: reduce)').matches;
+
+        // Color gamut
+        if (window.matchMedia('(color-gamut: rec2020)').matches) {
+            mediaQueriesData.colorGamut = 'rec2020';
+        } else if (window.matchMedia('(color-gamut: p3)').matches) {
+            mediaQueriesData.colorGamut = 'p3';
+        } else if (window.matchMedia('(color-gamut: srgb)').matches) {
+            mediaQueriesData.colorGamut = 'srgb';
+        } else {
+            mediaQueriesData.colorGamut = null;
+        }
+
+        // Pointer
+        if (window.matchMedia('(pointer: fine)').matches) {
+            mediaQueriesData.pointer = 'fine';
+        } else if (window.matchMedia('(pointer: coarse)').matches) {
+            mediaQueriesData.pointer = 'coarse';
+        } else if (window.matchMedia('(pointer: none)').matches) {
+            mediaQueriesData.pointer = 'none';
+        } else {
+            mediaQueriesData.pointer = null;
+        }
+
+        // Any pointer
+        if (window.matchMedia('(any-pointer: fine)').matches) {
+            mediaQueriesData.anyPointer = 'fine';
+        } else if (window.matchMedia('(any-pointer: coarse)').matches) {
+            mediaQueriesData.anyPointer = 'coarse';
+        } else if (window.matchMedia('(any-pointer: none)').matches) {
+            mediaQueriesData.anyPointer = 'none';
+        } else {
+            mediaQueriesData.anyPointer = null;
+        }
+
+        // Hover
+        mediaQueriesData.hover = window.matchMedia('(hover: hover)').matches;
+
+        // Any hover
+        mediaQueriesData.anyHover = window.matchMedia('(any-hover: hover)').matches;
+
+        // Color depth - find the maximum supported color depth
+        let maxColorDepth = 0;
+        for (let c = 0; c <= 16; c++) {
+            if (window.matchMedia(`(color: ${c})`).matches) {
+                maxColorDepth = c;
+            }
+        }
+        mediaQueriesData.colorDepth = maxColorDepth;
+
+    } catch (e) {
+        setObjectValues(mediaQueriesData, ERROR);
+    }
+
+    return mediaQueriesData;
+}

package/src/signals/memory.ts

@@ -0,0 +1,5 @@
+import { NA } from "./utils";
+
+export function memory() {
+    return (navigator as any).deviceMemory || NA;
+}

package/src/signals/multimediaDevices.ts

@@ -0,0 +1,34 @@
+import { NA, setObjectValues } from "./utils";
+
+export async function multimediaDevices() {
+    return new Promise(async function (resolve) {
+        var deviceToCount = {
+            "audiooutput": 0,
+            "audioinput": 0,
+            "videoinput": 0
+        };
+
+        if (navigator.mediaDevices && navigator.mediaDevices.enumerateDevices) {
+            const devices = await navigator.mediaDevices.enumerateDevices();
+            if (typeof devices !== "undefined") {
+                for (var i = 0; i < devices.length; i++) {
+                    var name = devices[i].kind as keyof typeof deviceToCount;
+                    deviceToCount[name] = deviceToCount[name] + 1;
+                }
+
+                return resolve({
+                    speakers: deviceToCount.audiooutput,
+                    microphones: deviceToCount.audioinput,
+                    webcams: deviceToCount.videoinput
+                });
+            } else {
+                setObjectValues(deviceToCount, NA);
+                return resolve(deviceToCount);
+            }
+
+        } else {
+            setObjectValues(deviceToCount, NA);
+            return resolve(deviceToCount);
+        }
+    });
+}

package/src/signals/navigatorPropertyDescriptors.ts

@@ -0,0 +1,17 @@
+export function navigatorPropertyDescriptors() {
+    const properties = ['deviceMemory', 'hardwareConcurrency', 'language', 'languages', 'platform'];
+
+    const results = [];
+
+    for (const property of properties) {
+        const res = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(navigator), property);
+
+        if (res && res.value) {
+            results.push('1');
+        } else {
+            results.push('0');
+        }
+    }
+
+    return results.join('');
+}

package/src/signals/nonce.ts

@@ -0,0 +1,3 @@
+export function nonce() {
+    return Math.random().toString(36).substring(2, 15);
+}

package/src/signals/platform.ts

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

package/src/signals/playwright.ts

@@ -0,0 +1,3 @@
+export function playwright() {
+    return '__pwInitScripts' in window || '__playwright__binding__' in window;
+}