@webdecoy/fcaptcha 1.0.4 → 1.12.0

package/detection.js

@@ -107,6 +107,69 @@ const EXPECTED_BROWSER_HEADERS = new Set([
   'accept', 'accept-language', 'accept-encoding', 'user-agent'
 ]);
 
+// Self-identifying AI agents and crawlers. These agents are honest about who they
+// are, so matching is high-confidence but intentionally LOW-severity: operators
+// decide via policy whether to allow polite agents rather than hard-blocking.
+// Keep in sync with server-go and server-python.
+const DECLARED_AI_AGENT_PATTERNS = [
+  /\bClaudeBot\b/i,
+  /\bClaude-User\b/i,
+  /\bClaude-SearchBot\b/i,
+  /\banthropic-ai\b/i,
+  /\bGPTBot\b/i,
+  /\bChatGPT-User\b/i,
+  /\bOAI-SearchBot\b/i,
+  /\bPerplexityBot\b/i,
+  /\bPerplexity-User\b/i,
+  /\bGoogle-Extended\b/i,
+  /\bCCBot\b/i,
+  /\bBytespider\b/i,
+  /\bmeta-externalagent\b/i,
+  /\bAmazonbot\b/i,
+  /\bcohere-ai\b/i,
+  /\bDiffbot\b/i,
+  /\bYouBot\b/i
+];
+
+// checkDeclaredAIAgent flags self-identifying AI agents via the User-Agent and
+// detects Web Bot Auth signed requests (RFC 9421 HTTP Message Signatures). Both
+// are high-confidence identifications surfaced as the declared_ai category so
+// callers can apply an allow/block policy instead of relying on a hard score.
+function checkDeclaredAIAgent(userAgent, headers = {}) {
+  const detections = [];
+  const ua = userAgent || '';
+
+  for (const re of DECLARED_AI_AGENT_PATTERNS) {
+    const match = ua.match(re);
+    if (match) {
+      detections.push({
+        category: 'declared_ai',
+        score: 0.5,
+        confidence: 0.99,
+        reason: `Declared AI agent user-agent: ${match[0]}`,
+        details: { matched: match[0] }
+      });
+      break;
+    }
+  }
+
+  // Web Bot Auth: presence of HTTP Message Signature headers identifies a
+  // (claimed) verified agent. v1 detects/identifies only; signature verification
+  // against the agent's published JWKS is a follow-up before trusting it.
+  const h = headers || {};
+  if (h['signature'] && h['signature-input'] && h['signature-agent']) {
+    detections.push({
+      category: 'declared_ai',
+      score: 0.4,
+      confidence: 0.95,
+      reason: `Signed agent request (Web Bot Auth): ${h['signature-agent']}`,
+      details: { signatureAgent: h['signature-agent'], verified: false }
+    });
+  }
+
+  return detections;
+}
+
 function analyzeHeaders(headers) {
   const detections = [];
   const headersLower = {};
@@ -311,6 +374,296 @@ function checkJA3Fingerprint(ja3Hash) {
   return [];
 }
 
+// =============================================================================
+// TLS Fingerprinting (JA4) — read from trusted reverse-proxy headers
+// =============================================================================
+//
+// Unlike the client-supplied X-JA3-Hash (which attackers can spoof), JA4
+// fingerprints are computed from the TLS ClientHello by the reverse proxy
+// and passed via a trusted header the server is configured to accept.
+// Configure with: TRUSTED_JA4_HEADERS=cf-ja4,x-tls-ja4 (comma-separated).
+
+const KNOWN_BOT_JA4_HASHES = {
+  // Populate with observed automation fingerprints in production.
+  // JA4 format: t##d####_####..._####
+  // Placeholders — administrators should add real fingerprints as they
+  // are collected from deployed environments.
+  // Example once identified:
+  //   't13d1516h2_8daaf6152771_02713d6af862': 'Go default stdlib TLS'
+};
+
+function getTrustedJA4HeaderNames() {
+  const env = process.env.TRUSTED_JA4_HEADERS;
+  if (!env) return [];
+  return env.split(',').map(h => h.trim().toLowerCase()).filter(Boolean);
+}
+
+function readJA4FromHeaders(headers, trustedHeaderNames) {
+  if (!trustedHeaderNames || trustedHeaderNames.length === 0) return null;
+  for (const name of trustedHeaderNames) {
+    const v = headers[name];
+    if (v && typeof v === 'string' && v.trim()) return v.trim();
+  }
+  return null;
+}
+
+function checkJA4Fingerprint(ja4) {
+  if (!ja4) return [];
+  const match = KNOWN_BOT_JA4_HASHES[ja4];
+  if (match) {
+    return [{
+      category: 'fingerprint',
+      score: 0.8,
+      confidence: 0.9,
+      reason: `TLS JA4 fingerprint matches: ${match}`
+    }];
+  }
+  return [];
+}
+
+// =============================================================================
+// Statistical Utility Functions (Keystroke Cadence Analysis)
+// =============================================================================
+
+function mean(arr) {
+  if (arr.length === 0) return 0;
+  return arr.reduce((a, b) => a + b, 0) / arr.length;
+}
+
+function stddev(arr) {
+  if (arr.length < 2) return 0;
+  const m = mean(arr);
+  const variance = arr.reduce((acc, v) => acc + (v - m) * (v - m), 0) / arr.length;
+  return Math.sqrt(variance);
+}
+
+function erf(x) {
+  // Abramowitz & Stegun approximation (max error ~1.5e-7)
+  const sign = x >= 0 ? 1 : -1;
+  x = Math.abs(x);
+  const t = 1.0 / (1.0 + 0.3275911 * x);
+  const y = 1.0 - (((((1.061405429 * t - 1.453152027) * t) + 1.421413741) * t - 0.284496736) * t + 0.254829592) * t * Math.exp(-x * x);
+  return sign * y;
+}
+
+function normalCDF(x, mu, sigma) {
+  if (sigma <= 0) return x >= mu ? 1.0 : 0.0;
+  return 0.5 * (1.0 + erf((x - mu) / (sigma * Math.SQRT2)));
+}
+
+function ksTestStatistic(samples, cdfFn) {
+  const n = samples.length;
+  if (n === 0) return 0;
+  const sorted = [...samples].sort((a, b) => a - b);
+  let maxD = 0;
+  for (let i = 0; i < n; i++) {
+    const empirical = (i + 1) / n;
+    const theoretical = cdfFn(sorted[i]);
+    const d1 = Math.abs(empirical - theoretical);
+    const d2 = Math.abs((i / n) - theoretical);
+    maxD = Math.max(maxD, d1, d2);
+  }
+  return maxD;
+}
+
+function shannonEntropy(arr, bins) {
+  if (arr.length === 0) return 0;
+  const min = Math.min(...arr);
+  const max = Math.max(...arr);
+  if (max === min) return 0;
+  const binWidth = (max - min) / bins;
+  const counts = new Array(bins).fill(0);
+  for (const v of arr) {
+    let idx = Math.floor((v - min) / binWidth);
+    if (idx >= bins) idx = bins - 1;
+    counts[idx]++;
+  }
+  const n = arr.length;
+  let entropy = 0;
+  for (const c of counts) {
+    if (c > 0) {
+      const p = c / n;
+      entropy -= p * Math.log2(p);
+    }
+  }
+  return entropy;
+}
+
+function lag1Autocorrelation(arr) {
+  if (arr.length < 3) return 0;
+  const n = arr.length - 1;
+  const x = arr.slice(0, n);
+  const y = arr.slice(1);
+  const mx = mean(x);
+  const my = mean(y);
+  let num = 0, dx2 = 0, dy2 = 0;
+  for (let i = 0; i < n; i++) {
+    const dx = x[i] - mx;
+    const dy = y[i] - my;
+    num += dx * dy;
+    dx2 += dx * dx;
+    dy2 += dy * dy;
+  }
+  const denom = Math.sqrt(dx2 * dy2);
+  if (denom === 0) return 0;
+  return num / denom;
+}
+
+// =============================================================================
+// Keystroke Cadence Analysis
+// =============================================================================
+
+function analyzeKeystrokeCadence(stats) {
+  const keyCount = stats.keyCount || 0;
+  const intervals = stats.intervals || [];
+  const dwellTimes = stats.dwellTimes || [];
+  const rollovers = stats.rollovers || 0;
+
+  // Gate on minimum data
+  if (keyCount < 20 || intervals.length < 15) return null;
+
+  const metrics = {};
+  let totalWeight = 0;
+  let weightedSum = 0;
+  let activeMetricCount = 0;
+
+  // 1. Dwell Variance (weight 0.15)
+  if (dwellTimes.length >= 10) {
+    const dSd = stddev(dwellTimes);
+    let score;
+    if (dSd < 3) score = 0;
+    else if (dSd < 10) score = 0.35 * (dSd - 3) / 7;
+    else if (dSd < 20) score = 0.35 + 0.65 * (dSd - 10) / 10;
+    else score = 1.0;
+    metrics.dwellVariance = score;
+    totalWeight += 0.15;
+    weightedSum += score * 0.15;
+    activeMetricCount++;
+  }
+
+  // 2. Log-Normal Fit (weight 0.20)
+  if (intervals.length >= 15) {
+    const logIntervals = intervals.filter(v => v > 0).map(v => Math.log(v));
+    if (logIntervals.length >= 10) {
+      const mu = mean(logIntervals);
+      const sigma = stddev(logIntervals);
+      const D = ksTestStatistic(logIntervals, (x) => normalCDF(x, mu, sigma));
+      // Critical value at α=0.10: 1.22 / sqrt(n)
+      const critical = 1.22 / Math.sqrt(logIntervals.length);
+      let score;
+      if (D <= critical * 0.8) score = 1.0;
+      else if (D <= critical) score = 0.7;
+      else if (D <= critical * 1.5) score = 0.3;
+      else score = 0;
+      metrics.logNormalFit = score;
+      totalWeight += 0.20;
+      weightedSum += score * 0.20;
+      activeMetricCount++;
+    }
+  }
+
+  // 3. Uniformity Detection (weight 0.15)
+  if (intervals.length >= 15) {
+    const minI = Math.min(...intervals);
+    const maxI = Math.max(...intervals);
+    if (maxI > minI) {
+      const D = ksTestStatistic(intervals, (x) => (x - minI) / (maxI - minI));
+      // Low D = looks uniform = bot-like
+      let score;
+      if (D < 0.05) score = 0;
+      else if (D < 0.1) score = 0.3;
+      else if (D < 0.15) score = 0.6;
+      else score = 1.0;
+      metrics.uniformity = score;
+      totalWeight += 0.15;
+      weightedSum += score * 0.15;
+      activeMetricCount++;
+    }
+  }
+
+  // 4. Lag-1 Autocorrelation (weight 0.15)
+  if (intervals.length >= 15) {
+    const r = Math.abs(lag1Autocorrelation(intervals));
+    let score;
+    if (r < 0.02) score = 0.1;
+    else if (r < 0.1) score = 0.1 + 0.4 * (r - 0.02) / 0.08;
+    else if (r < 0.2) score = 0.5 + 0.4 * (r - 0.1) / 0.1;
+    else if (r <= 0.4) score = 0.9;
+    else if (r <= 0.6) score = 0.9 - 0.4 * (r - 0.4) / 0.2;
+    else score = 0.5;
+    metrics.autocorrelation = score;
+    totalWeight += 0.15;
+    weightedSum += score * 0.15;
+    activeMetricCount++;
+  }
+
+  // 5. Burst Regularity (weight 0.10)
+  const burstGaps = [];
+  for (let i = 0; i < intervals.length; i++) {
+    if (intervals[i] > 300) burstGaps.push(intervals[i]);
+  }
+  if (burstGaps.length >= 3) {
+    const burstMean = mean(burstGaps);
+    const burstSd = stddev(burstGaps);
+    const cv = burstMean > 0 ? burstSd / burstMean : 0;
+    let score;
+    if (cv < 0.1) score = 0.1;
+    else if (cv < 0.3) score = 0.1 + 0.9 * (cv - 0.1) / 0.2;
+    else score = 1.0;
+    metrics.burstRegularity = score;
+    totalWeight += 0.10;
+    weightedSum += score * 0.10;
+    activeMetricCount++;
+  }
+
+  // 6. Shannon Entropy (weight 0.15)
+  if (intervals.length >= 15) {
+    const H = shannonEntropy(intervals, 10);
+    // Bell curve scoring: peak around H≈2.5
+    let score;
+    if (H < 0.5) score = 0.1;
+    else if (H < 1.5) score = 0.1 + 0.5 * (H - 0.5);
+    else if (H < 2.0) score = 0.6 + 0.4 * (H - 1.5) / 0.5;
+    else if (H <= 3.0) score = 1.0;
+    else if (H <= 3.3) score = 0.7;
+    else score = 0.4;
+    metrics.entropy = score;
+    totalWeight += 0.15;
+    weightedSum += score * 0.15;
+    activeMetricCount++;
+  }
+
+  // 7. Rollover Rate (weight 0.10)
+  if (keyCount >= 30) {
+    const rate = rollovers / keyCount;
+    let score;
+    if (rate === 0) score = 0.5;
+    else if (rate < 0.05) score = 0.5 + 0.3 * (rate / 0.05);
+    else if (rate < 0.15) score = 0.8 + 0.2 * ((rate - 0.05) / 0.1);
+    else score = 1.0;
+    metrics.rolloverRate = score;
+    totalWeight += 0.10;
+    weightedSum += score * 0.10;
+    activeMetricCount++;
+  }
+
+  if (totalWeight === 0) return null;
+
+  const humanScore = weightedSum / totalWeight;
+  const botScore = 1.0 - humanScore;
+
+  // Only emit detection when botScore > 0.55
+  if (botScore <= 0.55) return null;
+
+  return {
+    category: 'bot',
+    score: botScore * 0.7,
+    confidence: Math.min(0.7, activeMetricCount / 7),
+    reason: 'Keystroke cadence analysis indicates non-human typing pattern',
+    details: { metrics, cadenceHumanScore: humanScore }
+  };
+}
+
 // =============================================================================
 // Form Interaction Analysis (Credential Stuffing & Spam Detection)
 // =============================================================================
@@ -376,6 +729,18 @@ function analyzeFormInteraction(formAnalysis) {
   const textareaData = formAnalysis.textareaKeyboard;
   if (textareaData) {
     for (const [fieldId, stats] of Object.entries(textareaData)) {
+      // Programmatic fill: meaningful content appeared with zero keystrokes and
+      // zero pastes (e.g. Playwright fill() / element.value=). The length gate
+      // keeps this off browser autofill of short fields.
+      if ((stats.contentLength || 0) > 8 && (stats.keyCount || 0) === 0 && (stats.pasteCount || 0) === 0) {
+        detections.push({
+          category: 'automation',
+          score: 0.8,
+          confidence: 0.75,
+          reason: `Textarea "${fieldId}" filled programmatically (${stats.contentLength} chars, no keystrokes or paste)`
+        });
+      }
+
       // Check for paste-heavy input (spam bots often paste content)
       if (stats.pasteCount > 0 && stats.keyCount < 5) {
         detections.push({
@@ -425,18 +790,349 @@ function analyzeFormInteraction(formAnalysis) {
           reason: `Textarea "${fieldId}" has ${stats.contentLength} chars but no keyboard events (DOM manipulation)`
         });
       }
+
+      // Keystroke cadence analysis
+      const cadenceResult = analyzeKeystrokeCadence(stats);
+      if (cadenceResult) {
+        detections.push(cadenceResult);
+      }
     }
   }
 
   return detections;
 }
 
+// =============================================================================
+// Advanced Fingerprint Detection Functions
+// =============================================================================
+
+/**
+ * Analyze WebRTC signals for headless browser and VM detection
+ */
+function analyzeWebRTC(webrtcInfo) {
+  if (!webrtcInfo || !webrtcInfo.supported) return [];
+
+  const detections = [];
+
+  // Check media devices - headless browsers typically have 0 devices
+  const mediaDevices = webrtcInfo.mediaDevices || {};
+  if (mediaDevices.supported && mediaDevices.totalDevices === 0) {
+    detections.push({
+      category: 'headless',
+      score: 0.7,
+      confidence: 0.75,
+      reason: 'No media devices detected (typical of headless browsers)'
+    });
+  }
+
+  // Suspicious: has video inputs but no audio (unusual)
+  if (mediaDevices.supported && mediaDevices.videoInputs > 0 && mediaDevices.audioInputs === 0) {
+    detections.push({
+      category: 'bot',
+      score: 0.4,
+      confidence: 0.5,
+      reason: 'Has video devices but no audio devices (unusual configuration)'
+    });
+  }
+
+  // Check local IP detection - VMs and some headless setups may not expose local IPs
+  if (webrtcInfo.hasLocalIP === false && !webrtcInfo.localIPError) {
+    detections.push({
+      category: 'headless',
+      score: 0.4,
+      confidence: 0.5,
+      reason: 'No local IP addresses detected via WebRTC'
+    });
+  }
+
+  return detections;
+}
+
+/**
+ * Analyze Speech API signals - voices are OS/browser specific and hard to spoof
+ */
+function analyzeSpeechAPI(speechInfo) {
+  if (!speechInfo || !speechInfo.supported) return [];
+
+  const detections = [];
+
+  // No voices at all - suspicious
+  if (speechInfo.totalVoices === 0) {
+    detections.push({
+      category: 'headless',
+      score: 0.6,
+      confidence: 0.7,
+      reason: 'No speech synthesis voices available'
+    });
+  }
+
+  // Very few voices (less than 5) - could be headless or minimal VM
+  if (speechInfo.totalVoices > 0 && speechInfo.totalVoices < 5) {
+    detections.push({
+      category: 'headless',
+      score: 0.3,
+      confidence: 0.4,
+      reason: `Very few speech voices available (${speechInfo.totalVoices})`
+    });
+  }
+
+  // No local voices - all remote/network voices suggests unusual setup
+  if (speechInfo.localVoices === 0 && speechInfo.totalVoices > 0) {
+    detections.push({
+      category: 'bot',
+      score: 0.3,
+      confidence: 0.4,
+      reason: 'No local speech synthesis voices'
+    });
+  }
+
+  return detections;
+}
+
+/**
+ * Analyze Worker consistency - spoofed values often don't match between contexts
+ */
+function analyzeWorkerConsistency(workerConsistency) {
+  if (!workerConsistency || !workerConsistency.supported) return [];
+
+  const detections = [];
+
+  // Mismatches indicate fingerprint spoofing
+  if (!workerConsistency.consistent && workerConsistency.mismatchCount > 0) {
+    const score = Math.min(0.9, 0.3 + (workerConsistency.mismatchCount * 0.15));
+    detections.push({
+      category: 'bot',
+      score: score,
+      confidence: 0.85,
+      reason: `Worker/main thread mismatch detected: ${workerConsistency.mismatches.join(', ')}`
+    });
+  }
+
+  return detections;
+}
+
+/**
+ * Analyze CSS Media Queries for environment consistency
+ */
+function analyzeCSSMediaQueries(cssMedia, signals) {
+  if (!cssMedia || !cssMedia.supported) return [];
+
+  const detections = [];
+  const nav = (signals.environmental || {}).navigator || {};
+
+  // Check pointer consistency with touch capability
+  const maxTouch = nav.maxTouchPoints || 0;
+  if (cssMedia.pointer === 'coarse' && maxTouch === 0) {
+    detections.push({
+      category: 'bot',
+      score: 0.5,
+      confidence: 0.6,
+      reason: 'CSS reports coarse pointer but no touch support'
+    });
+  }
+
+  // Check hover capability - headless browsers may have unusual values
+  if (cssMedia.hover === false && cssMedia.pointer === 'fine') {
+    detections.push({
+      category: 'bot',
+      score: 0.3,
+      confidence: 0.4,
+      reason: 'Fine pointer reported but no hover capability'
+    });
+  }
+
+  // Forced colors mode with reduced motion - accessibility features
+  // Note: These are NOT suspicious on their own, just for fingerprinting
+  // Don't penalize accessibility users
+
+  return detections;
+}
+
+/**
+ * Analyze font detection results for consistency
+ */
+function analyzeFonts(fontsInfo, userAgent) {
+  if (!fontsInfo || !fontsInfo.supported) return [];
+
+  const detections = [];
+
+  // Very few fonts detected could indicate headless browser
+  if (fontsInfo.count < 3) {
+    detections.push({
+      category: 'headless',
+      score: 0.5,
+      confidence: 0.5,
+      reason: `Very few fonts detected (${fontsInfo.count})`
+    });
+  }
+
+  // Check OS-specific fonts against UA
+  const ua = (userAgent || '').toLowerCase();
+
+  // Windows UA but no Segoe UI
+  if (ua.includes('windows') && fontsInfo.hasSegoeUI === false && fontsInfo.count > 5) {
+    detections.push({
+      category: 'bot',
+      score: 0.5,
+      confidence: 0.6,
+      reason: 'Windows UA but Segoe UI font not detected'
+    });
+  }
+
+  // Mac UA but no SF Pro (modern macOS)
+  if ((ua.includes('mac os x') || ua.includes('macintosh')) && fontsInfo.hasSFPro === false &&
+      ua.includes('10_15') === false && ua.includes('10_14') === false && fontsInfo.count > 5) {
+    // SF Pro is on macOS 10.15+ (Catalina and later)
+    detections.push({
+      category: 'bot',
+      score: 0.3,
+      confidence: 0.4,
+      reason: 'Modern macOS UA but SF Pro font not detected'
+    });
+  }
+
+  // Linux UA but no DejaVu Sans (very common on Linux)
+  if (ua.includes('linux') && !ua.includes('android') &&
+      fontsInfo.hasDejaVuSans === false && fontsInfo.count > 5) {
+    detections.push({
+      category: 'bot',
+      score: 0.4,
+      confidence: 0.5,
+      reason: 'Linux UA but DejaVu Sans font not detected'
+    });
+  }
+
+  return detections;
+}
+
+/**
+ * Analyze permissions/API availability for headless detection
+ */
+function analyzePermissions(permissionsInfo) {
+  if (!permissionsInfo || !permissionsInfo.supported) return [];
+
+  const detections = [];
+
+  // Count available APIs
+  const apiKeys = [
+    'hasPermissionsAPI', 'hasClipboard', 'hasShare', 'hasCredentials',
+    'hasBluetooth', 'hasUsb', 'hasSerial', 'hasHid', 'hasXR',
+    'hasGeolocation', 'hasMIDI'
+  ];
+
+  const availableApis = apiKeys.filter(key => permissionsInfo[key] === true).length;
+
+  // Very few APIs available could indicate minimal/headless browser
+  if (availableApis < 3) {
+    detections.push({
+      category: 'headless',
+      score: 0.4,
+      confidence: 0.5,
+      reason: `Very few navigator APIs available (${availableApis})`
+    });
+  }
+
+  return detections;
+}
+
+/**
+ * Analyze DOMRect/geometry fingerprint for rendering anomalies
+ */
+function analyzeDOMRect(domRectInfo) {
+  if (!domRectInfo || !domRectInfo.supported) return [];
+
+  const detections = [];
+
+  // Check for zero or very small dimensions (rendering issues)
+  if (domRectInfo.rectAWidth === 0 || domRectInfo.rectBWidth === 0) {
+    detections.push({
+      category: 'headless',
+      score: 0.6,
+      confidence: 0.7,
+      reason: 'DOMRect rendering returned zero-width elements'
+    });
+  }
+
+  // Check for exact integer values (unusual in real browsers)
+  if (domRectInfo.rectAWidth === Math.floor(domRectInfo.rectAWidth) &&
+      domRectInfo.rectBWidth === Math.floor(domRectInfo.rectBWidth) &&
+      domRectInfo.rangeWidth === Math.floor(domRectInfo.rangeWidth)) {
+    detections.push({
+      category: 'bot',
+      score: 0.3,
+      confidence: 0.4,
+      reason: 'DOMRect measurements are all exact integers (unusual)'
+    });
+  }
+
+  return detections;
+}
+
+/**
+ * Master function to analyze all advanced fingerprint signals
+ */
+function analyzeAdvancedSignals(signals, userAgent) {
+  const detections = [];
+  const env = signals.environmental || {};
+
+  // WebRTC analysis
+  if (env.webrtcInfo) {
+    detections.push(...analyzeWebRTC(env.webrtcInfo));
+  }
+
+  // Speech API analysis
+  if (env.speechInfo) {
+    detections.push(...analyzeSpeechAPI(env.speechInfo));
+  }
+
+  // Worker consistency analysis
+  if (env.workerConsistency) {
+    detections.push(...analyzeWorkerConsistency(env.workerConsistency));
+  }
+
+  // CSS Media Queries analysis
+  if (env.cssMediaQueries) {
+    detections.push(...analyzeCSSMediaQueries(env.cssMediaQueries, signals));
+  }
+
+  // Font analysis
+  if (env.fontsInfo) {
+    detections.push(...analyzeFonts(env.fontsInfo, userAgent));
+  }
+
+  // Permissions analysis
+  if (env.permissionsInfo) {
+    detections.push(...analyzePermissions(env.permissionsInfo));
+  }
+
+  // DOMRect analysis
+  if (env.domRectFingerprint) {
+    detections.push(...analyzeDOMRect(env.domRectFingerprint));
+  }
+
+  return detections;
+}
+
 module.exports = {
   isDatacenterIP,
   checkIPReputation,
   analyzeHeaders,
   parseUserAgent,
   checkBrowserConsistency,
+  checkDeclaredAIAgent,
   checkJA3Fingerprint,
-  analyzeFormInteraction
+  checkJA4Fingerprint,
+  getTrustedJA4HeaderNames,
+  readJA4FromHeaders,
+  KNOWN_BOT_JA4_HASHES,
+  analyzeFormInteraction,
+  // Advanced fingerprint detection functions
+  analyzeWebRTC,
+  analyzeSpeechAPI,
+  analyzeWorkerConsistency,
+  analyzeCSSMediaQueries,
+  analyzeFonts,
+  analyzePermissions,
+  analyzeDOMRect,
+  analyzeAdvancedSignals
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webdecoy/fcaptcha",
-  "version": "1.0.4",
+  "version": "1.12.0",
   "description": "Open source CAPTCHA with PoW, bot detection, and Vision AI protection",
   "main": "index.js",
   "exports": {

package/server.js

@@ -7,6 +7,7 @@
 const express = require('express');
 const cors = require('cors');
 const crypto = require('crypto');
+const path = require('path');
 const detection = require('./detection');
 
 const app = express();
@@ -15,6 +16,21 @@ app.use(express.json());
 
 const SECRET_KEY = process.env.FCAPTCHA_SECRET || 'dev-secret-change-in-production';
 const PORT = process.env.PORT || 3000;
+const TRUSTED_JA4_HEADERS = detection.getTrustedJA4HeaderNames();
+
+// Serve the browser widget alongside the API so deployments expose a single
+// origin to integrators (the implicit contract behind <serverUrl>/fcaptcha.js).
+// Set FCAPTCHA_SERVE_CLIENT=false to opt out — useful when hosting the widget
+// on a separate CDN / edge cache. Set FCAPTCHA_CLIENT_PATH=/abs/path/fcaptcha.js
+// to override the default lookup when server-node is deployed standalone.
+const CLIENT_PATH = process.env.FCAPTCHA_CLIENT_PATH
+  || path.join(__dirname, '..', 'client', 'fcaptcha.js');
+
+if (process.env.FCAPTCHA_SERVE_CLIENT !== 'false') {
+  app.get('/fcaptcha.js', (req, res) => {
+    res.sendFile(CLIENT_PATH);
+  });
+}
 
 // =============================================================================
 // In-Memory Storage (Use Redis in production)
@@ -28,6 +44,7 @@ const powChallengeStore = {
   // Generate a new challenge
   generate(siteKey, ip, difficulty = 4) {
     const challengeId = crypto.randomBytes(16).toString('hex');
+    const nonce = crypto.randomBytes(16).toString('hex');
     const timestamp = Date.now();
     const expiresAt = timestamp + (5 * 60 * 1000); // 5 minutes
 
@@ -38,14 +55,14 @@ const powChallengeStore = {
       timestamp,
       expiresAt,
       difficulty,
+      nonce,
       prefix: `${challengeId}:${timestamp}:${difficulty}`
     };
 
     // Sign the challenge
     challengeData.sig = crypto.createHmac('sha256', SECRET_KEY)
       .update(JSON.stringify(challengeData))
-      .digest('hex')
-      .slice(0, 16);
+      .digest('hex');
 
     // Store challenge
     this.challenges.set(challengeId, {
@@ -60,8 +77,8 @@ const powChallengeStore = {
     return challengeData;
   },
 
-  // Verify a PoW solution
-  verify(challengeId, nonce, hash, siteKey) {
+  // Verify a PoW solution (signalsHash is optional for backward compat)
+  verify(challengeId, nonce, hash, siteKey, signalsHash = null) {
     const challenge = this.challenges.get(challengeId);
 
     if (!challenge) {
@@ -83,8 +100,10 @@ const powChallengeStore = {
       return { valid: false, reason: 'solution_already_used' };
     }
 
-    // Verify the hash
-    const input = `${challenge.prefix}:${nonce}`;
+    // Verify the hash (with optional signalsHash binding)
+    const input = signalsHash
+      ? `${challenge.prefix}:${signalsHash}:${nonce}`
+      : `${challenge.prefix}:${nonce}`;
     const expectedHash = crypto.createHash('sha256').update(input).digest('hex');
 
     if (hash !== expectedHash) {
@@ -103,7 +122,10 @@ const powChallengeStore = {
     // Delete challenge (one-time use)
     this.challenges.delete(challengeId);
 
-    return { valid: true, difficulty: challenge.difficulty };
+    // Calculate server-side elapsed time (un-spoofable)
+    const serverElapsed = Date.now() - challenge.createdAt;
+
+    return { valid: true, difficulty: challenge.difficulty, serverElapsed, nonce: challenge.nonce };
   },
 
   _cleanup() {
@@ -213,14 +235,15 @@ const AUTOMATION_UA_PATTERNS = [
 const WEIGHTS = {
   vision_ai: 0.15,
   headless: 0.15,
-  automation: 0.10,
+  automation: 0.08,
   cdp: 0.12,
   behavioral: 0.18,
-  fingerprint: 0.10,
-  rate_limit: 0.05,
-  datacenter: 0.10,
-  tor_vpn: 0.05,
-  bot: 0.10
+  fingerprint: 0.08,
+  rate_limit: 0.01,
+  datacenter: 0.07,
+  tor_vpn: 0.01,
+  bot: 0.13,
+  declared_ai: 0.02
 };
 
 // =============================================================================
@@ -236,6 +259,30 @@ function detectVisionAI(signals) {
   const b = signals.behavioral || {};
   const t = signals.temporal || {};
 
+  // Zero/minimal mouse movement - strong indicator of AI agent or programmatic click
+  // Exempt: touch users (mobile) and keyboard-only users (accessibility)
+  const totalPoints = b.totalPoints ?? 0;
+  const trajectory = b.trajectoryLength ?? 0;
+  const approachPts = b.approachPoints ?? 0;
+  const touchEvents = b.touchEvents ?? 0;
+  const keyEvents = b.keyEvents ?? 0;
+  const isTouchUser = touchEvents >= 3;
+  const isKeyboardUser = keyEvents >= 2 && totalPoints === 0;
+
+  if (totalPoints < 5 && trajectory < 10 && !isTouchUser && !isKeyboardUser) {
+    detections.push({
+      category: 'vision_ai', score: 0.9, confidence: 0.85,
+      reason: 'No mouse movement detected before click (AI agent pattern)'
+    });
+  }
+
+  if (approachPts === 0 && !isTouchUser && !isKeyboardUser) {
+    detections.push({
+      category: 'vision_ai', score: 0.7, confidence: 0.8,
+      reason: 'No approach trajectory to target'
+    });
+  }
+
   // PoW timing
   const pow = t.pow || {};
   if (pow.duration && pow.iterations) {
@@ -283,7 +330,6 @@ function detectVisionAI(signals) {
 
   // Exploration
   const exploration = b.explorationRatio ?? 0.3;
-  const trajectory = b.trajectoryLength ?? 0;
   if (exploration < 0.05 && trajectory > 50) {
     detections.push({
       category: 'vision_ai', score: 0.4, confidence: 0.4,
@@ -291,6 +337,31 @@ function detectVisionAI(signals) {
     });
   }
 
+  // Input-event forensics: teleport clicks and agent think-time cadence.
+  const fcs = b.inputForensics;
+  if (fcs) {
+    const teleports = fcs.teleportClicks ?? 0;
+    if (teleports >= 1 && !isTouchUser) {
+      detections.push({
+        category: 'vision_ai', score: 0.7, confidence: 0.7,
+        reason: `Click injected with no pointer trajectory (${teleports} teleport clicks)`
+      });
+    }
+    // Bursts of activity separated by multi-second perfect silence — the agent
+    // act -> screenshot -> inference loop. Low confidence (slow humans idle too);
+    // requires silence to dominate. Keyboard-only users are exempt.
+    if (!isKeyboardUser &&
+        (fcs.cadenceEvents ?? 0) >= 12 &&
+        (fcs.cadenceSilentGaps ?? 0) >= 3 &&
+        (fcs.cadenceGapCV ?? 0) > 2.5 &&
+        (fcs.cadenceSilentRatio ?? 0) > 0.6) {
+      detections.push({
+        category: 'vision_ai', score: 0.6, confidence: 0.5,
+        reason: 'Interaction cadence matches agent act/think loop (bursts + dead air)'
+      });
+    }
+  }
+
   return detections;
 }
 
@@ -365,6 +436,25 @@ function detectHeadless(signals, userAgent) {
     });
   }
 
+  // Playwright-specific detection
+  const playwright = env.playwright || {};
+  if (playwright.detected) {
+    const playwrightSignals = playwright.signals || [];
+    const scoreMap = {
+      playwright_globals: 0.95,
+      webdriver_deleted: 0.8,
+      webdriver_configurable: 0.7,
+      chrome_runtime_missing: 0.6,
+    };
+    for (const sig of playwrightSignals) {
+      const sigScore = scoreMap[sig] || 0.7;
+      detections.push({
+        category: 'headless', score: sigScore, confidence: 0.8,
+        reason: `Playwright artifact detected: ${sig}`
+      });
+    }
+  }
+
   return detections;
 }
 
@@ -416,6 +506,38 @@ function detectCDP(signals) {
   const env = signals.environmental || {};
   const cdp = env.cdp || {};
 
+  // Input-event forensics: catch CDP-injected input that reports isTrusted:true
+  // and so evades the global-based checks below. Touch users are exempt.
+  const b = signals.behavioral || {};
+  const isTouchUser = (b.touchEvents ?? 0) >= 3;
+  const fcs = b.inputForensics;
+  if (fcs && !isTouchUser) {
+    // Real mice coalesce several hardware samples per frame; a stream of
+    // pointermoves that NEVER coalesced is synthetic injection.
+    if ((fcs.coalescedSamples ?? 0) >= 20 && (fcs.coalescedMax ?? 0) <= 1) {
+      detections.push({
+        category: 'cdp', score: 0.8, confidence: 0.6,
+        reason: 'Pointer moves never coalesced across many samples (synthetic/CDP input)'
+      });
+    }
+    // movementX/Y incoherent with actual position deltas across most moves.
+    if ((fcs.pointerMoveSamples ?? 0) >= 20 && (fcs.pointerMoveZeroRatio ?? 0) > 0.9) {
+      detections.push({
+        category: 'cdp', score: 0.6, confidence: 0.5,
+        reason: 'Pointer movement deltas incoherent with position (synthetic input)'
+      });
+    }
+  }
+
+  // CDP Runtime/DevTools console consumer attached. Low confidence: a developer
+  // with DevTools open also trips this, so it contributes rather than blocks.
+  if (env.cdpRuntime && env.cdpRuntime.consoleAttached) {
+    detections.push({
+      category: 'cdp', score: 0.6, confidence: 0.5,
+      reason: 'CDP/DevTools console consumer attached (automation protocol or open DevTools)'
+    });
+  }
+
   if (cdp.detected) {
     const signalList = cdp.signals || [];
     const signalCount = signalList.length;
@@ -456,9 +578,29 @@ function detectBehavioral(signals) {
   const b = signals.behavioral || {};
   const t = signals.temporal || {};
 
+  // Insufficient mouse data - critical check for zero-click bots
+  // Exempt: touch users (mobile) and keyboard-only users (accessibility)
+  const totalPoints = b.totalPoints ?? 0;
+  const trajectory = b.trajectoryLength ?? 0;
+  const touchEvts = b.touchEvents ?? 0;
+  const keyEvts = b.keyEvents ?? 0;
+  const isTouchUsr = touchEvts >= 3;
+  const isKbdUser = keyEvts >= 2 && totalPoints === 0;
+
+  if (totalPoints === 0 && !isTouchUsr && !isKbdUser) {
+    detections.push({
+      category: 'behavioral', score: 0.8, confidence: 0.9,
+      reason: 'Zero mouse, touch, or keyboard events recorded'
+    });
+  } else if (totalPoints < 10 && !isTouchUsr && !isKbdUser && trajectory < 30) {
+    detections.push({
+      category: 'behavioral', score: 0.6, confidence: 0.7,
+      reason: 'Insufficient mouse movement before interaction'
+    });
+  }
+
   // Velocity variance
   const velVar = b.velocityVariance ?? 1;
-  const trajectory = b.trajectoryLength ?? 0;
   if (velVar < 0.02 && trajectory > 50) {
     detections.push({
       category: 'behavioral', score: 0.6, confidence: 0.6,
@@ -523,7 +665,6 @@ function detectBehavioral(signals) {
 
   // Direction changes
   const dirChanges = b.directionChanges ?? 10;
-  const totalPoints = b.totalPoints ?? 0;
   if (totalPoints > 50 && dirChanges < 3) {
     detections.push({
       category: 'behavioral', score: 0.4, confidence: 0.4,
@@ -534,6 +675,134 @@ function detectBehavioral(signals) {
   return detections;
 }
 
+// =============================================================================
+// Mobile-native detectors (touch authenticity, sensor entropy, touch kinematics)
+// UA-gated on mobile. Non-mobile UAs: no-op. Designed to never penalize iOS
+// Safari without permission (absence of motion events treated as neutral).
+// =============================================================================
+
+function _isMobileUA(userAgent) {
+  const ua = (userAgent || '').toLowerCase();
+  return /mobile|android|iphone|ipad|ipod/.test(ua);
+}
+
+function detectTouchAuthenticity(signals, userAgent) {
+  const detections = [];
+  if (!_isMobileUA(userAgent)) return detections;
+
+  const b = signals.behavioral || {};
+  const touchPoints = b.touchTotalPoints ?? b.touchEvents ?? 0;
+  if (touchPoints < 3) return detections;
+
+  const forceVariance = b.touchForceVariance ?? 0;
+  const radiusVariance = b.touchRadiusVariance ?? 0;
+  const forceAllOne = b.touchForceAllOne === true;
+  const uniqueIds = b.touchUniqueIdentifiers ?? 0;
+  const forceMax = b.touchForceMax ?? 0;
+  const radiusMax = b.touchRadiusMax ?? 0;
+
+  // Uniform non-zero force across all events → synthetic injection.
+  // Older Android returning all-zero is legitimate — only penalize uniformity
+  // when max > 0.
+  if (forceVariance === 0 && forceMax > 0 && touchPoints >= 5) {
+    detections.push({
+      category: 'behavioral', score: 0.75, confidence: 0.85,
+      reason: 'Touch force is identical across all events (synthetic touch)'
+    });
+  }
+
+  // All force=1 exactly is a common synthetic default in automation frameworks.
+  if (forceAllOne && touchPoints >= 5) {
+    detections.push({
+      category: 'behavioral', score: 0.8, confidence: 0.9,
+      reason: 'All touches report force=1.0 exactly (synthetic pattern)'
+    });
+  }
+
+  // Uniform contact radius across many events is unusual on real phones.
+  if (radiusVariance === 0 && radiusMax > 0 && touchPoints >= 5) {
+    detections.push({
+      category: 'behavioral', score: 0.7, confidence: 0.8,
+      reason: 'Touch contact radius identical across all events'
+    });
+  }
+
+  // Mobile UA with real touches but zero unique identifiers — framework default.
+  if (touchPoints >= 5 && uniqueIds === 0) {
+    detections.push({
+      category: 'behavioral', score: 0.6, confidence: 0.7,
+      reason: 'Mobile touches lack identifier tracking (synthetic injection)'
+    });
+  }
+
+  return detections;
+}
+
+function detectSensorEntropy(signals, userAgent) {
+  const detections = [];
+  if (!_isMobileUA(userAgent)) return detections;
+
+  const env = signals.environmental || {};
+  const sensor = env.sensor || {};
+  const motionCount = sensor.motionEventCount ?? 0;
+  const motionVariance = sensor.motionAccelVariance ?? 0;
+  const orientationCount = sensor.orientationEventCount ?? 0;
+  const orientationVariance = sensor.orientationVariance ?? 0;
+
+  // Sensor events fired but completely flat → emulator / headless mobile.
+  if (motionCount >= 10 && motionVariance < 0.01) {
+    detections.push({
+      category: 'headless', score: 0.7, confidence: 0.8,
+      reason: `Motion sensor active but flat (variance=${motionVariance.toFixed(4)}) — likely emulator`
+    });
+  }
+
+  if (orientationCount >= 10 && orientationVariance < 0.01) {
+    detections.push({
+      category: 'headless', score: 0.6, confidence: 0.7,
+      reason: 'Orientation sensor active but completely flat — likely emulator'
+    });
+  }
+
+  // motionCount == 0 is NEUTRAL (iOS w/o permission is the common case).
+
+  return detections;
+}
+
+function detectTouchKinematics(signals) {
+  const detections = [];
+  const b = signals.behavioral || {};
+  const touchPoints = b.touchTotalPoints ?? 0;
+  if (touchPoints < 10) return detections;
+
+  const straightLine = b.touchStraightLineRatio ?? 0;
+  const tremor = b.touchMicroTremorScore ?? 0;
+  const dirChanges = b.touchDirectionChanges ?? 0;
+
+  if (straightLine > 0.85 && touchPoints >= 20) {
+    detections.push({
+      category: 'behavioral', score: 0.65, confidence: 0.75,
+      reason: `Touch path too straight (ratio=${straightLine.toFixed(2)}) — automation pattern`
+    });
+  }
+
+  if (tremor < 0.05 && touchPoints >= 30) {
+    detections.push({
+      category: 'behavioral', score: 0.55, confidence: 0.65,
+      reason: 'Touch path has no micro-tremor (unnaturally smooth)'
+    });
+  }
+
+  if (dirChanges === 0 && touchPoints >= 30) {
+    detections.push({
+      category: 'behavioral', score: 0.5, confidence: 0.6,
+      reason: 'Touch path has zero direction changes over long trajectory'
+    });
+  }
+
+  return detections;
+}
+
 function detectFingerprint(signals, ip, siteKey) {
   const detections = [];
   const env = signals.environmental || {};
@@ -653,7 +922,7 @@ function generateToken(ip, siteKey, score) {
   };
 
   const payload = JSON.stringify(data, Object.keys(data).sort());
-  data.sig = crypto.createHmac('sha256', SECRET_KEY).update(payload).digest('hex').slice(0, 16);
+  data.sig = crypto.createHmac('sha256', SECRET_KEY).update(payload).digest('hex');
 
   return Buffer.from(JSON.stringify(data)).toString('base64url');
 }
@@ -671,7 +940,7 @@ function verifyToken(token, ip = null) {
     delete decoded.sig;
 
     const payload = JSON.stringify(decoded, Object.keys(decoded).sort());
-    const expectedSig = crypto.createHmac('sha256', SECRET_KEY).update(payload).digest('hex').slice(0, 16);
+    const expectedSig = crypto.createHmac('sha256', SECRET_KEY).update(payload).digest('hex');
 
     if (!crypto.timingSafeEqual(Buffer.from(sig), Buffer.from(expectedSig))) {
       return { valid: false, reason: 'invalid_signature' };
@@ -705,16 +974,34 @@ function verifyToken(token, ip = null) {
   }
 }
 
-function runVerification(signals, ip, siteKey, userAgent, headers = {}, ja3Hash = null, powSolution = null) {
-  const detections = [
-    ...detectVisionAI(signals),
-    ...detectHeadless(signals, userAgent),
-    ...detectAutomation(signals),
-    ...detectCDP(signals),
-    ...detectBehavioral(signals),
-    ...detectFingerprint(signals, ip, siteKey),
-    ...detectRateAbuse(ip, siteKey)
-  ];
+function runVerification(signals, ip, siteKey, userAgent, headers = {}, ja3Hash = null, powSolution = null, signalsJson = null, powTiming = null) {
+  const detections = [];
+
+  // Verify signal commitment (signalsJson hash must match powSolution.signalsHash)
+  const clientSignalsHash = powSolution?.signalsHash || null;
+  if (signalsJson && clientSignalsHash) {
+    const computedHash = crypto.createHash('sha256').update(signalsJson).digest('hex');
+    if (computedHash !== clientSignalsHash) {
+      detections.push({
+        category: 'bot',
+        score: 0.95,
+        confidence: 0.95,
+        reason: 'Signals tampered after PoW (signalsHash mismatch)'
+      });
+    }
+    // Use signalsJson as the canonical signals source
+    try {
+      signals = JSON.parse(signalsJson);
+    } catch (e) {
+      // Fall back to parsed signals if signalsJson is invalid
+    }
+  }
+
+  // Inject powTiming into signals.temporal.pow for detection functions
+  if (powTiming) {
+    if (!signals.temporal) signals.temporal = {};
+    signals.temporal.pow = powTiming;
+  }
 
   // Verify PoW if provided
   let powValid = false;
@@ -724,7 +1011,8 @@ function runVerification(signals, ip, siteKey, userAgent, headers = {}, ja3Hash
       powSolution.challengeId,
       powSolution.nonce,
       powSolution.hash,
-      siteKey
+      siteKey,
+      clientSignalsHash
     );
     powValid = powVerification.valid;
 
@@ -736,16 +1024,53 @@ function runVerification(signals, ip, siteKey, userAgent, headers = {}, ja3Hash
         reason: `PoW verification failed: ${powVerification.reason}`
       });
     }
+
+    // Verify challenge nonce binding
+    if (powValid && powVerification.nonce) {
+      const clientNonce = signals.meta?.challengeNonce;
+      if (!clientNonce || clientNonce !== powVerification.nonce) {
+        detections.push({
+          category: 'bot',
+          score: 0.9,
+          confidence: 0.9,
+          reason: 'Challenge nonce mismatch (signals not bound to challenge)'
+        });
+      }
+    }
+
+    if (powValid && powVerification.serverElapsed < 1500) {
+      // Server-side timing: challenge was solved too fast (un-spoofable)
+      detections.push({
+        category: 'bot',
+        score: 0.8,
+        confidence: 0.85,
+        reason: `Challenge solved too fast (${powVerification.serverElapsed}ms server-side)`
+      });
+    }
   } else {
-    // No PoW solution provided - suspicious
+    // No PoW solution provided - hard fail
     detections.push({
       category: 'bot',
-      score: 0.5,
-      confidence: 0.6,
+      score: 0.9,
+      confidence: 0.95,
       reason: 'No PoW solution provided'
     });
   }
 
+  // Run behavioral detectors
+  detections.push(
+    ...detectVisionAI(signals),
+    ...detectHeadless(signals, userAgent),
+    ...detectAutomation(signals),
+    ...detectCDP(signals),
+    ...detectBehavioral(signals),
+    ...detectTouchAuthenticity(signals, userAgent),
+    ...detectSensorEntropy(signals, userAgent),
+    ...detectTouchKinematics(signals),
+    ...detectFingerprint(signals, ip, siteKey),
+    ...detectRateAbuse(ip, siteKey)
+  );
+
   // Add IP reputation check (async but we'll use sync version for simplicity)
   if (detection.isDatacenterIP(ip)) {
     detections.push({
@@ -764,12 +1089,23 @@ function runVerification(signals, ip, siteKey, userAgent, headers = {}, ja3Hash
   const consistencyDetections = detection.checkBrowserConsistency(userAgent, signals);
   detections.push(...consistencyDetections);
 
-  // Add JA3 fingerprint check
+  // Flag declared/verified AI agents (self-identifying UA or Web Bot Auth signature)
+  detections.push(...detection.checkDeclaredAIAgent(userAgent, headers));
+
+  // Add JA3 fingerprint check (client-supplied — spoofable)
   if (ja3Hash) {
     const ja3Detections = detection.checkJA3Fingerprint(ja3Hash);
     detections.push(...ja3Detections);
   }
 
+  // Add JA4 fingerprint check from trusted proxy headers (un-spoofable by client)
+  if (TRUSTED_JA4_HEADERS.length > 0) {
+    const ja4 = detection.readJA4FromHeaders(headers, TRUSTED_JA4_HEADERS);
+    if (ja4) {
+      detections.push(...detection.checkJA4Fingerprint(ja4));
+    }
+  }
+
   // Add form interaction analysis (credential stuffing & spam detection)
   const formAnalysis = signals.formAnalysis;
   if (formAnalysis) {
@@ -777,6 +1113,10 @@ function runVerification(signals, ip, siteKey, userAgent, headers = {}, ja3Hash
     detections.push(...formDetections);
   }
 
+  // Add advanced fingerprint detection analysis
+  const advancedDetections = detection.analyzeAdvancedSignals(signals, userAgent);
+  detections.push(...advancedDetections);
+
   const categoryScores = calculateCategoryScores(detections);
   const finalScore = calculateFinalScore(categoryScores);
 
@@ -808,7 +1148,7 @@ app.get('/health', (req, res) => {
 });
 
 app.post('/api/verify', (req, res) => {
-  const { siteKey, signals, powSolution } = req.body;
+  const { siteKey, signals, powSolution, signalsJson, powTiming } = req.body;
   let ip = req.headers['x-real-ip'] || '';
   if (!ip) {
     const forwarded = req.headers['x-forwarded-for'];
@@ -827,12 +1167,12 @@ app.post('/api/verify', (req, res) => {
     headers[key.toLowerCase()] = Array.isArray(value) ? value[0] : value;
   }
 
-  const result = runVerification(signals, ip, siteKey, userAgent, headers, ja3Hash, powSolution);
+  const result = runVerification(signals, ip, siteKey, userAgent, headers, ja3Hash, powSolution, signalsJson, powTiming);
   res.json(result);
 });
 
 app.post('/api/score', (req, res) => {
-  const { siteKey, signals, action, powSolution } = req.body;
+  const { siteKey, signals, action, powSolution, signalsJson, powTiming } = req.body;
   let ip = req.headers['x-real-ip'] || '';
   if (!ip) {
     const forwarded = req.headers['x-forwarded-for'];
@@ -850,7 +1190,7 @@ app.post('/api/score', (req, res) => {
     headers[key.toLowerCase()] = Array.isArray(value) ? value[0] : value;
   }
 
-  const result = runVerification(signals, ip, siteKey, userAgent, headers, ja3Hash, powSolution);
+  const result = runVerification(signals, ip, siteKey, userAgent, headers, ja3Hash, powSolution, signalsJson, powTiming);
   res.json({
     success: result.success,
     score: result.score,
@@ -916,6 +1256,7 @@ app.get('/api/pow/challenge', (req, res) => {
     prefix: challenge.prefix,
     difficulty: challenge.difficulty,
     expiresAt: challenge.expiresAt,
+    nonce: challenge.nonce,
     sig: challenge.sig
   });
 });