@fanboynz/network-scanner 2.0.13 → 2.0.15

package/lib/fingerprint.js

@@ -16,17 +16,17 @@ const BUILT_IN_PROPERTIES = new Set([
 // User agent collections with latest versions
 const USER_AGENT_COLLECTIONS = {
   chrome: [
-    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
-    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
-    "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36"
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36",
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36",
+    "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36"
   ],
   firefox: [
-    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:133.0) Gecko/20100101 Firefox/133.0",
-    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:133.0) Gecko/20100101 Firefox/133.0",
-    "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:133.0) Gecko/20100101 Firefox/133.0"
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:143.0) Gecko/20100101 Firefox/143.0",
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:143.0) Gecko/20100101 Firefox/143.0",
+    "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:143.0) Gecko/20100101 Firefox/143.0"
   ],
   safari: [
-    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.2 Safari/605.1.15",
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Safari/605.1.15",
     "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.6 Safari/605.1.15"
   ]
 };
@@ -387,6 +387,7 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
         }
 
         // Remove webdriver properties
+        //
         safeExecute(() => {
           try {
             delete navigator.webdriver;
@@ -395,10 +396,15 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
         }, 'webdriver removal');
 
         // Remove automation properties
+        //
         safeExecute(() => {
           const automationProps = [
             'callPhantom', '_phantom', '__nightmare', '_selenium', '__selenium_unwrapped',
             '__webdriver_evaluate', '__driver_evaluate', '__webdriver_script_function',
+            '__fxdriver_evaluate', '__fxdriver_unwrapped', '__webdriver_script_fn',
+            'phantomjs', '_Selenium_IDE_Recorder', 'callSelenium', '_selenium',
+            '__phantomas', '__selenium_evaluate', '__driver_unwrapped',
+            'webdriver-evaluate', '__webdriverFunc', 'driver-evaluate', '__driver-evaluate', '__selenium-evaluate',
             'spawn', 'emit', 'Buffer', 'domAutomation', 'domAutomationController'
           ];
           
@@ -413,6 +419,7 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
         }, 'automation properties removal');
 
         // Simulate Chrome runtime
+        //
         safeExecute(() => {
           if (!window.chrome?.runtime) {
             window.chrome = {
@@ -445,22 +452,59 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
         }, 'Chrome runtime simulation');
 
         // Spoof plugins based on user agent
+        //
         safeExecute(() => {
           let plugins = [];
           if (userAgent.includes('Chrome')) {
             plugins = [
-              { name: 'Chrome PDF Plugin', description: 'Portable Document Format', filename: 'internal-pdf-viewer' },
-              { name: 'Chrome PDF Viewer', description: 'PDF Viewer', filename: 'mhjfbmdgcfjbbpaeojofohoefgiehjai' }
+              { 
+                name: 'Chrome PDF Plugin', 
+                description: 'Portable Document Format', 
+                filename: 'internal-pdf-viewer',
+                length: 1,
+                version: ''
+              },
+              { 
+                name: 'Chrome PDF Viewer', 
+                description: '', 
+                filename: 'mhjfbmdgcfjbbpaeojofohoefgiehjai',
+                length: 1,
+                version: ''
+              }
             ];
           } else if (userAgent.includes('Firefox')) {
             plugins = [
-              { name: 'PDF.js', description: 'Portable Document Format', filename: 'internal-pdf-js' }
+              { 
+                name: 'PDF.js', 
+                description: 'Portable Document Format', 
+                filename: 'internal-pdf-js',
+                length: 2,
+                version: '5.4.70'
+              }
             ];
+          } else if (userAgent.includes('Safari')) {
+            // Safari typically has no plugins in modern versions
+            plugins = [];
           }
-          safeDefinePropertyLocal(navigator, 'plugins', { get: () => plugins });
+          // Create proper array-like object with enumerable indices and length
+          const pluginsArray = {};
+          plugins.forEach((plugin, index) => {
+            pluginsArray[index] = plugin;
+          });
+          
+          // Ensure length property is properly defined
+          Object.defineProperty(pluginsArray, 'length', {
+            value: plugins.length,
+            writable: false,
+            enumerable: false,
+            configurable: false
+          });
+
+          safeDefinePropertyLocal(navigator, 'plugins', { get: () => pluginsArray });
         }, 'plugins spoofing');
 
         // Spoof languages
+        //
         safeExecute(() => {
           const languages = ['en-US', 'en'];
           safeDefinePropertyLocal(navigator, 'languages', { get: () => languages });
@@ -468,6 +512,7 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
         }, 'language spoofing');
 
         // Spoof vendor information
+        //
         safeExecute(() => {
           let vendor = 'Google Inc.';
           let product = 'Gecko';
@@ -482,7 +527,80 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
           safeDefinePropertyLocal(navigator, 'product', { get: () => product });
         }, 'vendor/product spoofing');
 
+        // Enhanced OS fingerprinting protection based on actual user agent content
+        //
+        safeExecute(() => {
+          let osType = 'windows';
+          let browserType = 'chrome';
+          
+          // Detect OS from user agent string patterns
+          if (userAgent.includes('Macintosh') || userAgent.includes('Mac OS X')) {
+            osType = 'mac';
+          } else if (userAgent.includes('X11; Linux') || userAgent.includes('Ubuntu')) {
+            osType = 'linux';
+          } else if (userAgent.includes('Windows NT')) {
+            osType = 'windows';
+          }
+          
+          // Detect browser type
+          if (userAgent.includes('Firefox/')) {
+            browserType = 'firefox';
+          } else if (userAgent.includes('Safari/') && !userAgent.includes('Chrome/')) {
+            browserType = 'safari';
+          }
+          
+          // Apply OS-specific navigator properties
+          if (osType === 'windows') {
+            if (browserType === 'firefox') {
+              safeDefinePropertyLocal(navigator, 'oscpu', { get: () => 'Windows NT 10.0; Win64; x64' });
+              safeDefinePropertyLocal(navigator, 'buildID', { get: () => '20100101' });
+            }
+            if (window.screen) {
+              safeDefinePropertyLocal(window.screen, 'fontSmoothingEnabled', { get: () => true });
+            }
+          } else if (osType === 'mac') {
+            if (browserType === 'firefox') {
+              safeDefinePropertyLocal(navigator, 'oscpu', { get: () => 'Intel Mac OS X 10.15' });
+              safeDefinePropertyLocal(navigator, 'buildID', { get: () => '20100101' });
+            }
+          } else if (osType === 'linux') {
+            if (browserType === 'firefox') {
+              safeDefinePropertyLocal(navigator, 'oscpu', { get: () => 'Linux x86_64' });
+              safeDefinePropertyLocal(navigator, 'buildID', { get: () => '20100101' });
+            }
+          }
+        }, 'enhanced OS fingerprinting protection');
+
+        // Hardware concurrency spoofing (universal coverage)
+        //
+        safeExecute(() => {
+          safeDefinePropertyLocal(navigator, 'hardwareConcurrency', { get: () => [4, 6, 8, 12][Math.floor(Math.random() * 4)] });
+        }, 'hardware concurrency spoofing');
+
+
+        // Screen resolution fingerprinting protection
+        //
+        safeExecute(() => {
+          // Common realistic resolutions to avoid fingerprinting
+          const commonResolutions = [
+            { width: 1920, height: 1080 },
+            { width: 2560, height: 1440 },
+            { width: 3840, height: 2160 },
+            { width: 1280, height: 720 },
+            { width: 1366, height: 768 },
+            { width: 1440, height: 900 },
+            { width: 1536, height: 864 }
+          ];
+          const resolution = commonResolutions[Math.floor(Math.random() * commonResolutions.length)];
+          
+          safeDefinePropertyLocal(window.screen, 'width', { get: () => resolution.width });
+          safeDefinePropertyLocal(window.screen, 'height', { get: () => resolution.height });
+          safeDefinePropertyLocal(window.screen, 'availWidth', { get: () => resolution.width });
+          safeDefinePropertyLocal(window.screen, 'availHeight', { get: () => resolution.height - 40 });
+        }, 'screen resolution protection');
+
         // Spoof MIME types
+        //
         safeExecute(() => {
           let mimeTypes = [];
           if (userAgent.includes('Chrome')) {
@@ -556,18 +674,336 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
         }, 'fingerprinting mocks');
 
         // WebGL spoofing
+        //
         safeExecute(() => {
+          // Enhanced WebGL fingerprinting protection
+          const webglParams = {
+            37445: 'Intel Inc.',                    // VENDOR
+            37446: 'Intel(R) UHD Graphics 630',    // RENDERER (more realistic)
+            7936: 'WebGL 1.0 (OpenGL ES 2.0 Chromium)', // VERSION
+            35724: 'WebGL GLSL ES 1.0 (OpenGL ES GLSL ES 1.00 Chromium)', // SHADING_LANGUAGE_VERSION
+            34076: 16384,                          // MAX_TEXTURE_SIZE
+            34024: 16384,                          // MAX_CUBE_MAP_TEXTURE_SIZE
+            34930: new Float32Array([1, 1]),       // ALIASED_LINE_WIDTH_RANGE
+            33901: new Float32Array([0, 1]),       // ALIASED_POINT_SIZE_RANGE
+            35660: 16,                             // MAX_VERTEX_ATTRIBS
+            35661: 16,                             // MAX_VERTEX_UNIFORM_VECTORS
+            35659: 16,                             // MAX_VARYING_VECTORS
+            35663: 16,                             // MAX_FRAGMENT_UNIFORM_VECTORS
+            36347: 4096,                           // MAX_RENDERBUFFER_SIZE
+            34852: 32,                             // MAX_COMBINED_TEXTURE_IMAGE_UNITS
+            2978: new Int32Array([0, 0, 1920, 1080]), // VIEWPORT
+            3379: new Int32Array([0, 0, 1920, 1080])  // SCISSOR_BOX
+          };
+          
           if (window.WebGLRenderingContext) {
             const getParameter = WebGLRenderingContext.prototype.getParameter;
             WebGLRenderingContext.prototype.getParameter = function(parameter) {
-              if (parameter === 37445) return 'Intel Inc.';
-              if (parameter === 37446) return 'Intel Iris OpenGL Engine';
+              if (webglParams.hasOwnProperty(parameter)) {
+                return webglParams[parameter];
+              }
               return getParameter.call(this, parameter);
             };
+            // Spoof supported extensions
+            const getSupportedExtensions = WebGLRenderingContext.prototype.getSupportedExtensions;
+            WebGLRenderingContext.prototype.getSupportedExtensions = function() {
+              return [
+                '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',
+                'WEBKIT_EXT_texture_filter_anisotropic',
+                'EXT_sRGB',
+                '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_debug_renderer_info',
+                'WEBGL_debug_shaders',
+                'WEBGL_depth_texture',
+                'WEBGL_draw_buffers',
+                'WEBGL_lose_context'
+              ];
+            };
+          }
+          // Also handle WebGL2 context
+          if (window.WebGL2RenderingContext) {
+            const getParameter2 = WebGL2RenderingContext.prototype.getParameter;
+            WebGL2RenderingContext.prototype.getParameter = function(parameter) {
+              if (webglParams.hasOwnProperty(parameter)) {
+                return webglParams[parameter];
+              }
+              return getParameter2.call(this, parameter);
+            };
           }
         }, 'WebGL spoofing');
 
+        // Permissions API spoofing
+        //
+        safeExecute(() => {
+          if (navigator.permissions?.query) {
+            const originalQuery = navigator.permissions.query;
+            navigator.permissions.query = function(descriptor) {
+              // More realistic permission states based on permission type
+              const permissionName = descriptor.name || descriptor;
+              let state = 'prompt'; // Default state
+              
+              // Common permissions that are usually granted
+              if (['notifications', 'persistent-storage'].includes(permissionName)) {
+                state = Math.random() > 0.3 ? 'granted' : 'prompt';
+              }
+              // Privacy-sensitive permissions that are usually denied/prompt
+              else if (['camera', 'microphone', 'geolocation'].includes(permissionName)) {
+                state = Math.random() > 0.8 ? 'granted' : 'prompt';
+              }
+              // Other permissions random
+              else {
+                state = Math.random() > 0.5 ? 'granted' : 'prompt';
+              }
+              
+              return Promise.resolve({ 
+                state: state,
+                onchange: null
+              });
+            };
+          }
+          // Block permission prompts from actually appearing
+          if (window.Notification && Notification.requestPermission) {
+            Notification.requestPermission = () => Promise.resolve('default');
+          }
+        }, 'permissions API spoofing');
+
+        // Media Device Spoofing
+        //
+        safeExecute(() => {
+          if (navigator.mediaDevices?.enumerateDevices) {
+            navigator.mediaDevices.enumerateDevices = function() {
+              return Promise.resolve([
+                { deviceId: 'default', kind: 'audioinput', label: 'Default - Microphone (Realtek Audio)', groupId: 'group1' },
+                { deviceId: 'default', kind: 'audiooutput', label: 'Default - Speakers (Realtek Audio)', groupId: 'group1' },
+                { deviceId: 'default', kind: 'videoinput', label: 'HD WebCam (USB Camera)', groupId: 'group2' }
+              ]);
+            };
+          }
+        }, 'media device spoofing');
+        
+        // Fetch Request Headers Normalization
+        //
+        safeExecute(() => {
+          const originalFetch = window.fetch;
+          window.fetch = function(url, options = {}) {
+            const headers = { ...(options.headers || {}) };
+            
+            // Add common browser headers if missing
+            if (!headers['Accept']) {
+              headers['Accept'] = 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8';
+            }
+            if (!headers['Accept-Language']) {
+              headers['Accept-Language'] = 'en-US,en;q=0.5';
+            }
+            if (!headers['Accept-Encoding']) {
+              headers['Accept-Encoding'] = 'gzip, deflate, br';
+            }
+            
+            return originalFetch.call(this, url, { ...options, headers });
+          };
+        }, 'fetch headers normalization');
+        
+        // Image Loading Pattern Obfuscation
+        //
+        safeExecute(() => {
+          const originalImageSrc = Object.getOwnPropertyDescriptor(HTMLImageElement.prototype, 'src');
+          if (originalImageSrc) {
+            Object.defineProperty(HTMLImageElement.prototype, 'src', {
+              set: function(value) {
+                // Add random delay to image loading (0-50ms)
+                setTimeout(() => {
+                  originalImageSrc.set.call(this, value);
+                }, Math.random() * 50);
+              },
+              get: originalImageSrc.get,
+              configurable: true
+            });
+          }
+        }, 'image loading obfuscation');
+
+        // CSS Media Query Spoofing
+        //
+        safeExecute(() => {
+          const originalMatchMedia = window.matchMedia;
+          window.matchMedia = function(query) {
+            const result = originalMatchMedia.call(this, query);
+            // Add slight randomization to avoid fingerprinting for device queries
+            if (query.includes('device-width') || query.includes('device-height') || 
+                query.includes('aspect-ratio') || query.includes('color-gamut')) {
+              Object.defineProperty(result, 'matches', {
+                get: () => Math.random() > 0.1 ? originalMatchMedia.call(window, query).matches : !originalMatchMedia.call(window, query).matches,
+                configurable: true
+              });
+            }
+            return result;
+          };
+        }, 'CSS media query spoofing');
+
+        // Enhanced WebRTC Spoofing
+        //
+        safeExecute(() => {
+          if (window.RTCPeerConnection) {
+            const OriginalRTC = window.RTCPeerConnection;
+            window.RTCPeerConnection = function(...args) {
+              const pc = new OriginalRTC(...args);
+              const originalCreateOffer = pc.createOffer;
+              pc.createOffer = function() {
+                return Promise.reject(new Error('WebRTC disabled'));
+              };
+              return pc;
+            };
+            Object.setPrototypeOf(window.RTCPeerConnection, OriginalRTC);
+          }
+        }, 'WebRTC spoofing');
+
+        // Font fingerprinting protection
+        //
+        safeExecute(() => {
+          // Standardize available fonts to common system fonts
+          const standardFonts = [
+            'Arial', 'Helvetica', 'Times New Roman', 'Times', 'Courier New', 'Courier',
+            'Verdana', 'Georgia', 'Palatino', 'Garamond', 'Bookman', 'Comic Sans MS',
+            'Trebuchet MS', 'Arial Black', 'Impact', 'Tahoma', 'Lucida Console'
+          ];
+          
+          // Intercept font availability detection
+          if (document.fonts && document.fonts.check) {
+            const originalCheck = document.fonts.check;
+            document.fonts.check = function(fontSpec) {
+              // Always return true for standard fonts, false for others
+              const fontFamily = fontSpec.match(/['"]([^'"]+)['"]/)?.[1] || fontSpec.split(' ').pop();
+              return standardFonts.some(font => fontFamily.includes(font));
+            };
+          }
+          
+          // Prevent font loading detection
+          if (document.fonts && document.fonts.load) {
+            document.fonts.load = function() {
+              return Promise.resolve([]);
+            };
+          }
+
+          // Canvas-based font fingerprinting protection
+          //
+          const originalFillText = CanvasRenderingContext2D.prototype.fillText;
+          const originalStrokeText = CanvasRenderingContext2D.prototype.strokeText;
+          const originalMeasureText = CanvasRenderingContext2D.prototype.measureText;
+          
+          CanvasRenderingContext2D.prototype.fillText = function(text, x, y, maxWidth) {
+            // Normalize font to standard before drawing
+            const currentFont = this.font;
+            if (currentFont && !standardFonts.some(font => currentFont.includes(font))) {
+              this.font = currentFont.replace(/['"]?[^'"]*['"]?/, '"Arial"');
+            }
+            return originalFillText.call(this, text, x, y, maxWidth);
+          };
+          
+          CanvasRenderingContext2D.prototype.strokeText = function(text, x, y, maxWidth) {
+            const currentFont = this.font;
+            if (currentFont && !standardFonts.some(font => currentFont.includes(font))) {
+              this.font = currentFont.replace(/['"]?[^'"]*['"]?/, '"Arial"');
+            }
+            return originalStrokeText.call(this, text, x, y, maxWidth);
+          };
+          
+          CanvasRenderingContext2D.prototype.measureText = function(text) {
+            const result = originalMeasureText.call(this, text);
+            // Add slight noise to text measurements to prevent precise fingerprinting
+            result.width += (Math.random() - 0.5) * 0.1;
+            return result;
+          };
+
+          // Comprehensive canvas fingerprinting protection
+          //
+          const originalGetImageData = CanvasRenderingContext2D.prototype.getImageData;
+          CanvasRenderingContext2D.prototype.getImageData = function(sx, sy, sw, sh) {
+            const imageData = originalGetImageData.call(this, sx, sy, sw, sh);
+            // Add subtle noise to pixel data
+            for (let i = 0; i < imageData.data.length; i += 4) {
+              if (Math.random() < 0.1) { // 10% chance to modify each pixel
+                imageData.data[i] = Math.max(0, Math.min(255, imageData.data[i] + Math.floor(Math.random() * 3) - 1));
+                imageData.data[i + 1] = Math.max(0, Math.min(255, imageData.data[i + 1] + Math.floor(Math.random() * 3) - 1));
+                imageData.data[i + 2] = Math.max(0, Math.min(255, imageData.data[i + 2] + Math.floor(Math.random() * 3) - 1));
+              }
+            }
+            return imageData;
+          };
+          
+          // WebGL canvas context fingerprinting
+          const originalGetContext = HTMLCanvasElement.prototype.getContext;
+          HTMLCanvasElement.prototype.getContext = function(contextType, contextAttributes) {
+            const context = originalGetContext.call(this, contextType, contextAttributes);
+            
+            if (contextType === 'webgl' || contextType === 'webgl2' || contextType === 'experimental-webgl') {
+              // Override WebGL-specific fingerprinting methods
+              const originalGetShaderPrecisionFormat = context.getShaderPrecisionFormat;
+              context.getShaderPrecisionFormat = function(shaderType, precisionType) {
+                return {
+                  rangeMin: 127,
+                  rangeMax: 127,
+                  precision: 23
+                };
+              };
+              
+              const originalGetExtension = context.getExtension;
+              context.getExtension = function(name) {
+                // Block access to fingerprinting-sensitive extensions
+                if (name === 'WEBGL_debug_renderer_info') {
+                  return null;
+                }
+                return originalGetExtension.call(this, name);
+              };
+            }
+            
+            return context;
+          };
+
+          // Override font detection methods
+          //
+          const originalOffsetWidth = Object.getOwnPropertyDescriptor(HTMLElement.prototype, 'offsetWidth');
+          const originalOffsetHeight = Object.getOwnPropertyDescriptor(HTMLElement.prototype, 'offsetHeight');
+          
+          if (originalOffsetWidth && originalOffsetHeight) {
+            Object.defineProperty(HTMLElement.prototype, 'offsetWidth', {
+              get: function() {
+                if (this.style && this.style.fontFamily) {
+                  return Math.floor(originalOffsetWidth.get.call(this) + (Math.random() - 0.5) * 2);
+                }
+                return originalOffsetWidth.get.call(this);
+              },
+              configurable: true
+            });
+          }
+        }, 'font fingerprinting protection');
+
+        // Performance timing obfuscation
+        //
+        safeExecute(() => {
+          const originalNow = performance.now;
+          performance.now = function() {
+            return originalNow.call(this) + (Math.random() - 0.5) * 2; // +/- 1ms variation
+          };
+        }, 'performance timing obfuscation');
+
         // Canvas fingerprinting protection
+        //
         safeExecute(() => {
           const originalToDataURL = HTMLCanvasElement.prototype.toDataURL;
           HTMLCanvasElement.prototype.toDataURL = function(...args) {
@@ -584,6 +1020,7 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
         }, 'canvas fingerprinting protection');
 
         // Battery API spoofing
+        //
         safeExecute(() => {
           if (navigator.getBattery) {
             navigator.getBattery = function() {
@@ -597,9 +1034,8 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
           }
         }, 'battery API spoofing');
 
-        // Suppress common console errors
-
         // Enhanced Mouse/Pointer Spoofing
+        //
         safeExecute(() => {
           // Spoof pointer capabilities
           if (navigator.maxTouchPoints !== undefined) {
@@ -623,6 +1059,7 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
           };
           
           // Spoof PointerEvent if available
+          //
           if (window.PointerEvent) {
             const OriginalPointerEvent = window.PointerEvent;
             window.PointerEvent = function(type, eventInitDict = {}) {
@@ -652,6 +1089,7 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
           }
           
           // Spoof mouse wheel behavior
+          //
           const originalWheelEvent = window.WheelEvent;
           if (originalWheelEvent) {
             window.WheelEvent = function(type, eventInitDict = {}) {
@@ -811,6 +1249,17 @@ async function applyFingerprintProtection(page, siteConfig, forceDebug, currentU
       // Memory spoofing
       safeDefinePropertyLocal(navigator, 'deviceMemory', { get: () => spoof.deviceMemory });
       safeDefinePropertyLocal(navigator, 'hardwareConcurrency', { get: () => spoof.hardwareConcurrency });
+
+      // Connection type spoofing
+      safeDefinePropertyLocal(navigator, 'connection', {
+        get: () => ({
+          effectiveType: ['slow-2g', '2g', '3g', '4g'][Math.floor(Math.random() * 4)],
+          type: Math.random() > 0.5 ? 'cellular' : 'wifi',
+          saveData: Math.random() > 0.8,
+          downlink: 1.5 + Math.random() * 8,
+          rtt: 50 + Math.random() * 200
+        })
+      });
       
       // Screen properties spoofing
       ['width', 'height', 'availWidth', 'availHeight', 'colorDepth', 'pixelDepth'].forEach(prop => {

package/nwss.js

@@ -1,4 +1,4 @@
-// === Network scanner script (nwss.js) v2.0.13 ===
+// === Network scanner script (nwss.js) v2.0.15 ===
 
 // puppeteer for browser automation, fs for file system operations, psl for domain parsing.
 // const pLimit = require('p-limit'); // Will be dynamically imported
@@ -130,7 +130,7 @@ const { navigateWithRedirectHandling, handleRedirectTimeout } = require('./lib/r
 const { monitorBrowserHealth, isBrowserHealthy, isQuicklyResponsive, performGroupWindowCleanup, performRealtimeWindowCleanup, trackPageForRealtime, updatePageUsage, cleanupPageBeforeReload } = require('./lib/browserhealth');
 
 // --- Script Configuration & Constants --- 
-const VERSION = '2.0.13'; // Script version
+const VERSION = '2.0.15'; // Script version
 
 // get startTime
 const startTime = Date.now();
@@ -1335,6 +1335,7 @@ function setupFrameHandling(page, forceDebug) {
         '--memory-pressure-off',
         '--max_old_space_size=2048',
         '--no-first-run',
+        '--disable-prompt-on-repost',  // Fixes form popup on page reload
         '--disable-default-apps',
         '--disable-component-extensions-with-background-pages',
         '--disable-background-networking',
@@ -1994,6 +1995,34 @@ function setupFrameHandling(page, forceDebug) {
       // --- Apply all fingerprint spoofing (user agent, Brave, fingerprint protection) ---
       try {
         await applyAllFingerprintSpoofing(page, siteConfig, forceDebug, currentUrl);
+        
+        // Client Hints protection for Chrome user agents
+        if (siteConfig.userAgent && siteConfig.userAgent.toLowerCase().includes('chrome')) {
+          let platform = 'Windows';
+          let platformVersion = '15.0.0';
+          let arch = 'x86';
+          
+          if (siteConfig.userAgent.toLowerCase() === 'chrome_mac') {
+            platform = 'macOS';
+            platformVersion = '13.5.0';
+            arch = 'arm';
+          } else if (siteConfig.userAgent.toLowerCase() === 'chrome_linux') {
+            platform = 'Linux';
+            platformVersion = '6.5.0';
+            arch = 'x86';
+          }
+          
+          await page.setExtraHTTPHeaders({
+            'Sec-CH-UA': '"Chromium";v="140", "Not=A?Brand";v="24", "Google Chrome";v="140"',
+            'Sec-CH-UA-Platform': `"${platform}"`,
+            'Sec-CH-UA-Platform-Version': `"${platformVersion}"`,
+            'Sec-CH-UA-Mobile': '?0',
+            'Sec-CH-UA-Arch': `"${arch}"`,
+            'Sec-CH-UA-Bitness': '"64"',
+            'Sec-CH-UA-Full-Version': '"140.0.7339.208"',
+            'Sec-CH-UA-Full-Version-List': '"Chromium";v="140.0.7339.208", "Not=A?Brand";v="24.0.0.0", "Google Chrome";v="140.0.7339.208"'
+          });
+        }
       } catch (fingerprintErr) {
         if (fingerprintErr.message.includes('Session closed') || 
             fingerprintErr.message.includes('Protocol error') ||

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fanboynz/network-scanner",
-  "version": "2.0.13",
+  "version": "2.0.15",
   "description": "A Puppeteer-based network scanner for analyzing web traffic, generating adblock filter rules, and identifying third-party requests. Features include fingerprint spoofing, Cloudflare bypass, content analysis with curl/grep, and multiple output formats.",
   "main": "nwss.js",
   "scripts": {