@fanboynz/network-scanner 2.0.22 → 2.0.24

package/lib/fingerprint.js

@@ -7,6 +7,81 @@
 const DEFAULT_PLATFORM = 'Win32';
 const DEFAULT_TIMEZONE = 'America/New_York';
 
+// Cached property descriptors for V8 optimization
+const CACHED_DESCRIPTORS = {
+  readOnlyValue: (value) => ({ value, writable: false, enumerable: true, configurable: true }),
+  getter: (fn) => ({ get: fn, enumerable: true, configurable: true }),
+  hiddenValue: (value) => ({ value, writable: false, enumerable: false, configurable: true })
+};
+
+// Type-specific property spoofing functions for monomorphic optimization
+function spoofNavigatorProperties(navigator, properties, options = {}) {
+  if (!navigator || typeof navigator !== 'object') return false;
+  
+  for (const [prop, descriptor] of Object.entries(properties)) {
+    if (!safeDefineProperty(navigator, prop, descriptor, options)) {
+      if (options.debug) console.log(`[fingerprint] Failed to spoof navigator.${prop}`);
+    }
+  }
+  return true;
+}
+
+function spoofScreenProperties(screen, properties, options = {}) {
+  if (!screen || typeof screen !== 'object') return false;
+  
+  for (const [prop, descriptor] of Object.entries(properties)) {
+    if (!safeDefineProperty(screen, prop, descriptor, options)) {
+      if (options.debug) console.log(`[fingerprint] Failed to spoof screen.${prop}`);
+    }
+  }
+  return true;
+}
+
+function spoofWindowProperties(window, properties, options = {}) {
+  if (!window || typeof window !== 'object') return false;
+  
+  for (const [prop, descriptor] of Object.entries(properties)) {
+    if (!safeDefineProperty(window, prop, descriptor, options)) {
+      if (options.debug) console.log(`[fingerprint] Failed to spoof window.${prop}`);
+    }
+  }
+  return true;
+}
+
+// Pre-compiled mock objects for V8 optimization
+const PRECOMPILED_MOCKS = Object.freeze({
+  chromeRuntime: Object.freeze({
+    onConnect: Object.freeze({ addListener: () => {}, removeListener: () => {} }),
+    onMessage: Object.freeze({ addListener: () => {}, removeListener: () => {} }),
+    sendMessage: () => {},
+    connect: () => Object.freeze({
+      onMessage: Object.freeze({ addListener: () => {}, removeListener: () => {} }),
+      postMessage: () => {},
+      disconnect: () => {}
+    }),
+    getManifest: () => Object.freeze({ name: "Chrome", version: "140.0.0.0" }),
+    getURL: (path) => `chrome-extension://invalid/${path}`,
+    id: undefined
+  }),
+  
+  fingerprintResult: Object.freeze({
+    visitorId: 'mock_visitor_' + Math.random().toString(36).substr(2, 9),
+    confidence: Object.freeze({ score: 0.99 }),
+    components: Object.freeze({
+      screen: Object.freeze({ value: Object.freeze({ width: 1920, height: 1080 }) }),
+      timezone: Object.freeze({ value: 'America/New_York' }),
+      language: Object.freeze({ value: 'en-US' })
+    })
+  }),
+  
+  loadTimes: Object.freeze({
+    commitLoadTime: performance.now() - Math.random() * 1000,
+    connectionInfo: 'http/1.1',
+    finishDocumentLoadTime: performance.now() - Math.random() * 500,
+    navigationType: 'Navigation'
+  })
+});
+
 // Built-in properties that should not be modified
 const BUILT_IN_PROPERTIES = new Set([
   'href', 'origin', 'protocol', 'host', 'hostname', 'port', 'pathname', 'search', 'hash',
@@ -55,10 +130,7 @@ function safeDefineProperty(target, property, descriptor, options = {}) {
       return false;
     }
 
-    Object.defineProperty(target, property, {
-      ...descriptor,
-      configurable: true
-    });
+    Object.defineProperty(target, property, descriptor);
     return true;
   } catch (err) {
     if (options.debug) console.log(`[fingerprint] Failed to define ${property}: ${err.message}`);
@@ -99,11 +171,61 @@ function getRealisticScreenResolution() {
 /**
  * Generates randomized but realistic browser fingerprint values
  */
-function getRandomFingerprint() {
-  const resolution = getRealisticScreenResolution();
+function generateRealisticFingerprint(userAgent) {
+  // Determine OS from user agent
+  let osType = 'windows';
+  if (userAgent.includes('Macintosh') || userAgent.includes('Mac OS X')) {
+    osType = 'mac';
+  } else if (userAgent.includes('X11; Linux') || userAgent.includes('Ubuntu')) {
+    osType = 'linux';
+  }
+  
+  // Generate OS-appropriate hardware specs
+  const profiles = {
+    windows: {
+      deviceMemory: [8, 16], // Common Windows configurations
+      hardwareConcurrency: [4, 6, 8], // Typical consumer CPUs
+      platform: 'Win32',
+      timezone: 'America/New_York',
+      language: 'en-US',
+      resolutions: [
+        { width: 1920, height: 1080 },
+        { width: 2560, height: 1440 },
+        { width: 1366, height: 768 }
+      ]
+    },
+    mac: {
+      deviceMemory: [8, 16], // MacBook/iMac typical configs
+      hardwareConcurrency: [8, 10], // Apple Silicon M1/M2 cores
+      platform: 'MacIntel',
+      timezone: 'America/Los_Angeles',
+      language: 'en-US',
+      resolutions: [
+        { width: 2560, height: 1600 }, // MacBook Pro
+        { width: 3840, height: 2160 }, // iMac 4K
+        { width: 1440, height: 900 }   // MacBook Air
+      ]
+    },
+    linux: {
+      deviceMemory: [8, 16],
+      hardwareConcurrency: [4, 8, 12], // Wide variety on Linux
+      platform: 'Linux x86_64',
+      timezone: 'America/New_York',
+      language: 'en-US',
+      resolutions: [
+        { width: 1920, height: 1080 },
+        { width: 2560, height: 1440 },
+        { width: 1600, height: 900 }
+      ]
+    }
+  };
+  
+  const profile = profiles[osType];
+  const resolution = profile.resolutions[Math.floor(Math.random() * profile.resolutions.length)];
+  
   return {
-    deviceMemory: [4, 8, 16, 32][Math.floor(Math.random() * 4)],
-    hardwareConcurrency: [2, 4, 6, 8, 12, 16][Math.floor(Math.random() * 6)],
+    deviceMemory: profile.deviceMemory[Math.floor(Math.random() * profile.deviceMemory.length)],
+    hardwareConcurrency: profile.hardwareConcurrency[Math.floor(Math.random() * profile.hardwareConcurrency.length)],
     screen: {
       width: resolution.width,
       height: resolution.height,
@@ -112,11 +234,11 @@ function getRandomFingerprint() {
       colorDepth: 24,
       pixelDepth: 24
     },
-    platform: Math.random() > 0.3 ? 'Win32' : 'MacIntel',
-    timezone: ['America/New_York', 'America/Los_Angeles', 'Europe/London', 'America/Chicago'][Math.floor(Math.random() * 4)],
-    language: ['en-US', 'en-GB', 'en-CA'][Math.floor(Math.random() * 3)],
+    platform: profile.platform,
+    timezone: profile.timezone,
+    language: profile.language,
     cookieEnabled: true,
-    doNotTrack: Math.random() > 0.7 ? '1' : null
+    doNotTrack: null // Most users don't enable DNT
   };
 }
 
@@ -124,19 +246,7 @@ function getRandomFingerprint() {
  * Creates mock Chrome runtime objects
  */
 function createMockChromeRuntime() {
-  return {
-    onConnect: { addListener: () => {}, removeListener: () => {} },
-    onMessage: { addListener: () => {}, removeListener: () => {} },
-    sendMessage: () => {},
-    connect: () => ({
-      onMessage: { addListener: () => {}, removeListener: () => {} },
-      postMessage: () => {},
-      disconnect: () => {}
-    }),
-    getManifest: () => ({ name: "Chrome", version: "131.0.0.0" }),
-    getURL: (path) => `chrome-extension://invalid/${path}`,
-    id: undefined
-  };
+  return PRECOMPILED_MOCKS.chromeRuntime;
 }
 
 /**
@@ -144,21 +254,8 @@ function createMockChromeRuntime() {
  */
 function generateRealisticLoadTimes() {
   const now = performance.now();
-  return {
-    commitLoadTime: now - Math.random() * 1000,
-    connectionInfo: 'http/1.1',
-    finishDocumentLoadTime: now - Math.random() * 500,
-    finishLoadTime: now - Math.random() * 100,
-    firstPaintAfterLoadTime: now - Math.random() * 50,
-    firstPaintTime: now - Math.random() * 200,
-    navigationType: 'Navigation',
-    npnNegotiatedProtocol: 'unknown',
-    requestTime: now - Math.random() * 2000,
-    startLoadTime: now - Math.random() * 1500,
-    wasAlternateProtocolAvailable: false,
-    wasFetchedViaSpdy: false,
-    wasNpnNegotiated: false
-  };
+  // Return a copy with updated timing values
+  return { ...PRECOMPILED_MOCKS.loadTimes, commitLoadTime: now - Math.random() * 1000 };
 }
 
 /**
@@ -194,22 +291,14 @@ async function validatePageForInjection(page, currentUrl, forceDebug) {
  * Creates mock fingerprinting objects
  */
 function createFingerprintMocks() {
-  const mockResult = {
-    visitorId: 'mock_visitor_' + Math.random().toString(36).substr(2, 9),
-    confidence: { score: 0.99 },
-    components: {
-      screen: { value: { width: 1920, height: 1080 } },
-      timezone: { value: DEFAULT_TIMEZONE },
-      language: { value: 'en-US' }
-    }
-  };
+  const mockResult = PRECOMPILED_MOCKS.fingerprintResult;
   
   return {
     fp: {
       getResult: (callback) => callback ? setTimeout(() => callback(mockResult), 0) : mockResult,
       get: (callback) => Promise.resolve(mockResult),
       load: () => Promise.resolve(window.fp),
-      components: { screen: { value: { width: 1920, height: 1080 } } },
+      components: mockResult.components,
       x64hash128: () => 'mock_hash',
       tz: DEFAULT_TIMEZONE,
       timezone: DEFAULT_TIMEZONE
@@ -351,7 +440,7 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
         // Create safe property definition helper
         function safeDefinePropertyLocal(target, property, descriptor) {
           const builtInProps = new Set(['href', 'origin', 'protocol', 'host', 'hostname', 'port', 'pathname', 'search', 'hash', 'constructor', 'prototype', '__proto__', 'toString', 'valueOf', 'assign', 'reload', 'replace']);
-          
+       
           if (builtInProps.has(property)) {
             if (debugEnabled) console.log(`[fingerprint] Skipping built-in property: ${property}`);
             return false;
@@ -374,6 +463,24 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
             return false;
           }
         }
+
+        // Add cached descriptors helper for page context
+        const CACHED_DESCRIPTORS = {
+          getter: (fn) => ({ get: fn, enumerable: true, configurable: true })
+        };
+        
+        // Add monomorphic spoofing functions for page context
+        function spoofNavigatorProperties(navigator, properties) {
+          for (const [prop, descriptor] of Object.entries(properties)) {
+            safeDefinePropertyLocal(navigator, prop, descriptor);
+          }
+        }
+        
+        function spoofScreenProperties(screen, properties) {
+          for (const [prop, descriptor] of Object.entries(properties)) {
+            safeDefinePropertyLocal(screen, prop, descriptor);
+          }
+        }
         
         // Safe execution wrapper
         function safeExecute(fn, description) {
@@ -428,7 +535,7 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
                 onMessage: { addListener: () => {}, removeListener: () => {} },
                 sendMessage: () => {},
                 connect: () => ({ onMessage: { addListener: () => {}, removeListener: () => {} }, postMessage: () => {}, disconnect: () => {} }),
-                getManifest: () => ({ name: "Chrome", version: "131.0.0.0" }),
+                getManifest: () => ({ name: "Chrome", version: "140.0.0.0" }),
                 getURL: (path) => `chrome-extension://invalid/${path}`,
                 id: undefined
               },
@@ -507,8 +614,11 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
         //
         safeExecute(() => {
           const languages = ['en-US', 'en'];
-          safeDefinePropertyLocal(navigator, 'languages', { get: () => languages });
-          safeDefinePropertyLocal(navigator, 'language', { get: () => languages[0] });
+          const languageProps = {
+            languages: { get: () => languages },
+            language: { get: () => languages[0] }
+          };
+          spoofNavigatorProperties(navigator, languageProps);
         }, 'language spoofing');
 
         // Spoof vendor information
@@ -523,8 +633,11 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
             vendor = 'Apple Computer, Inc.';
           }
           
-          safeDefinePropertyLocal(navigator, 'vendor', { get: () => vendor });
-          safeDefinePropertyLocal(navigator, 'product', { get: () => product });
+          const vendorProps = {
+            vendor: { get: () => vendor },
+            product: { get: () => product }
+          };
+          spoofNavigatorProperties(navigator, vendorProps);
         }, 'vendor/product spoofing');
 
         // Enhanced OS fingerprinting protection based on actual user agent content
@@ -574,7 +687,10 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
         // Hardware concurrency spoofing (universal coverage)
         //
         safeExecute(() => {
-          safeDefinePropertyLocal(navigator, 'hardwareConcurrency', { get: () => [4, 6, 8, 12][Math.floor(Math.random() * 4)] });
+          const hardwareProps = {
+            hardwareConcurrency: { get: () => [4, 6, 8, 12][Math.floor(Math.random() * 4)] }
+          };
+          spoofNavigatorProperties(navigator, hardwareProps);
         }, 'hardware concurrency spoofing');
 
 
@@ -593,10 +709,13 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
           ];
           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 });
+          const screenProps = {
+            width: { get: () => resolution.width },
+            height: { get: () => resolution.height },
+            availWidth: { get: () => resolution.width },
+            availHeight: { get: () => resolution.height - 40 }
+          };
+          spoofScreenProperties(window.screen, screenProps);
         }, 'screen resolution protection');
 
         // Spoof MIME types
@@ -1213,7 +1332,9 @@ async function applyFingerprintProtection(page, siteConfig, forceDebug, currentU
   // Validate page state before injection
   if (!(await validatePageForInjection(page, currentUrl, forceDebug))) return;
   
-  const spoof = fingerprintSetting === 'random' ? getRandomFingerprint() : {
+ const currentUserAgent = await page.evaluate(() => navigator.userAgent);
+  
+ const spoof = fingerprintSetting === 'random' ? generateRealisticFingerprint(currentUserAgent) : {
     deviceMemory: 8, 
     hardwareConcurrency: 4,
     screen: { width: 1920, height: 1080, availWidth: 1920, availHeight: 1040, colorDepth: 24, pixelDepth: 24 },
@@ -1244,11 +1365,15 @@ async function applyFingerprintProtection(page, siteConfig, forceDebug, currentU
       }
 
       // Platform spoofing
-      safeDefinePropertyLocal(navigator, 'platform', { get: () => spoof.platform });
+      const navigatorProps = {
+        platform: { get: () => spoof.platform },
+        deviceMemory: { get: () => spoof.deviceMemory },
+        hardwareConcurrency: { get: () => spoof.hardwareConcurrency }
+      };
+      spoofNavigatorProperties(navigator, navigatorProps);
       
-      // Memory spoofing
-      safeDefinePropertyLocal(navigator, 'deviceMemory', { get: () => spoof.deviceMemory });
-      safeDefinePropertyLocal(navigator, 'hardwareConcurrency', { get: () => spoof.hardwareConcurrency });
+      // Platform, memory, and hardware spoofing combined for better V8 optimization
+      // (moved into navigatorProps above);
 
       // Connection type spoofing
       safeDefinePropertyLocal(navigator, 'connection', {
@@ -1262,16 +1387,21 @@ async function applyFingerprintProtection(page, siteConfig, forceDebug, currentU
       });
       
       // Screen properties spoofing
+      const screenSpoofProps = {};
       ['width', 'height', 'availWidth', 'availHeight', 'colorDepth', 'pixelDepth'].forEach(prop => {
         if (spoof.screen[prop] !== undefined) {
-          safeDefinePropertyLocal(window.screen, prop, { get: () => spoof.screen[prop] });
+          screenSpoofProps[prop] = { get: () => spoof.screen[prop] };
         }
       });
+      spoofScreenProperties(window.screen, screenSpoofProps);
       
       // Language spoofing
       const languages = Array.isArray(spoof.language) ? spoof.language : [spoof.language, spoof.language.split('-')[0]];
-      safeDefinePropertyLocal(navigator, 'languages', { get: () => languages });
-      safeDefinePropertyLocal(navigator, 'language', { get: () => languages[0] });
+      const languageSpoofProps = {
+        languages: { get: () => languages },
+        language: { get: () => languages[0] }
+      };
+      spoofNavigatorProperties(navigator, languageSpoofProps);
 
       // Timezone spoofing
       if (spoof.timezone && window.Intl?.DateTimeFormat) {
@@ -1480,7 +1610,7 @@ function safeExecuteSpoofing(spoofFunction, description, forceDebug = false) {
 
 
 module.exports = {
-  getRandomFingerprint,
+  generateRealisticFingerprint,
   getRealisticScreenResolution,
   applyUserAgentSpoofing,
   applyBraveSpoofing,

package/lib/nettools.js

@@ -357,13 +357,13 @@ async function whoisLookup(domain, timeout = 10000, whoisServer = null, debugMod
  * @param {number} whoisDelay - Delay in milliseconds before whois requests (default: 2000)
  * @returns {Promise<Object>} Object with success status and output/error
  */
-async function whoisLookupWithRetry(domain, timeout = 10000, whoisServer = null, debugMode = false, retryOptions = {}, whoisDelay = 2000, logFunc = null) {
+async function whoisLookupWithRetry(domain, timeout = 10000, whoisServer = null, debugMode = false, retryOptions = {}, whoisDelay = 4000, logFunc = null) {
   const {
-    maxRetries = 2,
+    maxRetries = 3,
     timeoutMultiplier = 1.5,
     useFallbackServers = true,
     retryOnTimeout = true,
-    retryOnError = false
+    retryOnError = true
   } = retryOptions;
 
   let serversToTry = [];
@@ -709,7 +709,7 @@ function createNetToolsHandler(config) {
   const {
     whoisTerms,
     whoisOrTerms,
-    whoisDelay = 2000,
+    whoisDelay = 4000,
     whoisServer,
     whoisServerMode = 'random',
     debugLogFile = null,
@@ -941,7 +941,7 @@ function createNetToolsHandler(config) {
         
           // Configure retry options based on site config or use defaults
           const retryOptions = {
-            maxRetries: siteConfig.whois_max_retries || 2,
+            maxRetries: siteConfig.whois_max_retries || 3,
             timeoutMultiplier: siteConfig.whois_timeout_multiplier || 1.5,
             useFallbackServers: siteConfig.whois_use_fallback !== false, // Default true
             retryOnTimeout: siteConfig.whois_retry_on_timeout !== false, // Default true

package/nwss.1

@@ -383,7 +383,7 @@ Boolean. Retry on timeout errors (default: true).
 
 .TP
 .B whois_retry_on_error
-Boolean. Retry on connection/other errors (default: false).
+Boolean. Retry on connection/other errors (default: true).
 
 .TP
 .B whois_delay

package/nwss.js

@@ -1,4 +1,4 @@
-// === Network scanner script (nwss.js) v2.0.22 ===
+// === Network scanner script (nwss.js) v2.0.24 ===
 
 // puppeteer for browser automation, fs for file system operations, psl for domain parsing.
 // const pLimit = require('p-limit'); // Will be dynamically imported
@@ -132,7 +132,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.22'; // Script version
+const VERSION = '2.0.24'; // Script version
 
 // get startTime
 const startTime = Date.now();
@@ -575,7 +575,7 @@ Advanced Options:
   whois_timeout_multiplier: 1.5              Timeout increase multiplier per retry (default: 1.5)
   whois_use_fallback: true                   Add TLD-specific fallback servers (default: true)
   whois_retry_on_timeout: true               Retry on timeout errors (default: true)
-  whois_retry_on_error: false                Retry on connection/other errors (default: false)
+  whois_retry_on_error: true                 Retry on connection/other errors (default: true)
   whois_delay: <milliseconds>                Delay between whois requests for this site (default: global whois_delay)
   dig: ["term1", "term2"]                     Check dig output for ALL specified terms (AND logic)
   dig-or: ["term1", "term2"]                  Check dig output for ANY specified term (OR logic)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fanboynz/network-scanner",
-  "version": "2.0.22",
+  "version": "2.0.24",
   "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": {