@anonympins/fingerprint 0.3.8 → 0.4.0

package/src/js/tests/ip-reputation.test.js

@@ -0,0 +1,132 @@
+import {beforeEach, describe, expect, it} from 'vitest';
+import {__internal, configureStore, FingerprintEngine} from '../fingerprint.js';
+
+describe('IP Reputation Local System (Node.js)', () => {
+    let mockStore;
+
+    beforeEach(() => {
+        mockStore = {
+            _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); }
+        };
+        configureStore(mockStore);
+    });
+
+    it('should return a default score of 0 for unknown IPs', async () => {
+        const score = await __internal.getIpReputationScore('1.1.1.1');
+        expect(score).toBe(0);
+    });
+
+    it('should correctly increment and decrement score values', async () => {
+        const ip = '192.168.1.1';
+        await __internal.updateIpReputationScore(ip, 30);
+        let score = await __internal.getIpReputationScore(ip);
+        expect(score).toBe(30);
+
+        await __internal.updateIpReputationScore(ip, -10);
+        score = await __internal.getIpReputationScore(ip);
+        expect(score).toBe(20);
+    });
+
+    it('should clamp the reputation score within bounds [0, 100]', async () => {
+        const ip = '10.0.0.1';
+        await __internal.updateIpReputationScore(ip, 150);
+        let score = await __internal.getIpReputationScore(ip);
+        expect(score).toBe(100);
+
+        await __internal.updateIpReputationScore(ip, -200);
+        score = await __internal.getIpReputationScore(ip);
+        expect(score).toBe(0);
+    });
+
+    it('should apply passive decay of 2 points per hour of inactivity', async () => {
+        const ip = '172.16.0.1';
+        const now = Date.now();
+        
+        // Simulation d'un score de 50 mis à jour il y a 3 heures (3h * 2 points/heure = 6 points de perte)
+        await mockStore.set(`ip-reputation:${ip}`, {
+            score: 50,
+            lastUpdate: now - (3 * 60 * 60 * 1000)
+        });
+
+        const score = await __internal.getIpReputationScore(ip);
+        expect(score).toBe(44);
+    });
+
+    it('should integrate ipReputationScore into the final score calculation', async () => {
+        const ip = '1.2.3.4';
+        await __internal.updateIpReputationScore(ip, 60); // Set IP reputation to 60
+
+        const mockSecurityConfig = {
+            weights: {
+                ipReputationScore: 0.5, // Give it a weight
+                historyScore: 0.0, // Other weights to 0 for isolation
+                rotationScore: 0.0,
+                headerAnomalyScore: 0.0,
+                requestPatternScore: 0.0,
+                inconsistencyScore: 0.0,
+                honeypotScore: 0.0,
+                behaviorScore: 0.0,
+                botScore: 0.0,
+                crossLayerInconsistencyScore: 0.0,
+                tlsSpoofingScore: 0.0,
+                timeInconsistencyScore: 0.0,
+                clickVarianceScore: 0.0,
+                clientHintsInconsistencyScore: 0.0,
+                subnetScore: 0.0,
+            },
+            thresholds: { low: 0, medium: 0, high: 0, block: 100 }, // Irrelevant for this test
+        };
+
+        const ipRepScore = await __internal.getIpReputationScore(ip);
+        const suspicionVector = { ipReputationScore: ipRepScore };
+
+        const engine = new FingerprintEngine(mockSecurityConfig);
+        const finalScore = engine.calculateFinalScore(suspicionVector);
+
+        // Expected score: 60 (ipRepScore) * 0.5 (weight) = 30
+        expect(finalScore).toBe(30.0);
+    });
+
+    it('should return correct subnet for IPv4 and IPv6', async () => {
+        const ipv4Subnet = __internal.getIpSubnet('192.168.1.50', 24, 48);
+        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');
+    });
+
+    it('should calculate client hints inconsistency score correctly', async () => {
+        const mockContextMismatch = {
+            headers: {
+                'user-agent': 'Mozilla/5.0 Firefox/117.0',
+                'sec-ch-ua': '"Google Chrome";v="117"'
+            }
+        };
+        const scoreMismatch = __internal.getClientHintsInconsistencyScore(mockContextMismatch);
+        expect(scoreMismatch.clientHintsInconsistencyScore).toBe(90);
+
+        const mockContextVersionDrift = {
+            headers: {
+                'user-agent': 'Mozilla/5.0 Chrome/110.0',
+                'sec-ch-ua': '"Google Chrome";v="117"'
+            }
+        };
+        const scoreVersionDrift = __internal.getClientHintsInconsistencyScore(mockContextVersionDrift);
+        expect(scoreVersionDrift.clientHintsInconsistencyScore).toBe(80);
+    });
+
+    it('should integrate subnet history into subnet score', async () => {
+        const mockContext = { clientIp: '192.168.1.50' };
+        let score = await __internal.getSubnetScore(mockContext);
+        expect(score.subnetScore).toBe(0);
+        for (let i = 1; i <= 12; i++) {
+            await __internal.updateSubnetMetrics(mockContext, `dev-${i}`, 40);
+        }
+        score = await __internal.getSubnetScore(mockContext);
+        expect(score.subnetScore).toBeGreaterThan(0);
+    });
+});

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

@@ -0,0 +1,135 @@
+import crypto from 'crypto';
+import {getTlsSpoofingScore, parseJa3} from '../fingerprint.js';
+import {vi} from 'vitest';
+
+describe('JA3 Anomaly Detector (Node.js)', () => {
+    
+    // Mock d'un store de cache asynchrone en mémoire
+    const createMockStore = () => {
+        const storage = {};
+        return {
+            get: vi.fn(async (key) => storage[key] || null),
+            set: vi.fn(async (key, val) => { storage[key] = val; })
+        };
+    };
+
+    describe('parseJa3', () => {
+        it('devrait parser correctement une chaine JA3 brute', () => {
+            const rawJa3 = '771,4865-4866-4867,0-23-65281-10-11,29-23-24,0';
+            const parsed = parseJa3(rawJa3);
+            
+            expect(parsed).not.toBeNull();
+            expect(parsed.tlsVersion).toBe(771);
+            expect(parsed.ciphers).toEqual([4865, 4866, 4867]);
+            expect(parsed.extensions).toEqual([0, 23, 65281, 10, 11]);
+        });
+
+        it('devrait retourner null pour des chaines invalides', () => {
+            expect(parseJa3('')).toBeNull();
+            expect(parseJa3('771,4865')).toBeNull();
+        });
+    });
+
+    describe('getTlsSpoofingScore (Anomalies JA3 hachées)', () => {
+        it('devrait détecter l\'usurpation d\'identité d\'une bibliothèque (Python)', async () => {
+            const pythonJa3Hash = '47344a349b75c4e82333475553b5f358';
+            const chromeUa = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/120.0.0.0';
+
+            const context = {
+                headers: {
+                    'user-agent': chromeUa,
+                    'x-ja3-hash': pythonJa3Hash
+                }
+            };
+
+            const result = await getTlsSpoofingScore(context);
+            expect(result.tlsSpoofingScore).toBe(90);
+        });
+
+        it('devrait détecter la rotation d\'User-Agent sur un même hash JA3 (Stagnation)', async () => {
+            const mockStore = createMockStore();
+            const unknownJa3 = '00000000000000000000000000000000';
+            
+            const contextChrome = {
+                headers: {
+                    'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/120.0.0.0',
+                    'x-ja3-hash': unknownJa3
+                }
+            };
+
+            const contextFirefox = {
+                headers: {
+                    'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) Firefox/120.0',
+                    'x-ja3-hash': unknownJa3
+                }
+            };
+
+            // Injecter le mockStore dans le module de test si nécessaire ou mocker l'importation du store global
+            // Premier passage : Chrome
+            const res1 = await getTlsSpoofingScore(contextChrome, mockStore);
+            
+            // Deuxième passage : Firefox (Détection de la rotation de UA)
+            const res2 = await getTlsSpoofingScore(contextFirefox, mockStore);
+            expect(res2.tlsSpoofingScore).toBe(85);
+        });
+    });
+
+    describe('getTlsSpoofingScore (Anomalies JA3 brutes)', () => {
+        it('devrait suspecter un faux Chrome n\'utilisant pas le mécanisme GREASE', async () => {
+            const chromeUa = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/120.0.0.0';
+            // Pas de valeurs GREASE dans la suite
+            const ja3RawNoGrease = '771,4865-4866,0-23-10,29,0';
+            const ja3Hash = crypto.createHash('md5').update(ja3RawNoGrease).digest('hex');
+
+            const context = {
+                headers: {
+                    'user-agent': chromeUa,
+                    'x-ja3-raw': ja3RawNoGrease,
+                    'x-ja3-hash': ja3Hash
+                },
+                httpVersion: '2.0'
+            };
+
+            const result = await getTlsSpoofingScore(context);
+            expect(result.tlsSpoofingScore).toBe(75);
+        });
+
+        it('devrait valider un Chrome légitime utilisant des valeurs GREASE', async () => {
+            const chromeUa = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/120.0.0.0';
+            // 2570 est une suite GREASE valide
+            const ja3RawWithGrease = '771,4865-2570,0-23-10-16,29,0';
+            const ja3Hash = crypto.createHash('md5').update(ja3RawWithGrease).digest('hex');
+
+            const context = {
+                headers: {
+                    'user-agent': chromeUa,
+                    'x-ja3-raw': ja3RawWithGrease,
+                    'x-ja3-hash': ja3Hash
+                },
+                httpVersion: '2.0'
+            };
+
+            const result = await getTlsSpoofingScore(context);
+            expect(result.tlsSpoofingScore).toBeLessThan(70);
+        });
+
+        it('devrait détecter l\'absence d\'extension ALPN pour une connexion HTTP/2', async () => {
+            const chromeUa = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/120.0.0.0';
+            // Pas d'extension 16 (ALPN)
+            const ja3RawNoAlpn = '771,4865-2570,0-23-10,29,0';
+            const ja3Hash = crypto.createHash('md5').update(ja3RawNoAlpn).digest('hex');
+
+            const context = {
+                headers: {
+                    'user-agent': chromeUa,
+                    'x-ja3-raw': ja3RawNoAlpn,
+                    'x-ja3-hash': ja3Hash
+                },
+                httpVersion: '2.0'
+            };
+
+            const result = await getTlsSpoofingScore(context);
+            expect(result.tlsSpoofingScore).toBe(70);
+        });
+    });
+});

package/src/js/tests/library.test.js

@@ -0,0 +1,96 @@
+import {describe, expect, it} from 'vitest';
+import {Optimization} from '../library.js';
+
+describe('Optimization.Operators.benfordTest', () => {
+
+    it('should return 0 for non-array inputs', () => {
+        expect(Optimization.Operators.benfordTest("12345")).toBe(0);
+        expect(Optimization.Operators.benfordTest(null)).toBe(0);
+        expect(Optimization.Operators.benfordTest(undefined)).toBe(0);
+        expect(Optimization.Operators.benfordTest({ a: 1 })).toBe(0);
+    });
+
+    it('should return 0 for arrays with less than 10 valid numbers', () => {
+        const smallArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];
+        expect(Optimization.Operators.benfordTest(smallArray)).toBe(0);
+    });
+
+    it('should return 0 for an empty array', () => {
+        expect(Optimization.Operators.benfordTest([])).toBe(0);
+    });
+
+    it('should ignore zeros, non-numeric strings, and leading spaces', () => {
+        // This array contains only 9 valid leading digits.
+        const dirtyArray = [0, " 123", "abc", 2, 3, 4, 5, 6, 7, 8, 9, null, undefined];
+        expect(Optimization.Operators.benfordTest(dirtyArray)).toBe(0);
+    });
+
+    it('should return a very low score for a distribution that perfectly matches Benford\'s law', () => {
+        // Création d'un échantillon de 1000 nombres qui suit la loi de Benford
+        const benfordSample = [
+            ...Array(301).fill(100), // 301 nombres commençant par 1
+            ...Array(176).fill(200), // 176 nombres commençant par 2
+            ...Array(125).fill(300), // 125 nombres commençant par 3
+            ...Array(97).fill(400),  // etc.
+            ...Array(79).fill(500),
+            ...Array(67).fill(600),
+            ...Array(58).fill(700),
+            ...Array(51).fill(800),
+            ...Array(46).fill(900),
+        ];
+
+        const score = Optimization.Operators.benfordTest(benfordSample);
+        // Le score devrait être très proche de 0. On utilise toBeLessThan pour tolérer les imprécisions de calcul.
+        expect(score).toBeLessThan(1e-9);
+    });
+
+    it('should return a high (suspect) score for a uniform distribution', () => {
+        // Une distribution uniforme est très peu naturelle pour ce genre de données.
+        const uniformSample = [];
+        for (let i = 1; i <= 9; i++) {
+            for (let j = 0; j < 100; j++) {
+                uniformSample.push(i * 100 + j);
+            }
+        }
+
+        const score = Optimization.Operators.benfordTest(uniformSample);
+        // Un score > 0.15 est considéré comme suspect.
+        expect(score).toBeGreaterThan(0.15);
+    });
+
+    it('should return a high (suspect) score for a distribution skewed towards high digits', () => {
+        // L'inverse de la loi de Benford, très suspect.
+        const inverseBenfordSample = [
+            ...Array(46).fill(100),
+            ...Array(51).fill(200),
+            ...Array(58).fill(300),
+            ...Array(67).fill(400),
+            ...Array(79).fill(500),
+            ...Array(97).fill(600),
+            ...Array(125).fill(700),
+            ...Array(176).fill(800),
+            ...Array(301).fill(900),
+        ];
+
+        const score = Optimization.Operators.benfordTest(inverseBenfordSample);
+        expect(score).toBeGreaterThan(0.3); // Score attendu encore plus élevé
+    });
+
+    it('should handle real-world-like data (request timings)', () => {
+        // Simule des délais de requêtes générés par un bot (ex: aléatoire uniforme entre 500 et 1500ms)
+        const botTimings = Array.from({ length: 100 }, () => 500 + Math.random() * 1000);
+        const botScore = Optimization.Operators.benfordTest(botTimings);
+
+        // Simule des délais humains (plus de petits délais, quelques longs délais)
+        const humanTimings = [
+            123, 234, 180, 345, 150, 456, 110, 190, 210, 280, 567, 130, 890, 1200, 310, 160
+        ];
+        const humanScore = Optimization.Operators.benfordTest(humanTimings);
+
+        // Le score du bot devrait être significativement plus élevé que celui de l'humain.
+        // Les valeurs exactes peuvent varier, mais la tendance doit être claire.
+        expect(botScore).toBeGreaterThan(0.1);
+        expect(humanScore).toBeLessThan(botScore);
+    });
+
+});

package/src/js/tests/metrics.test.js

@@ -0,0 +1,104 @@
+import { describe, expect, it, vi, beforeEach } from 'vitest';
+import { handleMetricsRequest, __internal } from '../fingerprint.js';
+
+describe('Metrics & Authorization Callback Integration', () => {
+    let req, res;
+
+    beforeEach(() => {
+        req = {
+            ip: '127.0.0.1',
+            path: '/metrics',
+            headers: { 'user-agent': 'prometheus' },
+            query: {},
+            body: {},
+            cookies: {},
+            httpVersion: '1.1'
+        };
+        res = {
+            status: vi.fn().mockReturnThis(),
+            send: vi.fn().mockReturnThis(),
+            set: vi.fn().mockReturnThis(),
+            redirect: vi.fn().mockReturnThis()
+        };
+    });
+    it('should return metrics with 200 Content-Type if authorized', async () => {
+        const config = {
+            metricsAuthorizationCallback: () => true
+        };
+        await handleMetricsRequest(req, res, config);
+
+        expect(res.set).toHaveBeenCalledWith('Content-Type', expect.stringContaining('text/plain'));
+        expect(res.send).toHaveBeenCalledWith(expect.stringContaining('fingerprint_requests_total'));
+    });
+
+    it('should include current weights and thresholds in prometheus metrics output', async () => {
+        const config = {
+            metricsAuthorizationCallback: () => true,
+            weights: { historyScore: 0.35, rotationScore: 0.65 },
+            thresholds: { low: 22, block: 92 }
+        };
+        await handleMetricsRequest(req, res, config);
+
+        expect(res.set).toHaveBeenCalledWith('Content-Type', expect.stringContaining('text/plain'));
+        expect(res.send).toHaveBeenCalledWith(expect.stringContaining('fingerprint_security_weight{indicator="historyScore"} 0.35'));
+        expect(res.send).toHaveBeenCalledWith(expect.stringContaining('fingerprint_security_weight{indicator="rotationScore"} 0.65'));
+        expect(res.send).toHaveBeenCalledWith(expect.stringContaining('fingerprint_security_threshold{level="low"} 22'));
+        expect(res.send).toHaveBeenCalledWith(expect.stringContaining('fingerprint_security_threshold{level="block"} 92'));
+    });
+
+    it('should include auto-tuning performance metrics if a best solution is available', async () => {
+        __internal.setLastBestSolution({
+            solution: {},
+            objectives: [0.0123, 0.0456]
+        });
+
+        const config = {
+            metricsAuthorizationCallback: () => true
+        };
+        await handleMetricsRequest(req, res, config);
+
+        expect(res.set).toHaveBeenCalledWith('Content-Type', expect.stringContaining('text/plain'));
+        expect(res.send).toHaveBeenCalledWith(expect.stringContaining('fingerprint_autotuning_false_positive_rate 0.0123'));
+        expect(res.send).toHaveBeenCalledWith(expect.stringContaining('fingerprint_autotuning_false_negative_rate 0.0456'));
+
+        // Cleanup
+        __internal.setLastBestSolution(null);
+    });
+
+    it('should return 403 if authorization callback returns false', async () => {
+        const config = {
+            metricsAuthorizationCallback: () => false
+        };
+        await handleMetricsRequest(req, res, config);
+
+        expect(res.status).toHaveBeenCalledWith(403);
+        expect(res.send).toHaveBeenCalledWith('Access to metrics denied.');
+    });
+
+    it('should handle custom block action returned by authorization callback', async () => {
+        const config = {
+            metricsAuthorizationCallback: () => ({
+                action: 'block',
+                status: 401,
+                body: 'Custom unauthorized message'
+            })
+        };
+        await handleMetricsRequest(req, res, config);
+
+        expect(res.status).toHaveBeenCalledWith(401);
+        expect(res.send).toHaveBeenCalledWith('Custom unauthorized message');
+    });
+
+    it('should handle custom redirect action returned by authorization callback', async () => {
+        const config = {
+            metricsAuthorizationCallback: () => ({
+                action: 'redirect',
+                status: 302,
+                path: '/forbidden'
+            })
+        };
+        await handleMetricsRequest(req, res, config);
+
+        expect(res.redirect).toHaveBeenCalledWith(302, '/forbidden');
+    });
+});

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

@@ -0,0 +1,198 @@
+import {describe, expect, it, vi, beforeEach, afterEach} from 'vitest';
+import {createHash} from 'node:crypto';
+// Import the functions to be tested.
+// Since the inline file doesn't use exports, we can't directly import.
+// Instead, we'll test the ES module version which shares the same logic.
+import {solveChallenge, solveCpuTargetInline, solveMemory, solveTsp} from '../pow.solver.js';
+
+describe('Proof-of-Work Solvers', () => {
+
+    describe('solveCpuTargetInline', () => {
+        const nonce = 'test-nonce';
+        // A relatively easy target for quick tests (first 16 bits must be zero)
+        const targetHex = '0000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF';
+        const targetBigInt = BigInt('0x' + targetHex);
+
+        it('should find a valid CPU solution with a simple base block', async () => {
+            // Le `baseBlock` est maintenant un Uint8Array.
+            // Le client et le serveur doivent s'accorder sur sa construction.
+            // Ici, on simule un challenge simple avec juste le nonce.
+            const baseBlock = new TextEncoder().encode(`${nonce}:`);
+            const solution = await solveCpuTargetInline(baseBlock, targetHex);
+
+            // Verification: re-hash the solution and check against the target
+            const finalBlock = new Uint8Array([...baseBlock, ...new TextEncoder().encode(String(solution))]);
+            const hash = createHash('sha256').update(finalBlock).digest('hex');
+            const hashBigInt = BigInt('0x' + hash);
+
+            expect(hashBigInt).toBeLessThan(targetBigInt);
+        }, 20000);
+
+        it('should find a valid CPU solution with a client secret', async () => {
+            const clientSecret = 'my-secret';
+            const fingerprint = 'test-fp-string';
+            // Le `baseBlock` est maintenant un Uint8Array qui inclut toutes les informations.
+            const baseBlock = new TextEncoder().encode(`${nonce}:${clientSecret}:${fingerprint}:`);
+            const solution = await solveCpuTargetInline(baseBlock, targetHex);
+
+            // Verification: re-hash the solution and check against the target
+            const finalBlock = new Uint8Array([...baseBlock, ...new TextEncoder().encode(String(solution))]);
+            const hash = createHash('sha256').update(finalBlock).digest('hex');
+            const hashBigInt = BigInt('0x' + hash);
+            expect(hashBigInt).toBeLessThan(targetBigInt);
+        }, 20000);
+
+        it('should call the progress callback', async () => {
+            const progressCallback = vi.fn();
+            const baseBlock = new TextEncoder().encode(`${nonce}:`);
+            // Use a much harder target to ensure the loop runs long enough
+            const hardTarget = '0000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF';
+            await solveCpuTargetInline(baseBlock, hardTarget, progressCallback);
+
+            // Check if the callback was called with a number
+            expect(progressCallback).toHaveBeenCalled();
+            expect(progressCallback).toHaveBeenCalledWith(expect.any(Number));
+        }, 40000); // Increase timeout for harder challenge
+    });
+
+    describe('solveMemory', () => {
+        it('should produce a deterministic result for a given seed and difficulty', async () => {
+            const seed = 'test-seed';
+            const difficulty = 1; // 1MB
+
+            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));
+        });
+    });
+
+    describe('solveTsp', () => {
+        it('should solve a simple TSP problem', async () => {
+            const cities = [{ x: 10, y: 10 }, { x: 90, y: 90 }, { x: 10, y: 90 }, { x: 90, y: 10 }];
+            const result = await solveTsp(cities, 400);
+
+            expect(result.path).toBeInstanceOf(Array);
+            expect(result.path.length).toBe(4);
+            // The optimal path for a square is ~324. The nearest neighbor should find this.
+            expect(result.distance).toBeLessThan(330);
+        });
+    });
+
+    describe('solveChallenge', () => {
+        const nonce = 'challenge-nonce';
+        const clientSecret = 'challenge-secret';
+        const cpuTarget = '0000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF';
+
+        it('should solve a "cpu_target" challenge', async () => {
+            // The 'cpu_target' case in solveChallenge uses Web Workers, which are not available in Node.js test env.
+            // We will test the 'cpu_mem' case which uses the same underlying `solveCpuTargetInline` function.
+            // This test is effectively covered by the 'cpu_mem' test below.
+            expect(true).toBe(true);
+        });
+
+        it('should solve a "cpu_mem" challenge for an API client', async () => {
+            const challenge = {
+                type: 'cpu_mem',
+                nonce,
+                clientSecret,
+                cpuTarget,
+                memDifficulty: 1,
+                // Pour les appels API, le serveur pré-calcule le baseBlock
+                // sans l'IP du client, mais avec l'empreinte digitale.
+                baseBlock: [...new TextEncoder().encode(`${nonce}:${clientSecret}:`)]
+            };
+
+            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));
+        }, 20000);
+
+        it('should solve a "cpu_mem_inline" challenge for a browser', async () => {
+            const challenge = {
+                type: 'cpu_mem_inline',
+                nonce,
+                clientSecret,
+                cpuTarget,
+                memDifficulty: 1,
+                // Pour le challenge inline, le serveur inclut l'IP dans le baseBlock.
+                baseBlock: [...new TextEncoder().encode(`${nonce}:${clientSecret}:`)]
+            };
+
+            const solutions = await solveChallenge(challenge, '');
+            expect(solutions.rawSolution).toHaveProperty('cpu', expect.any(Number));
+            expect(solutions.rawSolution).toHaveProperty('mem', expect.any(Number));
+        }, 20000);
+
+        it('should solve a "tsp" challenge', async () => {
+            const challenge = {
+                type: 'tsp',
+                cities: [{ x: 0, y: 0 }, { x: 100, y: 100 }],
+                targetMaxDistance: 300
+            };
+            const solutions = await solveChallenge(challenge);
+            // Pour le TSP, la solution brute est directement le chemin
+            expect(solutions.rawSolution).toEqual([0, 1]);
+        });
+
+        it('should throw an error for an unknown challenge type', async () => {
+            const challenge = { type: 'unknown' };
+            await expect(solveChallenge(challenge)).rejects.toThrow('Unknown challenge type: unknown');
+        });
+    });
+
+    describe('WASM Solver Path Integration (Mocked)', () => {
+        let mockWasmModule;
+
+        beforeEach(() => {
+            mockWasmModule = {
+                _malloc: vi.fn().mockImplementation(() => 1234), // Simule un pointeur mémoire
+                _free: vi.fn(),
+                HEAPU8: new Uint8Array(10000),
+                HEAP8: new Int8Array(10000),
+                _solve_cpu_target: vi.fn().mockReturnValue(1337),
+                _solve_memory_challenge: vi.fn().mockReturnValue(777)
+            };
+
+            // Injecter le module WASM globalement pour simuler le comportement du navigateur
+            global.window = {
+                wasmModule: mockWasmModule
+            };
+        });
+
+        afterEach(() => {
+            // Nettoyer l'environnement global après chaque test
+            delete global.window;
+        });
+
+        it('should redirect solveCpuTargetInline to WASM and manage heap memory safely', async () => {
+            const baseBlock = new Uint8Array([1, 2, 3, 4]);
+            const target = '0000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF';
+
+            const solution = await solveCpuTargetInline(baseBlock, target);
+
+            // 1. Vérification du résultat natif retourné par le mock
+            expect(solution).toBe(1337);
+
+            // 2. Vérification des allocations et libérations mémoire pour le bloc de base et la cible hexadécimale
+            expect(mockWasmModule._malloc).toHaveBeenCalledTimes(2);
+            expect(mockWasmModule._free).toHaveBeenCalledTimes(2);
+
+            // 3. Vérification de l'appel à la fonction C++ exportée
+            expect(mockWasmModule._solve_cpu_target).toHaveBeenCalledWith(1234, baseBlock.length, 1234);
+        });
+
+        it('should redirect solveMemory to WASM and manage heap memory safely', async () => {
+            const seed = 'test-wasm-seed';
+            const difficulty = 4; // 4 MB
+
+            const solution = await solveMemory(seed, difficulty);
+
+            expect(solution).toBe(777);
+            expect(mockWasmModule._malloc).toHaveBeenCalledTimes(1);
+            expect(mockWasmModule._free).toHaveBeenCalledTimes(1);
+            expect(mockWasmModule._solve_memory_challenge).toHaveBeenCalledWith(1234, difficulty);
+        });
+    });
+});