@anonympins/fingerprint 0.4.6 → 0.5.1

package/src/js/tests/gpu_pow.test.js

@@ -0,0 +1,118 @@
+/**
+ * @vitest-environment jsdom
+ */
+
+import { describe, expect, it, vi } from 'vitest';
+import { GpuPowSolver } from '../gpu_pow.solver.js';
+
+describe('GpuPowSolver - Chaotic Logistic Map PoW', () => {
+    const seed = 'chaotic-pow-seed-test';
+    const iterations = 1000;
+
+    it('should hash seed deterministically to a float between 0 and 1', () => {
+        const f1 = GpuPowSolver._hashSeedToFloat(seed);
+        const f2 = GpuPowSolver._hashSeedToFloat(seed);
+        const f3 = GpuPowSolver._hashSeedToFloat('another-seed');
+
+        expect(f1).toBe(f2);
+        expect(f1).toBeGreaterThanOrEqual(0);
+        expect(f1).toBeLessThan(1);
+        expect(f1).not.toBe(f3);
+    });
+
+    it('should verify a mathematically correct trajectory solution', () => {
+        const numericSeed = GpuPowSolver._hashSeedToFloat(seed);
+        const r = 3.9999;
+        const rFloat = Math.fround(r);
+        const solutions = [];
+
+        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));
+            }
+            solutions.push(x.toFixed(6));
+        }
+
+        const validSolution = solutions.join(',');
+
+        // Verify the correct solution
+        expect(GpuPowSolver.verify(seed, iterations, validSolution)).toBe(true);
+    });
+
+    it('should reject invalid solutions', () => {
+        expect(GpuPowSolver.verify(seed, iterations, '')).toBe(false);
+        expect(GpuPowSolver.verify(seed, iterations, null)).toBe(false);
+        expect(GpuPowSolver.verify(seed, iterations, '1.0,2.0')).toBe(false); // Wrong length (should be 64)
+    });
+
+    it('should reject tampered solutions exceeding the threshold', () => {
+        const numericSeed = GpuPowSolver._hashSeedToFloat(seed);
+        const r = 3.9999;
+        const rFloat = Math.fround(r);
+        const solutions = [];
+
+        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));
+            }
+            solutions.push(x.toFixed(6));
+        }
+
+        // Tamper with the 12th channel (one of the default sample indices [0, 12, 35, 57])
+        const tamperedSolutions = [...solutions];
+        const originalVal = parseFloat(tamperedSolutions[12]);
+        tamperedSolutions[12] = (originalVal + 0.0002).toFixed(6); // exceeding 1e-4 tolerance
+
+        expect(GpuPowSolver.verify(seed, iterations, tamperedSolutions.join(','))).toBe(false);
+    });
+
+    it('should fallback to WebGL2 if WebGPU is not supported', async () => {
+        // Mock WebGPU as undefined
+        const originalGpu = global.navigator.gpu;
+        Object.defineProperty(global.navigator, 'gpu', {
+            value: undefined,
+            writable: true,
+            configurable: true
+        });
+
+        // Mock WebGL2 context
+        const mockGl = {
+            useProgram: vi.fn(),
+            createBuffer: vi.fn(),
+            bindBuffer: vi.fn(),
+            bufferData: vi.fn(),
+            enableVertexAttribArray: vi.fn(),
+            vertexAttribPointer: vi.fn(),
+            uniform1f: vi.fn(),
+            uniform1i: vi.fn(),
+            getUniformLocation: vi.fn(),
+            getAttribLocation: vi.fn(),
+            drawArrays: vi.fn(),
+            readPixels: vi.fn((x, y, w, h, format, type, pixels) => {
+                // Populate mock pixels with arbitrary valid floats
+                for (let i = 0; i < pixels.length; i++) {
+                    pixels[i] = 0.5;
+                }
+            })
+        };
+
+        const mockCanvas = {
+            getContext: vi.fn().mockReturnValue(mockGl)
+        };
+
+        vi.spyOn(document, 'createElement').mockImplementation((tagName) => {
+            if (tagName === 'canvas') return mockCanvas;
+            return {};
+        });
+
+        vi.spyOn(GpuPowSolver, '_createProgram').mockReturnValue({});
+
+        const result = await GpuPowSolver.solve(seed, 100);
+
+        expect(result.platform).toBe('webgl2');
+        expect(result.solution.split(',').length).toBe(64);
+        vi.restoreAllMocks();
+    });
+});

package/src/js/tests/ja3AnomalyDetector.test.js

@@ -1,6 +1,7 @@
 import crypto from 'crypto';
 import {getTlsSpoofingScore, parseJa3} from '../fingerprint.js';
 import {vi} from 'vitest';
+import { verifyZkpProof, decodePolymorphicFingerprint, deepMerge, getHeaderSignature, parseJa3, modPow, hashNetwork, normalizeReferer, isPrivateIp, parseUserAgent } from "../../js/fingerprint.utils.js";
 
 describe('JA3 Anomaly Detector (Node.js)', () => {
     

package/src/js/tests/quicFingerprint.test.js

@@ -0,0 +1,35 @@
+import { describe, expect, it } from 'vitest';
+import { __internal } from '../fingerprint.js';
+
+const { getQuicAnomalyScore } = __internal;
+
+describe('QUIC / HTTP/3 Flow Profiling', () => {
+    it('should return 0.0 if no QUIC fingerprint is present', () => {
+        const context = { headers: {} };
+        const score = getQuicAnomalyScore(context);
+        expect(score.quicAnomalyScore).toBe(0.0);
+    });
+
+    it('should detect Chrome spoofed with non-default stream/priority values', () => {
+        // Chrome attend un initial_max_data (1) >= 1MB, initial_max_streams_bidi (4) == 100, et extensible Priority (contient u=)
+        const context = {
+            headers: {
+                'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+                'x-quic-fp': '1;1=65536,4=50;i=0' // max_data trop bas, max_streams != 100, pas de priorité u=
+            }
+        };
+        const score = getQuicAnomalyScore(context);
+        expect(score.quicAnomalyScore).toBe(100.0);
+    });
+
+    it('should return 0.0 for a legitimate Chrome QUIC flow profile', () => {
+        const context = {
+            headers: {
+                'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+                'x-quic-fp': '1;1=1572864,4=100;u=2,i'
+            }
+        };
+        const score = getQuicAnomalyScore(context);
+        expect(score.quicAnomalyScore).toBe(0.0);
+    });
+});

package/src/php/AutoTuner.php

@@ -25,6 +25,11 @@ class AutoTuner
 
     private int $minDataPoints;
     private int $maxDataPoints;
+    private ?int $maxAgeMs;
+    private bool $clearAfterTuning;
+    /** @var ?callable */
+    private $onCleanup;
+    private ?string $savePath;
 
     /**
      * @var ?array<string, mixed> La dernière meilleure solution trouvée par l'optimiseur.
@@ -42,6 +47,48 @@ class AutoTuner
         $this->trafficData = &$trafficData;
         $this->minDataPoints = $options['minDataPoints'] ?? 200;
         $this->maxDataPoints = $options['maxDataPoints'] ?? 10000;
+        $this->maxAgeMs = $options['maxAgeMs'] ?? null;
+        $this->clearAfterTuning = $options['clearAfterTuning'] ?? false;
+        $this->onCleanup = $options['onCleanup'] ?? null;
+        $this->savePath = $options['savePath'] ?? null;
+    }
+
+    /**
+     * Prunes old or excess traffic logs to prevent memory leaks.
+     */
+    private function pruneTrafficData(): void
+    {
+        $now = (int)(microtime(true) * 1000);
+        $removed = [];
+
+        // 1. Expire par temps (maxAgeMs)
+        if ($this->maxAgeMs !== null && $this->maxAgeMs > 0) {
+            $threshold = $now - $this->maxAgeMs;
+            foreach ($this->trafficData as $key => $log) {
+                $logTs = $log['timestamp'] ?? $log['requestTimestamp'] ?? $now;
+                if ($logTs < $threshold) {
+                    $removed[] = $log;
+                    unset($this->trafficData[$key]);
+                }
+            }
+            $this->trafficData = array_values($this->trafficData);
+        }
+
+        // 2. Politique de taille maximale (maxDataPoints)
+        if ($this->maxDataPoints > 0 && count($this->trafficData) > $this->maxDataPoints) {
+            $overflowCount = count($this->trafficData) - $this->maxDataPoints;
+            $spliced = array_splice($this->trafficData, 0, $overflowCount);
+            $removed = array_merge($removed, $spliced);
+        }
+
+        // 3. Invocation du callback onCleanup
+        if ($this->onCleanup !== null && is_callable($this->onCleanup) && !empty($removed)) {
+            try {
+                call_user_func($this->onCleanup, $removed);
+            } catch (\Throwable $e) {
+                error_log("[AutoTuning] Error in onCleanup callback: " . $e->getMessage());
+            }
+        }
     }
 
     /**
@@ -49,6 +96,8 @@ class AutoTuner
      */
     public function runOptimizationCycle(): void
     {
+        $this->pruneTrafficData();
+
         $sanitizedData = RequestUtils::sanitizeTrafficData($this->trafficData);
 
         $highConfidenceLogs = count(array_filter(
@@ -176,6 +225,28 @@ class AutoTuner
         echo "[AutoTuning] Nouveaux seuils : " . json_encode($this->securityConfig['thresholds']) . "\n";
         echo "[AutoTuning] Nouveaux poids : " . json_encode($this->securityConfig['weights']) . "\n";
         echo "[AutoTuning] Nouveaux patterns : " . json_encode($this->securityConfig['patterns']) . "\n";
+
+        // NOUVEAU: Sauvegarder la meilleure configuration si un chemin est fourni.
+        if ($this->savePath !== null) {
+            try {
+                file_put_contents($this->savePath, json_encode($bestSolution['solution'], JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES));
+                echo "[AutoTuning] Meilleure configuration sauvegardée dans : {$this->savePath}\n";
+            } catch (\Throwable $e) {
+                error_log("[AutoTuning] Erreur lors de la sauvegarde de la configuration optimisée : " . $e->getMessage());
+            }
+        }
+
+        if ($this->clearAfterTuning) {
+            $cleared = array_splice($this->trafficData, 0);
+            if ($this->onCleanup !== null && is_callable($this->onCleanup) && !empty($cleared)) {
+                try {
+                    call_user_func($this->onCleanup, $cleared);
+                } catch (\Throwable $e) {
+                    error_log("[AutoTuning] Error in onCleanup callback after clearing: " . $e->getMessage());
+                }
+            }
+            echo sprintf("[AutoTuning] Explicitly cleared %d processed traffic data points.\n", count($cleared));
+        }
     }
 
     /**