@cloudglides/veil 0.1.0

package/src/entropy/permissions.ts

@@ -0,0 +1,15 @@
+export async function getPermissionsEntropy(): Promise<string> {
+  const perms = [];
+  const checks = ["geolocation", "notifications", "camera", "microphone"];
+
+  for (const perm of checks) {
+    try {
+      const result = await navigator.permissions.query({ name: perm as any });
+      perms.push(`${perm}:${result.state}`);
+    } catch {
+      perms.push(`${perm}:unknown`);
+    }
+  }
+
+  return perms.join("|");
+}

package/src/entropy/plugins.ts

@@ -0,0 +1,14 @@
+export async function getPluginsEntropy(): Promise<string> {
+  const plugins = Array.from(navigator.plugins).map((p) => p.name);
+  const pluginStr = plugins.join("|");
+  
+  const pluginCount = plugins.length;
+  const pluginEntropy = pluginCount > 0 
+    ? -plugins.reduce((h, p) => {
+        const p_freq = 1 / pluginCount;
+        return h + p_freq * Math.log2(p_freq);
+      }, 0)
+    : 0;
+  
+  return `count:${pluginCount}|H(plugins)=${pluginEntropy.toFixed(3)}|plugins:${pluginStr || "none"}`;
+}

package/src/entropy/preferences.ts

@@ -0,0 +1,12 @@
+export async function getPreferencesEntropy(): Promise<string> {
+  const darkMode = window.matchMedia("(prefers-color-scheme: dark)").matches;
+  const reducedMotion = window.matchMedia("(prefers-reduced-motion: reduce)").matches;
+  const highContrast = window.matchMedia("(prefers-contrast: more)").matches;
+  
+  const prefCount = [darkMode, reducedMotion, highContrast].filter(Boolean).length;
+  const maxCombinations = Math.pow(2, 3);
+  const preferenceBits = Math.log2(maxCombinations);
+  const actualEntropy = prefCount > 0 ? -((prefCount / 3) * Math.log2(prefCount / 3) + ((3 - prefCount) / 3) * Math.log2((3 - prefCount) / 3)) : 0;
+  
+  return `dark:${darkMode}|motion:${reducedMotion}|contrast:${highContrast}|enabled:${prefCount}|H(pref)=${actualEntropy.toFixed(3)}`;
+}

package/src/entropy/probabilistic.ts

@@ -0,0 +1,20 @@
+export async function getProbabilisticEntropy(): Promise<string> {
+  const metrics = [];
+  
+  const screen_values = [screen.width, screen.height, screen.colorDepth];
+  const hw_values = [navigator.hardwareConcurrency || 1, (navigator as any).deviceMemory || 4];
+  const all_values = [...screen_values, ...hw_values];
+
+  const mean = all_values.reduce((a, b) => a + b) / all_values.length;
+  const sorted = [...all_values].sort((a, b) => a - b);
+  const median = sorted[Math.floor(sorted.length / 2)];
+  const q1 = sorted[Math.floor(sorted.length / 4)];
+  const q3 = sorted[Math.floor(sorted.length * 3 / 4)];
+  const iqr = q3 - q1;
+
+  metrics.push(`mean:${mean.toFixed(2)}`);
+  metrics.push(`median:${median.toFixed(2)}`);
+  metrics.push(`iqr:${iqr.toFixed(2)}`);
+
+  return metrics.join("|");
+}

package/src/entropy/screen.ts

@@ -0,0 +1,12 @@
+export async function getScreenEntropy(): Promise<string> {
+  const w = screen.width;
+  const h = screen.height;
+  const d = screen.colorDepth;
+  
+  const pixelCount = w * h;
+  const totalColors = Math.pow(2, d);
+  const colorSpace = Math.log2(totalColors);
+  const screenSurface = Math.log2(pixelCount);
+  
+  return `${w}x${h}|colors:${d}|log₂(A)=${screenSurface.toFixed(2)}|log₂(C)=${colorSpace.toFixed(2)}`;
+}

package/src/entropy/screenInfo.ts

@@ -0,0 +1,8 @@
+export async function getScreenInfoEntropy(): Promise<string> {
+  const width = screen.width;
+  const height = screen.height;
+  const depth = screen.colorDepth;
+  const pixelDepth = screen.pixelDepth;
+  const devicePixelRatio = window.devicePixelRatio;
+  return `${width}x${height}|depth:${depth}|px:${pixelDepth}|ratio:${devicePixelRatio}`;
+}

package/src/entropy/spectral.ts

@@ -0,0 +1,8 @@
+import { spectral } from "./veil_core.js";
+import { seededRng } from "../seeded-rng";
+
+export async function getSpectralEntropy(seed: string): Promise<string> {
+  const samples = seededRng(seed, 128);
+  const entropy = spectral(new Float64Array(samples));
+  return `spectral:${entropy.toFixed(6)}`;
+}

package/src/entropy/statistical.ts

@@ -0,0 +1,15 @@
+export async function getStatisticalEntropy(): Promise<string> {
+  const ua = navigator.userAgent;
+  const freq: Record<string, number> = {};
+  
+  for (const char of ua) {
+    freq[char] = (freq[char] || 0) + 1;
+  }
+
+  const values = Object.values(freq);
+  const mean = values.reduce((a, b) => a + b) / values.length;
+  const variance = values.reduce((a, b) => a + Math.pow(b - mean, 2), 0) / values.length;
+  const stdDev = Math.sqrt(variance);
+
+  return `mean:${mean.toFixed(4)}|var:${variance.toFixed(4)}|std:${stdDev.toFixed(4)}`;
+}

package/src/entropy/storage.ts

@@ -0,0 +1,22 @@
+export async function getStorageEntropy(): Promise<string> {
+  let ls = false;
+  let idb = false;
+
+  try {
+    const test = "__storage_test__";
+    window.localStorage.setItem(test, test);
+    window.localStorage.removeItem(test);
+    ls = true;
+  } catch {
+    ls = false;
+  }
+
+  try {
+    const request = window.indexedDB.open("__idb_test__");
+    idb = true;
+  } catch {
+    idb = false;
+  }
+
+  return `localStorage:${ls}|indexedDB:${idb}`;
+}

package/src/entropy/timezone.ts

@@ -0,0 +1,10 @@
+export async function getTimezoneEntropy(): Promise<string> {
+  const tz = Intl.DateTimeFormat().resolvedOptions().timeZone;
+  const offset = new Date().getTimezoneOffset();
+  
+  const tzEntropy = Math.log2(Math.abs(offset) + 1);
+  const offsetBits = offset.toString().length * 8;
+  const tzUniqueness = Math.log2(24 * 60 / Math.max(Math.abs(offset), 1));
+  
+  return `TZ:${tz}|offset:${offset}|H(TZ)=${tzEntropy.toFixed(3)}|U=${tzUniqueness.toFixed(3)}`;
+}

package/src/entropy/userAgent.ts

@@ -0,0 +1,16 @@
+export async function getUserAgentEntropy(): Promise<string> {
+  const ua = navigator.userAgent;
+  
+  let entropy = 0;
+  const freq: Record<string, number> = {};
+  for (const char of ua) {
+    freq[char] = (freq[char] || 0) + 1;
+  }
+  
+  for (const count of Object.values(freq)) {
+    const p = count / ua.length;
+    entropy -= p * Math.log2(p);
+  }
+  
+  return `${ua}|H(UA)=${entropy.toFixed(4)}`;
+}

package/src/entropy/webFeatures.ts

@@ -0,0 +1,21 @@
+export async function getWebFeaturesEntropy(): Promise<string> {
+  const features = {
+    localStorage: !!window.localStorage,
+    sessionStorage: !!window.sessionStorage,
+    indexedDB: !!window.indexedDB,
+    openDatabase: !!(window as any).openDatabase,
+    serviceWorker: !!navigator.serviceWorker,
+    webWorker: typeof Worker !== "undefined",
+    geolocation: !!navigator.geolocation,
+    notifications: !!window.Notification,
+  };
+  
+  const enabled = Object.values(features).filter(Boolean).length;
+  const total = Object.keys(features).length;
+  const supportRatio = enabled / total;
+  const supportEntropy = Math.log2(total) * (1 - Math.abs(supportRatio - 0.5) * 2);
+  
+  return `enabled:${enabled}/${total}|σ=${supportRatio.toFixed(3)}|H(features)=${supportEntropy.toFixed(3)}|${Object.entries(features)
+    .map(([k, v]) => `${k}:${v}`)
+    .join("|")}`;
+}

package/src/entropy/webgl.ts

@@ -0,0 +1,11 @@
+export async function getWebGLEntropy(): Promise<string> {
+  const canvas = document.createElement("canvas");
+  const gl = canvas.getContext("webgl") || canvas.getContext("webgl2");
+  if (!gl) return "webgl:unavailable";
+
+  const vendor = gl.getParameter(gl.VENDOR) || "unknown";
+  const renderer = gl.getParameter(gl.RENDERER) || "unknown";
+  const version = gl.getParameter(gl.VERSION) || "unknown";
+  
+  return `vendor:${vendor}|renderer:${renderer}|version:${version}`;
+}

package/src/gpu.ts

@@ -0,0 +1,132 @@
+export async function runGPUBenchmark(): Promise<{
+  renderTime: number;
+  textureOps: number;
+  shaderPerformance: number;
+}> {
+  const canvas = document.createElement("canvas");
+  canvas.width = 512;
+  canvas.height = 512;
+
+  const gl = canvas.getContext("webgl2") || canvas.getContext("webgl");
+  if (!gl) {
+    return { renderTime: 0, textureOps: 0, shaderPerformance: 0 };
+  }
+
+  const start = performance.now();
+
+  const vertexShader = gl.createShader(gl.VERTEX_SHADER);
+  if (!vertexShader) return { renderTime: 0, textureOps: 0, shaderPerformance: 0 };
+  
+  gl.shaderSource(
+    vertexShader,
+    `
+    attribute vec2 position;
+    void main() {
+      gl_Position = vec4(position, 0.0, 1.0);
+    }
+  `,
+  );
+  gl.compileShader(vertexShader);
+
+  const fragmentShader = gl.createShader(gl.FRAGMENT_SHADER);
+  if (!fragmentShader) return { renderTime: 0, textureOps: 0, shaderPerformance: 0 };
+  
+  gl.shaderSource(
+    fragmentShader,
+    `
+    precision highp float;
+    uniform sampler2D tex;
+    void main() {
+      gl_FragColor = texture2D(tex, vec2(0.5, 0.5));
+    }
+  `,
+  );
+  gl.compileShader(fragmentShader);
+
+  const program = gl.createProgram();
+  if (!program) return { renderTime: 0, textureOps: 0, shaderPerformance: 0 };
+  
+  gl.attachShader(program, vertexShader);
+  gl.attachShader(program, fragmentShader);
+  gl.linkProgram(program);
+  gl.useProgram(program);
+
+  const positionBuffer = gl.createBuffer();
+  gl.bindBuffer(gl.ARRAY_BUFFER, positionBuffer);
+  gl.bufferData(
+    gl.ARRAY_BUFFER,
+    new Float32Array([-1, -1, 1, -1, -1, 1, 1, 1]),
+    gl.STATIC_DRAW,
+  );
+
+  const texture = gl.createTexture();
+  gl.bindTexture(gl.TEXTURE_2D, texture);
+  gl.texImage2D(
+    gl.TEXTURE_2D,
+    0,
+    gl.RGBA,
+    256,
+    256,
+    0,
+    gl.RGBA,
+    gl.UNSIGNED_BYTE,
+    new Uint8Array(256 * 256 * 4).fill(128),
+  );
+
+  for (let i = 0; i < 100; i++) {
+    gl.clear(gl.COLOR_BUFFER_BIT);
+    gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
+  }
+
+  gl.readPixels(0, 0, 1, 1, gl.RGBA, gl.UNSIGNED_BYTE, new Uint8Array(4));
+
+  const renderTime = performance.now() - start;
+
+  const textureOps = 100;
+  const shaderPerformance = 512 * 512 * 100 / (renderTime || 1);
+
+  gl.deleteShader(vertexShader);
+  gl.deleteShader(fragmentShader);
+  gl.deleteProgram(program);
+  gl.deleteBuffer(positionBuffer);
+  gl.deleteTexture(texture);
+
+  canvas.remove();
+
+  return {
+    renderTime,
+    textureOps,
+    shaderPerformance,
+  };
+}
+
+export async function getGPUHash(): Promise<string> {
+  const benchmark = await runGPUBenchmark();
+  const canvas = document.createElement("canvas");
+  canvas.width = 256;
+  canvas.height = 256;
+
+  const ctx = canvas.getContext("2d");
+  if (!ctx) return "";
+
+  for (let i = 0; i < 256; i++) {
+    for (let j = 0; j < 256; j++) {
+      const hue = (benchmark.renderTime * (i + j)) % 360;
+      const sat = (benchmark.shaderPerformance * i) % 100;
+      const lum = (benchmark.textureOps * j) % 100;
+
+      ctx.fillStyle = `hsl(${hue}, ${sat}%, ${lum}%)`;
+      ctx.fillRect(i, j, 1, 1);
+    }
+  }
+
+  const imageData = ctx.getImageData(0, 0, 256, 256);
+  const data = imageData.data;
+
+  let hash = 0;
+  for (let i = 0; i < data.length; i += 4) {
+    hash ^= ((data[i] + data[i + 1] + data[i + 2]) * (i * 1)) >> 0;
+  }
+
+  return hash.toString(16);
+}

package/src/index.test.ts

@@ -0,0 +1,26 @@
+import { describe, it, expect } from "vitest";
+import { getFingerprint } from "./index";
+
+describe("veil fingerprinting", () => {
+  it("should generate consistent fingerprint", async () => {
+    const fp1 = await getFingerprint();
+    const fp2 = await getFingerprint();
+    expect(fp1).toBe(fp2);
+  });
+
+  it("should generate different fingerprints with different options", async () => {
+    const fp1 = await getFingerprint({ entropy: { canvas: true } });
+    const fp2 = await getFingerprint({ entropy: { canvas: false } });
+    expect(fp1).not.toBe(fp2);
+  });
+
+  it("should support SHA-512", async () => {
+    const fp = await getFingerprint({ hash: "sha512" });
+    expect(fp.length).toBeGreaterThan(64);
+  });
+
+  it("should return hex string", async () => {
+    const fp = await getFingerprint();
+    expect(/^[a-f0-9]+$/.test(fp)).toBe(true);
+  });
+});

package/src/index.ts

@@ -0,0 +1,198 @@
+import type { FingerprintOptions, FingerprintResponse, SourceMetric } from "./types";
+import { getUserAgentEntropy } from "./entropy/userAgent";
+import { getCanvasEntropy } from "./entropy/canvas";
+import { getWebGLEntropy } from "./entropy/webgl";
+import { getFontsEntropy } from "./entropy/fonts";
+import { getStorageEntropy } from "./entropy/storage";
+import { getScreenEntropy } from "./entropy/screen";
+import { getDistributionEntropy } from "./entropy/distribution";
+import { getComplexityEntropy } from "./entropy/complexity";
+import { getSpectralEntropy } from "./entropy/spectral";
+import { getApproximateEntropy } from "./entropy/approximate";
+import { getOSEntropy } from "./entropy/os";
+import { getLanguageEntropy } from "./entropy/language";
+import { getTimezoneEntropy } from "./entropy/timezone";
+import { getHardwareEntropy } from "./entropy/hardware";
+import { getPluginsEntropy } from "./entropy/plugins";
+import { getBrowserEntropy } from "./entropy/browser";
+import { getOSVersionEntropy } from "./entropy/osVersion";
+import { getScreenInfoEntropy } from "./entropy/screenInfo";
+import { getAdblockEntropy } from "./entropy/adblock";
+import { getWebFeaturesEntropy } from "./entropy/webFeatures";
+import { getPreferencesEntropy } from "./entropy/preferences";
+import { getPermissionsEntropy } from "./entropy/permissions";
+import { getStatisticalEntropy } from "./entropy/statistical";
+import { getProbabilisticEntropy } from "./entropy/probabilistic";
+import {
+  murmur_hash,
+  fnv_hash,
+  shannon_entropy,
+  kolmogorov_complexity,
+} from "./veil_core.js";
+import * as normalize from "./normalize";
+import { initializeWasm } from "./wasm-loader";
+import { scoreFingerprint, calculateEntropy, type EntropySource } from "./scoring";
+import { getGPUHash, runGPUBenchmark } from "./gpu";
+import { getCPUHash, runCPUBenchmark } from "./cpu";
+import { seededRng } from "./seeded-rng";
+
+export async function getFingerprint(
+  options?: FingerprintOptions,
+): Promise<string | FingerprintResponse> {
+  await initializeWasm();
+
+  const opts = {
+    entropy: {},
+    hash: "sha256",
+    ...options,
+  };
+
+  const sources: EntropySource[] = [];
+
+  if (opts.entropy.userAgent !== false) {
+    const value = await getUserAgentEntropy();
+    sources.push({ name: "userAgent", value, entropy: calculateEntropy(value) });
+  }
+
+  if (opts.entropy.canvas !== false) {
+    const value = await getCanvasEntropy();
+    sources.push({ name: "canvas", value, entropy: calculateEntropy(value) });
+  }
+
+  if (opts.entropy.webgl !== false) {
+    const value = await getWebGLEntropy();
+    sources.push({ name: "webgl", value, entropy: calculateEntropy(value) });
+  }
+
+  if (opts.entropy.fonts !== false) {
+    const value = await getFontsEntropy();
+    sources.push({ name: "fonts", value, entropy: calculateEntropy(value) });
+  }
+
+  if (opts.entropy.storage !== false) {
+    const value = await getStorageEntropy();
+    sources.push({ name: "storage", value, entropy: calculateEntropy(value) });
+  }
+
+  if (opts.entropy.screen !== false) {
+    const value = await getScreenEntropy();
+    sources.push({ name: "screen", value, entropy: calculateEntropy(value) });
+  }
+
+  const baseSeed = sources.map(s => s.value).join("|");
+  
+  sources.push({ name: "distribution", value: await getDistributionEntropy(baseSeed), entropy: 0 });
+  sources.push({ name: "complexity", value: await getComplexityEntropy(), entropy: 0 });
+  sources.push({ name: "spectral", value: await getSpectralEntropy(baseSeed), entropy: 0 });
+  sources.push({ name: "approximate", value: await getApproximateEntropy(baseSeed), entropy: 0 });
+  sources.push({ name: "os", value: await getOSEntropy(), entropy: 0 });
+  sources.push({ name: "language", value: await getLanguageEntropy(), entropy: 0 });
+  sources.push({ name: "timezone", value: await getTimezoneEntropy(), entropy: 0 });
+  sources.push({ name: "hardware", value: await getHardwareEntropy(), entropy: 0 });
+  sources.push({ name: "plugins", value: await getPluginsEntropy(), entropy: 0 });
+  sources.push({ name: "browser", value: await getBrowserEntropy(), entropy: 0 });
+  sources.push({ name: "osVersion", value: await getOSVersionEntropy(), entropy: 0 });
+  sources.push({ name: "screenInfo", value: await getScreenInfoEntropy(), entropy: 0 });
+  sources.push({ name: "adblock", value: await getAdblockEntropy(), entropy: 0 });
+  sources.push({ name: "webFeatures", value: await getWebFeaturesEntropy(), entropy: 0 });
+  sources.push({ name: "preferences", value: await getPreferencesEntropy(), entropy: 0 });
+  sources.push({ name: "permissions", value: await getPermissionsEntropy(), entropy: 0 });
+  sources.push({ name: "statistical", value: await getStatisticalEntropy(), entropy: 0 });
+  sources.push({ name: "probabilistic", value: await getProbabilisticEntropy(), entropy: 0 });
+
+  for (const source of sources) {
+    if (source.entropy === 0) {
+      source.entropy = calculateEntropy(source.value);
+    }
+  }
+
+  const score = scoreFingerprint(sources);
+
+  const data = sources.map(s => s.value);
+
+  const dataStr = data.join("|");
+  const shannon = shannon_entropy(dataStr);
+  const kolmogorov = kolmogorov_complexity(dataStr);
+  const murmur = murmur_hash(dataStr);
+  const fnv = fnv_hash(dataStr);
+
+  const mathMetrics = `${shannon}|${kolmogorov}|${murmur}|${fnv}`;
+  const combined = dataStr + "|" + mathMetrics;
+
+  const algorithm = opts.hash === "sha512" ? "SHA-512" : "SHA-256";
+  const hash = await crypto.subtle.digest(
+    algorithm,
+    new TextEncoder().encode(combined),
+  );
+
+  let fingerprint = Array.from(new Uint8Array(hash))
+    .map((b) => b.toString(16).padStart(2, "0"))
+    .join("");
+
+  if (opts.gpuBenchmark) {
+    const gpuHash = await getGPUHash();
+    fingerprint = Array.from(new Uint8Array(
+      await crypto.subtle.digest("SHA-256", new TextEncoder().encode(fingerprint + gpuHash))
+    ))
+      .map((b) => b.toString(16).padStart(2, "0"))
+      .join("");
+  }
+
+  if (opts.cpuBenchmark) {
+    const cpuHash = await getCPUHash();
+    fingerprint = Array.from(new Uint8Array(
+      await crypto.subtle.digest("SHA-256", new TextEncoder().encode(fingerprint + cpuHash))
+    ))
+      .map((b) => b.toString(16).padStart(2, "0"))
+      .join("");
+  }
+
+  if (opts.detailed) {
+    const os = await getOSVersionEntropy();
+    const lang = await getLanguageEntropy();
+    const tz = await getTimezoneEntropy();
+    const hw = await getHardwareEntropy();
+    const sr = await getScreenInfoEntropy();
+    const ua = await getUserAgentEntropy();
+    const browser = await getBrowserEntropy();
+
+    const sourceMetrics: SourceMetric[] = sources.map(s => ({
+      source: s.name,
+      value: s.value,
+      entropy: s.entropy,
+      confidence: score.likelihood > 0 ? Math.min(s.entropy / score.likelihood, 1) : 0,
+    }));
+
+    const response: FingerprintResponse = {
+      hash: fingerprint,
+      uniqueness: score.uniqueness,
+      confidence: score.confidence,
+      sources: sourceMetrics,
+      system: {
+        os,
+        language: lang.split("|")[0],
+        timezone: tz.split("|")[0],
+        hardware: {
+          cores: navigator.hardwareConcurrency || 0,
+          memory: (navigator as any).deviceMemory || 0,
+        },
+      },
+      display: {
+        resolution: `${screen.width}x${screen.height}`,
+        colorDepth: screen.colorDepth,
+        devicePixelRatio: window.devicePixelRatio,
+      },
+      browser: {
+        userAgent: navigator.userAgent,
+        vendor: navigator.vendor,
+        cookieEnabled: navigator.cookieEnabled,
+      },
+    };
+
+    return response;
+  }
+
+  return fingerprint;
+}
+
+export type { FingerprintOptions, FingerprintResponse } from "./types";

package/src/normalize/index.ts

@@ -0,0 +1,31 @@
+export function normalizeScreen(width: number, height: number): string {
+  const bucketSize = 100;
+  const bw = Math.floor(width / bucketSize) * bucketSize;
+  const bh = Math.floor(height / bucketSize) * bucketSize;
+  return `${bw}x${bh}`;
+}
+
+export function normalizeTimezone(tz: string): string {
+  return tz.split("/")[0];
+}
+
+export function normalizeUserAgent(ua: string): string {
+  const parts = ua.split(" ");
+  return parts.slice(0, 3).join(" ");
+}
+
+export function normalizeFloat(num: number, decimals: number = 10): string {
+  return num.toFixed(decimals);
+}
+
+export function normalizeCanvas(dataUrl: string): string {
+  return dataUrl.substring(0, 100);
+}
+
+export function normalizeStorage(storageStr: string): string {
+  const [localStorage, indexedDB] = storageStr.split("|");
+  const ls = localStorage.includes("true") ? "1" : "0";
+  const idb = indexedDB.includes("true") ? "1" : "0";
+
+  return `${ls}${idb}`;
+}

package/src/probability.ts

@@ -0,0 +1,11 @@
+export function calculateMean(values: number[]): number {
+  if (values.length === 0) return 0;
+  return values.reduce((a, b) => a + b, 0) / values.length;
+}
+
+export function hellingerDistance(p: number[], q: number[]): number {
+  if (p.length !== q.length) return 0;
+  
+  const sum = p.reduce((s, pi, i) => s + Math.pow(Math.sqrt(pi) - Math.sqrt(q[i]), 2), 0);
+  return Math.sqrt(sum / 2);
+}