@fanboynz/network-scanner 2.0.53 → 2.0.54

package/lib/fingerprint.js

@@ -1023,8 +1023,9 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
 
             // Null context — return mock to prevent crashes
             if (ctx === null) {
-              return new Proxy({}, {
-                get(_, prop) {
+              const canvasEl = this; // capture the actual canvas element
+              const mock = new Proxy({}, {
+                get(target, prop) {
                   if (prop === 'getShaderPrecisionFormat') return () => ({ rangeMin: 127, rangeMax: 127, precision: 23 });
                   if (prop === 'getParameter') return (p) => webglSpoofParams[p] || 0;
                   if (prop === 'getSupportedExtensions') return () => [];
@@ -1032,12 +1033,28 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
                     if (name === 'WEBGL_debug_renderer_info') return { UNMASKED_VENDOR_WEBGL: 37445, UNMASKED_RENDERER_WEBGL: 37446 };
                     return null;
                   };
-                  if (prop === 'canvas') return this;
-                  if (prop === 'drawingBufferWidth') return 1920;
-                  if (prop === 'drawingBufferHeight') return 1080;
+                  if (prop === 'getContextAttributes') return () => ({
+                    alpha: true, antialias: true, depth: true, failIfMajorPerformanceCaveat: false,
+                    desynchronized: false, premultipliedAlpha: true, preserveDrawingBuffer: false,
+                    powerPreference: 'default', stencil: false, xrCompatible: false
+                  });
+                  if (prop === 'isContextLost') return () => false;
+                  if (prop === 'canvas') return canvasEl;
+                  if (prop === 'drawingBufferWidth') return canvasEl.width || 1920;
+                  if (prop === 'drawingBufferHeight') return canvasEl.height || 1080;
+                  if (prop === 'drawingBufferColorSpace') return 'srgb';
+                  // Identity — let prototype chain handle constructor/toString/Symbol.toStringTag
+                  if (prop === 'constructor') return WebGLRenderingContext;
+                  if (prop === Symbol.toStringTag) return 'WebGLRenderingContext';
+                  // Common draw/state methods — return noop to prevent crashes
                   return noop;
                 }
               });
+              // Make mock pass instanceof checks
+              if (window.WebGLRenderingContext) {
+                Object.setPrototypeOf(mock, WebGLRenderingContext.prototype);
+              }
+              return mock;
             }
 
             // Real context — wrap in Proxy to intercept getParameter/getExtension

package/lib/nettools.js

@@ -11,6 +11,20 @@ const execPromise = util.promisify(exec);
 // Cycling index for whois server rotation
 let whoisServerCycleIndex = 0;
 
+// Global dig result cache — shared across ALL handler instances and processUrl calls
+// Key: `${domain}-${recordType}`, Value: { result, timestamp }
+// DNS records don't change based on what terms you're searching for,
+// so we cache the raw dig output and let each handler check its own terms against it
+const globalDigResultCache = new Map();
+const GLOBAL_DIG_CACHE_TTL = 300000; // 5 minutes
+const GLOBAL_DIG_CACHE_MAX = 500;
+
+// Global whois result cache — shared across ALL handler instances and processUrl calls
+// Whois data is per root domain and doesn't change based on search terms
+const globalWhoisResultCache = new Map();
+const GLOBAL_WHOIS_CACHE_TTL = 900000; // 15 minutes (whois data changes less frequently)
+const GLOBAL_WHOIS_CACHE_MAX = 500;
+
 /**
  * Strips ANSI color codes from a string for clean file logging
  * @param {string} text - Text that may contain ANSI codes
@@ -26,27 +40,28 @@ function stripAnsiColors(text) {
  * @returns {Object} Object with isAvailable boolean and version/error info
  */
 function validateWhoisAvailability() {
+  if (validateWhoisAvailability._cached) return validateWhoisAvailability._cached;
   try {
     const result = execSync('whois --version 2>&1', { encoding: 'utf8' });
-    return {
+    validateWhoisAvailability._cached = {
       isAvailable: true,
       version: result.trim()
     };
   } catch (error) {
-    // Some systems don't have --version, try just whois
     try {
       execSync('which whois', { encoding: 'utf8' });
-      return {
+      validateWhoisAvailability._cached = {
         isAvailable: true,
         version: 'whois (version unknown)'
       };
     } catch (e) {
-      return {
+      validateWhoisAvailability._cached = {
         isAvailable: false,
         error: 'whois command not found'
       };
     }
   }
+  return validateWhoisAvailability._cached;
 }
 
 /**
@@ -54,18 +69,20 @@ function validateWhoisAvailability() {
  * @returns {Object} Object with isAvailable boolean and version/error info
  */
 function validateDigAvailability() {
+  if (validateDigAvailability._cached) return validateDigAvailability._cached;
   try {
     const result = execSync('dig -v 2>&1', { encoding: 'utf8' });
-    return {
+    validateDigAvailability._cached = {
       isAvailable: true,
       version: result.split('\n')[0].trim()
     };
   } catch (error) {
-    return {
+    validateDigAvailability._cached = {
       isAvailable: false,
       error: 'dig command not found'
     };
   }
+  return validateDigAvailability._cached;
 }
 
 /**
@@ -635,8 +652,8 @@ async function digLookup(domain = '', recordType = 'A', timeout = 5000) {
     // Clean domain
     const cleanDomain = domain.replace(/^https?:\/\//, '').replace(/\/.*$/, '').replace(/:\d+$/, '');
     
-    // Get short output first
-    const { stdout, stderr } = await execWithTimeout(`dig +short "${cleanDomain}" ${recordType}`, timeout);
+    // Single dig command — full output contains everything including the short answers
+    const { stdout: fullOutput, stderr } = await execWithTimeout(`dig "${cleanDomain}" ${recordType}`, timeout);
     
     if (stderr && stderr.trim()) {
       return {
@@ -647,13 +664,21 @@ async function digLookup(domain = '', recordType = 'A', timeout = 5000) {
       };
     }
     
-    // Also get full dig output for detailed analysis
-    const { stdout: fullOutput } = await execWithTimeout(`dig "${cleanDomain}" ${recordType}`, timeout);
+    // Extract short output from ANSWER SECTION of full dig output
+    const answerMatch = fullOutput.match(/;; ANSWER SECTION:\n([\s\S]*?)(?:\n;;|\n*$)/);
+    let shortOutput = '';
+    if (answerMatch) {
+      shortOutput = answerMatch[1]
+        .split('\n')
+        .map(line => line.split(/\s+/).pop())
+        .filter(Boolean)
+        .join('\n');
+    }
     
     return {
       success: true,
       output: fullOutput,
-      shortOutput: stdout.trim(),
+      shortOutput,
       domain: cleanDomain,
       recordType
     };
@@ -766,7 +791,6 @@ function createNetToolsHandler(config) {
     whoisDelay = 4000,
     whoisServer,
     whoisServerMode = 'random',
-    bufferedLogWrite = null,
     debugLogFile = null,
     digTerms,
     digOrTerms,
@@ -807,20 +831,10 @@ function createNetToolsHandler(config) {
     subdomain: digSubdomain
   });
 
-  // Add whois resolution caching to avoid redundant whois lookups
-  const whoisResultCache = new Map();
-  const WHOIS_CACHE_TTL = 900000; // 15 minutes cache TTL (whois data changes less frequently)
-  const MAX_CACHE_SIZE = 400; // Larger cache for whois due to longer TTL
-  // Size          Memory
-  // 100          ~900KB
-  // 200          1.8MB
-  // 300          2.6MB
-  // 400          3.4MB
-  // 500          4.2MB  
-  // Add DNS resolution caching to avoid redundant dig lookups
-  const digResultCache = new Map();
-  const DIG_CACHE_TTL = 300000; // 5 minutes cache TTL
-  const DIG_MAX_CACHE_SIZE = 400; // Smaller cache for dig due to shorter TTL
+  // Whois cache is global (globalWhoisResultCache) — shared across all handler instances
+  // Whois data is per root domain and doesn't change based on search terms
+  // Dig cache is global (globalDigResultCache) — shared across all handler instances
+  // DNS results are the same regardless of search terms
   
   return async function handleNetToolsCheck(domain, fullSubdomain) {
     // Use fullSubdomain parameter instead of originalDomain to maintain consistency
@@ -844,19 +858,17 @@ function createNetToolsHandler(config) {
 
     // Move the logToConsoleAndFile function declaration from later in the file to here:
     function logToConsoleAndFile(message) {
+      // Note: This function needs access to forceDebug, debugLogFile, and fs from the parent scope
+      // These are passed in via the config object to createNetToolsHandler
+      // forceDebug, debugLogFile, and fs are available in this closure
+
+      // Always log to console when in debug mode
       if (forceDebug) {
         console.log(formatLogMessage('debug', message));
       }
       
-      if (debugLogFile && bufferedLogWrite) {
-        try {
-          const timestamp = new Date().toISOString();
-          const cleanMessage = stripAnsiColors(message);
-          bufferedLogWrite(debugLogFile, `${timestamp} [debug nettools] ${cleanMessage}\n`);
-        } catch (logErr) {
-          // Silently fail file logging to avoid disrupting whois operations
-        }
-      } else if (debugLogFile && fs) {
+      // Also log to file if debug file logging is enabled
+      if (debugLogFile && fs) {
         try {
           const timestamp = new Date().toISOString();
           const cleanMessage = stripAnsiColors(message);
@@ -982,9 +994,9 @@ function createNetToolsHandler(config) {
         const now = Date.now();
         let whoisResult = null;
         
-        if (whoisResultCache.has(whoisCacheKey)) {
-          const cachedEntry = whoisResultCache.get(whoisCacheKey);
-          if (now - cachedEntry.timestamp < WHOIS_CACHE_TTL) {
+        if (globalWhoisResultCache.has(whoisCacheKey)) {
+          const cachedEntry = globalWhoisResultCache.get(whoisCacheKey);
+          if (now - cachedEntry.timestamp < GLOBAL_WHOIS_CACHE_TTL) {
             if (forceDebug) {
               const age = Math.round((now - cachedEntry.timestamp) / 1000);
               const serverInfo = (selectedServer && selectedServer !== '') ? ` (server: ${selectedServer})` : ' (default server)';
@@ -998,7 +1010,7 @@ function createNetToolsHandler(config) {
             });
           } else {
             // Cache expired, remove it
-            whoisResultCache.delete(whoisCacheKey);
+            globalWhoisResultCache.delete(whoisCacheKey);
             if (forceDebug) {
               logToConsoleAndFile(`${messageColors.highlight('[whois-cache]')} Cache expired for ${whoisRootDomain}, performing fresh lookup`);
             }
@@ -1030,7 +1042,7 @@ function createNetToolsHandler(config) {
                  !whoisResult.error.toLowerCase().includes('connection') &&
                  !whoisResult.error.toLowerCase().includes('network'))) {
               
-              whoisResultCache.set(whoisCacheKey, {
+              globalWhoisResultCache.set(whoisCacheKey, {
                 result: whoisResult,
                 timestamp: now
               });
@@ -1183,17 +1195,17 @@ function createNetToolsHandler(config) {
         }
         
         // Periodic whois cache cleanup to prevent memory leaks
-        if (whoisResultCache.size > MAX_CACHE_SIZE) {
+        if (globalWhoisResultCache.size > GLOBAL_WHOIS_CACHE_MAX) {
           const now = Date.now();
           let cleanedCount = 0;
-          for (const [key, entry] of whoisResultCache.entries()) {
-            if (now - entry.timestamp > WHOIS_CACHE_TTL) {
-              whoisResultCache.delete(key);
+          for (const [key, entry] of globalWhoisResultCache.entries()) {
+            if (now - entry.timestamp > GLOBAL_WHOIS_CACHE_TTL) {
+              globalWhoisResultCache.delete(key);
               cleanedCount++;
             }
           }
           if (forceDebug && cleanedCount > 0) {
-            logToConsoleAndFile(`${messageColors.highlight('[whois-cache]')} Cleaned ${cleanedCount} expired entries, cache size: ${whoisResultCache.size}`);
+            logToConsoleAndFile(`${messageColors.highlight('[whois-cache]')} Cleaned ${cleanedCount} expired entries, cache size: ${globalWhoisResultCache.size}`);
           }
         }
       }
@@ -1216,16 +1228,16 @@ function createNetToolsHandler(config) {
           const now = Date.now();
           let digResult = null;
           
-          if (digResultCache.has(digCacheKey)) {
-            const cachedEntry = digResultCache.get(digCacheKey);
-            if (now - cachedEntry.timestamp < DIG_CACHE_TTL) {
+          if (globalDigResultCache.has(digCacheKey)) {
+            const cachedEntry = globalDigResultCache.get(digCacheKey);
+            if (now - cachedEntry.timestamp < GLOBAL_DIG_CACHE_TTL) {
               if (forceDebug) {
                 logToConsoleAndFile(`${messageColors.highlight('[dig-cache]')} Using cached result for ${digDomain} (${digRecordType}) [age: ${Math.round((now - cachedEntry.timestamp) / 1000)}s]`);
               }
               digResult = cachedEntry.result;
             } else {
               // Cache expired, remove it
-              digResultCache.delete(digCacheKey);
+              globalDigResultCache.delete(digCacheKey);
             }
           }
           
@@ -1233,7 +1245,7 @@ function createNetToolsHandler(config) {
           digResult = await digLookup(digDomain, digRecordType, 5000); // 5 second timeout for dig
             
             // Cache the result for future use
-            digResultCache.set(digCacheKey, {
+            globalDigResultCache.set(digCacheKey, {
               result: digResult,
               timestamp: now
             });
@@ -1303,17 +1315,17 @@ function createNetToolsHandler(config) {
         }
         
         // Periodic dig cache cleanup to prevent memory leaks
-        if (digResultCache.size > DIG_MAX_CACHE_SIZE) {
+        if (globalDigResultCache.size > GLOBAL_DIG_CACHE_MAX) {
           const now = Date.now();
           let cleanedCount = 0;
-          for (const [key, entry] of digResultCache.entries()) {
-            if (now - entry.timestamp > DIG_CACHE_TTL) {
-              digResultCache.delete(key);
+          for (const [key, entry] of globalDigResultCache.entries()) {
+            if (now - entry.timestamp > GLOBAL_DIG_CACHE_TTL) {
+              globalDigResultCache.delete(key);
               cleanedCount++;
             }
           }
           if (forceDebug && cleanedCount > 0) {
-            logToConsoleAndFile(`${messageColors.highlight('[dig-cache]')} Cleaned ${cleanedCount} expired entries, cache size: ${digResultCache.size}`);
+            logToConsoleAndFile(`${messageColors.highlight('[dig-cache]')} Cleaned ${cleanedCount} expired entries, cache size: ${globalDigResultCache.size}`);
           }
         }
       }
@@ -1387,12 +1399,7 @@ function createNetToolsHandler(config) {
           
           // Add whois server info to log if custom server was used
           const serverInfo = whoisServer ? ` (whois-server: ${selectWhoisServer(whoisServer)})` : '';
-          const logLine = `${timestamp} [match][${simplifiedUrl}] ${domain} (${matchType.join(' + ')})${serverInfo}\n`;
-          if (bufferedLogWrite) {
-            bufferedLogWrite(matchedUrlsLogFile, logLine);
-          } else {
-            fs.appendFileSync(matchedUrlsLogFile, logLine);
-          }
+          fs.appendFileSync(matchedUrlsLogFile, `${timestamp} [match][${simplifiedUrl}] ${domain} (${matchType.join(' + ')})${serverInfo}\n`);
         }
       }
       

package/nwss.js

@@ -1447,7 +1447,7 @@ function setupFrameHandling(page, forceDebug) {
         '--disable-features=SafeBrowsing',
         '--disable-dev-shm-usage',
         '--disable-sync',
-        '--use-gl=swiftshader',  // Software WebGL — prevents ad script crashes in headless
+        '--disable-gpu',  // WebGL null-context handled by fingerprint.js Proxy mock
         '--mute-audio',
         '--disable-translate',
         '--window-size=1920,1080',
@@ -2730,9 +2730,7 @@ function setupFrameHandling(page, forceDebug) {
                 whoisDelay: siteConfig.whois_delay !== undefined ? siteConfig.whois_delay : whois_delay,
                 whoisServer,
                 whoisServerMode: siteConfig.whois_server_mode || whois_server_mode,
-                bufferedLogWrite,
                 debugLogFile,
-                fs,
                 digTerms,
                 digOrTerms,
                 digRecordType,
@@ -2838,9 +2836,7 @@ function setupFrameHandling(page, forceDebug) {
                whoisDelay: siteConfig.whois_delay !== undefined ? siteConfig.whois_delay : whois_delay, // Site-specific or global fallback
 	       whoisServer, // Pass whois server configuration
                whoisServerMode: siteConfig.whois_server_mode || whois_server_mode,
-               bufferedLogWrite,
-               debugLogFile, // Pass debug log file for whois error logging
-               fs, // Pass fs module for file operations
+               debugLogFile,
                digTerms,
                digOrTerms,
                digRecordType,

package/package.json

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