@magield/collectors 0.20.0 → 0.21.0

package/dist/registry.js

@@ -1,3 +1,4 @@
+import { gpuTimingCollector } from './signals/gpu-timing.js';
 import { adblockCollector } from './signals/adblock.js';
 import { appsCollector } from './signals/apps.js';
 import { audioCollector } from './signals/audio.js';
@@ -76,7 +77,7 @@ export const COLLECTOR_IDS = ALL_COLLECTORS.map((c) => c.id);
  * The split is the product position, not a technical one. `docs/` says what
  * Magic Shield collects by default, and this is the list that is not in it.
  */
-export const INVASIVE_COLLECTORS = [webrtcCollector, adblockCollector, appsCollector];
+export const INVASIVE_COLLECTORS = [webrtcCollector, adblockCollector, appsCollector, gpuTimingCollector];
 /**
  * Removed: localPortsCollector.
  *

package/dist/signals/gpu-timing.d.ts

@@ -0,0 +1,2 @@
+import type { Collector } from '../types.js';
+export declare const gpuTimingCollector: Collector;

package/dist/signals/gpu-timing.js

@@ -0,0 +1,157 @@
+/**
+ * How long this GPU takes to finish work stalled on each of a few points.
+ *
+ * A trial, in `INVASIVE_COLLECTORS`, and named `gputiming`: it costs a few
+ * hundred milliseconds of GPU and battery on the device, which is a decision
+ * for the page, not a default. Nothing scores it. It exists to answer one
+ * question on real traffic: can it tell apart phones of the same model, which
+ * is what a phone farm is and what every other signal here cannot?
+ *
+ * ## The idea
+ *
+ * DrawnApart (NDSS 2022, Laperdrix, Rudametkin, Oren et al.) showed that the
+ * execution units of one GPU model run at slightly different speeds, and that
+ * timing a draw in which one vertex does heavy work, moved from point to point,
+ * yields a vector particular to the physical chip. Canvas noise does not touch
+ * it, because it measures time rather than pixels. Reported accuracy on
+ * identical hardware ranged from about 36% to over 90% depending on the GPU,
+ * and nobody has measured it on low-end Android, which is the reason this is a
+ * trial collector and not a signal.
+ *
+ * ## What is sent
+ *
+ *   gpu.timing     the median time for each stall position, divided by their
+ *                  mean, three decimals, comma-joined: the shape, not the
+ *                  speed, so a busy or throttled phone still gives its own shape
+ *   gpu.timingMs   what the measurement cost on this device, to judge the trial
+ *   gpu.supported  false where there is no WebGL
+ *
+ * Bounded by its own deadline well inside the deep wave's budget: a slow GPU
+ * gets a partial measurement reported as null rather than a slow login.
+ */
+/** Stall positions, and samples per position. */
+const POINTS = 8;
+const RUNS = 5;
+/** The whole measurement, calibration included, in milliseconds. */
+const DEADLINE_MS = 300;
+/** What one stalled draw should cost, so the timer's coarseness stays small beside it. */
+const TARGET_DRAW_MS = 4;
+const VERTEX = `
+attribute float a_index;
+uniform float u_stall;
+uniform int u_work;
+void main() {
+  float acc = a_index;
+  if (abs(a_index - u_stall) < 0.5) {
+    for (int i = 0; i < 100000; i++) {
+      if (i >= u_work) break;
+      acc = sin(acc) * 1.0001 + cos(acc * 0.999);
+    }
+  }
+  gl_PointSize = 1.0;
+  gl_Position = vec4(acc * 1e-9, 0.0, 0.0, 1.0);
+}`;
+const FRAGMENT = `
+precision mediump float;
+void main() { gl_FragColor = vec4(0.0, 0.0, 0.0, 1.0); }`;
+export const gpuTimingCollector = {
+    id: 'gputiming',
+    wave: 'deep',
+    optional: true,
+    collect({ document, performance }) {
+        const out = {};
+        const started = performance.now();
+        let gl = null;
+        try {
+            const canvas = document.createElement('canvas');
+            canvas.width = 1;
+            canvas.height = 1;
+            gl = canvas.getContext('webgl');
+        }
+        catch {
+            gl = null;
+        }
+        if (gl === null) {
+            out['gpu.supported'] = false;
+            out['gpu.timing'] = null;
+            return out;
+        }
+        out['gpu.supported'] = true;
+        const program = link(gl);
+        if (program === undefined) {
+            out['gpu.timing'] = null;
+            return out;
+        }
+        gl.useProgram(program);
+        const buffer = gl.createBuffer();
+        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+        gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(Array.from({ length: POINTS }, (_, i) => i)), gl.STATIC_DRAW);
+        const index = gl.getAttribLocation(program, 'a_index');
+        gl.enableVertexAttribArray(index);
+        gl.vertexAttribPointer(index, 1, gl.FLOAT, false, 0, 0);
+        const stall = gl.getUniformLocation(program, 'u_stall');
+        const work = gl.getUniformLocation(program, 'u_work');
+        const context = gl;
+        const draw = (position, iterations) => {
+            context.uniform1f(stall, position);
+            context.uniform1i(work, iterations);
+            const t0 = performance.now();
+            context.drawArrays(context.POINTS, 0, POINTS);
+            context.finish();
+            return performance.now() - t0;
+        };
+        // Calibrate the work so one stalled draw costs about TARGET_DRAW_MS here:
+        // a fast GPU needs more of it to rise above the timer's resolution, a slow
+        // one less to stay inside the deadline.
+        let iterations = 2000;
+        for (let attempt = 0; attempt < 4; attempt++) {
+            const ms = Math.max(0.05, draw(0, iterations));
+            if (ms > TARGET_DRAW_MS * 0.5 && ms < TARGET_DRAW_MS * 2)
+                break;
+            iterations = Math.max(100, Math.min(100_000, Math.round((iterations * TARGET_DRAW_MS) / ms)));
+            if (performance.now() - started > DEADLINE_MS / 3)
+                break;
+        }
+        const samples = Array.from({ length: POINTS }, () => []);
+        // Interleaved, so a thermal or scheduling drift during the measurement
+        // falls on every position alike instead of on the last ones.
+        for (let run = 0; run < RUNS; run++) {
+            for (let position = 0; position < POINTS; position++) {
+                if (performance.now() - started > DEADLINE_MS) {
+                    out['gpu.timing'] = null;
+                    out['gpu.timingMs'] = Math.round(performance.now() - started);
+                    return out;
+                }
+                samples[position]?.push(draw(position, iterations));
+            }
+        }
+        const medians = samples.map(median);
+        const mean = medians.reduce((sum, value) => sum + value, 0) / medians.length;
+        out['gpu.timing'] = mean > 0 ? medians.map((value) => (value / mean).toFixed(3)).join(',') : null;
+        out['gpu.timingMs'] = Math.round(performance.now() - started);
+        return out;
+    },
+};
+function link(gl) {
+    const compile = (type, source) => {
+        const shader = gl.createShader(type);
+        if (shader === null)
+            return undefined;
+        gl.shaderSource(shader, source);
+        gl.compileShader(shader);
+        return gl.getShaderParameter(shader, gl.COMPILE_STATUS) === true ? shader : undefined;
+    };
+    const vertex = compile(gl.VERTEX_SHADER, VERTEX);
+    const fragment = compile(gl.FRAGMENT_SHADER, FRAGMENT);
+    const program = gl.createProgram();
+    if (vertex === undefined || fragment === undefined || program === null)
+        return undefined;
+    gl.attachShader(program, vertex);
+    gl.attachShader(program, fragment);
+    gl.linkProgram(program);
+    return gl.getProgramParameter(program, gl.LINK_STATUS) === true ? program : undefined;
+}
+function median(values) {
+    const sorted = [...values].sort((a, b) => a - b);
+    return sorted[Math.floor(sorted.length / 2)] ?? 0;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@magield/collectors",
-  "version": "0.20.0",
+  "version": "0.21.0",
   "description": "Browser signal collectors used by the Magic Shield web SDK",
   "license": "SEE LICENSE IN LICENSE",
   "files": [