/* * c.js — standalone capture beacon (Phase 24: decoupled from React). * Phase 30: ping/complete delivery model for beacon hardening. * * Loaded async from the document start with the session id inlined as * window.__CAPTURE_SESSION__, so it runs as soon as it downloads — NOT after the * React app hydrates (~1.6s). That earlier start both shortens time-to-capture * and rescues quick-bouncing visitors who leave before hydration. * * Phase 30 delivery model: * 1. Ping (t≈0): fires immediately before any probe starts, records that JS ran * and sends synchronously-available identity fields. beacon_stage='ping'. * The aggregator sets beaconReceivedAt but does NOT flush. * 2. Complete (t≈12s): the existing full-payload POST after the probe race. * beacon_stage='complete'. Aggregator merges fields (complete wins over ping * on overlap) and flushes. beacon_complete semantics unchanged. * 3. Unload (pagehide/visibilitychange): sends whatever is in payload at that * moment as a final complete with beacon_complete=false. This is the path that * rescues quick-bounce visitors. * * Backward compat: an aggregator that doesn't understand beacon_stage treats any * POST as a complete → safe rollout ordering (aggregator ships before UI or after). * * This is a faithful vanilla-JS port of the collection logic in * ui/app/Beacon.tsx — keep the two in sync. Beacon.tsx is now the status banner * only; this script is the sole collector. It sets window.__captureStarted so * the banner knows capture is handled, dispatches `capture:delivered` for the * landing Forwarder, and dedups per tab via sessionStorage. */ (function () { 'use strict'; var sessionId = window.__CAPTURE_SESSION__; if (!sessionId || typeof sessionId !== 'string') return; if (window.__captureStarted) return; window.__captureStarted = true; var key = 'beacon_sent_' + sessionId; function signalDelivered() { try { window.dispatchEvent(new CustomEvent('capture:delivered', { detail: { sessionId: sessionId } })); } catch (e) { /* no-op */ } } // Already captured this session in this tab — nothing to do but let the // landing Forwarder move on. try { if (sessionStorage.getItem(key)) { signalDelivered(); return; } } catch (e) { /* ignore */ } var V6_PROBE_URL = 'https://v6.stupidlysimplesecurity.com/api/dual-probe'; var H3_PROBE_URL = 'https://h3.stupidlysimplesecurity.com/api/h3-probe'; var H2_PROBE_URL = 'https://check.stupidlysimplesecurity.com:8443/api/h2-probe'; var DNS_PROBE_ZONE = 'q.stupidlysimplesecurity.com'; var STUN_URL = 'stun:stun.stupidlysimplesecurity.com:3478'; var PROBE_TIMEOUT_MS = 4000; var WEBRTC_TIMEOUT_MS = 1200; var RTT_TIMEOUT_MS = 3000; // The h3 loop needs its 3rd fetch to actually catch a QUIC handshake — the // browser usually still rides TCP on attempt 2. Dropping to 2 made h3Used // read false on real browsers, which trips h3-consistency's low "never raced // QUIC despite Alt-Svc" finding. Keep 3 attempts but a tight 200ms gap and a // 2500ms budget (was 5000) so it no longer dominates the tail. var H3_TOTAL_BUDGET_MS = 2500; var H3_MAX_ATTEMPTS = 3; var BEACON_DEADLINE_MS = 12000; // Phase 41: minimal WebGL program (pass-through vertex + solid-colour fragment) // for the render-to-hash. Returns the linked program or null on any failure. function createTestProgram(gl) { try { var vs = gl.createShader(gl.VERTEX_SHADER); gl.shaderSource(vs, 'attribute vec2 p;void main(){gl_Position=vec4(p,0.0,1.0);}'); gl.compileShader(vs); var fs = gl.createShader(gl.FRAGMENT_SHADER); gl.shaderSource(fs, 'precision lowp float;void main(){gl_FragColor=vec4(0.5,0.3,0.7,1.0);}'); gl.compileShader(fs); var prog = gl.createProgram(); gl.attachShader(prog, vs); gl.attachShader(prog, fs); gl.linkProgram(prog); if (!gl.getProgramParameter(prog, gl.LINK_STATUS)) return null; var buf = gl.createBuffer(); gl.bindBuffer(gl.ARRAY_BUFFER, buf); gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([-1, -1, 3, -1, -1, 3]), gl.STATIC_DRAW); var loc = gl.getAttribLocation(prog, 'p'); gl.enableVertexAttribArray(loc); gl.vertexAttribPointer(loc, 2, gl.FLOAT, false, 0, 0); return prog; } catch (e) { return null; } } function webglIdentity() { var out = { renderer: null, vendor: null, maxTexSize: null, maxVtxUni: null, extCount: null, renderHash: null }; try { var canvas = document.createElement('canvas'); canvas.width = 256; canvas.height = 256; var gl = canvas.getContext('webgl') || canvas.getContext('experimental-webgl'); if (!gl) return out; // Renderer/vendor strings need the debug extension; params do not. var dbg = gl.getExtension('WEBGL_debug_renderer_info'); if (dbg) { var renderer = gl.getParameter(dbg.UNMASKED_RENDERER_WEBGL); var vendor = gl.getParameter(dbg.UNMASKED_VENDOR_WEBGL); out.renderer = typeof renderer === 'string' ? renderer : null; out.vendor = typeof vendor === 'string' ? vendor : null; } // Phase 41: GPU parameter enumeration (device-class markers). try { out.maxTexSize = gl.getParameter(gl.MAX_TEXTURE_SIZE) || null; } catch (e) { /* ignore */ } try { out.maxVtxUni = gl.getParameter(gl.MAX_VERTEX_UNIFORM_VECTORS) || null; } catch (e) { /* ignore */ } try { var exts = gl.getSupportedExtensions(); out.extCount = exts ? exts.length : null; } catch (e) { /* ignore */ } // Phase 41: render-to-hash — draw a fixed scene, hash the pixel output. try { var prog = createTestProgram(gl); if (prog) { gl.useProgram(prog); gl.drawArrays(gl.TRIANGLES, 0, 3); var px = new Uint8Array(256 * 256 * 4); gl.readPixels(0, 0, 256, 256, gl.RGBA, gl.UNSIGNED_BYTE, px); var h = 0x811c9dc5; for (var i = 0; i < px.length; i += 8) { h ^= px[i]; h = Math.imul(h, 0x01000193); } out.renderHash = (h >>> 0).toString(16).padStart(8, '0'); } } catch (e) { /* ignore */ } return out; } catch (e) { return out; } } // Phase 41: second canvas render (radial gradient + bezier) → GPU-class hash, // distinct from the text-based canvasHash(). Synchronous. function canvasHashGpu() { try { var canvas = document.createElement('canvas'); canvas.width = 300; canvas.height = 150; var ctx = canvas.getContext('2d'); if (!ctx) return null; var grad = ctx.createRadialGradient(75, 50, 5, 90, 60, 100); grad.addColorStop(0, 'rgba(255,0,0,0.9)'); grad.addColorStop(0.5, 'rgba(0,255,0,0.7)'); grad.addColorStop(1, 'rgba(0,0,255,0.5)'); ctx.fillStyle = grad; ctx.fillRect(0, 0, 300, 150); ctx.beginPath(); ctx.moveTo(20, 100); ctx.bezierCurveTo(150, 0, 150, 300, 280, 100); ctx.strokeStyle = 'rgba(100,200,50,0.8)'; ctx.lineWidth = 3; ctx.stroke(); var data = canvas.toDataURL(); var h = 0x811c9dc5; for (var i = 0; i < data.length; i++) { h ^= data.charCodeAt(i); h = Math.imul(h, 0x01000193); } return (h >>> 0).toString(16).padStart(8, '0'); } catch (e) { return null; } } // Phase 41: AudioContext DSP fingerprint. OfflineAudioContext → sine oscillator // → DynamicsCompressor, FNV-hashed over the float32 output. Async (rendering). async function audioHash() { try { var AudioCtx = window.OfflineAudioContext || window.webkitOfflineAudioContext; if (!AudioCtx) return null; var ctx = new AudioCtx(1, 500, 44100); var osc = ctx.createOscillator(); osc.type = 'sine'; osc.frequency.setValueAtTime(440, ctx.currentTime); var comp = ctx.createDynamicsCompressor(); comp.threshold.value = -50; comp.knee.value = 40; comp.ratio.value = 12; comp.attack.value = 0; comp.release.value = 0.25; osc.connect(comp); comp.connect(ctx.destination); osc.start(0); var buf = await ctx.startRendering(); var data = buf.getChannelData(0); var view = new DataView(new ArrayBuffer(4)); var h = 0x811c9dc5; for (var i = 0; i < data.length; i += 5) { view.setFloat32(0, data[i]); h ^= view.getUint32(0); h = Math.imul(h, 0x01000193); } return (h >>> 0).toString(16).padStart(8, '0'); } catch (e) { return null; } } // Phase 38: CSS media-query input-model capabilities. Read synchronously via // window.matchMedia — reported by the rendering engine, not a navigator // property automation tools routinely patch. Each query is wrapped so a // throwing/unsupported feature yields null (unknown), never a false positive. function mediaCapabilities() { function mq(q) { try { return window.matchMedia(q).matches; } catch (e) { return null; } } var orient = null; try { orient = (screen.orientation && screen.orientation.type) || null; } catch (e) { orient = null; } return { pointer_fine: mq('(pointer: fine)'), pointer_coarse: mq('(pointer: coarse)'), hover_hover: mq('(hover: hover)'), any_pointer_fine: mq('(any-pointer: fine)'), color_gamut_p3: mq('(color-gamut: p3)'), prefers_reduced_motion: mq('(prefers-reduced-motion: reduce)'), forced_colors: mq('(forced-colors: active)'), orientation_type: orient, }; } // Phase 39: OS-signature font enumeration via canvas measureText width probing. // Renders a probe string in each target font (with monospace fallback); if the // measured width equals the fallback baseline, the font is absent. Returns // small per-OS presence counts (not the raw font list — OS consistency, not // re-identification) plus an Arial sanity flag. Synchronous, never throws. function fontProbe() { try { var canvas = document.createElement('canvas'); var ctx = canvas.getContext('2d'); if (!ctx) return null; var TEST_STRING = 'mmmmmmmmmmlli'; var FALLBACK = 'monospace'; var BASE = '72px '; ctx.font = BASE + FALLBACK; var baseWidth = ctx.measureText(TEST_STRING).width; function has(name) { ctx.font = BASE + '"' + name + '", ' + FALLBACK; return ctx.measureText(TEST_STRING).width !== baseWidth; } return { win: (has('Segoe UI') ? 1 : 0) + (has('Calibri') ? 1 : 0) + (has('Consolas') ? 1 : 0), mac: (has('Helvetica Neue') ? 1 : 0) + (has('Monaco') ? 1 : 0), linux: (has('Ubuntu') ? 1 : 0) + (has('Liberation Sans') ? 1 : 0), android:(has('Roboto') ? 1 : 0) + (has('Noto Sans') ? 1 : 0), arial: has('Arial'), }; } catch (e) { return null; } } function automationTells() { var webdriver = typeof navigator.webdriver === 'boolean' ? navigator.webdriver : null; var windowChrome = typeof window.chrome !== 'undefined'; var fnTamper = null; try { var toStr = Function.prototype.toString; var natives = [toStr, navigator.permissions && navigator.permissions.query]; var wdGetter = Object.getOwnPropertyDescriptor(Navigator.prototype, 'webdriver'); if (wdGetter && wdGetter.get) natives.push(wdGetter.get); fnTamper = natives.some(function (fn) { return typeof fn === 'function' && toStr.call(fn).indexOf('[native code]') === -1; }); } catch (e) { fnTamper = null; } // Phase 40: widened native-toString sweep over natives stealth tools patch // but the core sweep misses. null when none were checkable. var fnTamperExt = null; try { var toStr2 = Function.prototype.toString; var more = []; try { more.push(window.fetch); } catch (e) { /* ignore */ } try { if (navigator.mediaDevices && navigator.mediaDevices.enumerateDevices) more.push(navigator.mediaDevices.enumerateDevices); } catch (e) { /* ignore */ } try { if (window.HTMLElement && HTMLElement.prototype && HTMLElement.prototype.animate) more.push(HTMLElement.prototype.animate); } catch (e) { /* ignore */ } more = more.filter(function (f) { return typeof f === 'function'; }); fnTamperExt = more.length ? more.some(function (fn) { return toStr2.call(fn).indexOf('[native code]') === -1; }) : null; } catch (e) { fnTamperExt = null; } // Phase 40: navigator.plugins count. 0 under headless Chromium; real desktop // Chrome exposes its built-in PDF viewer. var pluginsLen = null; try { pluginsLen = (typeof navigator.plugins !== 'undefined' && navigator.plugins) ? navigator.plugins.length : null; } catch (e) { pluginsLen = null; } // Phase 40: chrome.runtime coherence. null = no chrome.runtime (the common, // fine case for a no-extension Chrome — handled by the windowChrome path); // true = has real extension-messaging methods; false = hollow object (spoof). var chromeRuntimeOk = null; try { if (typeof window.chrome !== 'undefined' && window.chrome && window.chrome.runtime) { var rt = window.chrome.runtime; chromeRuntimeOk = (typeof rt.connect === 'function' || typeof rt.sendMessage === 'function' || typeof rt.getManifest === 'function'); } } catch (e) { chromeRuntimeOk = null; } // Phase 40: CDP / automation-runtime global leak scan. A throw defaults to // false (clean) — errors are permission issues, not marker presence. var cdcLeak = false; try { cdcLeak = Object.getOwnPropertyNames(window).some(function (k) { return k.indexOf('cdc_') === 0 || k.indexOf('__puppeteer') === 0 || k.indexOf('__playwright') === 0 || k.indexOf('__driver') === 0 || k.indexOf('__selenium') === 0 || k.indexOf('__webdriver') === 0; }); } catch (e) { cdcLeak = false; } return { webdriver: webdriver, windowChrome: windowChrome, fnTamper: fnTamper, fnTamperExt: fnTamperExt, pluginsLen: pluginsLen, chromeRuntimeOk: chromeRuntimeOk, cdcLeak: cdcLeak, }; } // Phase 40: permission-API contradiction AND notification-default state, returned // as one object so the probe race captures both from a single call. function permContradiction() { try { if (typeof Notification === 'undefined' || !(navigator.permissions && navigator.permissions.query)) { return Promise.resolve({ contradiction: null, notifDefault: null }); } var perm = Notification.permission; // 'default' | 'granted' | 'denied' if (perm !== 'denied') { return Promise.resolve({ contradiction: false, notifDefault: perm === 'default' }); } return navigator.permissions.query({ name: 'notifications' }) .then(function (p) { return { contradiction: p.state === 'prompt', notifDefault: false }; }) .catch(function () { return { contradiction: null, notifDefault: null }; }); } catch (e) { return Promise.resolve({ contradiction: null, notifDefault: null }); } } // Phase 40: media device count via enumerateDevices. 0 in headless (no A/V // hardware); real desktops expose at least an audio output. Async, no labels. async function probeDeviceCount() { try { if (!navigator.mediaDevices || !navigator.mediaDevices.enumerateDevices) return null; var devices = await navigator.mediaDevices.enumerateDevices(); return Array.isArray(devices) ? devices.length : null; } catch (e) { return null; } } function canvasHash() { try { var canvas = document.createElement('canvas'); canvas.width = 200; canvas.height = 40; var ctx = canvas.getContext('2d'); if (!ctx) return null; ctx.textBaseline = 'top'; ctx.font = '14px Arial'; ctx.fillStyle = '#f60'; ctx.fillRect(10, 5, 100, 25); ctx.fillStyle = '#069'; ctx.fillText('proxy-detect \u{1F50D}', 2, 15); var data = canvas.toDataURL(); var hash = 0x811c9dc5; for (var i = 0; i < data.length; i++) { hash ^= data.charCodeAt(i); hash = Math.imul(hash, 0x01000193); } return (hash >>> 0).toString(16).padStart(8, '0'); } catch (e) { return null; } } function probeDualStack(sid) { var q = '?session=' + encodeURIComponent(sid); return Promise.all([ fetch('/api/dual-probe' + q, { signal: AbortSignal.timeout(PROBE_TIMEOUT_MS) }) .then(function (r) { return r.ok ? r.json() : null; }).catch(function () { return null; }), fetch(V6_PROBE_URL + q, { signal: AbortSignal.timeout(PROBE_TIMEOUT_MS) }) .then(function (r) { return r.ok ? r.json() : null; }).catch(function () { return null; }), ]).then(function (res) { var v4 = res[0], v6 = res[1]; return { ipv4_reached: !!v4, ipv6_reached: !!v6, dual_stack_ip: (v6 && v6.ip) || null }; }); } async function probeH3(sid) { var offered = false, used = false; var deadline = performance.now() + H3_TOTAL_BUDGET_MS; for (var n = 1; n <= H3_MAX_ATTEMPTS; n++) { if (performance.now() >= deadline) break; try { var res = await fetch(H3_PROBE_URL + '?session=' + encodeURIComponent(sid) + '&n=' + n, { signal: AbortSignal.timeout(PROBE_TIMEOUT_MS), cache: 'no-store', }); if (!res.ok) break; offered = true; var body = await res.json(); if (typeof body.proto === 'string' && body.proto.indexOf('HTTP/3') === 0) used = true; } catch (e) { break; } if (used || performance.now() >= deadline) break; await new Promise(function (r) { setTimeout(r, 200); }); } return { h3_offered: offered, h3_used: used }; } async function probeH2(sid) { var url = H2_PROBE_URL + '?session=' + encodeURIComponent(sid); var started = performance.now(); function attempt() { return fetch(url, { cache: 'no-store', mode: 'no-cors', signal: AbortSignal.timeout(PROBE_TIMEOUT_MS) }); } function elapsed() { return Math.round(performance.now() - started); } try { await attempt(); return { h2_probe: 'ok', h2_probe_ms: elapsed() }; } catch (e1) { await new Promise(function (r) { setTimeout(r, 300); }); try { await attempt(); return { h2_probe: 'retry_ok', h2_probe_ms: elapsed() }; } catch (e2) { var name = (e2 && e2.name) || 'Unknown'; return { h2_probe: name === 'TimeoutError' ? 'timeout' : 'error:' + name, h2_probe_ms: elapsed() }; } } } function makeDnsToken() { var bytes = new Uint8Array(9); crypto.getRandomValues(bytes); var hex = ''; for (var i = 0; i < bytes.length; i++) hex += bytes[i].toString(16).padStart(2, '0'); return 'd' + hex; } function probeDns(token) { // Trigger a recursive DNS resolution of the unique per-session token subdomain // so the authoritative dns-auth server records the client's resolver (IP + ECS). // Use dns-prefetch (DNS-only, no TLS connection) rather than an HTTPS fetch: // the token zone has no matching certificate, so a fetch surfaced a visible // net::ERR_CERT_COMMON_NAME_INVALID warning during the capture flow, right // before the redirect. dns-prefetch resolves the name without a connection — // no cert error — while still driving the resolver query the canary needs. // The unique token guarantees a cache miss, so the resolution actually fires. try { var link = document.createElement('link'); link.rel = 'dns-prefetch'; link.href = 'https://' + token + '.' + DNS_PROBE_ZONE; (document.head || document.documentElement).appendChild(link); } catch (e) { /* ignore — DNS canary is a corroborating signal, never blocks */ } return Promise.resolve(); } function parseCandidate(cand, result, seenPrivate) { var parts = cand.split(' '); var typIdx = parts.indexOf('typ'); if (typIdx === -1 || typIdx + 1 >= parts.length) return; var type = parts[typIdx + 1]; var address = parts[4]; if (!address) return; var isV6 = address.indexOf(':') !== -1; if (type === 'srflx') { if (isV6) { if (!result.public_ip_v6) result.public_ip_v6 = address; } else if (!result.public_ip) result.public_ip = address; } else if (type === 'host') { if (address.slice(-6) === '.local') return; if (!seenPrivate.has(address) && result.private_ips.length < 8) { seenPrivate.add(address); result.private_ips.push(address); } } } async function probeWebrtc() { var result = { private_ips: [], blocked: true }; var RTCPC = window.RTCPeerConnection; if (!RTCPC) return result; var pc = null; try { pc = new RTCPC({ iceServers: [{ urls: STUN_URL }] }); pc.createDataChannel('probe'); var seenPrivate = new Set(); var gathered = new Promise(function (resolve) { pc.onicegatheringstatechange = function () { if (pc.iceGatheringState === 'complete') resolve(); }; pc.onicecandidate = function (e) { if (!e.candidate || !e.candidate.candidate) { resolve(); return; } parseCandidate(e.candidate.candidate, result, seenPrivate); }; }); var offer = await pc.createOffer(); await pc.setLocalDescription(offer); await Promise.race([gathered, new Promise(function (r) { setTimeout(r, WEBRTC_TIMEOUT_MS); })]); result.blocked = !(result.public_ip || result.public_ip_v6); return result; } catch (e) { return { private_ips: [], blocked: true }; } finally { try { if (pc) pc.close(); } catch (e) { /* ignore */ } } } // Two samples (was three), reported as the MIN — the lowest round trip is the // least contended and the value rtt-vs-geo actually wants (the physical floor). // Dropping the third sample shaves one sequential round trip off the critical // path before the parallel probes start. async function measureRtt() { var samples = []; for (var i = 0; i < 2; i++) { try { var start = performance.now(); var res = await fetch('/api/rtt-probe', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: '{}', signal: AbortSignal.timeout(RTT_TIMEOUT_MS), }); if (!res.ok) return null; await res.json(); samples.push(performance.now() - start); } catch (e) { return null; } } samples.sort(function (a, b) { return a - b; }); return Math.round(samples[0]); } // Phase 43: JS-engine-exclusive globals + version-fragile tells. Synchronous, // never throws. Presence of an engine-exclusive marker under the wrong UA // family is the signal (scored by js-engine-vs-ua); the numeric/hash tells are // captured for future analysis only. function jsEngineProbe() { var out = { error_stack_limit: null, install_trigger: null, safari_obj: null, tan_pi2_len: null, intl_ar_hash: null, shared_array_buf: null, }; try { out.error_stack_limit = 'stackTraceLimit' in Error; } catch (e) { /* ignore */ } try { out.install_trigger = typeof window.InstallTrigger !== 'undefined'; } catch (e) { /* ignore */ } try { out.safari_obj = typeof window.safari !== 'undefined'; } catch (e) { /* ignore */ } try { out.tan_pi2_len = Math.tan(Math.PI / 2).toString().length; } catch (e) { /* ignore */ } try { var s = new Intl.DateTimeFormat('ar-SA').format(new Date(0)); var h = 0; for (var i = 0; i < s.length; i++) { h = (h * 31 + s.charCodeAt(i)) >>> 0; } out.intl_ar_hash = h.toString(16); } catch (e) { /* ignore */ } try { out.shared_array_buf = typeof SharedArrayBuffer !== 'undefined'; } catch (e) { /* ignore */ } return out; } // Phase 42: behavioral-biometrics sampler. Gated on the server-injected // window.__BEHAVIORAL_FP__ feature flag (default false → returns null, no // listeners attached, zero cost). When enabled, attaches PASSIVE listeners at // t≈0 and computes variance metrics on collect() at delivery. Complete beacon // only — the rule skips a partial (unload) beacon. function startBehavioral() { if (!window.__BEHAVIORAL_FP__) return null; var ptrDeltas = [], clickTimes = [], keyTimes = []; var scrollEvents = 0, lastScrollDir = null, scrollDirChanges = 0, lastSY = 0; var touchFired = false; var lastX = null, lastY = null, lastClickT = null; function onMove(e) { if (ptrDeltas.length >= 60) return; var dx = e.clientX - (lastX === null ? e.clientX : lastX); var dy = e.clientY - (lastY === null ? e.clientY : lastY); if (lastX !== null) ptrDeltas.push(dx * dx + dy * dy); lastX = e.clientX; lastY = e.clientY; } function onClick(e) { if (clickTimes.length >= 20) return; if (lastClickT !== null) clickTimes.push(e.timeStamp - lastClickT); lastClickT = e.timeStamp; } function onScroll() { scrollEvents++; var dir = window.scrollY > lastSY ? 1 : -1; if (lastScrollDir !== null && dir !== lastScrollDir) scrollDirChanges++; lastScrollDir = dir; lastSY = window.scrollY; } function onKey(e) { if (keyTimes.length < 30) keyTimes.push(e.timeStamp); } function onTouch() { touchFired = true; } try { document.addEventListener('mousemove', onMove, { passive: true }); document.addEventListener('click', onClick, { passive: true }); document.addEventListener('scroll', onScroll, { passive: true }); document.addEventListener('keydown', onKey, { passive: true }); document.addEventListener('touchstart', onTouch, { passive: true, once: true }); } catch (e) { return null; } function variance(arr) { if (!arr.length) return null; var m = arr.reduce(function (a, b) { return a + b; }, 0) / arr.length; return Math.round(arr.reduce(function (a, b) { return a + (b - m) * (b - m); }, 0) / arr.length); } return { collect: function () { try { document.removeEventListener('mousemove', onMove); document.removeEventListener('click', onClick); document.removeEventListener('scroll', onScroll); document.removeEventListener('keydown', onKey); document.removeEventListener('touchstart', onTouch); } catch (e) { /* ignore */ } var keyIntervals = []; for (var i = 1; i < keyTimes.length; i++) keyIntervals.push(keyTimes[i] - keyTimes[i - 1]); return { ptr_sample_count: ptrDeltas.length, ptr_variance: ptrDeltas.length >= 10 ? variance(ptrDeltas) : null, click_count: clickTimes.length + (lastClickT !== null ? 1 : 0), click_variance: clickTimes.length >= 3 ? variance(clickTimes) : null, scroll_count: scrollEvents, scroll_dir_changes: scrollDirChanges, key_count: keyTimes.length, key_variance: keyIntervals.length >= 5 ? variance(keyIntervals) : null, touch_fired: touchFired, }; }, }; } // ── Assemble + deliver ───────────────────────────────────────────────────── var delivered = false; var acquired = false; var dnsToken = makeDnsToken(); var webgl = webglIdentity(); var tells = automationTells(); var mediaCaps = mediaCapabilities(); var fonts = fontProbe(); var jsEng = jsEngineProbe(); var behavioral = startBehavioral(); var tz = null; try { tz = Intl.DateTimeFormat().resolvedOptions().timeZone || null; } catch (e) { tz = null; } // Synchronously-available identity fields — populated before any probe starts. // These are sent in the ping AND included in the complete payload so the // aggregator always has them regardless of which stage arrives first. var payload = { session_id: sessionId, ua: navigator.userAgent, rtt_ms: null, canvas_hash: canvasHash(), screen_color_depth: screen.colorDepth != null ? screen.colorDepth : null, device_memory: navigator.deviceMemory != null ? navigator.deviceMemory : null, webgl_renderer: webgl.renderer, webgl_vendor: webgl.vendor, // Phase 41: WebGL-deep params + render hash, canvas-GPU hash (sync), audio hash (async). webgl_max_tex: webgl.maxTexSize, webgl_max_vtx: webgl.maxVtxUni, webgl_ext_count: webgl.extCount, webgl_render_hash: webgl.renderHash, canvas_gpu_hash: canvasHashGpu(), audio_hash: null, nav_platform: navigator.platform || null, hw_concurrency: navigator.hardwareConcurrency != null ? navigator.hardwareConcurrency : null, nav_languages: Array.from(navigator.languages || []).join(',') || null, timezone_id: tz, timezone_offset: new Date().getTimezoneOffset(), screen_width: screen.width != null ? screen.width : null, screen_height: screen.height != null ? screen.height : null, dpr: window.devicePixelRatio != null ? window.devicePixelRatio : null, vp_width: window.innerWidth != null ? window.innerWidth : null, vp_height: window.innerHeight != null ? window.innerHeight : null, webdriver: tells.webdriver, window_chrome: tells.windowChrome, native_fn_tamper: tells.fnTamper, perm_contradiction: null, // Phase 40: extended automation / CDP-artifact tells (sync from tells; // notif_default + media_device_count filled by the async probe race). native_fn_tamper_ext: tells.fnTamperExt, plugins_len: tells.pluginsLen, chrome_runtime_ok: tells.chromeRuntimeOk, cdc_leak: tells.cdcLeak, notif_default: null, media_device_count: null, // Phase 38: CSS media-query input-model capabilities. media_pointer_fine: mediaCaps.pointer_fine, media_pointer_coarse: mediaCaps.pointer_coarse, media_hover_hover: mediaCaps.hover_hover, media_any_pointer_fine: mediaCaps.any_pointer_fine, media_color_gamut_p3: mediaCaps.color_gamut_p3, media_prefers_reduced_motion: mediaCaps.prefers_reduced_motion, media_forced_colors: mediaCaps.forced_colors, media_orientation_type: mediaCaps.orientation_type, // Phase 39: OS-signature font presence counts (complete beacon only). font_win_score: fonts ? fonts.win : null, font_mac_score: fonts ? fonts.mac : null, font_linux_score: fonts ? fonts.linux : null, font_android_score: fonts ? fonts.android : null, font_has_arial: fonts ? fonts.arial : null, // Phase 43: JS-engine-exclusive globals + version-fragile tells (synchronous). js_error_stack_limit: jsEng.error_stack_limit, js_install_trigger: jsEng.install_trigger, js_safari_obj: jsEng.safari_obj, js_tan_pi2_len: jsEng.tan_pi2_len, js_intl_ar_hash: jsEng.intl_ar_hash, js_shared_array_buf: jsEng.shared_array_buf, dns_token: dnsToken, }; // Phase 30: early ping — fire-and-forget before any probe starts. // Sends the synchronously-available identity fields immediately so the // aggregator records beaconReceivedAt ≈ t0, enabling h2/dns/enrichment joins // even when the visitor leaves before the probe race finishes. // The ping does NOT set sessionStorage (so the complete can still fire on the // same tab load), does NOT signal delivered, and does NOT block probe start. (function sendPing() { var pingBody = JSON.stringify({ session_id: sessionId, ua: navigator.userAgent, nav_platform: navigator.platform || null, webdriver: tells.webdriver, window_chrome: tells.windowChrome, timezone_id: tz, timezone_offset: new Date().getTimezoneOffset(), screen_width: screen.width != null ? screen.width : null, screen_height: screen.height != null ? screen.height : null, nav_languages: Array.from(navigator.languages || []).join(',') || null, canvas_hash: payload.canvas_hash, // Phase 38: primary input-model bits in the ping so a fast-bounce visitor // still delivers the media-caps contradiction signal. media_pointer_fine: mediaCaps.pointer_fine, media_pointer_coarse: mediaCaps.pointer_coarse, media_hover_hover: mediaCaps.hover_hover, // Phase 40: cheap synchronous automation tells in the ping too. cdc_leak: tells.cdcLeak, plugins_len: tells.pluginsLen, // Phase 41: synchronous canvas-GPU hash in the ping too. canvas_gpu_hash: payload.canvas_gpu_hash, // Phase 43: scored JS-engine markers in the ping too (synchronous). js_error_stack_limit: jsEng.error_stack_limit, js_install_trigger: jsEng.install_trigger, js_safari_obj: jsEng.safari_obj, dns_token: dnsToken, beacon_stage: 'ping', }); try { fetch('/api/beacon', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: pingBody, keepalive: true, }).catch(function () { /* best-effort */ }); } catch (e) { /* sendPing is fully fire-and-forget */ } // Plan 004 (inline bot-redirect / TDS): also feed the ping to the edge's // connection-time fast-verdict endpoint. Phase 0 is SHADOW — the response // (a would-be routing decision) is intentionally ignored here; the edge // only measures. A later phase will read it and act. Same body, fully // fire-and-forget, never blocks capture. try { fetch('/api/fast-beacon', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: pingBody, keepalive: true, }).catch(function () { /* best-effort — shadow, response ignored */ }); } catch (e) { /* fully fire-and-forget */ } })(); // deliver() sends the complete payload (beacon_stage='complete'). // Called either by the probe-race resolution or by the unload handlers. // Unload fires beacon_complete=false (partial); probe completion fires true. // The sessionStorage key is set only on a successful fetch response so a // remount (e.g. tab backgrounded then foregrounded) can still send a complete // if the first one was an unload sendBeacon with no response confirmation. function deliver(viaUnload) { if (delivered) return; delivered = true; payload.beacon_complete = acquired; payload.beacon_stage = 'complete'; // Phase 42: fold in behavioral-entropy metrics (detaches listeners + computes // variances). Only present when the feature flag enabled the sampler; the rule // ignores anything from a partial (unload) beacon. if (behavioral) { try { var b = behavioral.collect(); payload.ptr_sample_count = b.ptr_sample_count; payload.ptr_variance = b.ptr_variance; payload.click_count = b.click_count; payload.click_variance = b.click_variance; payload.scroll_count = b.scroll_count; payload.scroll_dir_changes = b.scroll_dir_changes; payload.key_count = b.key_count; payload.key_variance = b.key_variance; payload.touch_fired = b.touch_fired; } catch (e) { /* behavioral is best-effort */ } } // sendBeacon budget: 64 KB. Our payload is well under 10 KB even with all // probe fields filled — well within budget. var body = JSON.stringify(payload); if (viaUnload && typeof navigator.sendBeacon === 'function') { navigator.sendBeacon('/api/beacon', new Blob([body], { type: 'application/json' })); try { sessionStorage.setItem(key, '1'); } catch (e) { /* ignore */ } signalDelivered(); return; } signalDelivered(); fetch('/api/beacon', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: body, keepalive: true, }) .then(function (res) { if (res.ok) { try { sessionStorage.setItem(key, '1'); } catch (e) { /* ignore */ } } }) .catch(function () { /* aggregator down / not through the edge */ }); } function onPageHide() { deliver(true); } function onVisibility() { if (document.visibilityState === 'hidden') deliver(true); } window.addEventListener('pagehide', onPageHide); document.addEventListener('visibilitychange', onVisibility); var run = (async function () { // Fire EVERY probe up front, concurrently — BEFORE React hydration // monopolizes the main thread (~1.6-2.3s), so their network I/O is already // in flight and nothing waits for the thread to free up. RTT loses its // "quiet connection" but under contention it only reads HIGHER, which is // safe for rtt-vs-geo (that rule flags an impossibly-LOW round trip for the // geo distance, never a high one). h2/h3/dns/v6 are captured server-side by // session id regardless, so their exact payload values aren't load-bearing. var r = await Promise.all([ probeDualStack(sessionId), // r[0] probeH3(sessionId), // r[1] probeWebrtc(), // r[2] permContradiction(), // r[3] → { contradiction, notifDefault } probeH2(sessionId), // r[4] probeDns(dnsToken), // r[5] measureRtt(), // r[6] probeDeviceCount(), // r[7] (Phase 40) audioHash(), // r[8] (Phase 41) ]); Object.assign(payload, r[0], r[1], r[4]); // dualStack, h3, h2 payload.webrtc = r[2]; // Phase 40: permContradiction now returns an object carrying both signals. payload.perm_contradiction = r[3] ? r[3].contradiction : null; payload.notif_default = r[3] ? r[3].notifDefault : null; payload.rtt_ms = r[6]; payload.media_device_count = r[7]; payload.audio_hash = r[8]; acquired = true; })(); Promise.race([run, new Promise(function (resolve) { setTimeout(resolve, BEACON_DEADLINE_MS); })]) .then(function () { deliver(false); }) .catch(function () { deliver(false); }); })();