@anonympins/fingerprint 0.5.0 → 0.5.1

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/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', () => {

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

@@ -33,6 +33,7 @@ const {
     getCompositeDeviceHash,
 } = fingerprint;
 const { store, getRequestPatternScore, getDeviceHash } = __internal;
+const { getRenderingAnomalyScore } = __internal;
 let { getBehaviorScore, getClickVarianceScore } = __internal;
 // Mock the entire dns module
 vi.mock('node:dns/promises');
@@ -1492,6 +1493,50 @@ describe('Fingerprint & PoW Security Suite', () => {
         });
     });
 
+    describe('getRenderingAnomalyScore', () => {
+        it('should return 0 if rendering metrics are missing', () => {
+            const context = { headers: {} };
+            const { renderingAnomalyScore } = getRenderingAnomalyScore(context);
+            expect(renderingAnomalyScore).toBe(0);
+        });
+
+        it('should return 100 if offscreen canvas spoofing is detected', () => {
+            const context = {
+                headers: {
+                    'x-behavior-metrics': JSON.stringify({
+                        rendering: { fps: 60, jitter: 0.1, offscreenAnom: true }
+                    })
+                }
+            };
+            const { renderingAnomalyScore } = getRenderingAnomalyScore(context);
+            expect(renderingAnomalyScore).toBe(100);
+        });
+
+        it('should return a high score if jitter is very high', () => {
+            const context = {
+                headers: {
+                    'x-behavior-metrics': JSON.stringify({
+                        rendering: { fps: 60, jitter: 12.5, offscreenAnom: false }
+                    })
+                }
+            };
+            const { renderingAnomalyScore } = getRenderingAnomalyScore(context);
+            expect(renderingAnomalyScore).toBe(65); // (12.5 - 6.0) * 10 = 65
+        });
+
+        it('should return a high score if FPS is abnormal', () => {
+            const context = {
+                headers: {
+                    'x-behavior-metrics': JSON.stringify({
+                        rendering: { fps: 300, jitter: 1.0, offscreenAnom: false }
+                    })
+                }
+            };
+            const { renderingAnomalyScore } = getRenderingAnomalyScore(context);
+            expect(renderingAnomalyScore).toBe(50);
+        });
+    });
+
     describe('getBehaviorScore', () => {
         // La fonction est privée, on la récupère via l'export __internal
         // FIX: Correctly assign the function before tests run.
@@ -1542,6 +1587,24 @@ describe('Fingerprint & PoW Security Suite', () => {
         });
     });
 
+    it('should return a high score for keystroke dynamics with very low dwell/flight variance (bot emulation)', () => {
+        const metrics = {
+            honeypotInteraction: false,
+            keystrokeLatency: 100.0,
+            keystrokeDwellTimes: [50, 50, 50, 50, 50], // stdDev = 0
+            keystrokeFlightTimes: [
+                { digraph: 'ab', time: 100 },
+                { digraph: 'bc', time: 100 },
+                { digraph: 'cd', time: 100 },
+                { digraph: 'de', time: 100 },
+                { digraph: 'ef', time: 100 }
+            ] // stdDev = 0
+        };
+        const context = { headers: { 'x-behavior-metrics': JSON.stringify(metrics) } };
+        const { behaviorScore } = getBehaviorScore(context);
+        expect(behaviorScore).toBeGreaterThanOrEqual(70); // 35 (stdDevDwell) + 35 (stdDevFlight) = 70
+    });
+
     describe('getClickVarianceScore', () => {
         // FIX: Correctly assign the function before tests run.
         beforeEach(() => {

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/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/Challenge/ChallengeUtils.php

@@ -14,6 +14,48 @@ use Anonympins\Fingerprint\Utils\RequestUtils;
  */
 class ChallengeUtils
 {
+    private static function fround(float $value): float
+    {
+        return unpack('f', pack('f', $value))[1];
+    }
+
+    public static function hashSeedToFloat(string $seed): float
+    {
+        $hash = 0;
+        for ($i = 0; $i < strlen($seed); $i++) {
+            $hash = (($hash << 5) - $hash + ord($seed[$i])) & 0xffffffff;
+            if ($hash & 0x80000000) {
+                $hash = $hash - 0x100000000;
+            }
+        }
+        return abs($hash % 1000000) / 1000000;
+    }
+
+    public static function verifyGpuPow(string $seed, int $iterations, string $solution, array $sampleIndices = [0, 12, 35, 57]): bool
+    {
+        $values = explode(',', $solution);
+        if (count($values) !== 64) {
+            return false;
+        }
+        $numericSeed = self::hashSeedToFloat($seed);
+        $r = 3.9999;
+        foreach ($sampleIndices as $idx) {
+            if ($idx < 0 || $idx >= 64) {
+                return false;
+            }
+            $x = self::fround($numericSeed + $idx * 0.015);
+            $rFloat = self::fround($r);
+            for ($i = 0; $i < $iterations; $i++) {
+                $x = self::fround($rFloat * $x * self::fround(1.0 - $x));
+            }
+            $clientVal = (float)$values[$idx];
+            if (abs($clientVal - $x) > 1e-4) {
+                return false;
+            }
+        }
+        return true;
+    }
+
     private const TRAP_URL_TEMPLATES = [
         '/includes/config-{RANDOM}.php',
         '/.env.{RANDOM}',

package/src/php/Config/SecurityProfiles.php

@@ -41,6 +41,8 @@ class SecurityProfiles
                 'subnetScore' => 0.5, // Pénalise les sous-réseaux IP avec une activité suspecte agrégée
                 'botnetClusterScore' => 0.6, // NOUVEAU: Poids pour le clustering botnet
                 'tcpAnomalyScore' => 0.8, // NEW: Anomalie de pile TCP/IP
+                'quicAnomalyScore' => 0.8, // NEW: Anomalie QUIC
+                'renderingAnomalyScore' => 0.8, // NEW: Anomalie de rendu
 
             ],
             'thresholds' => ['low' => 20, 'medium' => 45, 'high' => 75, 'block' => 95],
@@ -87,6 +89,8 @@ class SecurityProfiles
                 'subnetScore' => 0.7, // Poids plus élevé en mode strict
                 'botnetClusterScore' => 0.8, // NOUVEAU: Poids pour le clustering botnet
                 'tcpAnomalyScore' => 1.0, // NEW: Anomalie de pile TCP/IP
+                'quicAnomalyScore' => 1.0, // NEW: Anomalie QUIC
+                'renderingAnomalyScore' => 1.0, // NEW: Anomalie de rendu
 
             ],
             'thresholds' => ['low' => 10, 'medium' => 35, 'high' => 65, 'block' => 90],
@@ -133,6 +137,7 @@ class SecurityProfiles
                 'subnetScore' => 0.8, // Très important pour les API pour détecter les botnets
                 'botnetClusterScore' => 0.7, // NOUVEAU: Poids pour le clustering botnet
                 'tcpAnomalyScore' => 0.8, // NEW: Anomalie de pile TCP/IP
+                'quicAnomalyScore' => 0.8, // NEW: Anomalie QUIC
 
             ],
             'thresholds' => ['low' => 25, 'medium' => 50, 'high' => 80, 'block' => 95],
@@ -181,6 +186,8 @@ class SecurityProfiles
                 'subnetScore' => 0.4, // Utile contre le spam de commentaires coordonné
                 'botnetClusterScore' => 0.5, // NOUVEAU: Poids pour le clustering botnet
                 'tcpAnomalyScore' => 0.5, // NEW: Anomalie de pile TCP/IP
+                'quicAnomalyScore' => 0.5, // NEW: Anomalie QUIC
+                'renderingAnomalyScore' => 0.5, // NEW: Anomalie de rendu
 
             ],
             'thresholds' => ['low' => 25, 'medium' => 55, 'high' => 80, 'block' => 95],
@@ -228,6 +235,8 @@ class SecurityProfiles
                 'subnetScore' => 0.9, // Crucial contre les attaques de scalping distribuées
                 'botnetClusterScore' => 0.9, // NOUVEAU: Poids pour le clustering botnet
                 'tcpAnomalyScore' => 0.9, // NEW: Anomalie de pile TCP/IP
+                'quicAnomalyScore' => 0.9, // NEW: Anomalie QUIC
+                'renderingAnomalyScore' => 0.9, // NEW: Anomalie de rendu
 
             ],
             'thresholds' => ['low' => 15, 'medium' => 40, 'high' => 70, 'block' => 90],

package/src/php/FingerprintEngine.php

@@ -61,6 +61,19 @@
          $this->validateConfig($securityConfig);
      }
 
+    /**
+     * Applique à chaud une nouvelle configuration de sécurité (poids, seuils, etc.)
+     * sans nécessiter de redémarrage.
+     *
+     * @param array $newConfig La nouvelle configuration (partielle ou complète).
+     */
+    public function updateConfig(array $newConfig): void
+    {
+        $this->validateConfig($newConfig);
+        $this->securityConfig = SecurityProfiles::deepMerge($this->securityConfig, $newConfig);
+        $this->log('Configuration mise à jour à chaud (Hot-Reloaded)', $this->securityConfig);
+    }
+
      private function validateConfig(array $config): void
      {
          if (empty($config)) {
@@ -467,6 +480,12 @@
          // Score d'anomalie de pile TCP/IP
          $tcpAnomaly = RequestUtils::getTcpAnomalyScore($context);
 
+         // Score d'anomalie de flux QUIC/HTTP3
+         $quicAnomaly = RequestUtils::getQuicAnomalyScore($context);
+
+         // Score d'anomalie de rendu d'affichage (V-Sync)
+         $renderingAnomaly = RequestUtils::getRenderingAnomalyScore($context);
+
          // Assemblage du vecteur de suspicion final
          $suspicionVector = array_merge($suspicionVector, [
              'inconsistencyScore' => $inconsistencyScore,
@@ -486,6 +505,8 @@
              'subnetScore' => $subnetScore['subnetScore'],
              'botnetClusterScore' => $botnetCluster['botnetClusterScore'],
              'tcpAnomalyScore' => $tcpAnomaly['tcpAnomalyScore'],
+             'quicAnomalyScore' => $quicAnomaly['quicAnomalyScore'],
+             'renderingAnomalyScore' => $renderingAnomaly['renderingAnomalyScore'],
          ]);
  
          // Sauvegarder l'état mis à jour de l'appareil dans le store

package/src/php/RequestContext.php

@@ -38,6 +38,7 @@ class RequestContext
     public ?string $ja4s = null;
     public ?string $ja4h = null;
     public ?string $http2Fingerprint = null;
+    public ?string $quicFingerprint = null;
     public ?string $tcpFingerprint = null;
 
     /**
@@ -77,6 +78,7 @@ class RequestContext
         $this->ja4h = $this->headers['x-ja4h-hash'] ?? null;
         $this->http2Fingerprint = $this->headers['x-http2-fingerprint'] ?? null;
         $this->tcpFingerprint = $this->headers['x-tcp-fingerprint'] ?? null;
+        $this->quicFingerprint = $this->headers['x-quic-fp'] ?? null;
         $this->tlsSessionId = $this->headers['x-tls-session-id'] ?? $this->headers['x-ssl-session-id'] ?? null;
     }
     /**