jumpy-lion 0.1.1 → 0.1.2

package/dist/fingerprinting/fingerprint-overrides/webgl-spoofing.js

@@ -0,0 +1,215 @@
+/**
+ * WebGL Fingerprinting Protection
+ * Platform-aware GPU spoofing for WebGL contexts
+ */
+export const createWebGLSpoofingScript = (fingerprintWebGL) => {
+    // If fingerprint data is provided, use it; otherwise use platform-based defaults
+    const useFingerprint = fingerprintWebGL && (fingerprintWebGL.vendorUnmasked || fingerprintWebGL.rendererUnmasked);
+    return `
+(() => {
+    'use strict';
+    
+    // WebGL Spoofing for 2025 - Platform-aware
+    const spoofWebGL = () => {
+        const getParameterProto = WebGLRenderingContext.prototype.getParameter;
+        const getExtensionProto = WebGLRenderingContext.prototype.getExtension;
+        const getSupportedExtensionsProto = WebGLRenderingContext.prototype.getSupportedExtensions;
+        
+        ${useFingerprint ? `
+        // Use fingerprint-provided WebGL values
+        const fingerprintConfig = ${JSON.stringify(fingerprintWebGL)};
+        const selectedVendor = fingerprintConfig.vendorUnmasked || fingerprintConfig.vendor || 'Intel Inc.';
+        const selectedRenderer = fingerprintConfig.rendererUnmasked || fingerprintConfig.renderer || 'Intel Iris OpenGL Engine';
+        console.log('[CDP-FP-DEBUG] WebGL using fingerprint data - Vendor:', selectedVendor, 'Renderer:', selectedRenderer.substring(0, 50));
+        ` : `
+        // Detect platform from navigator
+        const platform = navigator.platform || 'Win32';
+        
+        // Platform-specific GPU configurations - 2024-2025 updated
+        // IMPORTANT: Windows GPU strings must follow the exact Chrome ANGLE format
+        const gpuConfigs = {
+            'Win32': {
+                // Windows uses "Google Inc. (VENDOR)" format for vendor
+                vendors: [
+                    'Google Inc. (NVIDIA)',
+                    'Google Inc. (AMD)',
+                    'Google Inc. (Intel)'
+                ],
+                // Windows renderers use Direct3D11 format - authentic Chrome strings
+                renderers: [
+                    'ANGLE (NVIDIA, NVIDIA GeForce GTX 1660 Ti Direct3D11 vs_5_0 ps_5_0, D3D11)',
+                    'ANGLE (NVIDIA, NVIDIA GeForce RTX 3060 Direct3D11 vs_5_0 ps_5_0, D3D11)',
+                    'ANGLE (NVIDIA, NVIDIA GeForce RTX 4070 Direct3D11 vs_5_0 ps_5_0, D3D11)',
+                    'ANGLE (AMD, AMD Radeon RX 6700 XT Direct3D11 vs_5_0 ps_5_0, D3D11)',
+                    'ANGLE (AMD, AMD Radeon RX 6600 Direct3D11 vs_5_0 ps_5_0, D3D11)',
+                    'ANGLE (Intel, Intel(R) UHD Graphics 630 Direct3D11 vs_5_0 ps_5_0, D3D11)',
+                    'ANGLE (Intel, Intel(R) Iris(R) Xe Graphics Direct3D11 vs_5_0 ps_5_0, D3D11)',
+                    'ANGLE (NVIDIA, NVIDIA GeForce RTX 4060 Direct3D11 vs_5_0 ps_5_0, D3D11)',
+                    'ANGLE (NVIDIA, NVIDIA GeForce RTX 4070 Ti Direct3D11 vs_5_0 ps_5_0, D3D11)',
+                ],
+                vendorPairs: [
+                    { vendor: 'Google Inc. (NVIDIA)', renderer: 'ANGLE (NVIDIA, NVIDIA GeForce GTX 1660 Ti Direct3D11 vs_5_0 ps_5_0, D3D11)' },
+                    { vendor: 'Google Inc. (NVIDIA)', renderer: 'ANGLE (NVIDIA, NVIDIA GeForce RTX 3060 Direct3D11 vs_5_0 ps_5_0, D3D11)' },
+                    { vendor: 'Google Inc. (AMD)', renderer: 'ANGLE (AMD, AMD Radeon RX 6700 XT Direct3D11 vs_5_0 ps_5_0, D3D11)' },
+                    { vendor: 'Google Inc. (Intel)', renderer: 'ANGLE (Intel, Intel(R) UHD Graphics 630 Direct3D11 vs_5_0 ps_5_0, D3D11)' },
+                    { vendor: 'Google Inc. (NVIDIA)', renderer: 'ANGLE (NVIDIA, NVIDIA GeForce RTX 4060 Direct3D11 vs_5_0 ps_5_0, D3D11)' },
+                ],
+            },
+            'MacIntel': {
+                vendors: ['Google Inc. (Apple)', 'Google Inc. (Intel)', 'Google Inc. (AMD)'],
+                renderers: [
+                    'ANGLE (Apple, Apple M1 Pro, OpenGL 4.1)',
+                    'ANGLE (Apple, Apple M2, OpenGL 4.1)',
+                    'ANGLE (Intel Inc., Intel(R) Iris(TM) Plus Graphics OpenGL Engine, OpenGL 4.1)',
+                    'ANGLE (AMD, AMD Radeon Pro 5500M OpenGL Engine, OpenGL 4.1)',
+                ],
+                vendorPairs: [
+                    { vendor: 'Google Inc. (Apple)', renderer: 'ANGLE (Apple, Apple M1 Pro, OpenGL 4.1)' },
+                    { vendor: 'Google Inc. (Intel)', renderer: 'ANGLE (Intel Inc., Intel(R) Iris(TM) Plus Graphics OpenGL Engine, OpenGL 4.1)' },
+                ],
+            },
+            'Linux x86_64': {
+                vendors: ['Google Inc. (Intel)', 'Google Inc. (NVIDIA)', 'Google Inc. (AMD)'],
+                renderers: [
+                    'ANGLE (Intel, Mesa Intel(R) UHD Graphics 630 (CFL GT2), OpenGL 4.6)',
+                    'ANGLE (NVIDIA, NVIDIA GeForce GTX 1660 Ti/PCIe/SSE2, OpenGL 4.6)',
+                    'ANGLE (AMD, AMD Radeon RX 6600 (NAVY_FLOUNDER, DRM 3.42.0, 5.15.0-56-generic, LLVM 12.0.0), OpenGL 4.6)',
+                ],
+                vendorPairs: [
+                    { vendor: 'Google Inc. (Intel)', renderer: 'ANGLE (Intel, Mesa Intel(R) UHD Graphics 630 (CFL GT2), OpenGL 4.6)' },
+                    { vendor: 'Google Inc. (NVIDIA)', renderer: 'ANGLE (NVIDIA, NVIDIA GeForce GTX 1660 Ti/PCIe/SSE2, OpenGL 4.6)' },
+                ],
+            },
+        };
+        
+        // Default to Windows for better anti-bot evasion (most common platform)
+        const config = gpuConfigs[platform] || gpuConfigs['Win32'];
+        
+        // Select a consistent vendor/renderer pair per session.
+        // Use Date.now() XOR'd with UA hash so different sessions get different GPUs
+        // even with the same user agent (avoids mass correlation).
+        const uaHash = (navigator.userAgent || '').split('').reduce((a, b) => ((a << 5) - a + b.charCodeAt(0)) | 0, 0);
+        const sessionSeed = (Date.now() ^ uaHash) >>> 0;
+        const seededIdx = sessionSeed % config.vendorPairs.length;
+        const selectedPair = config.vendorPairs[seededIdx];
+        const selectedVendor = selectedPair.vendor;
+        const selectedRenderer = selectedPair.renderer;
+        
+        console.log('[CDP-FP-DEBUG] WebGL using platform:', platform, '- Vendor:', selectedVendor, 'Renderer:', selectedRenderer.substring(0, 60) + '...');
+        `}
+        
+        // Override getParameter
+        WebGLRenderingContext.prototype.getParameter = function(param) {
+            // UNMASKED_VENDOR_WEBGL
+            if (param === 0x9245) {
+                return selectedVendor;
+            }
+            // UNMASKED_RENDERER_WEBGL
+            if (param === 0x9246) {
+                return selectedRenderer;
+            }
+            // Standard WebGL parameters - use fingerprint values if available
+            if (param === 0x1F00) { // VENDOR
+                return ${useFingerprint && fingerprintWebGL?.vendor ? `'${fingerprintWebGL.vendor}'` : "'WebKit'"};
+            }
+            if (param === 0x1F01) { // RENDERER
+                return ${useFingerprint && fingerprintWebGL?.renderer ? `'${fingerprintWebGL.renderer}'` : "'WebKit WebGL'"};
+            }
+            if (param === 0x1F02) { // VERSION
+                return 'WebGL 1.0 (OpenGL ES 2.0 Chromium)';
+            }
+            // MAX_TEXTURE_SIZE
+            if (param === 0x0D33) {
+                return 16384;
+            }
+            // MAX_VIEWPORT_DIMS
+            if (param === 0x0D3A) {
+                return new Int32Array([32767, 32767]);
+            }
+            
+            return getParameterProto.apply(this, arguments);
+        };
+        
+        // Also apply to WebGL2
+        if (typeof WebGL2RenderingContext !== 'undefined') {
+            WebGL2RenderingContext.prototype.getParameter = function(param) {
+                // For WebGL2, return appropriate version
+                if (param === 0x1F02) { // VERSION
+                    return 'WebGL 2.0 (OpenGL ES 3.0 Chromium)';
+                }
+                // Use same logic as WebGL1 for other params
+                return WebGLRenderingContext.prototype.getParameter.call(this, param);
+            };
+        }
+        
+        // Override getSupportedExtensions with platform-appropriate extensions
+        const baseExtensions = [
+            'ANGLE_instanced_arrays', 'EXT_blend_minmax', 'EXT_color_buffer_half_float',
+            'EXT_disjoint_timer_query', 'EXT_float_blend', 'EXT_frag_depth',
+            'EXT_shader_texture_lod', 'EXT_texture_compression_rgtc',
+            'EXT_texture_filter_anisotropic', 'EXT_sRGB', 'KHR_parallel_shader_compile',
+            'OES_element_index_uint', 'OES_fbo_render_mipmap', 'OES_standard_derivatives',
+            'OES_texture_float', 'OES_texture_float_linear', 'OES_texture_half_float',
+            'OES_texture_half_float_linear', 'OES_vertex_array_object', 'WEBGL_color_buffer_float',
+            'WEBGL_compressed_texture_s3tc', 'WEBGL_compressed_texture_s3tc_srgb',
+            'WEBGL_debug_renderer_info', 'WEBGL_debug_shaders', 'WEBGL_depth_texture',
+            'WEBGL_draw_buffers', 'WEBGL_lose_context', 'WEBGL_multi_draw'
+        ];
+        
+        ${!useFingerprint ? `
+        // Add platform-specific extensions
+        const platformExtensions = {
+            'Win32': ['EXT_texture_compression_bptc', 'WEBGL_compressed_texture_astc'],
+            'MacIntel': ['WEBGL_compressed_texture_pvrtc', 'WEBKIT_WEBGL_compressed_texture_pvrtc'],
+            'Linux x86_64': ['EXT_texture_compression_bptc'],
+        };
+        
+        const allExtensions = [...baseExtensions, ...(platformExtensions[platform] || [])];
+        ` : `
+        const allExtensions = baseExtensions;
+        `}
+        
+        WebGLRenderingContext.prototype.getSupportedExtensions = function() {
+            return allExtensions;
+        };
+        
+        if (typeof WebGL2RenderingContext !== 'undefined') {
+            WebGL2RenderingContext.prototype.getSupportedExtensions = function() {
+                return [...allExtensions, 'EXT_color_buffer_float', 'EXT_disjoint_timer_query_webgl2', 'WEBGL_compressed_texture_etc'];
+            };
+        }
+        
+        // Override getExtension to handle WEBGL_debug_renderer_info properly
+        WebGLRenderingContext.prototype.getExtension = function(name) {
+            const result = getExtensionProto.apply(this, arguments);
+            
+            if (name === 'WEBGL_debug_renderer_info' && result) {
+                // Return the extension but ensure our spoofed values are used
+                return {
+                    UNMASKED_VENDOR_WEBGL: 0x9245,
+                    UNMASKED_RENDERER_WEBGL: 0x9246,
+                };
+            }
+            
+            return result;
+        };
+        
+        if (typeof WebGL2RenderingContext !== 'undefined') {
+            WebGL2RenderingContext.prototype.getExtension = WebGLRenderingContext.prototype.getExtension;
+        }
+    };
+    
+    const DEBUG_PREFIX = '[CDP-FP-DEBUG]';
+    const ERROR_PREFIX = '[CDP-FP-ERROR]';
+    
+    try {
+        console.log(DEBUG_PREFIX, 'Starting WebGL spoofing...');
+        spoofWebGL();
+        console.log(DEBUG_PREFIX, '✓ WebGL spoofing applied');
+    } catch (e) {
+        console.error(ERROR_PREFIX, '✗ Failed to apply WebGL spoofing:', e);
+        throw e; // Rethrow to make errors visible
+    }
+})();`;
+};
+//# sourceMappingURL=webgl-spoofing.js.map

package/dist/fingerprinting/fingerprint-overrides/webgl-spoofing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"webgl-spoofing.js","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/webgl-spoofing.ts"],"names":[],"mappings":"AAAA;;;GAGG;AASH,MAAM,CAAC,MAAM,yBAAyB,GAAG,CAAC,gBAA8B,EAAU,EAAE;IAChF,iFAAiF;IACjF,MAAM,cAAc,GAAG,gBAAgB,IAAI,CAAC,gBAAgB,CAAC,cAAc,IAAI,gBAAgB,CAAC,gBAAgB,CAAC,CAAC;IAElH,OAAO;;;;;;;;;;UAUD,cAAc,CAAC,CAAC,CAAC;;oCAES,IAAI,CAAC,SAAS,CAAC,gBAAgB,CAAC;;;;SAI3D,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SA2EH;;;;;;;;;;;;;;yBAcgB,cAAc,IAAI,gBAAgB,EAAE,MAAM,CAAC,CAAC,CAAC,IAAI,gBAAgB,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,UAAU;;;yBAGxF,cAAc,IAAI,gBAAgB,EAAE,QAAQ,CAAC,CAAC,CAAC,IAAI,gBAAgB,CAAC,QAAQ,GAAG,CAAC,CAAC,CAAC,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA2CjH,CAAC,cAAc,CAAC,CAAC,CAAC;;;;;;;;;SASnB,CAAC,CAAC,CAAC;;SAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA2CH,CAAC;AACP,CAAC,CAAC"}

package/dist/fingerprinting/fingerprint-overrides/webgpu-spoofing.d.ts

@@ -0,0 +1,6 @@
+/**
+ * WebGPU Fingerprinting Protection
+ * Spoofs GPU adapter information
+ */
+export declare const createWebGPUSpoofingScript: (experimentalMode?: boolean) => string;
+//# sourceMappingURL=webgpu-spoofing.d.ts.map

package/dist/fingerprinting/fingerprint-overrides/webgpu-spoofing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webgpu-spoofing.d.ts","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/webgpu-spoofing.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,eAAO,MAAM,0BAA0B,kCAA+B,MAoMrE,CAAC"}

package/dist/fingerprinting/fingerprint-overrides/webgpu-spoofing.js

@@ -0,0 +1,202 @@
+/**
+ * WebGPU Fingerprinting Protection
+ * Spoofs GPU adapter information
+ */
+export const createWebGPUSpoofingScript = (experimentalMode = false) => {
+    return `
+(() => {
+    'use strict';
+    
+    // WebGPU Fingerprinting Protection
+    const spoofWebGPU = () => {
+        // Experimental mode: completely disable WebGPU
+        ${experimentalMode ? `
+        if ('GPU' in window) {
+            delete window.GPU;
+        }
+        if ('navigator' in window && 'gpu' in navigator) {
+            delete navigator.gpu;
+        }
+        // Return early as WebGPU is completely disabled
+        return;
+        ` : ''}
+
+        // Standard mode: spoof WebGPU
+        // Session-stable seeded PRNG to ensure consistent GPU selection across navigations
+        const sessionSeed = Date.now() ^ 0xD4E5F617;
+        const createSeededRNG = (seed) => {
+            let s = seed | 0;
+            return () => {
+                s = s + 0x6D2B79F5 | 0;
+                let t = Math.imul(s ^ s >>> 15, 1 | s);
+                t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+                return ((t ^ t >>> 14) >>> 0) / 4294967296;
+            };
+        };
+        const seededRandom = createSeededRNG(sessionSeed);
+
+        if ('GPU' in window && window.GPU) {
+            const OriginalGPU = window.GPU;
+            
+            // Override requestAdapter to provide consistent fake adapter info
+            window.GPU = new Proxy(OriginalGPU, {
+                get(target, prop) {
+                    if (prop === 'requestAdapter') {
+                        return async function(options) {
+                            const adapter = await target.requestAdapter.call(target, options);
+                            if (!adapter) return null;
+                            
+                            // Wrap the adapter to provide fake but consistent info
+                            return new Proxy(adapter, {
+                                get(adapterTarget, adapterProp) {
+                                    if (adapterProp === 'name') {
+                                        // Return a common GPU name based on platform
+                                        const gpuNames = [
+                                            'NVIDIA GeForce RTX 4060',
+                                            'NVIDIA GeForce RTX 3060',
+                                            'NVIDIA GeForce GTX 1660 Ti',
+                                            'AMD Radeon RX 7600',
+                                            'AMD Radeon RX 6600',
+                                            'Intel(R) Arc(TM) A770',
+                                            'Intel(R) UHD Graphics 770',
+                                        ];
+                                        const idx = Math.floor(seededRandom() * gpuNames.length);
+                                        return gpuNames[idx];
+                                    }
+                                    
+                                    if (adapterProp === 'features') {
+                                        // Return a consistent set of features
+                                        const fakeFeatures = new Set([
+                                            'depth-clip-control',
+                                            'depth32float-stencil8',
+                                            'texture-compression-bc',
+                                            'texture-compression-etc2',
+                                            'texture-compression-astc',
+                                            'timestamp-query',
+                                            'indirect-first-instance',
+                                            'shader-f16',
+                                            'rg11b10ufloat-renderable',
+                                            'bgra8unorm-storage',
+                                            'float32-filterable',
+                                        ]);
+                                        
+                                        return new Proxy(adapterTarget.features || fakeFeatures, {
+                                            get(featuresTarget, featuresProp) {
+                                                if (featuresProp === 'has') {
+                                                    return (feature) => fakeFeatures.has(feature);
+                                                }
+                                                if (featuresProp === 'size') {
+                                                    return fakeFeatures.size;
+                                                }
+                                                if (featuresProp === Symbol.iterator) {
+                                                    return fakeFeatures[Symbol.iterator].bind(fakeFeatures);
+                                                }
+                                                return Reflect.get(featuresTarget, featuresProp);
+                                            }
+                                        });
+                                    }
+                                    
+                                    if (adapterProp === 'limits') {
+                                        // Return realistic GPU limits
+                                        return {
+                                            maxTextureDimension1D: 16384,
+                                            maxTextureDimension2D: 16384,
+                                            maxTextureDimension3D: 2048,
+                                            maxTextureArrayLayers: 2048,
+                                            maxBindGroups: 4,
+                                            maxBindGroupsPlusVertexBuffers: 24,
+                                            maxBindingsPerBindGroup: 1000,
+                                            maxDynamicUniformBuffersPerPipelineLayout: 8,
+                                            maxDynamicStorageBuffersPerPipelineLayout: 4,
+                                            maxSampledTexturesPerShaderStage: 16,
+                                            maxSamplersPerShaderStage: 16,
+                                            maxStorageBuffersPerShaderStage: 8,
+                                            maxStorageTexturesPerShaderStage: 4,
+                                            maxUniformBuffersPerShaderStage: 12,
+                                            maxUniformBufferBindingSize: 65536,
+                                            maxStorageBufferBindingSize: 134217728,
+                                            minUniformBufferOffsetAlignment: 256,
+                                            minStorageBufferOffsetAlignment: 256,
+                                            maxVertexBuffers: 8,
+                                            maxBufferSize: 268435456,
+                                            maxVertexAttributes: 16,
+                                            maxVertexBufferArrayStride: 2048,
+                                            maxInterStageShaderComponents: 60,
+                                            maxInterStageShaderVariables: 16,
+                                            maxColorAttachments: 8,
+                                            maxColorAttachmentBytesPerSample: 32,
+                                            maxComputeWorkgroupStorageSize: 16384,
+                                            maxComputeInvocationsPerWorkgroup: 256,
+                                            maxComputeWorkgroupSizeX: 256,
+                                            maxComputeWorkgroupSizeY: 256,
+                                            maxComputeWorkgroupSizeZ: 64,
+                                            maxComputeWorkgroupsPerDimension: 65535,
+                                        };
+                                    }
+                                    
+                                    if (adapterProp === 'requestDevice') {
+                                        return async function(descriptor) {
+                                            const device = await adapterTarget.requestDevice.call(adapterTarget, descriptor);
+                                            if (!device) return null;
+                                            
+                                            // Wrap the device to intercept timing queries
+                                            return new Proxy(device, {
+                                                get(deviceTarget, deviceProp) {
+                                                    if (deviceProp === 'createQuerySet') {
+                                                        return function(descriptor) {
+                                                            const querySet = deviceTarget.createQuerySet.call(deviceTarget, descriptor);
+                                                            
+                                                            // If it's a timestamp query, we need to fake the results
+                                                            if (descriptor.type === 'timestamp') {
+                                                                return new Proxy(querySet, {
+                                                                    get(queryTarget, queryProp) {
+                                                                        // Intercept resolve operations to fake timestamps
+                                                                        return Reflect.get(queryTarget, queryProp);
+                                                                    }
+                                                                });
+                                                            }
+                                                            
+                                                            return querySet;
+                                                        };
+                                                    }
+                                                    
+                                                    return Reflect.get(deviceTarget, deviceProp);
+                                                }
+                                            });
+                                        };
+                                    }
+                                    
+                                    return Reflect.get(adapterTarget, adapterProp);
+                                }
+                            });
+                        };
+                    }
+                    
+                    if (prop === 'getPreferredCanvasFormat') {
+                        return function() {
+                            // Return the most common format
+                            return 'bgra8unorm';
+                        };
+                    }
+                    
+                    return Reflect.get(target, prop);
+                }
+            });
+        }
+        
+    };
+    
+    const DEBUG_PREFIX = '[CDP-FP-DEBUG]';
+    const ERROR_PREFIX = '[CDP-FP-ERROR]';
+    
+    try {
+        console.log(DEBUG_PREFIX, 'Starting WebGPU spoofing...');
+        spoofWebGPU();
+        console.log(DEBUG_PREFIX, '✓ WebGPU spoofing applied');
+    } catch (e) {
+        console.error(ERROR_PREFIX, '✗ Failed to apply WebGPU spoofing:', e);
+        throw e;
+    }
+})();`;
+};
+//# sourceMappingURL=webgpu-spoofing.js.map

package/dist/fingerprinting/fingerprint-overrides/webgpu-spoofing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"webgpu-spoofing.js","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/webgpu-spoofing.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,CAAC,MAAM,0BAA0B,GAAG,CAAC,gBAAgB,GAAG,KAAK,EAAU,EAAE;IAC3E,OAAO;;;;;;;UAOD,gBAAgB,CAAC,CAAC,CAAC;;;;;;;;;SASpB,CAAC,CAAC,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAkLR,CAAC;AACP,CAAC,CAAC"}

package/dist/fingerprinting/fingerprint-overrides/webrtc-spoofing.d.ts

@@ -0,0 +1,6 @@
+/**
+ * WebRTC Spoofing
+ * Prevents IP leaks and provides fake device information
+ */
+export declare const createWebRTCSpoofingScript: () => string;
+//# sourceMappingURL=webrtc-spoofing.d.ts.map

package/dist/fingerprinting/fingerprint-overrides/webrtc-spoofing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webrtc-spoofing.d.ts","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/webrtc-spoofing.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,eAAO,MAAM,0BAA0B,QAAO,MAsL7C,CAAC"}

package/dist/fingerprinting/fingerprint-overrides/webrtc-spoofing.js

@@ -0,0 +1,188 @@
+/**
+ * WebRTC Spoofing
+ * Prevents IP leaks and provides fake device information
+ */
+export const createWebRTCSpoofingScript = () => {
+    return `
+(() => {
+    'use strict';
+
+    // Use crypto.getRandomValues for device IDs - these must be truly random
+    // per session to avoid correlation/blocking across sessions.
+    // Seeded PRNG is only used for non-identifying jitter (stats).
+    const createSeededRNG = (seed) => {
+        let s = seed | 0;
+        return () => {
+            s = s + 0x6D2B79F5 | 0;
+            let t = Math.imul(s ^ s >>> 15, 1 | s);
+            t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+            return ((t ^ t >>> 14) >>> 0) / 4294967296;
+        };
+    };
+    const sessionSeed = Date.now() ^ 0xC3A5F917;
+    const seededRandom = createSeededRNG(sessionSeed);
+
+    // Generate crypto-quality random hex device IDs (64 chars)
+    const generateDeviceId = () => {
+        if (typeof crypto !== 'undefined' && crypto.getRandomValues) {
+            const bytes = new Uint8Array(32);
+            crypto.getRandomValues(bytes);
+            return Array.from(bytes, b => b.toString(16).padStart(2, '0')).join('');
+        }
+        // Fallback: combine Date.now, Math.random, and performance.now for entropy
+        let id = '';
+        for (let i = 0; i < 64; i++) {
+            id += Math.floor(Math.random() * 16).toString(16);
+        }
+        return id;
+    };
+
+    // Pre-generate device IDs once per session for consistency within a session
+    const cachedDeviceIds = {};
+    const getDeviceId = (key) => {
+        if (!cachedDeviceIds[key]) cachedDeviceIds[key] = generateDeviceId();
+        return cachedDeviceIds[key];
+    };
+
+    // Redact local IP addresses from ICE candidate strings
+    const redactCandidateIP = (candidateStr) => {
+        if (!candidateStr) return candidateStr;
+        // Match private/local IPs (10.x, 172.16-31.x, 192.168.x, fd00::/8, fe80::/10)
+        return candidateStr
+            .replace(/(?:(?:10|127)\.\\d{1,3}|192\\.168|172\\.(?:1[6-9]|2\\d|3[01]))(?:\\.\\d{1,3}){2}/g, '0.0.0.0')
+            .replace(/[0-9a-f]{1,4}(?::[0-9a-f]{1,4}){7}/gi, (match) => {
+                if (match.startsWith('fd') || match.startsWith('fe80')) return '0.0.0.0';
+                return match;
+            });
+    };
+
+    // WebRTC Spoofing for 2025
+    const spoofWebRTC = () => {
+        // Override RTCPeerConnection
+        const OriginalRTCPeerConnection = window.RTCPeerConnection || window.webkitRTCPeerConnection || window.mozRTCPeerConnection;
+
+        if (OriginalRTCPeerConnection) {
+            window.RTCPeerConnection = window.webkitRTCPeerConnection = window.mozRTCPeerConnection = new Proxy(OriginalRTCPeerConnection, {
+                construct(target, args) {
+                    const config = args[0] || {};
+
+                    // Keep STUN servers intact - they are needed for ICE candidate gathering
+                    const pc = Reflect.construct(target, [config, ...args.slice(1)]);
+
+                    // Intercept onicecandidate to redact local IPs from candidates
+                    let userOnicecandidateHandler = null;
+                    Object.defineProperty(pc, 'onicecandidate', {
+                        get() {
+                            return userOnicecandidateHandler;
+                        },
+                        set(handler) {
+                            if (typeof handler === 'function') {
+                                userOnicecandidateHandler = handler;
+                                const wrappedHandler = (event) => {
+                                    if (event.candidate && event.candidate.candidate) {
+                                        const redacted = redactCandidateIP(event.candidate.candidate);
+                                        if (redacted !== event.candidate.candidate) {
+                                            const newCandidate = new RTCIceCandidate({
+                                                candidate: redacted,
+                                                sdpMid: event.candidate.sdpMid,
+                                                sdpMLineIndex: event.candidate.sdpMLineIndex,
+                                                usernameFragment: event.candidate.usernameFragment,
+                                            });
+                                            const newEvent = new RTCPeerConnectionIceEvent('icecandidate', { candidate: newCandidate });
+                                            handler.call(pc, newEvent);
+                                            return;
+                                        }
+                                    }
+                                    handler.call(pc, event);
+                                };
+                                pc.addEventListener('icecandidate', wrappedHandler);
+                            } else {
+                                userOnicecandidateHandler = null;
+                            }
+                        },
+                        configurable: true,
+                        enumerable: true,
+                    });
+
+                    // Override getStats to provide fake statistics
+                    const originalGetStats = pc.getStats;
+                    pc.getStats = function() {
+                        return originalGetStats.apply(this, arguments).then(stats => {
+                            // Modify stats to hide identifying information
+                            const modifiedStats = new Map();
+                            stats.forEach((stat, key) => {
+                                const modifiedStat = Object.assign({}, stat);
+
+                                // Use seeded PRNG for deterministic jitter
+                                if ('bytesReceived' in modifiedStat) {
+                                    modifiedStat.bytesReceived = Math.floor(modifiedStat.bytesReceived * (0.9 + seededRandom() * 0.2));
+                                }
+                                if ('bytesSent' in modifiedStat) {
+                                    modifiedStat.bytesSent = Math.floor(modifiedStat.bytesSent * (0.9 + seededRandom() * 0.2));
+                                }
+                                if ('jitter' in modifiedStat) {
+                                    modifiedStat.jitter = modifiedStat.jitter * (0.9 + seededRandom() * 0.2);
+                                }
+
+                                modifiedStats.set(key, modifiedStat);
+                            });
+                            return modifiedStats;
+                        });
+                    };
+
+                    return pc;
+                }
+            });
+        }
+
+        // Override MediaDevices.enumerateDevices
+        if (navigator.mediaDevices && navigator.mediaDevices.enumerateDevices) {
+            const originalEnumerateDevices = navigator.mediaDevices.enumerateDevices;
+
+            // Pre-build the device list once per session
+            // Real browsers have varying numbers of devices (1-5+ depending on hardware)
+            // We use the real device list as a base but replace IDs with random ones
+            let cachedDeviceList = null;
+
+            navigator.mediaDevices.enumerateDevices = function() {
+                if (cachedDeviceList) return Promise.resolve(cachedDeviceList);
+
+                return originalEnumerateDevices.apply(this, arguments).then(devices => {
+                    // Replace device IDs with crypto-random ones, keep real device kinds/count
+                    // This preserves the natural device count from the actual browser
+                    // while preventing tracking via device IDs
+                    const groupIds = {};
+                    cachedDeviceList = devices.map((device, index) => {
+                        const groupKey = device.kind.replace(/input|output/, '');
+                        if (!groupIds[groupKey]) groupIds[groupKey] = getDeviceId('group_' + groupKey);
+
+                        return {
+                            deviceId: getDeviceId(device.kind + '_' + index),
+                            kind: device.kind,
+                            label: '', // Empty label = no permission granted (realistic)
+                            groupId: groupIds[groupKey],
+                            toJSON() {
+                                return { deviceId: this.deviceId, kind: this.kind, label: this.label, groupId: this.groupId };
+                            },
+                        };
+                    });
+                    return cachedDeviceList;
+                });
+            };
+        }
+    };
+    
+    const DEBUG_PREFIX = '[CDP-FP-DEBUG]';
+    const ERROR_PREFIX = '[CDP-FP-ERROR]';
+    
+    try {
+        console.log(DEBUG_PREFIX, 'Starting WebRTC spoofing...');
+        spoofWebRTC();
+        console.log(DEBUG_PREFIX, '✓ WebRTC spoofing applied');
+    } catch (e) {
+        console.error(ERROR_PREFIX, '✗ Failed to apply WebRTC spoofing:', e);
+        throw e;
+    }
+})();`;
+};
+//# sourceMappingURL=webrtc-spoofing.js.map

package/dist/fingerprinting/fingerprint-overrides/webrtc-spoofing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"webrtc-spoofing.js","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/webrtc-spoofing.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,CAAC,MAAM,0BAA0B,GAAG,GAAW,EAAE;IACnD,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAoLL,CAAC;AACP,CAAC,CAAC"}

package/dist/index.d.ts

@@ -1,4 +1,8 @@
 import CDPCrawler from "./crawler.js";
+import CdpPage from "./page.js";
 export default CDPCrawler;
 export { createCDPRouter } from "./crawler.js";
+export type { CDPRouter, CDPCrawlingContext, CDPCrawlerOptions, CDPLaunchContext, CDPRequestHandler } from "./crawler.js";
+export type { GotoOptions, SelectOptionOptions } from "./page.js";
+export { CdpPage };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,UAAU,MAAM,cAAc,CAAC;AAEtC,eAAe,UAAU,CAAC;AAC1B,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,UAAU,MAAM,cAAc,CAAC;AACtC,OAAO,OAAO,MAAM,WAAW,CAAC;AAEhC,eAAe,UAAU,CAAC;AAC1B,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAC/C,YAAY,EAAE,SAAS,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAC1H,YAAY,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAC;AAClE,OAAO,EAAE,OAAO,EAAE,CAAC"}