@cloudglides/veil 0.1.1 → 1.0.1

package/src/entropy/approximate.ts

@@ -1,9 +0,0 @@
-import { getWasmModule } from "../wasm-loader";
-import { seededRng } from "../seeded-rng";
-
-export async function getApproximateEntropy(seed: string): Promise<string> {
-  const samples = seededRng(seed, 256);
-  const wasm = await getWasmModule();
-  const apen = wasm.approx_entropy(new Float64Array(samples), 2);
-  return `apen:${apen.toFixed(6)}`;
-}

package/src/entropy/audio.ts

@@ -1,17 +0,0 @@
-export async function getAudioEntropy(): Promise<string> {
-  try {
-    const ctx = new (window.AudioContext || (window as any).webkitAudioContext)();
-    const state = ctx.state;
-    const sampleRate = ctx.sampleRate;
-    
-    const bitDepth = 32;
-    const nyquistFreq = sampleRate / 2;
-    const frequencyBits = Math.log2(nyquistFreq + 1);
-    const audioCapacity = bitDepth * sampleRate;
-    
-    ctx.close();
-    return `state:${state}|sr:${sampleRate}|f_nyquist:${nyquistFreq}|H(audio)=${frequencyBits.toFixed(3)}`;
-  } catch {
-    return "audio:unavailable";
-  }
-}

package/src/entropy/battery.ts

@@ -1,10 +0,0 @@
-export async function getBatteryEntropy(): Promise<string> {
-  const nav = navigator as any;
-  if (!nav.getBattery) return "battery:unavailable";
-  try {
-    const battery = await nav.getBattery();
-    return `level:${battery.level}|charging:${battery.charging}`;
-  } catch {
-    return "battery:unavailable";
-  }
-}

package/src/entropy/browser.ts

@@ -1,7 +0,0 @@
-export async function getBrowserEntropy(): Promise<string> {
-  const ua = navigator.userAgent;
-  const vendor = navigator.vendor;
-  const cookieEnabled = navigator.cookieEnabled;
-  const doNotTrack = navigator.doNotTrack;
-  return `ua:${ua}|vendor:${vendor}|cookies:${cookieEnabled}|dnt:${doNotTrack}`;
-}

package/src/entropy/canvas.ts

@@ -1,17 +0,0 @@
-export async function getCanvasEntropy(): Promise<string> {
-  try {
-    const canvas = document.createElement("canvas");
-    if (canvas.getContext === undefined) return "canvas:unavailable";
-
-    const ctx = canvas.getContext("2d");
-    if (!ctx) return "canvas:unavailable";
-
-    const support = ctx.fillText ? "fillText" : "none";
-    const textMetrics = ctx.measureText ? "measureText" : "none";
-    const imageDataSupport = ctx.getImageData ? "getImageData" : "none";
-
-    return `support:${support}|metrics:${textMetrics}|imageData:${imageDataSupport}`;
-  } catch {
-    return "canvas:unavailable";
-  }
-}

package/src/entropy/complexity.ts

@@ -1,14 +0,0 @@
-import { getWasmModule } from "../wasm-loader";
-
-export async function getComplexityEntropy(): Promise<string> {
-  const ua = navigator.userAgent;
-  const bytes = new Uint8Array(ua.length);
-  
-  for (let i = 0; i < ua.length; i++) {
-    bytes[i] = ua.charCodeAt(i) % 256;
-  }
-
-  const wasm = await getWasmModule();
-  const complexity = wasm.lz_complexity(bytes);
-  return `lz:${complexity}`;
-}

package/src/entropy/connection.ts

@@ -1,14 +0,0 @@
-export async function getConnectionEntropy(): Promise<string> {
-  const nav = navigator as any;
-  const conn = nav.connection || nav.mozConnection || nav.webkitConnection;
-  if (!conn) return "connection:unknown";
-  
-  const rtt = conn.rtt || 0;
-  const downlink = conn.downlink || 0;
-  
-  const bandwidth = Math.log2(downlink * 1000 + 1);
-  const latencyEntropy = Math.log2(rtt + 2);
-  const connectionScore = (downlink / rtt) * 1000;
-  
-  return `type:${conn.effectiveType}|bw:${bandwidth.toFixed(3)}|H(RTT)=${latencyEntropy.toFixed(3)}|Q=${connectionScore.toFixed(2)}`;
-}

package/src/entropy/distribution.ts

@@ -1,9 +0,0 @@
-import { getWasmModule } from "../wasm-loader";
-import { seededRng } from "../seeded-rng";
-
-export async function getDistributionEntropy(seed: string): Promise<string> {
-  const samples = seededRng(seed, 1000);
-  const wasm = await getWasmModule();
-  const ksStatistic = wasm.ks_test(new Float64Array(samples));
-  return `ks:${ksStatistic.toFixed(6)}`;
-}

package/src/entropy/fonts.ts

@@ -1,4 +0,0 @@
-export async function getFontsEntropy(): Promise<string> {
-  const fonts = ["Arial", "Courier", "Georgia", "Verdana"];
-  return fonts.join(",");
-}

package/src/entropy/hardware.ts

@@ -1,10 +0,0 @@
-export async function getHardwareEntropy(): Promise<string> {
-  const cores = navigator.hardwareConcurrency || 1;
-  const memory = (navigator as any).deviceMemory || 4;
-  
-  const computePower = Math.log2(cores) * Math.log2(memory);
-  const memoryBits = Math.ceil(Math.log2(memory * 1024));
-  const coreEntropy = cores > 0 ? Math.log2(cores) : 0;
-  
-  return `cores:${cores}|mem:${memory}GB|P(compute)=${computePower.toFixed(3)}|H(cores)=${coreEntropy.toFixed(3)}`;
-}

package/src/entropy/language.ts

@@ -1,14 +0,0 @@
-export async function getLanguageEntropy(): Promise<string> {
-  const language = navigator.language;
-  const languages = navigator.languages;
-  
-  const langCount = languages.length;
-  const langDiversity = Math.log2(langCount + 1);
-  const primaryEntropy = -Array.from(language).reduce((h, c) => {
-    const p = 1 / language.length;
-    return h + p * Math.log2(p);
-  }, 0);
-  
-  const combined = languages.join("|");
-  return `primary:${language}|langs:${langCount}|H(L)=${primaryEntropy.toFixed(3)}|D=${langDiversity.toFixed(3)}`;
-}

package/src/entropy/os.ts

@@ -1,12 +0,0 @@
-export async function getOSEntropy(): Promise<string> {
-  const platform = navigator.platform || "unknown";
-  const oscpu = (navigator as any).oscpu || "unknown";
-  const combined = platform + oscpu;
-  
-  const uniqueChars = new Set(combined).size;
-  const totalChars = combined.length;
-  const charDiversity = uniqueChars / totalChars;
-  const surprisal = -Math.log2(1 / uniqueChars);
-  
-  return `OS:${platform}|CPU:${oscpu}|δ=${charDiversity.toFixed(4)}|I=${surprisal.toFixed(2)}`;
-}

package/src/entropy/osVersion.ts

@@ -1,6 +0,0 @@
-export async function getOSVersionEntropy(): Promise<string> {
-  const ua = navigator.userAgent;
-  const match = ua.match(/Windows NT|Mac OS|Linux|Android|iOS/i);
-  const os = match ? match[0] : "unknown";
-  return os;
-}

package/src/entropy/performance.ts

@@ -1,14 +0,0 @@
-export async function getPerformanceEntropy(): Promise<string> {
-  if (!performance.memory) return "perf:unavailable";
-  const mem = (performance as any).memory;
-  
-  const used = mem.usedJSHeapSize;
-  const total = mem.totalJSHeapSize;
-  const limit = mem.jsHeapSizeLimit;
-  
-  const utilizationRatio = used / limit;
-  const fragmentation = (total - used) / total;
-  const headroomBits = Math.log2(limit - used + 1);
-  
-  return `used:${used}|limit:${limit}|ρ=${utilizationRatio.toFixed(4)}|frag=${fragmentation.toFixed(4)}|H(mem)=${headroomBits.toFixed(2)}`;
-}

package/src/entropy/permissions.ts

@@ -1,15 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

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

package/src/entropy/statistical.ts

@@ -1,15 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,132 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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);
-  });
-});