@anonympins/fingerprint 0.5.0 → 0.5.2

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');
@@ -748,7 +749,7 @@ describe('Fingerprint & PoW Security Suite', () => {
                     pow_type: 'cpu_mem',
                     pow_nonce: nonce,
                     pow_solution_cpu: String(cpuSolution),
-                    pow_solution_mem: String(memSolution),
+                    pow_solution_mem: JSON.stringify(memSolution),
                     pow_fp: solverFingerprint
                 },
                 headers: { 'user-agent': userAgent, 'x-device-fingerprint': solverFingerprint },
@@ -842,7 +843,7 @@ describe('Fingerprint & PoW Security Suite', () => {
                     pow_type: 'cpu_mem',
                     pow_nonce: nonce,
                     pow_solution_cpu: String(cpuSolution),
-                    pow_solution_mem: String(memSolution),
+                    pow_solution_mem: JSON.stringify(memSolution),
                     pow_fp: solverFingerprint // The client submits its fingerprint.
                 },
                 headers: { 'user-agent': userAgent, 'x-device-fingerprint': solverFingerprint }, rawHeaders: ['User-Agent', userAgent], httpVersion: '1.1'
@@ -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(() => {
@@ -2059,7 +2122,7 @@ describe('Challenge Page Generation Security (XSS)', () => {
     });
 
     it('should escape the path parameter in generateCombinedPoWChallengePage to prevent XSS', () => {
-        const maliciousPath = `test.com";\nconsole.log("pwned");//`;
+        const maliciousPath = `test.com";\nconsole.log("pwned");//`; // Original malicious path
         const challengeDetails = { nonce: 'test-nonce', target: '0000', path: maliciousPath };
 
         const html = generateCombinedPoWChallengePage(challengeDetails, 16, '127.0.0.1', 'secret', {}, '');
@@ -2658,3 +2721,87 @@ describe('Botnet Cluster Scoring (Node.js)', () => {
         const isDiffIpValid = await fingerprint.isTicketValid('192.168.1.1', ticket, 'device-123', 'hash-abc', false);
         expect(isDiffIpValid).toBe(false);
     });
+
+describe('IP Registration and Filtering', () => {
+    const localInMemoryStore = {
+        _map: new Map(),
+        async get(key) { return this._map.get(key); },
+        async set(key, value) { this._map.set(key, value); },
+        async has(key) { return this._map.has(key); },
+        async delete(key) { this._map.delete(key); },
+        clear() { this._map.clear(); }
+    };
+
+    beforeEach(() => {
+        localInMemoryStore.clear();
+        configureStore(localInMemoryStore);
+        vi.restoreAllMocks();
+        vi.spyOn(fingerprint.__internal, 'getTlsFingerprint').mockReturnValue({
+            ja3: 'mock-ja3', ja4: 'mock-ja4'
+        });
+    });
+
+    it('should immediately allow requests from IPs in the static allowlist', async () => {
+        const whitelistedIp = '198.51.100.42';
+        const config = {
+            weights: { historyScore: 1.0 },
+            thresholds: { low: 20, block: 95 },
+            whitelist: [
+                { type: 'allowlist', entries: [whitelistedIp] }
+            ]
+        };
+        const engine = new FingerprintEngine(config);
+
+        const req = {
+            clientIp: whitelistedIp,
+            path: '/',
+            cookies: {},
+            query: {},
+            headers: { 'user-agent': 'test-ua' },
+            rawHeaders: ['User-Agent', 'test-ua'],
+            httpVersion: '1.1'
+        };
+
+        const decision = await engine.processRequest(req);
+        expect(decision.action).toBe('next');
+        expect(decision.vector.whitelisted).toBe(100);
+        expect(decision.vector.type).toBe('allowlist');
+    });
+
+    it('should register distinct client IPs for a device in the data store', async () => {
+        const ip1 = '192.168.1.100';
+        const ip2 = '192.168.1.101';
+        const deviceId = 'test-ip-reg-device';
+
+        await localInMemoryStore.set(`device:${deviceId}`, {
+            initialDeviceHash: 'some-hash',
+            ips: new Set([ip1]),
+            lastUpdate: Date.now(),
+            lastFpHash: 'some-hash',
+            lastChangeTimestamp: 0,
+            rapidChangeCount: 0,
+        });
+
+        const req = {
+            clientIp: ip2,
+            path: '/',
+            cookies: { device_id: deviceId },
+            query: {},
+            headers: { 'user-agent': 'test-ua' },
+            rawHeaders: ['User-Agent', 'test-ua'],
+            httpVersion: '1.1'
+        };
+
+        const engine = new FingerprintEngine({
+            weights: { historyScore: 1.0 },
+            thresholds: { low: 20, block: 95 }
+        });
+
+        await engine.processRequest(req);
+
+        const storedData = await localInMemoryStore.get(`device:${deviceId}`);
+        expect(storedData.ips).toBeInstanceOf(Set);
+        expect(storedData.ips.has(ip1)).toBe(true);
+        expect(storedData.ips.has(ip2)).toBe(true);
+    });
+});

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

@@ -0,0 +1,199 @@
+/**
+ * @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();
+    });
+
+    it('should fallback to WebGL1 if both WebGPU and WebGL2 are not supported', async () => {
+        // Mock WebGPU as undefined
+        Object.defineProperty(global.navigator, 'gpu', {
+            value: undefined,
+            writable: true,
+            configurable: true
+        });
+
+        // Mock WebGL1 (webgl) context with float extensions enabled
+        const mockGl1 = {
+            FRAMEBUFFER: 36160,
+            FRAMEBUFFER_COMPLETE: 36053,
+            COLOR_ATTACHMENT0: 36064,
+            TEXTURE_2D: 3553,
+            RGBA: 6408,
+            FLOAT: 5126,
+            TRIANGLES: 4,
+            CLAMP_TO_EDGE: 33071,
+            TEXTURE_MAG_FILTER: 10240,
+            TEXTURE_MIN_FILTER: 10241,
+            NEAREST: 9728,
+            TEXTURE_WRAP_S: 10242,
+            TEXTURE_WRAP_T: 10243,
+            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(),
+            getExtension: vi.fn().mockImplementation((ext) => {
+                if (ext === 'OES_texture_float' || ext === 'WEBGL_color_buffer_float') {
+                    return {};
+                }
+                return null;
+            }),
+            createTexture: vi.fn(),
+            bindTexture: vi.fn(),
+            texImage2D: vi.fn(),
+            texParameteri: vi.fn(),
+            createFramebuffer: vi.fn(),
+            bindFramebuffer: vi.fn(),
+            framebufferTexture2D: vi.fn(),
+            checkFramebufferStatus: vi.fn().mockReturnValue(36053), // gl.FRAMEBUFFER_COMPLETE
+            viewport: vi.fn(),
+            readPixels: vi.fn((x, y, w, h, format, type, pixels) => {
+                for (let i = 0; i < pixels.length; i++) {
+                    pixels[i] = 0.75;
+                }
+            })
+        };
+
+        const mockCanvas = {
+            width: 8,
+            height: 8,
+            getContext: vi.fn().mockImplementation((contextId) => {
+                if (contextId === 'webgl2') return null;
+                if (contextId === 'webgl' || contextId === 'experimental-webgl') return mockGl1;
+                return null;
+            })
+        };
+
+        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('webgl1');
+        expect(result.solution.split(',').length).toBe(64);
+        expect(result.solution.split(',')[0]).toBe('0.750000');
+        vi.restoreAllMocks();
+    });
+});

package/src/js/tests/pow.solver.test.js

@@ -63,8 +63,8 @@ describe('Proof-of-Work Solvers', () => {
             const solution1 = await solveMemory(seed, difficulty);
             const solution2 = await solveMemory(seed, difficulty);
 
-            expect(solution1).toBe(solution2);
-            expect(solution1).not.toBe(await solveMemory('different-seed', difficulty));
+            expect(solution1).toStrictEqual(solution2);
+            expect(solution1).not.toStrictEqual(await solveMemory('different-seed', difficulty));
         });
     });
 
@@ -106,7 +106,7 @@ describe('Proof-of-Work Solvers', () => {
 
             const solutions = await solveChallenge(challenge, ''); // Le fingerprint est passé en 2e arg
             expect(solutions.rawSolution).toHaveProperty('cpu', expect.any(Number));
-            expect(solutions.rawSolution).toHaveProperty('mem', expect.any(Number));
+            expect(solutions.rawSolution).toHaveProperty('mem', expect.any(Object));
         }, 20000);
 
         it('should solve a "cpu_mem_inline" challenge for a browser', async () => {
@@ -122,7 +122,7 @@ describe('Proof-of-Work Solvers', () => {
 
             const solutions = await solveChallenge(challenge, '');
             expect(solutions.rawSolution).toHaveProperty('cpu', expect.any(Number));
-            expect(solutions.rawSolution).toHaveProperty('mem', expect.any(Number));
+            expect(solutions.rawSolution).toHaveProperty('mem', expect.any(Object));
         }, 20000);
 
         it('should solve a "tsp" challenge', async () => {

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);
+    });
+});