@cloudglides/veil 0.1.0 → 0.1.1

package/example/veil_core.js

@@ -0,0 +1,370 @@
+let wasm;
+
+let cachedFloat64ArrayMemory0 = null;
+function getFloat64ArrayMemory0() {
+    if (cachedFloat64ArrayMemory0 === null || cachedFloat64ArrayMemory0.byteLength === 0) {
+        cachedFloat64ArrayMemory0 = new Float64Array(wasm.memory.buffer);
+    }
+    return cachedFloat64ArrayMemory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return decodeText(ptr, len);
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+function passArrayF64ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 8, 8) >>> 0;
+    getFloat64ArrayMemory0().set(arg, ptr / 8);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+function passStringToWasm0(arg, malloc, realloc) {
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+    numBytesDecoded += len;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = len;
+    }
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    }
+}
+
+let WASM_VECTOR_LEN = 0;
+
+/**
+ * @param {Float64Array} samples
+ * @param {number} m
+ * @returns {number}
+ */
+export function approx_entropy(samples, m) {
+    const ptr0 = passArrayF64ToWasm0(samples, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.approx_entropy(ptr0, len0, m);
+    return ret;
+}
+
+/**
+ * @param {Float64Array} v1
+ * @param {Float64Array} v2
+ * @returns {number}
+ */
+export function cosine_similarity(v1, v2) {
+    const ptr0 = passArrayF64ToWasm0(v1, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(v2, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.cosine_similarity(ptr0, len0, ptr1, len1);
+    return ret;
+}
+
+/**
+ * @param {string} s
+ * @returns {string}
+ */
+export function fnv_hash(s) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(s, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.fnv_hash(ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * @param {string} s
+ * @returns {number}
+ */
+export function kolmogorov_complexity(s) {
+    const ptr0 = passStringToWasm0(s, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.kolmogorov_complexity(ptr0, len0);
+    return ret;
+}
+
+/**
+ * @param {Float64Array} values
+ * @returns {number}
+ */
+export function ks_test(values) {
+    const ptr0 = passArrayF64ToWasm0(values, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.ks_test(ptr0, len0);
+    return ret;
+}
+
+/**
+ * @param {string} s1
+ * @param {string} s2
+ * @returns {number}
+ */
+export function levenshtein_distance(s1, s2) {
+    const ptr0 = passStringToWasm0(s1, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(s2, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.levenshtein_distance(ptr0, len0, ptr1, len1);
+    return ret >>> 0;
+}
+
+/**
+ * @param {Uint8Array} data
+ * @returns {number}
+ */
+export function lz_complexity(data) {
+    const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.lz_complexity(ptr0, len0);
+    return ret >>> 0;
+}
+
+/**
+ * @param {string} s
+ * @returns {string}
+ */
+export function murmur_hash(s) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(s, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.murmur_hash(ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * @param {Float64Array} samples
+ * @param {number} m
+ * @param {number} r
+ * @returns {number}
+ */
+export function sample_ent(samples, m, r) {
+    const ptr0 = passArrayF64ToWasm0(samples, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.sample_ent(ptr0, len0, m, r);
+    return ret;
+}
+
+/**
+ * @param {string} s
+ * @returns {number}
+ */
+export function shannon_entropy(s) {
+    const ptr0 = passStringToWasm0(s, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.shannon_entropy(ptr0, len0);
+    return ret;
+}
+
+/**
+ * @param {string} s1
+ * @param {string} s2
+ * @returns {number}
+ */
+export function similarity_score(s1, s2) {
+    const ptr0 = passStringToWasm0(s1, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(s2, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.similarity_score(ptr0, len0, ptr1, len1);
+    return ret;
+}
+
+/**
+ * @param {Float64Array} samples
+ * @returns {number}
+ */
+export function spectral(samples) {
+    const ptr0 = passArrayF64ToWasm0(samples, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.spectral(ptr0, len0);
+    return ret;
+}
+
+const EXPECTED_RESPONSE_TYPES = new Set(['basic', 'cors', 'default']);
+
+async function __wbg_load(module, imports) {
+    if (typeof Response === 'function' && module instanceof Response) {
+        if (typeof WebAssembly.instantiateStreaming === 'function') {
+            try {
+                return await WebAssembly.instantiateStreaming(module, imports);
+            } catch (e) {
+                const validResponse = module.ok && EXPECTED_RESPONSE_TYPES.has(module.type);
+
+                if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {
+                    console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+
+                } else {
+                    throw e;
+                }
+            }
+        }
+
+        const bytes = await module.arrayBuffer();
+        return await WebAssembly.instantiate(bytes, imports);
+    } else {
+        const instance = await WebAssembly.instantiate(module, imports);
+
+        if (instance instanceof WebAssembly.Instance) {
+            return { instance, module };
+        } else {
+            return instance;
+        }
+    }
+}
+
+function __wbg_get_imports() {
+    const imports = {};
+    imports.wbg = {};
+    imports.wbg.__wbindgen_init_externref_table = function() {
+        const table = wasm.__wbindgen_externrefs;
+        const offset = table.grow(4);
+        table.set(0, undefined);
+        table.set(offset + 0, undefined);
+        table.set(offset + 1, null);
+        table.set(offset + 2, true);
+        table.set(offset + 3, false);
+    };
+
+    return imports;
+}
+
+function __wbg_finalize_init(instance, module) {
+    wasm = instance.exports;
+    __wbg_init.__wbindgen_wasm_module = module;
+    cachedFloat64ArrayMemory0 = null;
+    cachedUint8ArrayMemory0 = null;
+
+
+    wasm.__wbindgen_start();
+    return wasm;
+}
+
+function initSync(module) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (typeof module !== 'undefined') {
+        if (Object.getPrototypeOf(module) === Object.prototype) {
+            ({module} = module)
+        } else {
+            console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
+        }
+    }
+
+    const imports = __wbg_get_imports();
+    if (!(module instanceof WebAssembly.Module)) {
+        module = new WebAssembly.Module(module);
+    }
+    const instance = new WebAssembly.Instance(module, imports);
+    return __wbg_finalize_init(instance, module);
+}
+
+async function __wbg_init(module_or_path) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (typeof module_or_path !== 'undefined') {
+        if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+            ({module_or_path} = module_or_path)
+        } else {
+            console.warn('using deprecated parameters for the initialization function; pass a single object instead')
+        }
+    }
+
+    if (typeof module_or_path === 'undefined') {
+        module_or_path = new URL('veil_core_bg.wasm', import.meta.url).href;
+    }
+    const imports = __wbg_get_imports();
+
+    if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
+        module_or_path = fetch(module_or_path);
+    }
+
+    const { instance, module } = await __wbg_load(await module_or_path, imports);
+
+    return __wbg_finalize_init(instance, module);
+}
+
+export { initSync };
+export default __wbg_init;

package/example/veil_core_bg.wasm.d.ts

@@ -0,0 +1,20 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const cosine_similarity: (a: number, b: number, c: number, d: number) => number;
+export const levenshtein_distance: (a: number, b: number, c: number, d: number) => number;
+export const similarity_score: (a: number, b: number, c: number, d: number) => number;
+export const approx_entropy: (a: number, b: number, c: number) => number;
+export const fnv_hash: (a: number, b: number) => [number, number];
+export const kolmogorov_complexity: (a: number, b: number) => number;
+export const ks_test: (a: number, b: number) => number;
+export const lz_complexity: (a: number, b: number) => number;
+export const sample_ent: (a: number, b: number, c: number, d: number) => number;
+export const shannon_entropy: (a: number, b: number) => number;
+export const spectral: (a: number, b: number) => number;
+export const murmur_hash: (a: number, b: number) => [number, number];
+export const __wbindgen_externrefs: WebAssembly.Table;
+export const __wbindgen_malloc: (a: number, b: number) => number;
+export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+export const __wbindgen_free: (a: number, b: number, c: number) => void;
+export const __wbindgen_start: () => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloudglides/veil",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Math-based deterministic browser fingerprinting library",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/src/entropy/approximate.ts

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

package/src/entropy/complexity.ts

@@ -1,4 +1,4 @@
-import { lz_complexity } from "./veil_core.js";
+import { getWasmModule } from "../wasm-loader";
 
 export async function getComplexityEntropy(): Promise<string> {
   const ua = navigator.userAgent;
@@ -8,6 +8,7 @@ export async function getComplexityEntropy(): Promise<string> {
     bytes[i] = ua.charCodeAt(i) % 256;
   }
 
-  const complexity = lz_complexity(bytes);
+  const wasm = await getWasmModule();
+  const complexity = wasm.lz_complexity(bytes);
   return `lz:${complexity}`;
 }

package/src/entropy/distribution.ts

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

package/src/entropy/spectral.ts

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

package/src/index.ts

@@ -23,18 +23,38 @@ 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";
+function levenshteinDistance(s1: string, s2: string): number {
+  const len1 = s1.length;
+  const len2 = s2.length;
+  const matrix: number[][] = Array(len1 + 1).fill(null).map(() => Array(len2 + 1).fill(0));
+
+  for (let i = 0; i <= len1; i++) matrix[i][0] = i;
+  for (let j = 0; j <= len2; j++) matrix[0][j] = j;
+
+  for (let i = 1; i <= len1; i++) {
+    for (let j = 1; j <= len2; j++) {
+      const cost = s1[i - 1] === s2[j - 1] ? 0 : 1;
+      matrix[i][j] = Math.min(
+        matrix[i - 1][j] + 1,
+        matrix[i][j - 1] + 1,
+        matrix[i - 1][j - 1] + cost,
+      );
+    }
+  }
+  return matrix[len1][len2];
+}
+
+function similarityScore(s1: string, s2: string): number {
+  const distance = levenshteinDistance(s1, s2);
+  const maxLen = Math.max(s1.length, s2.length);
+  return maxLen === 0 ? 1 : 1 - distance / maxLen;
+}
+
 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";
+import { analyzeTamper } from "./tamper";
+import { getSourceStability, assessFingerprint, generateDeviceIdentity } from "./stability";
 
 export async function getFingerprint(
   options?: FingerprintOptions,
@@ -107,46 +127,29 @@ export async function getFingerprint(
   }
 
   const score = scoreFingerprint(sources);
+  const tamper = analyzeTamper(sources);
+  const stability = getSourceStability(sources);
+  const assessment = assessFingerprint(sources);
 
-  const data = sources.map(s => s.value);
+  const deviceIdentity = generateDeviceIdentity(sources);
 
-  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 data = sources.map(s => s.value);
+  const combined = data.join("|");
 
-  const mathMetrics = `${shannon}|${kolmogorov}|${murmur}|${fnv}`;
-  const combined = dataStr + "|" + mathMetrics;
+  const coreWeight = "core:" + deviceIdentity.core_hash;
+  const prefsWeight = "prefs:" + deviceIdentity.preferences_hash;
+  const weightedInput = `${coreWeight}|${prefsWeight}|${combined}`;
 
   const algorithm = opts.hash === "sha512" ? "SHA-512" : "SHA-256";
   const hash = await crypto.subtle.digest(
     algorithm,
-    new TextEncoder().encode(combined),
+    new TextEncoder().encode(weightedInput),
   );
 
   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();
@@ -156,17 +159,32 @@ export async function getFingerprint(
     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 sourceMetrics: SourceMetric[] = sources.map(s => {
+      const stab = stability.find(st => st.source === s.name);
+      return {
+        source: s.name,
+        value: s.value,
+        entropy: s.entropy,
+        confidence: score.likelihood > 0 ? Math.min(s.entropy / score.likelihood, 1) : 0,
+        stability: stab?.stability,
+      };
+    });
+
+    const avgStability = stability.length > 0
+      ? stability.reduce((a, b) => a + b.stability, 0) / stability.length
+      : 0;
 
     const response: FingerprintResponse = {
       hash: fingerprint,
       uniqueness: score.uniqueness,
       confidence: score.confidence,
+      stability_score: avgStability,
+      usable: assessment.usable,
+      warnings: assessment.warnings.length > 0 ? assessment.warnings : undefined,
+      entropy_warnings: assessment.entropy_warnings.length > 0 ? assessment.entropy_warnings : undefined,
+      tampering_risk: tamper.tampering_risk,
+      anomalies: tamper.anomalies,
+      device_identity: deviceIdentity,
       sources: sourceMetrics,
       system: {
         os,
@@ -195,4 +213,36 @@ export async function getFingerprint(
   return fingerprint;
 }
 
+export async function compareFingerpints(
+  fp1: string | FingerprintResponse,
+  fp2: string | FingerprintResponse,
+): Promise<{ similarity: number; match: boolean }> {
+  const hash1 = typeof fp1 === "string" ? fp1 : fp1.hash;
+  const hash2 = typeof fp2 === "string" ? fp2 : fp2.hash;
+
+  const sim = similarityScore(hash1, hash2);
+  const match = sim > 0.95;
+
+  return { similarity: sim, match };
+}
+
+export async function matchProbability(
+  storedFingerprints: (string | FingerprintResponse)[],
+  currentFingerprint: string | FingerprintResponse,
+): Promise<{ bestMatch: number; confidence: number }> {
+  const currentHash = typeof currentFingerprint === "string" ? currentFingerprint : currentFingerprint.hash;
+  
+  let bestMatch = 0;
+  for (const stored of storedFingerprints) {
+    const storedHash = typeof stored === "string" ? stored : stored.hash;
+    const sim = similarityScore(currentHash, storedHash);
+    if (sim > bestMatch) {
+      bestMatch = sim;
+    }
+  }
+
+  const confidence = Math.min(bestMatch * 1.2, 1.0);
+  return { bestMatch, confidence };
+}
+
 export type { FingerprintOptions, FingerprintResponse } from "./types";