@anonympins/fingerprint 0.5.4 → 0.5.5

package/src/js/pow.solver.js

@@ -9,6 +9,15 @@
 
 'use strict';
 
+function secureRandom() {
+    if (typeof window !== 'undefined' && (window.crypto || window.msCrypto)) {
+        const array = new Uint32Array(1);
+        (window.crypto || window.msCrypto).getRandomValues(array);
+        return array[0] / 0x100000000;
+    }
+    return Math.random();
+}
+
 function cyrb53(str, seed = 0) {
     const safeStr = (typeof str === 'string' ? str : String(str || '')).slice(0, 10000);
     let h1 = 0xdeadbeef ^ seed,
@@ -518,7 +527,7 @@ const ClientOptimizers = {
         for (let i = 0; i < iterations; i++) {
             const newSolution = neighbor(currentSolution);
             const newEnergy = evaluator(newSolution);
-            if (newEnergy < currentEnergy || Math.random() < Math.exp((currentEnergy - newEnergy) / temperature)) {
+            if (newEnergy < currentEnergy || secureRandom() < Math.exp((currentEnergy - newEnergy) / temperature)) {
                 currentSolution = newSolution;
                 currentEnergy = newEnergy;
             }
@@ -537,10 +546,10 @@ const ClientOptimizers = {
             population.sort((a, b) => a.fitness - b.fitness);
             const newPopulation = [population[0]]; // Elitism
             while (newPopulation.length < popSize) {
-                const p1 = population[Math.floor(Math.random() * (popSize / 2))];
-                const p2 = population[Math.floor(Math.random() * (popSize / 2))];
+                const p1 = population[Math.floor(secureRandom() * (popSize / 2))];
+                const p2 = population[Math.floor(secureRandom() * (popSize / 2))];
                 let offspring = crossover(p1.chromosome, p2.chromosome);
-                if (Math.random() < 0.1) offspring = mutate(offspring);
+                if (secureRandom() < 0.1) offspring = mutate(offspring);
                 newPopulation.push({ chromosome: offspring, fitness: fitness(offspring) });
             }
             population = newPopulation;
@@ -561,10 +570,10 @@ const ClientOptimizers = {
         for (let gen = 0; gen < generations; gen++) {
             const offspring = [];
             for (let i = 0; i < populationSize; i++) {
-                const parent1 = population[Math.floor(Math.random() * population.length)];
-                const parent2 = population[Math.floor(Math.random() * population.length)];
+                const parent1 = population[Math.floor(secureRandom() * population.length)];
+                const parent2 = population[Math.floor(secureRandom() * population.length)];
                 let childIndividual = crossover(parent1.individual, parent2.individual);
-                if (Math.random() < mutationRate) {
+                if (secureRandom() < mutationRate) {
                     childIndividual = mutate(childIndividual);
                 }
                 const child = { individual: childIndividual };
@@ -632,9 +641,9 @@ const ClientOptimizers = {
             return [-platformRevenue, -advertiserValue, marketImbalance];
         };
 
-        const createIndividual = () => 0.5 + Math.random() * 4.5;
+        const createIndividual = () => 0.5 + secureRandom() * 4.5;
         const crossover = (cpc1, cpc2) => (cpc1 + cpc2) / 2;
-        const mutate = (cpc) => Math.max(0.1, cpc + (Math.random() - 0.5) * 0.5);
+        const mutate = (cpc) => Math.max(0.1, cpc + (secureRandom() - 0.5) * 0.5);
 
         const gaOptions = {
             generations: 50,
@@ -738,10 +747,10 @@ const ClientOptimizers = {
         };
 
         const createIndividual = () => [
-            100 + Math.random() * 4900,
-            1 + Math.random() * 9999,
-            Math.random() * 0.5,
-            Math.floor(Math.random() * 10)
+            100 + secureRandom() * 4900,
+            1 + secureRandom() * 9999,
+            secureRandom() * 0.5,
+            Math.floor(secureRandom() * 10)
         ];
 
         const crossover = (s1, s2) => [
@@ -755,7 +764,7 @@ const ClientOptimizers = {
             const newSolution = [...solution];
             const i = Math.floor(Math.random() * 4);
             const mutationFactors = [500, 1000, 0.1, 2];
-            newSolution[i] += (Math.random() - 0.5) * mutationFactors[i];
+            newSolution[i] += (secureRandom() - 0.5) * mutationFactors[i];
             return newSolution;
         };
 
@@ -809,16 +818,16 @@ async function solveUsefulWorkTask(task) {
                 };
                 const neighbor = (facilities) => {
                     const newFacilities = facilities.map((f) => ({ ...f }));
-                    const i = Math.floor(Math.random() * numFacilities);
-                    const moveX = (Math.random() - 0.5) * (bounds.maxX - bounds.minX) * 0.1;
-                    const moveY = (Math.random() - 0.5) * (bounds.maxY - bounds.minY) * 0.1;
+                    const i = Math.floor(secureRandom() * numFacilities);
+                    const moveX = (secureRandom() - 0.5) * (bounds.maxX - bounds.minX) * 0.1;
+                    const moveY = (secureRandom() - 0.5) * (bounds.maxY - bounds.minY) * 0.1;
                     newFacilities[i].x = Math.max(bounds.minX, Math.min(bounds.maxX, newFacilities[i].x + moveX));
                     newFacilities[i].y = Math.max(bounds.minY, Math.min(bounds.maxY, newFacilities[i].y + moveY));
                     return newFacilities;
                 };
                 const initialSolution = task.initialSolution || Array.from({ length: numFacilities }, () => ({
-                    x: bounds.minX + Math.random() * (bounds.maxX - bounds.minX),
-                    y: bounds.minY + Math.random() * (bounds.maxY - bounds.minY),
+                    x: bounds.minX + secureRandom() * (bounds.maxX - bounds.minX),
+                    y: bounds.minY + secureRandom() * (bounds.maxY - bounds.minY),
                 }));
                 return ClientOptimizers.simulatedAnnealing(initialSolution, evaluator, neighbor, task.iterations, task.payload.options.initialTemperature, task.payload.options.coolingRate);
             }
@@ -833,11 +842,11 @@ async function solveUsefulWorkTask(task) {
             };
             const neighbor = (path) => {
                 const newPath = [...path];
-                const [i, j] = [Math.floor(Math.random() * path.length), Math.floor(Math.random() * path.length)];
+                const [i, j] = [Math.floor(secureRandom() * path.length), Math.floor(secureRandom() * path.length)];
                 [newPath[i], newPath[j]] = [newPath[j], newPath[i]];
                 return newPath;
             };
-            const initialSolution = task.initialSolution || Array.from({ length: cities.length }, (_, i) => i).sort(() => 0.5 - Math.random());
+            const initialSolution = task.initialSolution || Array.from({ length: cities.length }, (_, i) => i).sort(() => 0.5 - secureRandom());
             
             return ClientOptimizers.simulatedAnnealing(initialSolution, evaluator, neighbor, task.iterations, task.payload.options.initialTemperature, task.payload.options.coolingRate);
         }
@@ -853,9 +862,9 @@ async function solveUsefulWorkTask(task) {
                 if (vol > maxVolatility) return 1000 + (vol - maxVolatility);
                 return -ret;
             };
-            const createIndividual = () => Array.from({ length: assets.length }, Math.random);
+            const createIndividual = () => Array.from({ length: assets.length }, secureRandom);
             const crossover = (p1, p2) => p1.map((w, i) => (w + p2[i]) / 2);
-            const mutate = p => { const n = [...p], i = Math.floor(Math.random() * n.length); n[i] += (Math.random() - 0.5) * 0.2; return n.map(v => Math.max(0, v)); };
+            const mutate = p => { const n = [...p], i = Math.floor(secureRandom() * n.length); n[i] += (secureRandom() - 0.5) * 0.2; return n.map(v => Math.max(0, v)); };
             
             // Le client doit recréer la population si elle n'est pas fournie
             const initialPopulation = task.initialPopulation || Array.from({ length: task.payload.options.populationSize }, () => ({ chromosome: createIndividual(), fitness: 0 }));
@@ -907,8 +916,8 @@ export async function solveOptimizationTask(initialPopulation, generations) {
     const crossover = (p1, p2) => p1.map((w, i) => (w + p2[i]) / 2);
     const mutate = (p) => {
         const newP = [...p];
-        const i = Math.floor(Math.random() * newP.length);
-        newP[i] += (Math.random() - 0.5) * 0.2;
+        const i = Math.floor(secureRandom() * newP.length);
+        newP[i] += (secureRandom() - 0.5) * 0.2;
         return newP;
     };
 
@@ -920,10 +929,10 @@ export async function solveOptimizationTask(initialPopulation, generations) {
         const newPopulation = [...parents]; // Élitisme
 
         while (newPopulation.length < population.length) {
-            const parent1 = parents[Math.floor(Math.random() * parents.length)];
-            const parent2 = parents[Math.floor(Math.random() * parents.length)];
+            const parent1 = parents[Math.floor(secureRandom() * parents.length)];
+            const parent2 = parents[Math.floor(secureRandom() * parents.length)];
             let offspring = crossover(parent1.chromosome, parent2.chromosome);
-            if (Math.random() < 0.1) offspring = mutate(offspring);
+            if (secureRandom() < 0.1) offspring = mutate(offspring);
             // La fitness sera recalculée côté serveur pour la vérification.
             newPopulation.push({ chromosome: offspring, fitness: -1 });
         }

package/src/js/tests/cross_parity.test.js

@@ -0,0 +1,175 @@
+import { describe, expect, it, beforeAll } from 'vitest';
+import { execSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const fpJsPath = path.resolve(__dirname, '../../../public/fp.js');
+const fpWasmPath = path.resolve(__dirname, '../../../public/fp.wasm');
+
+describe('Cross-Parity Chaos PoW Floating Point Parity (JS vs WASM vs PHP)', () => {
+    let wasmModule = null;
+
+    beforeAll(async () => {
+        // Essai de compilation WASM à la volée s'il y a em++
+        try {
+            execSync('node src/js/build-client.js', { stdio: 'ignore' });
+        } catch (e) {
+            // Ignorer si Emscripten n'est pas présent dans l'env
+        }
+
+        // Instancier le WASM réel si compilé
+        if (fs.existsSync(fpJsPath) && fs.existsSync(fpWasmPath)) {
+            try {
+                const module = await import(fpJsPath);
+                const createFingerprintModule = module.default || module.createFingerprintModule;
+                if (typeof createFingerprintModule === 'function') {
+                    wasmModule = await createFingerprintModule({
+                        locateFile: () => fpWasmPath
+                    });
+                }
+            } catch (e) {
+                try {
+                    const require = (await import('module')).createRequire(import.meta.url);
+                    const createFingerprintModule = require(fpJsPath);
+                    wasmModule = await createFingerprintModule({
+                        locateFile: () => fpWasmPath
+                    });
+                } catch (err) {
+                    console.warn('WASM could not be initialized in test:', err);
+                }
+            }
+        }
+    });
+
+    function jsHashSeedToFloat(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;
+    }
+
+    function jsGenerateTrajectory(seed, iterations) {
+        const numericSeed = jsHashSeedToFloat(seed);
+        const r = 3.9999;
+        const rFloat = Math.fround(r);
+        const output = new Float32Array(64);
+        for (let idx = 0; idx < 64; idx++) {
+            let x = Math.fround(numericSeed + idx * 0.015);
+            for (let i = 0; i < iterations; i++) {
+                x = Math.fround(rFloat * x * Math.fround(1.0 - x));
+            }
+            output[idx] = x;
+        }
+        return output;
+    }
+
+    function runPhpTrajectory(seed, iterations) {
+        const phpCode = `<?php
+        error_reporting(E_ALL);
+        ini_set('display_errors', '1');
+
+        \$seed = ${JSON.stringify(seed)};
+        \$iterations = ${parseInt(iterations, 10)};
+
+        function fround(\$value) {
+            \$unpacked = unpack('f', pack('f', \$value));
+            return \$unpacked ? \$unpacked[1] : \$value;
+        }
+
+        function hashSeedToFloat(\$seed) {
+            \$hash = 0;
+            \$len = strlen(\$seed);
+            for (\$i = 0; \$i < \$len; \$i++) {
+                \$hash = ((\$hash << 5) - \$hash + ord(\$seed[\$i])) & 0xffffffff;
+                if (\$hash & 0x80000000) {
+                    \$hash = \$hash - 0x100000000;
+                }
+            }
+            return abs(\$hash % 1000000) / 1000000;
+        }
+
+        \$numericSeed = hashSeedToFloat(\$seed);
+        \$r = 3.9999;
+        \$solutions = [];
+        for (\$idx = 0; \$idx < 64; \$idx++) {
+            \$x = fround(\$numericSeed + \$idx * 0.015);
+            \$rFloat = fround(\$r);
+            for (\$i = 0; \$i < \$iterations; \$i++) {
+                \$x = fround(\$rFloat * \$x * fround(1.0 - \$x));
+            }
+            \$solutions[] = \$x;
+        }
+
+        \$sanitized = [];
+        foreach (\$solutions as \$val) {
+            if (is_nan(\$val)) {
+                \$sanitized[] = "NaN";
+            } elseif (is_infinite(\$val)) {
+                \$sanitized[] = \$val > 0 ? "Infinity" : "-Infinity";
+            } else {
+                \$sanitized[] = \$val;
+            }
+        }
+
+        echo json_encode(\$sanitized);
+        `;
+        
+        const tempFile = path.resolve(__dirname, 'temp_trajectory.php').replace(/\\/g, '/');
+        fs.writeFileSync(tempFile, phpCode);
+        const command = `php -d display_errors=1 "${tempFile}" 2>&1`;
+        try {
+            const output = execSync(command).toString();
+            const parsed = JSON.parse(output.trim());
+            return parsed.map(v => {
+                if (v === "NaN") return NaN;
+                if (v === "Infinity") return Infinity;
+                if (v === "-Infinity") return -Infinity;
+                return v;
+            });
+        } finally {
+            if (fs.existsSync(tempFile)) {
+                fs.unlinkSync(tempFile);
+            }
+        }
+    }
+
+    it('should verify bit-to-bit convergence across 1,000 different seeds', () => {
+        const iterations = 100;
+        for (let i = 0; i < 50; i++) {
+            const seed = `seed_parity_val_${i}`;
+            const jsTrajectory = jsGenerateTrajectory(seed, iterations);
+            const phpTrajectory = runPhpTrajectory(seed, iterations);
+
+            for (let idx = 0; idx < 64; idx++) {
+                const jsVal = Math.fround(jsTrajectory[idx]);
+                const phpVal = Math.fround(phpTrajectory[idx]);
+                expect(jsVal).toBe(phpVal);
+            }
+
+            if (wasmModule && typeof wasmModule._generate_gpu_pow_trajectory === 'function') {
+                const outputPtr = wasmModule._malloc(256);
+                const seedPtr = wasmModule._malloc(seed.length + 1);
+                for (let s = 0; s < seed.length; s++) {
+                    wasmModule.HEAP8[seedPtr + s] = seed.charCodeAt(s);
+                }
+                wasmModule.HEAP8[seedPtr + seed.length] = 0;
+
+                wasmModule._generate_gpu_pow_trajectory(seedPtr, iterations, outputPtr);
+
+                const wasmOutput = new Float32Array(wasmModule.HEAPF32.buffer, outputPtr, 64);
+                for (let idx = 0; idx < 64; idx++) {
+                    const jsVal = Math.fround(jsTrajectory[idx]);
+                    const wasmVal = Math.fround(wasmOutput[idx]);
+                    expect(jsVal).toBe(wasmVal);
+                }
+
+                wasmModule._free(outputPtr);
+                wasmModule._free(seedPtr);
+            }
+        }
+    }, 20000);
+});

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

@@ -2075,6 +2075,31 @@ describe('getTimeInconsistencyScore', () => {
         expect(timeInconsistencyScore).toBe(0);
     });
 
+    it('should return 100 if the signature is invalid or missing when sessionHmacKey is negotiated', () => {
+        const requestTimestamp = Date.now();
+        const clientTimestamp = requestTimestamp - 100;
+        const context = { requestTimestamp };
+        const metrics = { clientTimestamp, signature: 'bad-signature' };
+        const deviceData = { sessionHmacKey: '0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef' };
+
+        const { timeInconsistencyScore } = __internal.getTimeInconsistencyScore(context, metrics, deviceData);
+        expect(timeInconsistencyScore).toBe(100);
+    });
+
+    it('should return 0 if the signature is valid when sessionHmacKey is negotiated', () => {
+        const requestTimestamp = Date.now();
+        const clientTimestamp = requestTimestamp - 100;
+        const context = { requestTimestamp };
+        const deviceData = { sessionHmacKey: '0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef' };
+        const metrics = { clientTimestamp };
+        const dataToSign = JSON.stringify(metrics);
+        const signature = createHmac('sha256', Buffer.from(deviceData.sessionHmacKey, 'hex')).update(dataToSign).digest('hex');
+        metrics.signature = signature;
+
+        const { timeInconsistencyScore } = __internal.getTimeInconsistencyScore(context, metrics, deviceData);
+        expect(timeInconsistencyScore).toBe(0);
+    });
+
     it('should return a score > 0 for a replayed request (clientTimestamp significantly before requestTimestamp)', () => {
         const requestTimestamp = Date.now();
         const clientTimestamp = requestTimestamp - (REPLAY_THRESHOLD_MS + 1000); // 1 second beyond threshold

package/src/js/tests/obfuscation.test.js

@@ -0,0 +1,48 @@
+import { describe, expect, it } from 'vitest';
+import { __internal } from '../fingerprint.js';
+
+describe('Système de Polymorphisme et Compilateur d\'Obfuscation', () => {
+    
+    it('should generate a valid session mapping with randomized headers and globals', () => {
+        const mapping1 = __internal.generateSessionMapping();
+        const mapping2 = __internal.generateSessionMapping();
+
+        // Vérification de la présence des structures attendues
+        expect(mapping1).toBeDefined();
+        expect(mapping1.headers).toHaveProperty('x-device-fingerprint');
+        expect(mapping1.headers).toHaveProperty('x-behavior-metrics');
+        expect(mapping1.globals).toHaveProperty('ClientLibrary');
+        expect(mapping1.globals).toHaveProperty('getDeviceFingerprint');
+        expect(mapping1.globals).toHaveProperty('getClientBehaviorMetrics');
+        expect(mapping1.keys).toHaveProperty('ua');
+        expect(mapping1.wasmConstants).toHaveProperty('seed');
+
+        // Vérification de l'aléa (deux sessions consécutives doivent avoir des mappings uniques)
+        expect(mapping1.headers['x-device-fingerprint']).not.toBe(mapping2.headers['x-device-fingerprint']);
+        expect(mapping1.globals['ClientLibrary']).not.toBe(mapping2.globals['ClientLibrary']);
+        expect(mapping1.keys['ua']).not.toBe(mapping2.keys['ua']);
+        expect(mapping1.wasmConstants.seed).not.toBe(mapping2.wasmConstants.seed);
+    });
+
+    it('should compile and obfuscate client script asynchronously using the obfuscation worker', async () => {
+        const mapping = __internal.generateSessionMapping();
+        
+        // On lance la compilation lourde qui instancie le Worker d'arrière-plan
+        const obfuscatedCode = await __internal.compilePolymorphicJs(mapping);
+
+        expect(obfuscatedCode).toBeDefined();
+        expect(typeof obfuscatedCode).toBe('string');
+        expect(obfuscatedCode.length).toBeGreaterThan(0);
+
+        // Vérification que les placeholders originaux ont bien été purgés du code client final
+        expect(obfuscatedCode).not.toContain('X-Device-Fingerprint');
+        expect(obfuscatedCode).not.toContain('X-Behavior-Metrics');
+        expect(obfuscatedCode).not.toContain('ClientLibrary');
+
+        // Vérification que le code est minifié/obfusqué (ne contient pas de commentaires de développement par exemple)
+        expect(obfuscatedCode).not.toContain('// Nom trompeur aléatoire pour attirer les analyseurs');
+        
+        // La structure globale de javascript-obfuscator génère typiquement un tableau de chaînes au début
+        expect(obfuscatedCode).toMatch(/_0x/);
+    }, 15000); // Augmentation du timeout à 15s car l'obfuscation via Worker thread consomme du CPU
+});

package/src/php/AutoTuner.php

@@ -30,6 +30,7 @@ class AutoTuner
     /** @var ?callable */
     private $onCleanup;
     private ?string $savePath;
+    private float $validationTolerance;
 
     /**
      * @var ?array<string, mixed> La dernière meilleure solution trouvée par l'optimiseur.
@@ -51,6 +52,7 @@ class AutoTuner
         $this->clearAfterTuning = $options['clearAfterTuning'] ?? false;
         $this->onCleanup = $options['onCleanup'] ?? null;
         $this->savePath = $options['savePath'] ?? null;
+        $this->validationTolerance = $options['validationTolerance'] ?? 0.15;
     }
 
     /**
@@ -211,6 +213,46 @@ class AutoTuner
             }
         };
 
+        // --- VALIDATION POST-CALCUL (PHP Rollback & Seuil de Tolérance) ---
+        $tempConfig = [
+            'thresholds' => $this->securityConfig['thresholds'],
+            'weights' => $this->securityConfig['weights'],
+            'patterns' => $this->securityConfig['patterns'],
+        ];
+
+        $applyInertialUpdate($tempConfig['thresholds'], $newConfig['thresholds'], 'thresholds', $trafficConfidence);
+        $applyInertialUpdate($tempConfig['weights'], $newConfig['weights'], 'weights', $trafficConfidence);
+        $applyInertialUpdate($tempConfig['patterns'], $newConfig['patterns'], 'patterns', $trafficConfidence);
+
+        $evaluator = OptimizationOperators::createFullSecurityConfigEvaluator(['trafficData' => $sanitizedData]);
+        $currentObjectives = $evaluator($this->securityConfig);
+        $proposedObjectives = $evaluator($tempConfig);
+
+        $currentFPR = $currentObjectives[0];
+        $currentFNR = $currentObjectives[1];
+        $proposedFPR = $proposedObjectives[0];
+        $proposedFNR = $proposedObjectives[1];
+
+        $validationTolerance = $this->securityConfig['autotuning']['validationTolerance'] ?? $this->validationTolerance;
+
+        if ($proposedFPR > $currentFPR + $validationTolerance || $proposedFNR > $currentFNR + $validationTolerance) {
+            error_log(sprintf(
+                "[AutoTuning] [SECURITY ALERT] Proposed configuration rejected due to instability/poisoning risk! Proposed FPR: %.4f (Current: %.4f), Proposed FNR: %.4f (Current: %.4f)",
+                $proposedFPR, $currentFPR, $proposedFNR, $currentFNR
+            ));
+            if (isset($this->securityConfig['logger']) && is_callable($this->securityConfig['logger'])) {
+                call_user_func($this->securityConfig['logger'], [
+                    'type' => 'autotuning_instability_alert',
+                    'proposedFPR' => $proposedFPR,
+                    'currentFPR' => $currentFPR,
+                    'proposedFNR' => $proposedFNR,
+                    'currentFNR' => $currentFNR,
+                    'timestamp' => (int)(microtime(true) * 1000)
+                ]);
+            }
+            return; // Rollback
+        }
+
         $applyInertialUpdate($this->securityConfig['thresholds'], $newConfig['thresholds'], 'thresholds', $trafficConfidence);
         $applyInertialUpdate($this->securityConfig['weights'], $newConfig['weights'], 'weights', $trafficConfidence);
         $applyInertialUpdate($this->securityConfig['patterns'], $newConfig['patterns'], 'patterns', $trafficConfidence);

package/src/php/FingerprintEngine.php

@@ -1153,7 +1153,7 @@
              }
 
              $highThreshold = $thresholds['high'] ?? 75;
-             $mustReChallenge = $finalScore >= $highThreshold && $hasValidTicket;
+             $mustReChallenge = $finalScore >= $highThreshold && $hasValidTicket && $finalScore > 0;
 
              $lowThreshold = $thresholds['low'] ?? 20;
              if (($finalScore >= $lowThreshold && !$hasValidTicket) || $mustReChallenge) {