engagelab-captcha-sdk 1.0.0

package/src/deep_probes.ts

@@ -0,0 +1,690 @@
+/**
+ * Deep environment probes — counter Camoufox/Nodriver/Stealth attacks.
+ * These tests exploit behavioral and timing differences that are extremely
+ * difficult to fake even with C++-level browser patching.
+ */
+
+import { sdkLogger } from './logger';
+
+export interface DeepProbeResult {
+  name: string;
+  detected: boolean;
+  value: string;
+  weight: number;
+  confidence: number; // 0-1, how confident we are this is a true signal
+}
+
+export async function runDeepProbes(): Promise<DeepProbeResult[]> {
+  sdkLogger.debug('DeepProbes', 'runDeepProbes start');
+  const results: DeepProbeResult[] = [];
+
+  const push = (r: DeepProbeResult) => {
+    results.push(r);
+    sdkLogger.debug('DeepProbes', `probe ${r.name}`, { detected: r.detected, weight: r.weight });
+  };
+
+  push(probePropertyDescriptors());
+  push(probeErrorStackDepth());
+  push(probeCanvasConsistency());
+  push(probeWebGLParamDepth());
+  push(probeIntlConsistency());
+  push(probeTimerCoherence());
+  push(probeFontRendering());
+  push(probeObjectStringify());
+  push(probeWorkerScope());
+  push(probeSharedArrayBuffer());
+  push(probeAudioContextFingerprint());
+  push(probeEventTrustChain());
+  push(probeNavigatorInconsistency());
+  push(await probeNetworkTiming());
+
+  push(probeFingerprintBrowser());
+  push(probeMultiLoginBrowserArtifacts());
+
+  const detectedCount = results.filter(p => p.detected).length;
+  sdkLogger.info('DeepProbes', `Completed ${results.length} probes, ${detectedCount} detected`);
+
+  return results;
+}
+
+/**
+ * Check if native property descriptors have been tampered.
+ * Camoufox/Stealth modify getters but rarely fix the descriptor metadata.
+ */
+function probePropertyDescriptors(): DeepProbeResult {
+  let tampered = 0;
+  const checks = [
+    { obj: navigator, prop: 'webdriver' },
+    { obj: navigator, prop: 'languages' },
+    { obj: navigator, prop: 'plugins' },
+    { obj: navigator, prop: 'hardwareConcurrency' },
+    { obj: screen, prop: 'width' },
+    { obj: screen, prop: 'height' },
+  ];
+
+  for (const { obj, prop } of checks) {
+    try {
+      const desc = Object.getOwnPropertyDescriptor(obj, prop);
+      // Native properties should NOT have own descriptors on the instance
+      // They should be on the prototype. If found on instance = patched
+      if (desc && desc.get && !Function.prototype.toString.call(desc.get).includes('[native code]')) {
+        tampered++;
+      }
+      // Also check: own property on instance instead of prototype
+      if (desc && Object.prototype.hasOwnProperty.call(obj, prop)) {
+        const protoDesc = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(obj), prop);
+        if (protoDesc && protoDesc.get) {
+          // Property exists on both instance AND prototype = suspicious override
+          tampered++;
+        }
+      }
+    } catch { /* skip */ }
+  }
+
+  return {
+    name: 'property_descriptor_tampering',
+    detected: tampered > 1,
+    value: String(tampered),
+    weight: tampered > 2 ? 15 : tampered > 0 ? 8 : 0,
+    confidence: Math.min(1, tampered / 3),
+  };
+}
+
+/**
+ * Analyze Error stack trace depth and format.
+ * Automated browsers often have different stack patterns.
+ */
+function probeErrorStackDepth(): DeepProbeResult {
+  let anomalies = 0;
+  try {
+    const e = new Error('probe');
+    const stack = e.stack || '';
+    const lines = stack.split('\n').filter(l => l.trim().length > 0);
+
+    // Check for automation-framework frames in stack
+    const suspiciousFrames = ['puppeteer', 'playwright', 'selenium', 'webdriver', 'cdp', 'devtools', '__puppeteer'];
+    for (const frame of lines) {
+      const lower = frame.toLowerCase();
+      for (const sus of suspiciousFrames) {
+        if (lower.includes(sus)) anomalies++;
+      }
+    }
+
+    // Very shallow stack in non-minimal context = suspicious
+    if (lines.length < 2) anomalies++;
+
+    // Check Error.captureStackTrace behavior (Chrome-specific)
+    if (typeof Error.captureStackTrace === 'function') {
+      const obj: Record<string, unknown> = {};
+      Error.captureStackTrace(obj);
+      const st = typeof obj.stack === 'string' ? obj.stack : '';
+      if (!st || st.length < 10) anomalies++;
+    }
+  } catch {
+    anomalies++;
+  }
+
+  return {
+    name: 'error_stack_anomaly',
+    detected: anomalies > 0,
+    value: String(anomalies),
+    weight: anomalies > 1 ? 10 : anomalies > 0 ? 5 : 0,
+    confidence: Math.min(1, anomalies / 2),
+  };
+}
+
+/**
+ * Canvas rendering consistency check.
+ * Draw the same thing twice with slight timing — result should be identical.
+ * Randomized fingerprint spoofing will produce different results.
+ */
+function probeCanvasConsistency(): DeepProbeResult {
+  try {
+    const draw = () => {
+      const c = document.createElement('canvas');
+      c.width = 100; c.height = 30;
+      const ctx = c.getContext('2d')!;
+      ctx.textBaseline = 'alphabetic';
+      ctx.fillStyle = '#f60';
+      ctx.fillRect(10, 1, 62, 20);
+      ctx.fillStyle = '#069';
+      ctx.font = '11px Arial';
+      ctx.fillText('Cwm fjordbank', 2, 15);
+      ctx.fillStyle = 'rgba(102,204,0,0.7)';
+      ctx.font = '18px Arial';
+      ctx.fillText('glyphs vext', 4, 25);
+      return c.toDataURL();
+    };
+
+    const hash1 = draw();
+    const hash2 = draw();
+    const consistent = hash1 === hash2;
+
+    // Inconsistency = fingerprint randomization (Camoufox does this)
+    return {
+      name: 'canvas_consistency',
+      detected: !consistent,
+      value: consistent ? 'consistent' : 'randomized',
+      weight: !consistent ? 20 : 0,
+      confidence: !consistent ? 0.9 : 0,
+    };
+  } catch {
+    return { name: 'canvas_consistency', detected: false, value: 'error', weight: 0, confidence: 0 };
+  }
+}
+
+/**
+ * Deep WebGL parameter check.
+ * Query many obscure WebGL parameters; spoofed renderers often miss some.
+ */
+function probeWebGLParamDepth(): DeepProbeResult {
+  try {
+    const canvas = document.createElement('canvas');
+    const gl = canvas.getContext('webgl') || canvas.getContext('experimental-webgl');
+    if (!gl) return { name: 'webgl_param_depth', detected: false, value: 'no_webgl', weight: 0, confidence: 0 };
+
+    const g = gl as WebGLRenderingContext;
+    let inconsistencies = 0;
+
+    const ext = g.getExtension('WEBGL_debug_renderer_info');
+    const renderer = ext ? String(g.getParameter(ext.UNMASKED_RENDERER_WEBGL) ?? '') : '';
+    const vendor = ext ? String(g.getParameter(ext.UNMASKED_VENDOR_WEBGL) ?? '') : '';
+
+    // Check max values consistency with renderer
+    const maxTextureSize = g.getParameter(g.MAX_TEXTURE_SIZE) as number;
+
+    // Software renderers have specific limits
+    if (renderer.includes('SwiftShader') || renderer.includes('llvmpipe')) {
+      // Already caught by headless detection
+    } else if (renderer.includes('ANGLE')) {
+      // ANGLE on real GPU: maxTextureSize is usually 16384+
+      if (maxTextureSize < 4096) inconsistencies++;
+    }
+
+    // Check: if vendor is "Google Inc." but not ANGLE = suspicious
+    if (vendor === 'Google Inc.' && !renderer.includes('ANGLE') && !renderer.includes('SwiftShader')) {
+      inconsistencies++;
+    }
+
+    // Check aliased line width range (often not spoofed)
+    const aliasedLineRange = g.getParameter(g.ALIASED_LINE_WIDTH_RANGE) as Float32Array | null;
+    if (aliasedLineRange && aliasedLineRange[0] === aliasedLineRange[1]) {
+      inconsistencies++;
+    }
+
+    return {
+      name: 'webgl_param_depth',
+      detected: inconsistencies > 0,
+      value: `renderer=${renderer.substring(0, 30)},issues=${inconsistencies}`,
+      weight: inconsistencies > 1 ? 12 : inconsistencies > 0 ? 5 : 0,
+      confidence: Math.min(1, inconsistencies / 2),
+    };
+  } catch {
+    return { name: 'webgl_param_depth', detected: false, value: 'error', weight: 0, confidence: 0 };
+  }
+}
+
+/**
+ * Intl API consistency check.
+ * Timezone, locale, and Intl formatting should all be consistent.
+ * Fingerprint spoofers often miss Intl.
+ */
+function probeIntlConsistency(): DeepProbeResult {
+  let inconsistencies = 0;
+  try {
+    const tz = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    const locale = Intl.DateTimeFormat().resolvedOptions().locale;
+    const tzOffset = new Date().getTimezoneOffset();
+
+    // Check: navigator.language vs Intl locale
+    const navLang = navigator.language;
+    if (navLang && locale && navLang.split('-')[0] !== locale.split('-')[0]) {
+      // Language mismatch between navigator and Intl
+      inconsistencies++;
+    }
+
+    // Check: timezone offset should be plausible for the Intl timezone
+    // This is hard to fake consistently
+    if (tz && tzOffset !== undefined) {
+      const d = new Date();
+      const fmt = new Intl.DateTimeFormat('en-US', { timeZone: tz, hour: 'numeric', hour12: false });
+      // If this throws, tz is invalid
+      try { fmt.format(d); } catch { inconsistencies++; }
+    }
+
+    // Check NumberFormat consistency
+    const nf = new Intl.NumberFormat(navLang);
+    nf.format(1234.5);
+    // formatted should use the grouping/decimal separators of navLang
+    // If navigator.language was spoofed but Intl wasn't, this may reveal inconsistency
+  } catch {
+    inconsistencies++;
+  }
+
+  return {
+    name: 'intl_consistency',
+    detected: inconsistencies > 0,
+    value: String(inconsistencies),
+    weight: inconsistencies > 0 ? 8 : 0,
+    confidence: Math.min(1, inconsistencies / 2),
+  };
+}
+
+/**
+ * Timer coherence test.
+ * Compare performance.now() vs Date.now() drift.
+ * Automated environments sometimes have desynchronized timers.
+ */
+function probeTimerCoherence(): DeepProbeResult {
+  const perfStart = performance.now();
+  const dateStart = Date.now();
+
+  // Busy wait ~5ms
+  while (performance.now() - perfStart < 5) { /* spin */ }
+
+  const perfElapsed = performance.now() - perfStart;
+  const dateElapsed = Date.now() - dateStart;
+
+  const drift = Math.abs(perfElapsed - dateElapsed);
+  // Normally these should agree within ~2ms
+  // Virtualized or hooked timers may show larger drift
+  const detected = drift > 10;
+
+  return {
+    name: 'timer_coherence',
+    detected,
+    value: `perf=${perfElapsed.toFixed(2)},date=${dateElapsed},drift=${drift.toFixed(2)}`,
+    weight: detected ? 8 : 0,
+    confidence: detected ? 0.6 : 0,
+  };
+}
+
+/**
+ * Font rendering measurement.
+ * Measure specific text rendering dimensions; spoofed font lists create inconsistencies.
+ */
+function probeFontRendering(): DeepProbeResult {
+  try {
+    const testFonts = ['monospace', 'serif', 'sans-serif'];
+    const span = document.createElement('span');
+    span.style.position = 'absolute';
+    span.style.left = '-9999px';
+    span.style.fontSize = '72px';
+    span.textContent = 'mmmmmmmmmmlli';
+    document.body.appendChild(span);
+
+    const widths: number[] = [];
+    for (const font of testFonts) {
+      span.style.fontFamily = font;
+      widths.push(span.offsetWidth);
+    }
+    document.body.removeChild(span);
+
+    // All three should produce different widths on real systems
+    const allSame = widths[0] === widths[1] && widths[1] === widths[2];
+    const detected = allSame && widths[0] > 0;
+
+    return {
+      name: 'font_rendering',
+      detected,
+      value: widths.join(','),
+      weight: detected ? 10 : 0,
+      confidence: detected ? 0.7 : 0,
+    };
+  } catch {
+    return { name: 'font_rendering', detected: false, value: 'error', weight: 0, confidence: 0 };
+  }
+}
+
+/**
+ * Check if toString() on native objects has been overridden.
+ * Stealth plugins often override toString to hide modifications.
+ */
+function probeObjectStringify(): DeepProbeResult {
+  let tampered = 0;
+  try {
+    // Check if Function.prototype.toString itself was modified
+    const toStringStr = Function.prototype.toString.toString();
+    if (!toStringStr.includes('[native code]')) tampered += 2;
+
+    // Check Object.getOwnPropertyDescriptor hasn't been wrapped
+    const gopdStr = Object.getOwnPropertyDescriptor.toString();
+    if (!gopdStr.includes('[native code]')) tampered++;
+
+    // Check Proxy detection: new Proxy wrapping often leaks
+    const test = { a: 1 };
+    const keys = Object.keys(test);
+    if (keys.length !== 1) tampered++;
+  } catch {
+    tampered++;
+  }
+
+  return {
+    name: 'object_stringify_tampering',
+    detected: tampered > 0,
+    value: String(tampered),
+    weight: tampered >= 2 ? 15 : tampered > 0 ? 8 : 0,
+    confidence: Math.min(1, tampered / 2),
+  };
+}
+
+/**
+ * Check Worker scope availability.
+ * Some automation tools have inconsistent Worker support.
+ */
+function probeWorkerScope(): DeepProbeResult {
+  try {
+    const hasServiceWorker = 'serviceWorker' in navigator;
+    const ua = navigator.userAgent.toLowerCase();
+
+    // Chrome should have all three
+    if (ua.includes('chrome') && !ua.includes('edge')) {
+      if (!hasServiceWorker) return { name: 'worker_scope', detected: true, value: 'no_sw', weight: 10, confidence: 0.7 };
+    }
+
+    return { name: 'worker_scope', detected: false, value: 'ok', weight: 0, confidence: 0 };
+  } catch {
+    return { name: 'worker_scope', detected: false, value: 'error', weight: 0, confidence: 0 };
+  }
+}
+
+/**
+ * SharedArrayBuffer availability check.
+ * Requires COOP/COEP headers; automated environments often don't have this.
+ */
+function probeSharedArrayBuffer(): DeepProbeResult {
+  const hasSAB = typeof SharedArrayBuffer !== 'undefined';
+  // Not having SAB is common and not suspicious by itself
+  // But having it when COOP headers aren't set IS suspicious
+  return { name: 'shared_array_buffer', detected: false, value: String(hasSAB), weight: 0, confidence: 0 };
+}
+
+/**
+ * AudioContext fingerprint timing.
+ * Real audio processing takes measurable time; mocked contexts return instantly.
+ */
+function probeAudioContextFingerprint(): DeepProbeResult {
+  try {
+    const w = window as typeof window & { webkitAudioContext?: typeof AudioContext };
+    const AudioCtx = w.AudioContext || w.webkitAudioContext;
+    if (!AudioCtx) return { name: 'audio_context', detected: false, value: 'unsupported', weight: 0, confidence: 0 };
+
+    const ctx = new AudioCtx();
+    const oscillator = ctx.createOscillator();
+    const analyser = ctx.createAnalyser();
+    const gain = ctx.createGain();
+
+    oscillator.type = 'triangle';
+    oscillator.connect(analyser);
+    analyser.connect(gain);
+    gain.connect(ctx.destination);
+
+    gain.gain.value = 0; // mute
+    oscillator.start(0);
+    oscillator.stop(ctx.currentTime + 0.01);
+
+    const data = new Float32Array(analyser.fftSize);
+    analyser.getFloatTimeDomainData(data);
+
+    ctx.close();
+
+    // All zeros = mocked audio
+    const allZero = data.every(v => v === 0);
+    return {
+      name: 'audio_context',
+      detected: allZero,
+      value: allZero ? 'mocked' : 'real',
+      weight: allZero ? 8 : 0,
+      confidence: allZero ? 0.6 : 0,
+    };
+  } catch {
+    return { name: 'audio_context', detected: false, value: 'error', weight: 0, confidence: 0 };
+  }
+}
+
+/**
+ * Event trust chain verification.
+ * Dispatch a custom event and verify isTrusted behavior.
+ */
+function probeEventTrustChain(): DeepProbeResult {
+  let tampered = false;
+  try {
+    const div = document.createElement('div');
+    let receivedTrusted: boolean | null = null;
+
+    div.addEventListener('click', (e: MouseEvent) => {
+      receivedTrusted = e.isTrusted;
+    });
+
+    // Programmatically dispatched events should have isTrusted=false
+    div.dispatchEvent(new MouseEvent('click'));
+
+    // If isTrusted is true for programmatic event = hook detected
+    if (receivedTrusted === true) {
+      tampered = true;
+    }
+  } catch {
+    // Ignore
+  }
+
+  return {
+    name: 'event_trust_chain',
+    detected: tampered,
+    value: String(tampered),
+    weight: tampered ? 20 : 0,
+    confidence: tampered ? 0.95 : 0,
+  };
+}
+
+/**
+ * Navigator property enumeration inconsistency.
+ * Count enumerable properties; automated browsers often have extra or missing ones.
+ */
+function probeNavigatorInconsistency(): DeepProbeResult {
+  let score = 0;
+  try {
+    // Check for extra properties injected by automation
+    const navKeys = Object.keys(navigator);
+    const suspiciousKeys = ['__driver', '__webdriver', '__selenium', '__nightmare', 'domAutomation', 'domAutomationController'];
+    for (const k of navKeys) {
+      if (suspiciousKeys.some(s => k.toLowerCase().includes(s))) score += 2;
+    }
+
+    // In normal Chrome, navigator shouldn't have many own enumerable properties
+    if (navKeys.length > 5) score++;
+
+    // Check if navigator.permissions.query exists and works correctly
+    if (!navigator.permissions) score++;
+  } catch {
+    score++;
+  }
+
+  return {
+    name: 'navigator_inconsistency',
+    detected: score > 1,
+    value: String(score),
+    weight: score > 2 ? 12 : score > 0 ? 5 : 0,
+    confidence: Math.min(1, score / 3),
+  };
+}
+
+/**
+ * Detect fingerprint browsers (AdsPower, HubStudio, Multilogin, GoLogin, etc.)
+ * These tools create isolated browser profiles with spoofed fingerprints.
+ * They leave detectable artifacts in window/navigator/DOM.
+ */
+function probeFingerprintBrowser(): DeepProbeResult {
+  let score = 0;
+  const artifacts: string[] = [];
+
+  try {
+    const w = window as any;
+    const n = navigator as any;
+
+    // AdsPower specific artifacts
+    if (w.__adspower || w.ADS_POWER || w._adspower_state) { score += 3; artifacts.push('adspower_global'); }
+    if (n.adspower || n.__adspower_id) { score += 3; artifacts.push('adspower_nav'); }
+
+    // HubStudio / Hubstudio artifacts
+    if (w.__hubstudio || w.HubStudio || w._hubstudio) { score += 3; artifacts.push('hubstudio_global'); }
+
+    // Multilogin artifacts
+    if (w.__multilogin || w.Multilogin || w._mla_data) { score += 3; artifacts.push('multilogin_global'); }
+    if (n.multiloginVersion || n.__multilogin_profile_id) { score += 3; artifacts.push('multilogin_nav'); }
+
+    // GoLogin artifacts
+    if (w.__gologin || w.GoLogin || w._gologin) { score += 3; artifacts.push('gologin_global'); }
+
+    // VMLogin artifacts
+    if (w.__vmlogin || w.VmLogin || w._vmlogin) { score += 3; artifacts.push('vmlogin_global'); }
+
+    // Generic fingerprint browser detection heuristics
+
+    // Check for profile-id or session-id cookies that fingerprint browsers often inject
+    const cookies = document.cookie;
+    const fpBrowserCookies = ['_adspower_', '_multilogin_', '_gologin_', '_vmlogin_', '_hubstudio_'];
+    for (const prefix of fpBrowserCookies) {
+      if (cookies.includes(prefix)) { score += 2; artifacts.push(`cookie_${prefix}`); }
+    }
+
+    // Many fingerprint browsers inject custom extensions with predictable IDs
+    if ('chrome' in window && (window as any).chrome?.runtime) {
+      const knownExtIds = [
+        'fhbjgbiflinjbdggehcddcbncdddomop', // AdsPower
+        'nkbihfbeogaeaoehlefnkodbefgpgknn', // Some multilogin
+      ];
+      for (const id of knownExtIds) {
+        try {
+          const img = new Image();
+          img.src = `chrome-extension://${id}/icon.png`;
+          // Can't fully check, but attempt is recorded
+        } catch { /* expected */ }
+      }
+    }
+
+    // Detect Chromium kernel modifications:
+    // Fingerprint browsers modify Chrome version string inconsistently
+    const ua = navigator.userAgent;
+    const chromeMatch = ua.match(/Chrome\/(\d+)/);
+    if (chromeMatch) {
+      const majorVersion = parseInt(chromeMatch[1]);
+      // Check if claimed Chrome version is consistent with feature support
+      if (majorVersion > 100 && !('cookieStore' in window)) {
+        score += 1; // Mild signal: cookie Store API missing in claimed modern Chrome
+      }
+      if (majorVersion > 90 && typeof (navigator as any).userAgentData === 'undefined') {
+        score += 1; // Modern Chrome should have userAgentData
+        artifacts.push('missing_ua_data');
+      }
+    }
+
+    // Timezone spoofing detection via Performance API timing
+    const perfTiming = performance.timing;
+    if (perfTiming && perfTiming.navigationStart > 0) {
+      const now = Date.now();
+      const drift = Math.abs(now - perfTiming.navigationStart - performance.now());
+      if (drift > 100) {
+        score += 1;
+        artifacts.push('timing_drift');
+      }
+    }
+
+  } catch { /* ignore detection errors */ }
+
+  return {
+    name: 'fingerprint_browser',
+    detected: score >= 3,
+    value: artifacts.length > 0 ? artifacts.join(',') : 'none',
+    weight: score >= 6 ? 25 : score >= 3 ? 15 : 0,
+    confidence: Math.min(1, score / 6),
+  };
+}
+
+/**
+ * Detect multi-login browser profile artifacts via DOM/API inconsistencies.
+ * Fingerprint browsers create profiles that reuse the same underlying Chromium
+ * but spoof device parameters — resulting in subtle inconsistencies.
+ */
+function probeMultiLoginBrowserArtifacts(): DeepProbeResult {
+  let inconsistencies = 0;
+
+  try {
+    // Check: deviceMemory + hardwareConcurrency vs WebGL renderer
+    const mem = (navigator as any).deviceMemory;
+    const cores = navigator.hardwareConcurrency;
+
+    const canvas = document.createElement('canvas');
+    const gl = canvas.getContext('webgl');
+    if (gl) {
+      const ext = gl.getExtension('WEBGL_debug_renderer_info');
+      const renderer = ext ? String(gl.getParameter(ext.UNMASKED_RENDERER_WEBGL) ?? '') : '';
+
+      // Low-end spoofed: claims 2GB RAM but has high-end GPU name
+      if (mem && mem <= 2 && renderer.match(/RTX|RX 6|RX 7|Arc A/i)) {
+        inconsistencies++;
+      }
+      // Claims many cores but software renderer
+      if (cores && cores >= 8 && renderer.match(/SwiftShader|llvmpipe|Software/i)) {
+        inconsistencies++;
+      }
+    }
+
+    // Check: screen resolution vs device pixel ratio mismatch
+    const screenW = screen.width;
+    const screenH = screen.height;
+    const dpr = window.devicePixelRatio;
+    // Common spoofed combo: mobile resolution with desktop DPR
+    if (screenW <= 414 && screenH <= 896 && dpr === 1 && !('ontouchstart' in window)) {
+      inconsistencies++;
+    }
+
+    // Check: platform vs userAgent consistency
+    const platform = navigator.platform;
+    const ua = navigator.userAgent;
+    if (platform === 'Win32' && ua.includes('Macintosh')) inconsistencies += 2;
+    if (platform === 'MacIntel' && ua.includes('Windows')) inconsistencies += 2;
+    if (platform === 'Linux x86_64' && ua.includes('Windows NT')) inconsistencies++;
+
+    // Check: language list consistency with timezone
+    const lang = navigator.language;
+    const tz = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    // Chinese language with US timezone or vice versa (mild signal)
+    if (lang.startsWith('zh') && tz.startsWith('America/')) inconsistencies++;
+    if (lang.startsWith('en-US') && tz.startsWith('Asia/Shanghai')) inconsistencies++;
+
+  } catch { /* ignore */ }
+
+  return {
+    name: 'multilogin_artifacts',
+    detected: inconsistencies >= 2,
+    value: String(inconsistencies),
+    weight: inconsistencies >= 3 ? 18 : inconsistencies >= 2 ? 10 : 0,
+    confidence: Math.min(1, inconsistencies / 4),
+  };
+}
+
+/**
+ * Network request timing test.
+ * Measure time to fetch a tiny resource; automated environments in VMs
+ * sometimes have different network characteristics.
+ */
+async function probeNetworkTiming(): Promise<DeepProbeResult> {
+  try {
+    const start = performance.now();
+    // Fetch the same page/a small known resource
+    await fetch(window.location.href, { method: 'HEAD', cache: 'no-store' }).catch(() => {});
+    const elapsed = performance.now() - start;
+
+    // Very fast response (< 1ms) = mocked fetch
+    const detected = elapsed < 0.5;
+    return {
+      name: 'network_timing',
+      detected,
+      value: `${elapsed.toFixed(2)}ms`,
+      weight: detected ? 10 : 0,
+      confidence: detected ? 0.7 : 0,
+    };
+  } catch {
+    return { name: 'network_timing', detected: false, value: 'error', weight: 0, confidence: 0 };
+  }
+}