jumpy-lion 0.0.41 → 0.0.42

package/dist/fingerprinting/fingerprint-overrides/platform-consistency.js

@@ -1,6 +1,14 @@
 /**
  * Platform Consistency Script
  * Ensures all browser properties match the specified platform (1:1 fingerprinting)
+ *
+ * 2024-2025 Enhancements:
+ * - Screen orientation API consistency
+ * - screen.availLeft/availTop for Windows
+ * - visualViewport properties consistency
+ * - window.outerWidth/outerHeight ratios
+ * - window.screenX/screenY typical values
+ * - matchMedia() platform-appropriate results
  */
 export const createPlatformConsistencyScript = (platform, fingerprintData) => {
     // Platform-specific configurations for 1:1 consistency
@@ -103,103 +111,129 @@ export const createPlatformConsistencyScript = (platform, fingerprintData) => {
     // Platform Consistency for ${platform}
     const config = ${JSON.stringify(config)};
     
-    // Override navigator properties for platform consistency
-    Object.defineProperty(navigator, 'platform', { get: () => config.platform, configurable: false });
-    Object.defineProperty(navigator, 'vendor', { get: () => config.vendor, configurable: false });
-    Object.defineProperty(navigator, 'vendorSub', { get: () => config.vendorSub, configurable: false });
-    Object.defineProperty(navigator, 'productSub', { get: () => config.productSub, configurable: false });
-    Object.defineProperty(navigator, 'hardwareConcurrency', { get: () => config.hardwareConcurrency, configurable: false });
-    Object.defineProperty(navigator, 'maxTouchPoints', { get: () => config.maxTouchPoints, configurable: false });
-    Object.defineProperty(navigator, 'cookieEnabled', { get: () => config.cookieEnabled, configurable: false });
-    Object.defineProperty(navigator, 'onLine', { get: () => config.onLine, configurable: false });
-    Object.defineProperty(navigator, 'language', { get: () => config.language, configurable: false });
-    Object.defineProperty(navigator, 'languages', { get: () => config.languages, configurable: false });
+    // Helper to safely define property with guards
+    const safeDefineProperty = (obj, prop, getter) => {
+        try {
+            const descriptor = Object.getOwnPropertyDescriptor(obj, prop);
+            if (descriptor && descriptor.configurable === false) {
+                return false; // Property already defined as non-configurable
+            }
+            Object.defineProperty(obj, prop, { 
+                get: getter, 
+                configurable: true,  // Allow other scripts to modify if needed
+                enumerable: true 
+            });
+            return true;
+        } catch (e) {
+            return false;
+        }
+    };
+    
+    // Override navigator properties for platform consistency (with guards)
+    safeDefineProperty(navigator, 'platform', () => config.platform);
+    safeDefineProperty(navigator, 'vendor', () => config.vendor);
+    safeDefineProperty(navigator, 'vendorSub', () => config.vendorSub);
+    safeDefineProperty(navigator, 'productSub', () => config.productSub);
+    safeDefineProperty(navigator, 'hardwareConcurrency', () => config.hardwareConcurrency);
+    safeDefineProperty(navigator, 'maxTouchPoints', () => config.maxTouchPoints);
+    safeDefineProperty(navigator, 'cookieEnabled', () => config.cookieEnabled);
+    safeDefineProperty(navigator, 'onLine', () => config.onLine);
+    safeDefineProperty(navigator, 'language', () => config.language);
+    safeDefineProperty(navigator, 'languages', () => config.languages);
     
     // Additional navigator properties for Windows consistency
     if (config.userAgent) {
-        Object.defineProperty(navigator, 'userAgent', { get: () => config.userAgent, configurable: false });
+        safeDefineProperty(navigator, 'userAgent', () => config.userAgent);
     }
     if (config.appVersion) {
-        Object.defineProperty(navigator, 'appVersion', { get: () => config.appVersion, configurable: false });
+        safeDefineProperty(navigator, 'appVersion', () => config.appVersion);
     }
     if (config.appName) {
-        Object.defineProperty(navigator, 'appName', { get: () => config.appName, configurable: false });
+        safeDefineProperty(navigator, 'appName', () => config.appName);
     }
     if (config.appCodeName) {
-        Object.defineProperty(navigator, 'appCodeName', { get: () => config.appCodeName, configurable: false });
+        safeDefineProperty(navigator, 'appCodeName', () => config.appCodeName);
     }
     if (config.product) {
-        Object.defineProperty(navigator, 'product', { get: () => config.product, configurable: false });
+        safeDefineProperty(navigator, 'product', () => config.product);
     }
     if (config.oscpu !== undefined) {
-        Object.defineProperty(navigator, 'oscpu', { get: () => config.oscpu, configurable: false });
+        safeDefineProperty(navigator, 'oscpu', () => config.oscpu);
     }
     
-    // Override navigator.plugins for Windows consistency
+    // Override navigator.plugins for Windows consistency (with guards)
     if (config.plugins) {
-        Object.defineProperty(navigator, 'plugins', {
-            get: () => {
-                const arr = Object.create(PluginArray.prototype);
-                config.plugins.forEach((p, i) => {
-                    const plugin = Object.create(Plugin.prototype);
-                    plugin.name = p.name;
-                    plugin.filename = p.filename;
-                    plugin.description = p.description;
-                    plugin.length = 1;
-                    plugin[0] = config.mimeTypes?.[i] || { type: 'application/pdf', suffixes: 'pdf', description: 'Portable Document Format' };
-                    arr[i] = plugin;
-                    arr[p.name] = plugin;
-                });
-                arr.length = config.plugins.length;
-                arr.item = (index) => arr[index] || null;
-                arr.namedItem = (name) => arr[name] || null;
-                arr.refresh = () => {};
-                return arr;
-            },
-            configurable: false,
-            enumerable: true
-        });
+        const pluginsGetter = () => {
+            const arr = Object.create(PluginArray.prototype);
+            config.plugins.forEach((p, i) => {
+                const plugin = Object.create(Plugin.prototype);
+                // Use Object.defineProperty for read-only properties
+                Object.defineProperty(plugin, 'name', { value: p.name, writable: false, enumerable: true });
+                Object.defineProperty(plugin, 'filename', { value: p.filename, writable: false, enumerable: true });
+                Object.defineProperty(plugin, 'description', { value: p.description, writable: false, enumerable: true });
+                Object.defineProperty(plugin, 'length', { value: 1, writable: false, enumerable: true });
+                plugin[0] = config.mimeTypes?.[i] || { type: 'application/pdf', suffixes: 'pdf', description: 'Portable Document Format' };
+                arr[i] = plugin;
+                arr[p.name] = plugin;
+            });
+            // Use Object.defineProperty for length (PluginArray.prototype.length is read-only)
+            Object.defineProperty(arr, 'length', { value: config.plugins.length, writable: false, enumerable: true });
+            Object.defineProperty(arr, 'item', { value: (index) => arr[index] || null, writable: false, enumerable: false });
+            Object.defineProperty(arr, 'namedItem', { value: (name) => arr[name] || null, writable: false, enumerable: false });
+            Object.defineProperty(arr, 'refresh', { value: () => {}, writable: false, enumerable: false });
+            return arr;
+        };
+        safeDefineProperty(navigator, 'plugins', pluginsGetter);
     }
     
-    // Override navigator.mimeTypes for Windows consistency
+    // Override navigator.mimeTypes for Windows consistency (with guards)
     if (config.mimeTypes) {
-        Object.defineProperty(navigator, 'mimeTypes', {
-            get: () => {
-                const arr = Object.create(MimeTypeArray.prototype);
-                config.mimeTypes.forEach((m, i) => {
-                    const mimeType = Object.create(MimeType.prototype);
-                    mimeType.type = m.type;
-                    mimeType.suffixes = m.suffixes;
-                    mimeType.description = m.description;
-                    mimeType.enabledPlugin = config.plugins?.[0] || null;
-                    arr[i] = mimeType;
-                    arr[m.type] = mimeType;
-                });
-                arr.length = config.mimeTypes.length;
-                arr.item = (index) => arr[index] || null;
-                arr.namedItem = (name) => arr[name] || null;
-                return arr;
-            },
-            configurable: false,
-            enumerable: true
-        });
+        const mimeTypesGetter = () => {
+            const arr = Object.create(MimeTypeArray.prototype);
+            config.mimeTypes.forEach((m, i) => {
+                const mimeType = Object.create(MimeType.prototype);
+                // Use Object.defineProperty for read-only properties
+                Object.defineProperty(mimeType, 'type', { value: m.type, writable: false, enumerable: true });
+                Object.defineProperty(mimeType, 'suffixes', { value: m.suffixes, writable: false, enumerable: true });
+                Object.defineProperty(mimeType, 'description', { value: m.description, writable: false, enumerable: true });
+                Object.defineProperty(mimeType, 'enabledPlugin', { value: config.plugins?.[0] || null, writable: false, enumerable: true });
+                arr[i] = mimeType;
+                arr[m.type] = mimeType;
+            });
+            // Use Object.defineProperty for length (MimeTypeArray.prototype.length is read-only)
+            Object.defineProperty(arr, 'length', { value: config.mimeTypes.length, writable: false, enumerable: true });
+            Object.defineProperty(arr, 'item', { value: (index) => arr[index] || null, writable: false, enumerable: false });
+            Object.defineProperty(arr, 'namedItem', { value: (name) => arr[name] || null, writable: false, enumerable: false });
+            return arr;
+        };
+        safeDefineProperty(navigator, 'mimeTypes', mimeTypesGetter);
     }
     
     // Override navigator.connection for Windows consistency
+    // Note: Some connection properties (like downlink, rtt) are non-configurable in Chrome
     if (config.connection && navigator.connection) {
         Object.keys(config.connection).forEach(key => {
-            Object.defineProperty(navigator.connection, key, {
-                value: config.connection[key],
-                writable: false,
-                configurable: true
-            });
+            try {
+                const descriptor = Object.getOwnPropertyDescriptor(navigator.connection, key);
+                if (descriptor && descriptor.configurable === false) {
+                    // Property is non-configurable, skip it
+                    return;
+                }
+                Object.defineProperty(navigator.connection, key, {
+                    value: config.connection[key],
+                    writable: false,
+                    configurable: true
+                });
+            } catch (e) {
+                // Silently ignore non-configurable properties
+            }
         });
     }
     
-    // Override screen properties
-    Object.defineProperty(window, 'devicePixelRatio', { get: () => config.devicePixelRatio, configurable: false });
-    Object.defineProperty(screen, 'colorDepth', { get: () => config.colorDepth, configurable: false });
-    Object.defineProperty(screen, 'pixelDepth', { get: () => config.screenDepth || config.colorDepth, configurable: false });
+    // Override screen properties (with guards)
+    safeDefineProperty(window, 'devicePixelRatio', () => config.devicePixelRatio);
+    safeDefineProperty(screen, 'colorDepth', () => config.colorDepth);
+    safeDefineProperty(screen, 'pixelDepth', () => config.screenDepth || config.colorDepth);
     
     // Ensure WebGL returns platform-appropriate values
     const getParameterProto = WebGLRenderingContext.prototype.getParameter;
@@ -222,6 +256,315 @@ export const createPlatformConsistencyScript = (platform, fingerprintData) => {
     if (typeof WebGL2RenderingContext !== 'undefined') {
         WebGL2RenderingContext.prototype.getParameter = WebGLRenderingContext.prototype.getParameter;
     }
+    
+    // ========== 2024-2025 Enhanced Platform Consistency ==========
+    
+    // Screen Orientation API Consistency
+    const spoofScreenOrientation = () => {
+        if (screen.orientation) {
+            Object.defineProperty(screen.orientation, 'type', {
+                get: () => 'landscape-primary',
+                configurable: true,
+                enumerable: true
+            });
+            
+            Object.defineProperty(screen.orientation, 'angle', {
+                get: () => 0,
+                configurable: true,
+                enumerable: true
+            });
+        }
+    };
+    
+    // Screen availLeft/availTop for Windows (taskbar consideration)
+    const spoofScreenAvailability = () => {
+        const screenConfig = {
+            'Win32': {
+                availLeft: 0,
+                availTop: 0,
+                availWidth: screen.width || 1920,
+                availHeight: (screen.height || 1080) - 40 // Windows taskbar ~40px
+            },
+            'MacIntel': {
+                availLeft: 0,
+                availTop: 25, // macOS menu bar
+                availWidth: screen.width || 1920,
+                availHeight: (screen.height || 1080) - 25
+            },
+            'Linux x86_64': {
+                availLeft: 0,
+                availTop: 0,
+                availWidth: screen.width || 1920,
+                availHeight: (screen.height || 1080) - 30 // GNOME panel
+            }
+        };
+        
+        const screenVals = screenConfig[config.platform] || screenConfig['Win32'];
+        
+        Object.defineProperty(screen, 'availLeft', {
+            get: () => screenVals.availLeft,
+            configurable: true,
+            enumerable: true
+        });
+        
+        Object.defineProperty(screen, 'availTop', {
+            get: () => screenVals.availTop,
+            configurable: true,
+            enumerable: true
+        });
+        
+        Object.defineProperty(screen, 'availWidth', {
+            get: () => screenVals.availWidth,
+            configurable: true,
+            enumerable: true
+        });
+        
+        Object.defineProperty(screen, 'availHeight', {
+            get: () => screenVals.availHeight,
+            configurable: true,
+            enumerable: true
+        });
+    };
+    
+    // Visual Viewport consistency
+    const spoofVisualViewport = () => {
+        if (window.visualViewport) {
+            const originalViewport = window.visualViewport;
+            
+            // Ensure consistent values
+            Object.defineProperty(originalViewport, 'scale', {
+                get: () => 1,
+                configurable: true
+            });
+            
+            Object.defineProperty(originalViewport, 'offsetLeft', {
+                get: () => 0,
+                configurable: true
+            });
+            
+            Object.defineProperty(originalViewport, 'offsetTop', {
+                get: () => 0,
+                configurable: true
+            });
+            
+            Object.defineProperty(originalViewport, 'pageLeft', {
+                get: () => window.scrollX || 0,
+                configurable: true
+            });
+            
+            Object.defineProperty(originalViewport, 'pageTop', {
+                get: () => window.scrollY || 0,
+                configurable: true
+            });
+        }
+    };
+    
+    // Window outer dimensions (browser chrome size)
+    const spoofWindowDimensions = () => {
+        const outerConfig = {
+            'Win32': {
+                outerWidthOffset: 16, // Windows chrome borders
+                outerHeightOffset: 92 // Title bar + tabs + bookmarks
+            },
+            'MacIntel': {
+                outerWidthOffset: 0, // macOS has no side borders
+                outerHeightOffset: 87 // Title bar + tabs
+            },
+            'Linux x86_64': {
+                outerWidthOffset: 2, // Minimal borders
+                outerHeightOffset: 85 // GNOME decorations
+            }
+        };
+        
+        const dimConfig = outerConfig[config.platform] || outerConfig['Win32'];
+        
+        Object.defineProperty(window, 'outerWidth', {
+            get: () => window.innerWidth + dimConfig.outerWidthOffset,
+            configurable: true,
+            enumerable: true
+        });
+        
+        Object.defineProperty(window, 'outerHeight', {
+            get: () => window.innerHeight + dimConfig.outerHeightOffset,
+            configurable: true,
+            enumerable: true
+        });
+    };
+    
+    // Window screen position
+    const spoofWindowPosition = () => {
+        const posConfig = {
+            'Win32': { screenX: 0, screenY: 0 },
+            'MacIntel': { screenX: 0, screenY: 25 }, // Below menu bar
+            'Linux x86_64': { screenX: 0, screenY: 0 }
+        };
+        
+        const pos = posConfig[config.platform] || posConfig['Win32'];
+        
+        Object.defineProperty(window, 'screenX', {
+            get: () => pos.screenX,
+            configurable: true,
+            enumerable: true
+        });
+        
+        Object.defineProperty(window, 'screenY', {
+            get: () => pos.screenY,
+            configurable: true,
+            enumerable: true
+        });
+        
+        Object.defineProperty(window, 'screenLeft', {
+            get: () => pos.screenX,
+            configurable: true,
+            enumerable: true
+        });
+        
+        Object.defineProperty(window, 'screenTop', {
+            get: () => pos.screenY,
+            configurable: true,
+            enumerable: true
+        });
+    };
+    
+    // matchMedia platform-specific behavior
+    const spoofMatchMedia = () => {
+        const originalMatchMedia = window.matchMedia;
+        
+        window.matchMedia = function(query) {
+            const result = originalMatchMedia.call(this, query);
+            
+            // Platform-specific media query handling
+            if (query.includes('prefers-color-scheme')) {
+                // Default to light mode (most common)
+                const isDark = query.includes('dark');
+                return new Proxy(result, {
+                    get(target, prop) {
+                        if (prop === 'matches') {
+                            return !isDark; // Most users use light mode
+                        }
+                        return target[prop];
+                    }
+                });
+            }
+            
+            if (query.includes('prefers-reduced-motion')) {
+                // Most users don't have reduced motion
+                return new Proxy(result, {
+                    get(target, prop) {
+                        if (prop === 'matches') {
+                            return false;
+                        }
+                        return target[prop];
+                    }
+                });
+            }
+            
+            if (query.includes('prefers-contrast')) {
+                // Most users use default contrast
+                return new Proxy(result, {
+                    get(target, prop) {
+                        if (prop === 'matches') {
+                            return query.includes('no-preference');
+                        }
+                        return target[prop];
+                    }
+                });
+            }
+            
+            if (query.includes('pointer')) {
+                // Desktop platforms have fine pointer (mouse)
+                const hasFinePointer = config.platform !== 'Android' && config.maxTouchPoints === 0;
+                return new Proxy(result, {
+                    get(target, prop) {
+                        if (prop === 'matches') {
+                            if (query.includes('fine')) return hasFinePointer;
+                            if (query.includes('coarse')) return !hasFinePointer;
+                            if (query.includes('none')) return false;
+                        }
+                        return target[prop];
+                    }
+                });
+            }
+            
+            if (query.includes('hover')) {
+                // Desktop platforms support hover
+                return new Proxy(result, {
+                    get(target, prop) {
+                        if (prop === 'matches') {
+                            return query.includes('hover') && !query.includes('none');
+                        }
+                        return target[prop];
+                    }
+                });
+            }
+            
+            return result;
+        };
+    };
+    
+    // ScreenDetails API (multi-monitor detection)
+    const spoofScreenDetails = () => {
+        if ('getScreenDetails' in window) {
+            window.getScreenDetails = function() {
+                return Promise.resolve({
+                    screens: [{
+                        availHeight: screen.availHeight,
+                        availWidth: screen.availWidth,
+                        availLeft: 0,
+                        availTop: 0,
+                        colorDepth: config.colorDepth || 24,
+                        devicePixelRatio: config.devicePixelRatio || 1,
+                        height: screen.height,
+                        width: screen.width,
+                        isExtended: false,
+                        isPrimary: true,
+                        label: 'Primary Display',
+                        left: 0,
+                        orientation: screen.orientation || { angle: 0, type: 'landscape-primary' },
+                        pixelDepth: config.screenDepth || 24,
+                        top: 0
+                    }],
+                    currentScreen: null,
+                    onscreenschange: null,
+                    oncurrentscreenchange: null,
+                    addEventListener: () => {},
+                    removeEventListener: () => {}
+                });
+            };
+        }
+    };
+    
+    // Initialize all enhanced spoofing
+    const DEBUG_PREFIX = '[CDP-FP-DEBUG]';
+    const ERROR_PREFIX = '[CDP-FP-ERROR]';
+    
+    console.log(DEBUG_PREFIX, 'Starting platform consistency overrides for:', config.platform);
+    
+    const applyConsistency = (name, fn) => {
+        try {
+            fn();
+            console.log(DEBUG_PREFIX, \`✓ Applied \${name}\`);
+            return true;
+        } catch (e) {
+            console.error(ERROR_PREFIX, \`✗ Failed to apply \${name}:\`, e);
+            throw e; // Rethrow to make errors visible
+        }
+    };
+    
+    try {
+        applyConsistency('Screen Orientation', spoofScreenOrientation);
+        applyConsistency('Screen Availability', spoofScreenAvailability);
+        applyConsistency('Visual Viewport', spoofVisualViewport);
+        applyConsistency('Window Dimensions', spoofWindowDimensions);
+        applyConsistency('Window Position', spoofWindowPosition);
+        applyConsistency('Match Media', spoofMatchMedia);
+        applyConsistency('Screen Details API', spoofScreenDetails);
+        
+        console.log(DEBUG_PREFIX, \`✓ Platform consistency complete for \${config.platform}\`);
+    } catch (e) {
+        console.error(ERROR_PREFIX, '✗ Failed to apply platform consistency:', e);
+        throw e; // Rethrow to make errors visible
+    }
 })();`;
 };
 //# sourceMappingURL=platform-consistency.js.map

package/dist/fingerprinting/fingerprint-overrides/platform-consistency.js.map

@@ -1 +1 @@
-{"version":3,"file":"platform-consistency.js","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/platform-consistency.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"platform-consistency.js","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/platform-consistency.ts"],"names":[],"mappings":"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"}

package/dist/fingerprinting/fingerprint-overrides/runtime-enable-bypass.d.ts

@@ -1,6 +1,13 @@
 /**
- * Runtime.enable Bypass
- * Prevents CDP detection through console.log(Error) technique
+ * Runtime.enable Bypass Script
+ * Prevents CDP detection through console.log(Error) technique and stack trace analysis.
+ *
+ * IMPORTANT: This is now a SCRIPT to be injected via addScriptToEvaluateOnNewDocument,
+ * NOT via Runtime.evaluate (which would defeat the purpose since Runtime.evaluate IS detectable!)
  */
-export declare const setupRuntimeEnableBypass: (client: any) => Promise<void>;
+/**
+ * Creates the runtime enable bypass script that should be bundled with other stealth scripts.
+ * This script runs BEFORE page JavaScript and patches Error/console to hide CDP markers.
+ */
+export declare const createRuntimeEnableBypassScript: () => string;
 //# sourceMappingURL=runtime-enable-bypass.d.ts.map

package/dist/fingerprinting/fingerprint-overrides/runtime-enable-bypass.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime-enable-bypass.d.ts","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/runtime-enable-bypass.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,eAAO,MAAM,wBAAwB,WAAkB,GAAG,KAAG,OAAO,CAAC,IAAI,CA8ExE,CAAC"}
+{"version":3,"file":"runtime-enable-bypass.d.ts","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/runtime-enable-bypass.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;GAGG;AACH,eAAO,MAAM,+BAA+B,QAAO,MAkIlD,CAAC"}