@anonympins/fingerprint 0.4.6 → 0.5.1

package/src/js/fingerprint.utils.js

@@ -0,0 +1,184 @@
+import {cyrb53} from "./fingerprint.builder.js";
+
+export function verifyZkpProof(yStr, tStr, sStr) {
+    try {
+        const y = BigInt('0x' + yStr);
+        const t = BigInt('0x' + tStr);
+        const s = BigInt('0x' + sStr);
+
+        const ZKP_P = 115792089237316195423570985008687907853269984665640564039457584007908834671663n;
+        const ZKP_G = 2n;
+
+        const cStr = ZKP_G.toString() + y.toString() + t.toString();
+        const hashHex = crypto.createHash('sha256').update(cStr).digest('hex');
+        const c = BigInt('0x' + hashHex) % ZKP_P;
+
+        return modPow(ZKP_G, s, ZKP_P) === (t * modPow(y, c, ZKP_P)) % ZKP_P;
+    } catch (e) {
+        return false;
+    }
+}
+
+export function decodePolymorphicFingerprint(fpString, mapping) {
+    if (!fpString || !mapping || !mapping.keys) return fpString;
+    const reverseKeys = {};
+    for (const [orig, rand] of Object.entries(mapping.keys)) {
+        reverseKeys[rand] = orig;
+    }
+    const parts = fpString.split('|');
+    const mappedParts = parts.map(part => {
+        const pair = part.split(':');
+        if (pair.length === 2) {
+            const origKey = reverseKeys[pair[0]] || pair[0];
+            return `${origKey}:${pair[1]}`;
+        }
+        return part;
+    });
+    return mappedParts.join('|');
+}
+
+
+/**
+ * @private
+ * Deep merges two objects. The `source` object's properties overwrite the `target`'s.
+ * @param {object} target - The target object.
+ * @param {object} source - The source object.
+ * @returns {object} The merged object.
+ */
+export function deepMerge(target, source) {
+    const output = { ...target };
+    if (target && typeof target === 'object' && source && typeof source === 'object') {
+        Object.keys(source).forEach(key => {
+            if (source[key] && typeof source[key] === 'object' && key in target) {
+                output[key] = deepMerge(target[key], source[key]);
+            } else {
+                output[key] = source[key];
+            }
+        });
+    }
+    return output;
+}
+
+/**
+ * Creates a stable hash based on device characteristics, independent of the IP.
+ * This is our "level 2 fingerprint".
+ * @param {object} context - The request context.
+ * @returns {string} A hash representing the device.
+ */
+export function getHeaderSignature(context) {
+    if (!context.rawHeaders) return '';
+    const headerKeys = [];
+    for (let i = 0; i < context.rawHeaders.length; i += 2) {
+        headerKeys.push(context.rawHeaders[i]);
+    }
+    return cyrb53(headerKeys.sort().join(','));
+}
+
+/**
+ * Analyses a raw JA3 string.
+ * Format: "TLSVersion,Ciphers,Extensions,EllipticCurves,EllipticCurveFormats"
+ * @param {string} ja3String
+ * @returns {object|null}
+ */
+export function parseJa3(ja3String) {
+    if (!ja3String || typeof ja3String !== 'string') {
+        return null;
+    }
+    const parts = ja3String.split(',');
+    if (parts.length !== 5) {
+        return null;
+    }
+    return {
+        tlsVersion: parseInt(parts[0], 10),
+        ciphers: parts[1] !== '' ? parts[1].split('-').map(Number) : [],
+        extensions: parts[2] !== '' ? parts[2].split('-').map(Number) : [],
+        curves: parts[3] !== '' ? parts[3].split('-').map(Number) : [],
+        points: parts[4] !== '' ? parts[4].split('-').map(Number) : []
+    };
+}
+
+export function modPow(base, exponent, modulus) {
+    if (modulus === 1n) return 0n;
+    let result = 1n;
+    base = base % modulus;
+    while (exponent > 0n) {
+        if (exponent % 2n === 1n) {
+            result = (result * base) % modulus;
+        }
+        exponent = exponent >> 1n;
+        base = (base * base) % modulus;
+    }
+    return result;
+}
+
+
+export function hashNetwork(ip, prefix = 24) {
+    // Hash du réseau (masque /24 ou /16)
+    const parts = ip.split('.');
+    if (parts.length !== 4) return null;
+    const maskBytes = prefix / 8;
+    const network = parts.slice(0, maskBytes).join('.');
+    // Hash simple
+    let hash = 0;
+    for (let i = 0; i < network.length; i++) {
+        const char = network.charCodeAt(i);
+        hash = ((hash << 5) - hash) + char;
+        hash = hash & hash;
+    }
+    return hash.toString(16);
+}
+export function normalizeReferer(referer) {
+    try {
+        const url = new URL(referer);
+        return `${url.protocol}//${url.hostname}`;
+    } catch {
+        return referer;
+    }
+}
+
+export function isPrivateIp(ip) {
+    // Vérifier si l'IP est privée
+    const parts = ip.split('.');
+    if (parts.length !== 4) return false;
+    const first = parseInt(parts[0]);
+    return (first === 10) || (first === 172 && parseInt(parts[1]) >= 16 && parseInt(parts[1]) <= 31) || (first === 192 && parseInt(parts[1]) === 168);
+}
+// Fonctions utilitaires
+export function parseUserAgent(ua) {
+    // Parser basique du User-Agent
+    const result = {};
+
+    // Détection du navigateur
+    if (ua.includes('Chrome') && !ua.includes('Edg')) {
+        result.browser = 'Chrome';
+        const match = ua.match(/Chrome\/(\d+)/);
+        if (match) result.browser += `/${match[1]}`;
+    } else if (ua.includes('Firefox')) {
+        result.browser = 'Firefox';
+        const match = ua.match(/Firefox\/(\d+)/);
+        if (match) result.browser += `/${match[1]}`;
+    } else if (ua.includes('Safari') && !ua.includes('Chrome')) {
+        result.browser = 'Safari';
+        const match = ua.match(/Version\/(\d+)/);
+        if (match) result.browser += `/${match[1]}`;
+    } else if (ua.includes('Edg')) {
+        result.browser = 'Edge';
+        const match = ua.match(/Edg\/(\d+)/);
+        if (match) result.browser += `/${match[1]}`;
+    }
+
+    // Détection de l'OS
+    if (ua.includes('Windows NT 10.0')) result.os = 'Windows 10';
+    else if (ua.includes('Windows NT 6.1')) result.os = 'Windows 7';
+    else if (ua.includes('Mac OS X')) result.os = 'macOS';
+    else if (ua.includes('Linux') && !ua.includes('Android')) result.os = 'Linux';
+    else if (ua.includes('Android')) result.os = 'Android';
+    else if (ua.includes('iPhone') || ua.includes('iPad')) result.os = 'iOS';
+
+    // Détection du type d'appareil
+    if (ua.includes('Mobile')) result.device = 'mobile';
+    else if (ua.includes('Tablet')) result.device = 'tablet';
+    else result.device = 'desktop';
+
+    return result;
+}

package/src/js/gpu_pow.solver.js

@@ -0,0 +1,217 @@
+/**
+ * GPU Proof-of-Work Solver (WebGPU with WebGL2 Fallback)
+ * Forces massive parallel floats computation to exhaust CPU emulators (SwiftShader).
+ */
+export class GpuPowSolver {
+    /**
+     * Solve the GPU challenge.
+     * @param {string} seed - The hexadecimal/string challenge seed from the server.
+     * @param {number} iterations - Number of chaotic map iterations per thread.
+     * @returns {Promise<{solution: string, platform: string, duration: number}>}
+     */
+    static async solve(seed, iterations = 200000) {
+        const start = performance.now();
+        const numericSeed = this._hashSeedToFloat(seed);
+
+        try {
+            if (navigator.gpu) {
+                const result = await this._solveWebGPU(numericSeed, iterations);
+                return {
+                    solution: result,
+                    platform: 'webgpu',
+                    duration: performance.now() - start
+                };
+            }
+        } catch (e) {
+            console.warn('[GPU-PoW] WebGPU failed or disabled, falling back to WebGL2:', e);
+        }
+
+        // Fallback to WebGL2
+        try {
+            const result = await this._solveWebGL2(numericSeed, iterations);
+            return {
+                solution: result,
+                platform: 'webgl2',
+                duration: performance.now() - start
+            };
+        } catch (e) {
+            throw new Error(`[GPU-PoW] Both WebGPU and WebGL2 solvers failed: ${e.message}`);
+        }
+    }
+
+    /**
+     * Verifies a GPU PoW solution.
+     * To prevent server-side DoS, it verifies a sample of the 64 channels.
+     * @param {string} seed - The challenge seed.
+     * @param {number} iterations - Number of iterations.
+     * @param {string} solution - The comma-separated solution string.
+     * @param {Array<number>} [sampleIndices=[0, 12, 35, 57]] - Indices to verify.
+     * @returns {boolean} True if the solution is valid.
+     */
+    static verify(seed, iterations, solution, sampleIndices = [0, 12, 35, 57]) {
+        if (!solution || typeof solution !== 'string') return false;
+        const values = solution.split(',');
+        if (values.length !== 64) return false;
+
+        const numericSeed = this._hashSeedToFloat(seed);
+        const r = 3.9999;
+
+        for (const idx of sampleIndices) {
+            if (idx < 0 || idx >= 64) return false;
+            let x = Math.fround(numericSeed + idx * 0.015);
+            const rFloat = Math.fround(r);
+            for (let i = 0; i < iterations; i++) {
+                x = Math.fround(rFloat * x * Math.fround(1.0 - x));
+            }
+            const clientVal = parseFloat(values[idx]);
+            if (isNaN(clientVal) || Math.abs(clientVal - x) > 1e-4) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    static _hashSeedToFloat(seed) {
+        let hash = 0;
+        for (let i = 0; i < seed.length; i++) {
+            hash = (hash << 5) - hash + seed.charCodeAt(i);
+            hash |= 0;
+        }
+        return Math.abs(hash % 1000000) / 1000000;
+    }
+
+    static async _solveWebGPU(seed, iterations) {
+        const adapter = await navigator.gpu.requestAdapter();
+        if (!adapter) throw new Error('No compatible GPU adapter found.');
+        const device = await adapter.requestDevice();
+
+        // Compute shader performing a chaotic logistic map iteration
+        const shaderCode = `
+            @group(0) @binding(0) var<storage, read_write> data: array<f32>;
+            @compute @workgroup_size(64)
+            fn main(@builtin(global_invocation_id) global_id: vec3<u32>) {
+                let index = global_id.x;
+                if (index >= 64) { return; }
+                
+                var x: f32 = data[index];
+                let r: f32 = 3.9999; // Chaotic regime
+                
+                for (var i: u32 = 0u; i < ${iterations}u; i = i + 1u) {
+                    x = r * x * (1.0 - x);
+                }
+                data[index] = x;
+            }
+        `;
+
+        const shaderModule = device.createShaderModule({ code: shaderCode });
+        const pipeline = device.createComputePipeline({
+            layout: 'auto',
+            compute: { module: shaderModule, entryPoint: 'main' }
+        });
+
+        const inputData = new Float32Array(64);
+        for (let i = 0; i < 64; i++) {
+            inputData[i] = seed + (i * 0.015);
+        }
+
+        const gpuBuffer = device.createBuffer({
+            size: inputData.byteLength,
+            usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST,
+            mappedAtCreation: true
+        });
+        new Float32Array(gpuBuffer.getMappedRange()).set(inputData);
+        gpuBuffer.unmap();
+
+        const readBuffer = device.createBuffer({
+            size: inputData.byteLength,
+            usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ
+        });
+
+        const bindGroup = device.createBindGroup({
+            layout: pipeline.getBindGroupLayout(0),
+            entries: [{ binding: 0, resource: { buffer: gpuBuffer } }]
+        });
+
+        const commandEncoder = device.createCommandEncoder();
+        const passEncoder = commandEncoder.beginComputePass();
+        passEncoder.setPipeline(pipeline);
+        passEncoder.setBindGroup(0, bindGroup);
+        passEncoder.dispatchWorkgroups(1);
+        passEncoder.end();
+
+        commandEncoder.copyBufferToBuffer(gpuBuffer, 0, readBuffer, 0, inputData.byteLength);
+        device.queue.submit([commandEncoder.finish()]);
+
+        await readBuffer.mapAsync(GPUMapMode.READ);
+        const result = new Float32Array(readBuffer.getMappedRange());
+        const solutionHash = Array.from(result).map(v => v.toFixed(6)).join(',');
+        readBuffer.unmap();
+
+        return solutionHash;
+    }
+
+    static async _solveWebGL2(seed, iterations) {
+        const canvas = document.createElement('canvas');
+        canvas.width = 8;
+        canvas.height = 8; // 64 pixels total matching WebGPU size
+        const gl = canvas.getContext('webgl2');
+        if (!gl) throw new Error('WebGL2 context not supported.');
+
+        const vs = `#version 300 es\nin vec4 pos; void main() { gl_Position = pos; }`;
+        const fs = `#version 300 es
+            precision highp float;
+            out vec4 outColor;
+            uniform float uSeed;
+            uniform int uIterations;
+            void main() {
+                float index = gl_FragCoord.x + (gl_FragCoord.y * 8.0);
+                float x = uSeed + (index * 0.015);
+                float r = 3.9999;
+                for(int i = 0; i < uIterations; i++) {
+                    x = r * x * (1.0 - x);
+                }
+                outColor = vec4(x, 0.0, 0.0, 1.0);
+            }`;
+
+        // Setup programs, draw fullscreen quad, etc.
+        const program = this._createProgram(gl, vs, fs);
+        gl.useProgram(program);
+
+        const posAttr = gl.getAttribLocation(program, 'pos');
+        const buffer = gl.createBuffer();
+        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+        gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([-1,-1, 1,-1, -1,1, -1,1, 1,-1, 1,1]), gl.STATIC_DRAW);
+        gl.enableVertexAttribArray(posAttr);
+        gl.vertexAttribPointer(posAttr, 2, gl.FLOAT, false, 0, 0);
+
+        gl.uniform1f(gl.getUniformLocation(program, 'uSeed'), seed);
+        gl.uniform1i(gl.getUniformLocation(program, 'uIterations'), iterations);
+
+        gl.drawArrays(gl.TRIANGLES, 0, 6);
+
+        const pixels = new Float32Array(8 * 8 * 4);
+        gl.readPixels(0, 0, 8, 8, gl.RGBA, gl.FLOAT, pixels);
+
+        const result = [];
+        for (let i = 0; i < 64; i++) {
+            result.push(pixels[i * 4]);
+        }
+
+        return result.map(v => v.toFixed(6)).join(',');
+    }
+
+    static _createProgram(gl, vsSource, fsSource) {
+        const vs = gl.createShader(gl.VERTEX_SHADER);
+        gl.shaderSource(vs, vsSource);
+        gl.compileShader(vs);
+        const fs = gl.createShader(gl.FRAGMENT_SHADER);
+        gl.shaderSource(fs, fsSource);
+        gl.compileShader(fs);
+        
+        const program = gl.createProgram();
+        gl.attachShader(program, vs);
+        gl.attachShader(program, fs);
+        gl.linkProgram(program);
+        return program;
+    }
+}

package/src/js/library.js

@@ -1551,7 +1551,7 @@ Optimization.Operators.createFullSecurityConfigEvaluator = ({ trafficData }) =>
       // Pour cet exemple, nous utilisons une version simplifiée.
       let score = 0;
       for (const key in config.weights) {
-        score += (log.vector[key] || 0) * config.weights[key];
+        score += (log.vector?.[key] || 0) * config.weights[key];
       }
       return score;
     };

package/src/js/pow.solver.inline.js

@@ -70,7 +70,7 @@ async function initializeSpace(seed, sizeMb) {
     store.put({ sizeMb, seed }, metadataKey);
 }
 
-async function solveSpaceChallenge(seed, queries, nonce, clientSecret) {
+async function solveSpaceChallenge(seed, queries, nonce, clientSecret, peerBlock = '') {
     const db = await openDb();
     const transaction = db.transaction("blocks", "readonly");
     const store = transaction.objectStore("blocks");
@@ -88,11 +88,19 @@ async function solveSpaceChallenge(seed, queries, nonce, clientSecret) {
         combined.set(block, i * 1024);
     }
     
+    let finalCombined = combined;
+    if (peerBlock) {
+        const peerBytes = new Uint8Array(peerBlock.match(/.{1,2}/g).map(byte => parseInt(byte, 16)));
+        finalCombined = new Uint8Array(combined.length + peerBytes.length);
+        finalCombined.set(combined);
+        finalCombined.set(peerBytes, combined.length);
+    }
+    
     const encoder = new TextEncoder();
     const nonceBytes = encoder.encode(nonce + ":" + clientSecret);
-    const finalBlock = new Uint8Array(combined.length + nonceBytes.length);
-    finalBlock.set(combined);
-    finalBlock.set(nonceBytes, combined.length);
+    const finalBlock = new Uint8Array(finalCombined.length + nonceBytes.length);
+    finalBlock.set(finalCombined);
+    finalBlock.set(nonceBytes, finalCombined.length);
     
     const buf = await crypto.subtle.digest("SHA-256", finalBlock);
     return Array.from(new Uint8Array(buf)).map(b => b.toString(16).padStart(2, '0')).join('');

package/src/js/pow.solver.js

@@ -73,7 +73,7 @@ export async function initializeSpace(seed, sizeMb) {
     store.put({ sizeMb, seed }, metadataKey);
 }
 
-export async function solveSpaceChallenge(seed, queries, nonce, clientSecret) {
+export async function solveSpaceChallenge(seed, queries, nonce, clientSecret, peerBlock = '') {
     const db = await openDb();
     const transaction = db.transaction("blocks", "readonly");
     const store = transaction.objectStore("blocks");
@@ -91,11 +91,19 @@ export async function solveSpaceChallenge(seed, queries, nonce, clientSecret) {
         combined.set(block, i * 1024);
     }
     
+    let finalCombined = combined;
+    if (peerBlock) {
+        const peerBytes = new Uint8Array(peerBlock.match(/.{1,2}/g).map(byte => parseInt(byte, 16)));
+        finalCombined = new Uint8Array(combined.length + peerBytes.length);
+        finalCombined.set(combined);
+        finalCombined.set(peerBytes, combined.length);
+    }
+    
     const encoder = new TextEncoder();
     const nonceBytes = encoder.encode(nonce + ":" + clientSecret);
-    const finalBlock = new Uint8Array(combined.length + nonceBytes.length);
-    finalBlock.set(combined);
-    finalBlock.set(nonceBytes, combined.length);
+    const finalBlock = new Uint8Array(finalCombined.length + nonceBytes.length);
+    finalBlock.set(finalCombined);
+    finalBlock.set(nonceBytes, finalCombined.length);
     
     const buf = await crypto.subtle.digest("SHA-256", finalBlock);
     return Array.from(new Uint8Array(buf)).map(b => b.toString(16).padStart(2, '0')).join('');

package/src/js/tests/fingerprint.client.init.test.js

@@ -28,7 +28,7 @@ global.TextEncoder = dom.window.TextEncoder;
 describe('ClientLibrary.initializeClient', () => {
 
     // On utilise des espions (spies) pour vérifier si les méthodes internes sont appelées.
-    let startMouseSpy, startKeystrokeSpy, startClickSpy, startTouchSpy, initWasmSpy, initHoneypotsSpy, injectTrapsSpy, initFetchSpy, injectPhantomTrapsSpy;
+    let startMouseSpy, startKeystrokeSpy, startClickSpy, startTouchSpy, startRenderingSpy, initWasmSpy, initHoneypotsSpy, injectTrapsSpy, initFetchSpy, injectPhantomTrapsSpy;
 
     beforeEach(() => {
         // Réinitialiser l'état du client avant chaque test
@@ -39,6 +39,7 @@ describe('ClientLibrary.initializeClient', () => {
         startKeystrokeSpy = vi.spyOn(ClientLibrary, 'startKeystrokeDynamicsTracker');
         startClickSpy = vi.spyOn(ClientLibrary, 'startClickTracker');
         startTouchSpy = vi.spyOn(ClientLibrary, 'startTouchEventTracker');
+        startRenderingSpy = vi.spyOn(ClientLibrary, 'startRenderingTracker');
         initWasmSpy = vi.spyOn(ClientLibrary, 'initializeWasm').mockResolvedValue(undefined);
         initHoneypotsSpy = vi.spyOn(ClientLibrary, 'initializeHoneypots');
         injectTrapsSpy = vi.spyOn(ClientLibrary, 'injectTrapLinks');
@@ -58,16 +59,18 @@ describe('ClientLibrary.initializeClient', () => {
         expect(startKeystrokeSpy).toHaveBeenCalled();
         expect(startClickSpy).toHaveBeenCalled();
         expect(startTouchSpy).toHaveBeenCalled();
+        expect(startRenderingSpy).toHaveBeenCalled();
         expect(injectPhantomTrapsSpy).toHaveBeenCalled();
     });
 
     it('should disable trackers when configured', () => {
-        ClientLibrary.initializeClient({ mouse: false, keystrokes: false, clicks: false, touches: false });
+        ClientLibrary.initializeClient({ mouse: false, keystrokes: false, clicks: false, touches: false, rendering: false });
 
         expect(startMouseSpy).not.toHaveBeenCalled();
         expect(startKeystrokeSpy).not.toHaveBeenCalled();
         expect(startClickSpy).not.toHaveBeenCalled();
         expect(startTouchSpy).not.toHaveBeenCalled();
+        expect(startRenderingSpy).not.toHaveBeenCalled();
     });
 
     it('should initialize WASM if wasmPath is configured', () => {