@fanboynz/network-scanner 2.0.14 → 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,6 +396,7 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
         }, 'webdriver removal');
 
         // Remove automation properties
+        //
         safeExecute(() => {
           const automationProps = [
             'callPhantom', '_phantom', '__nightmare', '_selenium', '__selenium_unwrapped',
@@ -417,6 +419,7 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
         }, 'automation properties removal');
 
         // Simulate Chrome runtime
+        //
         safeExecute(() => {
           if (!window.chrome?.runtime) {
             window.chrome = {
@@ -449,6 +452,7 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
         }, 'Chrome runtime simulation');
 
         // Spoof plugins based on user agent
+        //
         safeExecute(() => {
           let plugins = [];
           if (userAgent.includes('Chrome')) {
@@ -482,12 +486,25 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
             // Safari typically has no plugins in modern versions
             plugins = [];
           }
-          // Create array-like object with length property
-          const pluginsArray = Object.assign(plugins, { length: plugins.length });
+          // 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 });
@@ -495,6 +512,7 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
         }, 'language spoofing');
 
         // Spoof vendor information
+        //
         safeExecute(() => {
           let vendor = 'Google Inc.';
           let product = 'Gecko';
@@ -510,6 +528,7 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
         }, 'vendor/product spoofing');
 
         // Enhanced OS fingerprinting protection based on actual user agent content
+        //
         safeExecute(() => {
           let osType = 'windows';
           let browserType = 'chrome';
@@ -552,7 +571,15 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
           }
         }, '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 = [
@@ -573,6 +600,7 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
         }, 'screen resolution protection');
 
         // Spoof MIME types
+        //
         safeExecute(() => {
           let mimeTypes = [];
           if (userAgent.includes('Chrome')) {
@@ -646,28 +674,118 @@ 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) {
-              return Promise.resolve({ state: Math.random() > 0.5 ? 'granted' : 'prompt' });
+              // 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() {
@@ -681,6 +799,7 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
         }, 'media device spoofing');
         
         // Fetch Request Headers Normalization
+        //
         safeExecute(() => {
           const originalFetch = window.fetch;
           window.fetch = function(url, options = {}) {
@@ -702,6 +821,7 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
         }, 'fetch headers normalization');
         
         // Image Loading Pattern Obfuscation
+        //
         safeExecute(() => {
           const originalImageSrc = Object.getOwnPropertyDescriptor(HTMLImageElement.prototype, 'src');
           if (originalImageSrc) {
@@ -719,6 +839,7 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
         }, 'image loading obfuscation');
 
         // CSS Media Query Spoofing
+        //
         safeExecute(() => {
           const originalMatchMedia = window.matchMedia;
           window.matchMedia = function(query) {
@@ -736,6 +857,7 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
         }, 'CSS media query spoofing');
 
         // Enhanced WebRTC Spoofing
+        //
         safeExecute(() => {
           if (window.RTCPeerConnection) {
             const OriginalRTC = window.RTCPeerConnection;
@@ -752,6 +874,7 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
         }, 'WebRTC spoofing');
 
         // Font fingerprinting protection
+        //
         safeExecute(() => {
           // Standardize available fonts to common system fonts
           const standardFonts = [
@@ -760,7 +883,100 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
             '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');
           
@@ -778,6 +994,7 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
         }, 'font fingerprinting protection');
 
         // Performance timing obfuscation
+        //
         safeExecute(() => {
           const originalNow = performance.now;
           performance.now = function() {
@@ -786,6 +1003,7 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
         }, 'performance timing obfuscation');
 
         // Canvas fingerprinting protection
+        //
         safeExecute(() => {
           const originalToDataURL = HTMLCanvasElement.prototype.toDataURL;
           HTMLCanvasElement.prototype.toDataURL = function(...args) {
@@ -802,6 +1020,7 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
         }, 'canvas fingerprinting protection');
 
         // Battery API spoofing
+        //
         safeExecute(() => {
           if (navigator.getBattery) {
             navigator.getBattery = function() {
@@ -815,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) {
@@ -841,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 = {}) {
@@ -870,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 = {}) {

package/nwss.js

@@ -1,4 +1,4 @@
-// === Network scanner script (nwss.js) v2.0.14 ===
+// === 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.14'; // 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.14",
+  "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": {