@anonympins/fingerprint 0.5.1 → 0.5.4

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

@@ -31,6 +31,7 @@ const {
     default_whitelist,
     stopThresholdAutoTuning,
     getCompositeDeviceHash,
+    sanitizeTrafficData,
 } = fingerprint;
 const { store, getRequestPatternScore, getDeviceHash } = __internal;
 const { getRenderingAnomalyScore } = __internal;
@@ -749,7 +750,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 },
@@ -843,7 +844,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'
@@ -1083,6 +1084,35 @@ describe('Fingerprint & PoW Security Suite', () => {
     describe('Threshold Auto-Tuning', () => {
         let setIntervalSpy, clearIntervalSpy, consoleLogSpy;
 
+    test('should sanitize traffic data based on stable hardware cluster', async () => {
+        const trafficData = [];
+        // Attacker rotating IPs and deviceIds but having the same hardware fingerprint
+        for (let i = 0; i < 100; i++) {
+            trafficData.push({
+                type: 'trap_triggered',
+                deviceId: `attacker-dev-${i}`,
+                clientIp: `192.168.1.${i}`,
+                fingerprint: 'gpu:spoofed-nvidia-gpu|cvs:spoofed-canvas-data'
+            });
+        }
+
+        // Unique legit users
+        for (let i = 0; i < 10; i++) {
+            trafficData.push({
+                type: 'challenge_solved',
+                deviceId: `legit-dev-${i}`,
+                clientIp: `10.0.0.${i}`,
+                fingerprint: `gpu:legit-gpu-${i}|cvs:legit-canvas-${i}`
+            });
+        }
+
+        const sanitized = sanitizeTrafficData(trafficData);
+        const attackerLogs = sanitized.filter(log => log.deviceId.startsWith('attacker-dev-'));
+
+        // Total 110 logs. 2% limit = Math.max(3, 2) = 3.
+        expect(attackerLogs.length).toBeLessThanOrEqual(3);
+    });
+
         beforeEach(() => {
             setIntervalSpy = vi.spyOn(global, 'setInterval');
             clearIntervalSpy = vi.spyOn(global, 'clearInterval');
@@ -2122,7 +2152,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', {}, '');
@@ -2305,9 +2335,9 @@ describe('Subnet Scoring (Node.js)', () => {
         // The new version handles other prefixes
         expect(getIpSubnet('10.20.30.40', 16)).toBe('10.20.0.0/16');
         // IPv6
-        expect(getIpSubnet('2001:db8:abcd:0012:0000:0000:0000:0001', 48)).toBe('2001:db8:abcd:0:0:0:0:0/48');
+        expect(getIpSubnet('2001:db8:abcd:0012:0000:0000:0000:0001', 48)).toBe('2001:0db8:abcd:0000:0000:0000:0000:0000/48');
         // The new version handles other prefixes
-        expect(getIpSubnet('2a01:e0a:129:57c0:a1b2:c3d4:e5f6:a7b8', 64)).toBe('2a01:e0a:129:0:0:0:0:0/48');
+        expect(getIpSubnet('2a01:e0a:129:57c0:a1b2:c3d4:e5f6:a7b8', 64)).toBe('2a01:0e0a:0129:0000:0000:0000:0000:0000/48');
         // Invalid IPs
         expect(getIpSubnet('not-an-ip')).toBeNull();
     });
@@ -2721,3 +2751,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

@@ -115,4 +115,85 @@ describe('GpuPowSolver - Chaotic Logistic Map PoW', () => {
         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/ip-reputation.test.js

@@ -96,7 +96,7 @@ describe('IP Reputation Local System (Node.js)', () => {
         expect(ipv4Subnet).toBe('192.168.1.0/24');
 
         const ipv6Subnet = __internal.getIpSubnet('2001:db8:abcd:12::1', 24, 48);
-        expect(ipv6Subnet).toBe('2001:db8:abcd:0:0:0:0:0/48');
+        expect(ipv6Subnet).toBe('2001:0db8:abcd:0000:0000:0000:0000:0000/48');
     });
 
     it('should calculate client hints inconsistency score correctly', async () => {

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 () => {
@@ -223,9 +223,12 @@ describe('Proof-of-Work Solvers', () => {
             const seed = 'test-wasm-seed';
             const difficulty = 4; // 4 MB
 
-            const solution = await solveMemory(seed, difficulty);
+            const result = await solveMemory(seed, difficulty);
 
-            expect(solution).toBe(777);
+            expect(result).toBeInstanceOf(Object);
+            expect(result.solution).toBe(777);
+            expect(result.merkleRoot).toBeDefined();
+            expect(result.proofs).toBeDefined();
             expect(mockWasmModule._malloc).toHaveBeenCalledTimes(1);
             expect(mockWasmModule._free).toHaveBeenCalledTimes(1);
             expect(mockWasmModule._solve_memory_challenge).toHaveBeenCalledWith(1234, difficulty);

package/src/js/tests/usefulWorkSolver.test.js

@@ -0,0 +1,162 @@
+import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest';
+import { solveChallenge } from '../pow.solver.js'; // Assuming pow.solver.js is the ES module version
+
+// Mock crypto.subtle for hashing operations
+const mockSubtleDigest = vi.fn(async (algorithm, data) => {
+    // Return a consistent mock hash for testing purposes
+    const hash = new Uint8Array(32); // 32 bytes for SHA-256
+    for (let i = 0; i < hash.length; i++) {
+        hash[i] = i; // Simple predictable hash
+    }
+    return hash.buffer;
+});
+
+// Mock Math.random for deterministic optimization results
+const mockMathRandom = vi.fn(() => 0.5);
+
+// Mock IndexedDB for pospace challenges, even if not directly used by this test
+const mockIndexedDB = {
+    open: vi.fn(() => ({
+        onupgradeneeded: null,
+        onsuccess: null,
+        onerror: null,
+        result: {
+            objectStoreNames: { contains: vi.fn(() => true) },
+            createObjectStore: vi.fn(),
+            transaction: vi.fn(() => ({
+                objectStore: vi.fn(() => ({
+                    put: vi.fn(),
+                    get: vi.fn(() => ({ onsuccess: null, result: null }))
+                }))
+            }))
+        }
+    }))
+};
+
+describe('Useful Work Solver for Optimization Challenges', () => {
+    let originalMathRandom;
+    let originalIndexedDB;
+
+    beforeEach(() => {
+        // Save original implementations
+        originalMathRandom = global.Math.random;
+        originalIndexedDB = global.indexedDB;
+
+        // Mock global objects
+        vi.stubGlobal('crypto', {
+            subtle: {
+                digest: mockSubtleDigest,
+            },
+            randomInt: vi.fn((min, max) => Math.floor(mockMathRandom() * (max - min) + min)), // Mock randomInt for crypto
+            randomBytes: vi.fn((length) => new Uint8Array(length).fill(0x01)), // Mock randomBytes for crypto
+        });
+        global.Math.random = mockMathRandom;
+        global.indexedDB = mockIndexedDB;
+
+        // Reset mocks
+        mockSubtleDigest.mockClear();
+        mockMathRandom.mockClear();
+        mockIndexedDB.open.mockClear();
+    });
+
+    afterEach(() => {
+        // Restore original implementations
+        vi.unstubAllGlobals();
+        global.Math.random = originalMathRandom;
+        global.indexedDB = originalIndexedDB;
+    });
+
+    it('should solve a "useful_work_task" with fraud.solve and return a Pareto front', async () => {
+        const mockChallenge = {
+            type: 'useful_work_task',
+            nonce: 'test-nonce-fraud',
+            usefulWorkTask: {
+                problemId: 'fraud_detection_challenge',
+                task: {
+                    type: 'multi_objective_genetic_algorithm',
+                    solverName: 'fraud.solve',
+                    generations: 5, // Keep generations low for quick test
+                    populationSize: 10, // Keep population low for quick test
+                    payload: {
+                        legitimateClicks: [
+                            { fingerprint: 'fp1', timeToClick: 500, clickX: 10, clickY: 10, mouseEntropy: 0.8, scrollEvents: 5 },
+                            { fingerprint: 'fp1', timeToClick: 600, clickX: 12, clickY: 12, mouseEntropy: 0.7, scrollEvents: 6 },
+                            { fingerprint: 'fp2', timeToClick: 700, clickX: 20, clickY: 20, mouseEntropy: 0.9, scrollEvents: 7 },
+                        ],
+                        fraudulentClicks: [
+                            { fingerprint: 'fp3', timeToClick: 50, clickX: 5, clickY: 5, mouseEntropy: 0.1, scrollEvents: 0 },
+                            { fingerprint: 'fp3', timeToClick: 60, clickX: 6, clickY: 6, mouseEntropy: 0.2, scrollEvents: 1 },
+                            { fingerprint: 'fp4', timeToClick: 100, clickX: 10, clickY: 10, mouseEntropy: 0.3, scrollEvents: 2 },
+                        ],
+                    },
+                },
+            },
+        };
+
+        const solution = await solveChallenge(mockChallenge);
+
+        // Assert the structure of the returned solution
+        expect(solution.type).toBe('useful_work_task');
+        expect(solution.nonce).toBe('test-nonce-fraud');
+        expect(solution.rawSolution).toHaveProperty('problem_id', 'fraud_detection_challenge');
+        expect(solution.rawSolution).toHaveProperty('work_result');
+
+        const workResult = solution.rawSolution.work_result;
+        expect(workResult).toHaveProperty('paretoFront');
+        expect(workResult.paretoFront).toBeInstanceOf(Array);
+        expect(workResult.paretoFront.length).toBeGreaterThan(0);
+
+        // Check the structure of a single solution in the Pareto front
+        const firstParetoSolution = workResult.paretoFront[0];
+        expect(firstParetoSolution).toHaveProperty('solution');
+        expect(firstParetoSolution.solution).toBeInstanceOf(Array); // fraud.solve returns an array of thresholds
+        expect(firstParetoSolution.solution.length).toBe(4); // [minTimeToClick, maxClickVariance, minMouseEntropy, minScrollEvents]
+        expect(firstParetoSolution).toHaveProperty('objectives');
+        expect(firstParetoSolution.objectives).toBeInstanceOf(Array); // [objective1, objective2]
+        expect(firstParetoSolution.objectives.length).toBe(2);
+    }, 10000); // Increase timeout for GA, even with low generations/population
+
+    it('should solve a "useful_work_task" with cpc.solve and return a Pareto front', async () => {
+        const mockChallenge = {
+            type: 'useful_work_task',
+            nonce: 'test-nonce-cpc',
+            usefulWorkTask: {
+                problemId: 'cpc_optimization_challenge',
+                task: {
+                    type: 'multi_objective_genetic_algorithm',
+                    solverName: 'cpc.solve',
+                    generations: 5, // Keep generations low for quick test
+                    populationSize: 10, // Keep population low for quick test
+                    payload: {
+                        platformParams: { optimalBaseCommission: 0.3, optimalBonusFactor: 0.1 },
+                        website: { relevanceScore: 70 },
+                        advertiser: { credits: 1000 },
+                        estimatedImpressions: 500,
+                        competingAds: [{ id: 'ad1' }, { id: 'ad2' }],
+                    },
+                },
+            },
+        };
+
+        const solution = await solveChallenge(mockChallenge);
+
+        // Assert the structure of the returned solution
+        expect(solution.type).toBe('useful_work_task');
+        expect(solution.nonce).toBe('test-nonce-cpc');
+        expect(solution.rawSolution).toHaveProperty('problem_id', 'cpc_optimization_challenge');
+        expect(solution.rawSolution).toHaveProperty('work_result');
+
+        const workResult = solution.rawSolution.work_result;
+        expect(workResult).toHaveProperty('paretoFront');
+        expect(workResult.paretoFront).toBeInstanceOf(Array);
+        expect(workResult.paretoFront.length).toBeGreaterThan(0);
+
+        // Check the structure of a single solution in the Pareto front
+        const firstParetoSolution = workResult.paretoFront[0];
+        expect(firstParetoSolution).toHaveProperty('solution');
+        expect(typeof firstParetoSolution.solution).toBe('number'); // cpc.solve returns a single CPC value
+        expect(firstParetoSolution).toHaveProperty('objectives');
+        expect(firstParetoSolution.objectives).toBeInstanceOf(Array); // [platformRevenue, advertiserValue, marketImbalance]
+        expect(firstParetoSolution.objectives.length).toBe(3);
+    }, 10000);
+});