fpscanner 1.0.2 → 1.0.4-beta.0

package/dist/signals/worker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"worker.d.ts","sourceRoot":"","sources":["../../src/signals/worker.ts"],"names":[],"mappings":"AAEA,wBAAsB,MAAM,qBAkG3B"}
+{"version":3,"file":"worker.d.ts","sourceRoot":"","sources":["../../src/signals/worker.ts"],"names":[],"mappings":"AAEA,wBAAsB,MAAM,qBAmH3B"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fpscanner",
-  "version": "1.0.2",
+  "version": "1.0.4-beta.0",
   "description": "A lightweight browser fingerprinting and bot detection library with encryption, obfuscation, and cross-context validation",
   "main": "dist/fpScanner.cjs.js",
   "module": "dist/fpScanner.es.js",

package/src/detections/hasMismatchPlatformWorker.ts

@@ -1,10 +1,36 @@
 import { Fingerprint } from "../types";
 import { ERROR, NA, SKIPPED } from "../signals/utils";
 
+/**
+ * iPad Safari in desktop-style mode often reports navigator.platform as "MacIntel"
+ * in the top-level window (and same-origin iframe) while dedicated workers can still
+ * report "iPad". That split is expected on real hardware, not a worker spoof signal.
+ */
+function isBenignIPadMacPlatformSplit(a: string, b: string): boolean {
+    const aIsIPad = a.includes("iPad");
+    const bIsIPad = b.includes("iPad");
+    if (aIsIPad === bIsIPad) {
+        return false;
+    }
+    const macDesktopCompat = (p: string) => p === "MacIntel" || p === "MacPPC";
+    return macDesktopCompat(a) || macDesktopCompat(b);
+}
+
 export function hasMismatchPlatformWorker(fingerprint: Fingerprint) {
     if (fingerprint.signals.contexts.webWorker.platform === NA || fingerprint.signals.contexts.webWorker.platform === ERROR || fingerprint.signals.contexts.webWorker.platform === SKIPPED) {
         return false;
     }
 
-    return fingerprint.signals.device.platform !== fingerprint.signals.contexts.webWorker.platform;
+    const devicePlatform = fingerprint.signals.device.platform;
+    const workerPlatform = fingerprint.signals.contexts.webWorker.platform;
+
+    if (devicePlatform === workerPlatform) {
+        return false;
+    }
+
+    if (isBenignIPadMacPlatformSplit(devicePlatform, workerPlatform)) {
+        return false;
+    }
+
+    return true;
 }

package/src/detections/hasMismatchWebGLInWorker.ts

@@ -1,11 +1,23 @@
 import { Fingerprint } from "../types";
-import { ERROR, NA, SKIPPED } from "../signals/utils";
+import { ERROR, INIT, NA, SKIPPED } from "../signals/utils";
+
+function webGLStringUnavailable(value: unknown): boolean {
+    if (typeof value !== "string" || value.length === 0) {
+        return true;
+    }
+    return value === NA || value === ERROR || value === SKIPPED || value === INIT;
+}
 
 export function hasMismatchWebGLInWorker(fingerprint: Fingerprint) {
     const worker = fingerprint.signals.contexts.webWorker;
     const webGL = fingerprint.signals.graphics.webGL;
-    
-    if (worker.vendor === ERROR || worker.renderer === ERROR || webGL.vendor === NA || webGL.renderer === NA || worker.vendor === SKIPPED) {
+
+    if (
+        webGLStringUnavailable(webGL.vendor) ||
+        webGLStringUnavailable(webGL.renderer) ||
+        webGLStringUnavailable(worker.vendor) ||
+        webGLStringUnavailable(worker.renderer)
+    ) {
         return false;
     }
 

package/src/detections/hasMissingChromeObject.ts

@@ -1,6 +1,26 @@
 import { Fingerprint } from "../types";
 
+/**
+ * In-app browsers and system WebViews on Android/iOS often ship a Chrome-like UA but
+ * do not expose window.chrome. That is common on real devices, so this rule is only
+ * meant for desktop-style environments where missing chrome is suspicious.
+ */
+function isClaimedMobileUserAgent(ua: string): boolean {
+    return (
+        ua.includes("Android") ||
+        ua.includes("iPhone") ||
+        ua.includes("iPod") ||
+        ua.includes("iPad")
+    );
+}
+
 export function hasMissingChromeObject(fingerprint: Fingerprint) {
     const userAgent = fingerprint.signals.browser.userAgent;
-    return fingerprint.signals.browser.features.chrome === false && typeof userAgent === 'string' && userAgent.includes('Chrome');
+    if (typeof userAgent !== "string" || !userAgent.includes("Chrome")) {
+        return false;
+    }
+    if (isClaimedMobileUserAgent(userAgent)) {
+        return false;
+    }
+    return fingerprint.signals.browser.features.chrome === false;
 }

package/src/signals/worker.ts

@@ -1,4 +1,4 @@
-import { ERROR, INIT, setObjectValues } from './utils';
+import { ERROR, INIT, NA, setObjectValues } from './utils';
 
 export async function worker() {
     return new Promise((resolve) => {
@@ -23,29 +23,45 @@ export async function worker() {
         };
 
         try {
-            const workerCode = `try {
-                var fingerprintWorker = {};
-
+            const workerCode = `var fingerprintWorker = {
+                userAgent: 'NA',
+                language: 'NA',
+                cpuCount: 'NA',
+                platform: 'NA',
+                memory: 'NA',
+                vendor: 'NA',
+                renderer: 'NA'
+            };
+            try {
                 fingerprintWorker.userAgent = navigator.userAgent;
                 fingerprintWorker.language = navigator.language;
                 fingerprintWorker.cpuCount = navigator.hardwareConcurrency;
                 fingerprintWorker.platform = navigator.platform;
-                fingerprintWorker.memory = navigator.deviceMemory;
-                
+                if (typeof navigator.deviceMemory !== 'undefined') {
+                    fingerprintWorker.memory = navigator.deviceMemory;
+                }
 
-                var canvas = new OffscreenCanvas(1, 1);
-                fingerprintWorker.vendor = 'INIT';
-                fingerprintWorker.renderer = 'INIT';
-                var gl = canvas.getContext('webgl');
-                const isFirefox = navigator.userAgent.includes('Firefox');
                 try {
-                    if (gl && !isFirefox) {
-                        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 {
+                    if (typeof OffscreenCanvas === 'undefined') {
                         fingerprintWorker.vendor = 'NA';
                         fingerprintWorker.renderer = 'NA';
+                    } else {
+                        var canvas = new OffscreenCanvas(1, 1);
+                        var gl = canvas.getContext('webgl');
+                        var isFirefox = navigator.userAgent.indexOf('Firefox') !== -1;
+                        if (gl && !isFirefox) {
+                            var glExt = gl.getExtension('WEBGL_debug_renderer_info');
+                            if (glExt) {
+                                fingerprintWorker.vendor = gl.getParameter(glExt.UNMASKED_VENDOR_WEBGL);
+                                fingerprintWorker.renderer = gl.getParameter(glExt.UNMASKED_RENDERER_WEBGL);
+                            } else {
+                                fingerprintWorker.vendor = 'NA';
+                                fingerprintWorker.renderer = 'NA';
+                            }
+                        } else {
+                            fingerprintWorker.vendor = 'NA';
+                            fingerprintWorker.renderer = 'NA';
+                        }
                     }
                 } catch (_) {
                     fingerprintWorker.vendor = 'ERROR';
@@ -70,13 +86,14 @@ export async function worker() {
 
             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;
+                    const pick = (v: any) => (typeof v === 'undefined' ? NA : v);
+                    workerData.vendor = pick(e.data.vendor);
+                    workerData.renderer = pick(e.data.renderer);
+                    workerData.userAgent = pick(e.data.userAgent);
+                    workerData.language = pick(e.data.language);
+                    workerData.platform = pick(e.data.platform);
+                    workerData.memory = pick(e.data.memory);
+                    workerData.cpuCount = pick(e.data.cpuCount);
                 } catch (_) {
                     setObjectValues(workerData, ERROR);
                 } finally {