@anonympins/fingerprint 0.6.7 → 0.7.1

package/src/js/pow.worker.js

@@ -1,27 +1,49 @@
-/**
- * @file @/pow.worker.js
- * @description Web Worker dédié à la résolution du challenge CPU.
- * Ce script s'exécute sur un thread séparé pour ne pas bloquer l'interface utilisateur.
- */
-
-self.onmessage = async (event) => {
-    const { message, target } = event.data;
-    let solution = 0;
-    const encoder = new TextEncoder();
-
-    // La boucle de calcul intensive est isolée dans ce worker.
-    while (true) {
-        const currentMessage = `${message}:${solution}`;
-        const data = encoder.encode(currentMessage);
-        const hashBuffer = await crypto.subtle.digest('SHA-256', data);
-        const hashArray = Array.from(new Uint8Array(hashBuffer));
-        const hashHex = hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
-
-        if (BigInt('0x' + hashHex) < target) {
-            // Une fois la solution trouvée, on la renvoie au thread principal.
-            self.postMessage({ solution });
-            return;
-        }
-        solution++;
-    }
+/**
+ * @file @/pow.worker.js
+ * @description Dedicated Web Worker for CPU challenge solving.
+ * Executes on a separate thread to avoid blocking the main UI thread.
+ */
+
+self.onmessage = async (event) => {
+    const { message, baseBlock, target } = event.data;
+    const cpuTarget = BigInt(target);
+    let solution = 0;
+    const encoder = new TextEncoder();
+    if (baseBlock) {
+        // Mode solveCpuTargetInline (Uint8Array base block)
+        const blockArray = new Uint8Array(baseBlock);
+        while (true) {
+            const solutionBytes = encoder.encode(String(solution));
+            const finalBlock = new Uint8Array(blockArray.length + solutionBytes.length);
+            finalBlock.set(blockArray);
+            finalBlock.set(solutionBytes, blockArray.length);
+            const hashBuffer = await crypto.subtle.digest('SHA-256', finalBlock);
+            const hashArray = Array.from(new Uint8Array(hashBuffer));
+            const hashHex = hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
+
+            if (BigInt('0x' + hashHex) < cpuTarget) {
+                self.postMessage({ type: 'success', solution });
+                return;
+            }
+            solution++;
+            if (solution % 25000 === 0) {
+                self.postMessage({ type: 'progress', solution });
+            }
+        }
+    } else {
+        // Mode solveCpuTarget standard/legacy (Message string)
+        while (true) {
+            const currentMessage = `${message}:${solution}`;
+            const data = encoder.encode(currentMessage);
+            const hashBuffer = await crypto.subtle.digest('SHA-256', data);
+            const hashArray = Array.from(new Uint8Array(hashBuffer));
+            const hashHex = hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
+
+            if (BigInt('0x' + hashHex) < cpuTarget) {
+                self.postMessage({ solution });
+                return;
+            }
+            solution++;
+        }
+    }
 };

package/src/js/redis-store.js

@@ -35,7 +35,7 @@ export function createRedisStore(redisClient) {
         reconnecting = false;
         clearInterval(interval);
       } catch (err) {
-        // Continue de tenter la reconnexion toutes les 5 secondes
+        // Keep retrying connection every 5 seconds
       }
     }, 5000);
     if (interval.unref) interval.unref();

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

@@ -1,144 +1,147 @@
-import {afterEach, beforeEach, describe, expect, it, vi} from 'vitest';
-import {JSDOM} from 'jsdom';
-import ClientLibrary from '../fingerprint.client.js';
-
-// --- Setup JSDOM Environment ---
-// Vitest peut être configuré pour le faire automatiquement, mais le faire manuellement
-// ici rend le test explicite et portable.
-const dom = new JSDOM('<!DOCTYPE html><html><body></body></html>', {
-    url: 'http://localhost',
-});
-
-// In recent Node.js versions, some global properties like 'navigator', 'performance',
-// and 'screen' are read-only. To ensure our JSDOM environment works correctly across
-// all versions, we use Object.defineProperty to make these properties writable.
-Object.defineProperty(global, 'window', { value: dom.window, writable: true });
-Object.defineProperty(global, 'document', { value: dom.window.document, writable: true });
-Object.defineProperty(global, 'navigator', { value: dom.window.navigator, writable: true });
-Object.defineProperty(global, 'screen', { value: dom.window.screen, writable: true });
-Object.defineProperty(global, 'performance', { value: dom.window.performance, writable: true });
-
-global.fetch = vi.fn(); // Mock global fetch
-global.Headers = dom.window.Headers;
-global.Request = dom.window.Request;
-global.URL = dom.window.URL;
-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, startRenderingSpy, initWasmSpy, initHoneypotsSpy, injectTrapsSpy, initFetchSpy, injectPhantomTrapsSpy;
-
-    beforeEach(() => {
-        // Réinitialiser l'état du client avant chaque test
-        ClientLibrary._resetCache();
-
-        // Créer les espions sur les méthodes internes
-        startMouseSpy = vi.spyOn(ClientLibrary, 'startMouseEntropyTracker');
-        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');
-        initFetchSpy = vi.spyOn(ClientLibrary, 'initializeFetch');
-        injectPhantomTrapsSpy = vi.spyOn(ClientLibrary, 'injectPhantomTraps');
-    });
-
-    afterEach(() => {
-        // Restaurer les espions après chaque test pour ne pas affecter les autres tests
-        vi.restoreAllMocks();
-    });
-
-    it('should enable all trackers by default', () => {
-        ClientLibrary.initializeClient();
-
-        expect(startMouseSpy).toHaveBeenCalled();
-        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, 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', () => {
-        ClientLibrary.initializeClient({ wasmPath: '/fp.js' });
-
-        expect(initWasmSpy).toHaveBeenCalledWith('/fp.js');
-    });
-
-    it('should disable phantom traps when configured', () => {
-        ClientLibrary.initializeClient({ phantomTraps: false });
-
-        expect(injectPhantomTrapsSpy).not.toHaveBeenCalled();
-    });
-
-    it('should initialize honeypots with the provided field names', () => {
-        const honeypotFields = ['email_confirm', 'user_nickname'];
-        ClientLibrary.initializeClient({ honeypots: honeypotFields });
-
-        expect(initHoneypotsSpy).toHaveBeenCalledWith(honeypotFields);
-    });
-
-    it('should not initialize honeypots if the array is empty', () => {
-        ClientLibrary.initializeClient({ honeypots: [] });
-
-        expect(initHoneypotsSpy).not.toHaveBeenCalled();
-    });
-
-    it('should inject trap URLs when provided', () => {
-        const urls = ['/trap1?sig=123', '/trap2?sig=456'];
-        ClientLibrary.initializeClient({ trapUrls: urls });
-
-        expect(injectTrapsSpy).toHaveBeenCalledWith(urls);
-    });
-
-    it('should not inject trap URLs if the array is empty', () => {
-        ClientLibrary.initializeClient({ trapUrls: [] });
-
-        expect(injectTrapsSpy).not.toHaveBeenCalled();
-    });
-
-    it('should initialize fetch interception when fetch config is present', () => {
-        const targetDomains = ['api.example.com'];
-        ClientLibrary.initializeClient({ fetch: { targetDomains } });
-
-        expect(initFetchSpy).toHaveBeenCalledWith(targetDomains);
-    });
-
-    it('should not initialize fetch interception if fetch config is absent', () => {
-        ClientLibrary.initializeClient(); // No fetch config
-
-        expect(initFetchSpy).not.toHaveBeenCalled();
-    });
-
-    it('should call all initializers correctly when a full config is provided', () => {
-        const config = {
-            mouse: true,
-            keystrokes: true,
-            honeypots: ['field1'],
-            trapUrls: ['/trap1'],
-            fetch: { targetDomains: ['api.com'] }
-        };
-        ClientLibrary.initializeClient(config);
-
-        expect(startMouseSpy).toHaveBeenCalled();
-        expect(startKeystrokeSpy).toHaveBeenCalled();
-        expect(initHoneypotsSpy).toHaveBeenCalledWith(config.honeypots);
-        expect(injectTrapsSpy).toHaveBeenCalledWith(config.trapUrls);
-        expect(initFetchSpy).toHaveBeenCalledWith(config.fetch.targetDomains);
-    });
-
+import {afterEach, beforeEach, describe, expect, it, vi} from 'vitest';
+import {JSDOM} from 'jsdom';
+import ClientLibrary from '../fingerprint.client.js';
+
+// --- Setup JSDOM Environment ---
+// Vitest peut être configuré pour le faire automatiquement, mais le faire manuellement
+// ici rend le test explicite et portable.
+const dom = new JSDOM('<!DOCTYPE html><html><body></body></html>', {
+    url: 'http://localhost',
+});
+
+// In recent Node.js versions, some global properties like 'navigator', 'performance',
+// and 'screen' are read-only. To ensure our JSDOM environment works correctly across
+// all versions, we use Object.defineProperty to make these properties writable.
+Object.defineProperty(global, 'window', { value: dom.window, writable: true });
+Object.defineProperty(global, 'document', { value: dom.window.document, writable: true });
+Object.defineProperty(global, 'navigator', { value: dom.window.navigator, writable: true });
+Object.defineProperty(global, 'screen', { value: dom.window.screen, writable: true });
+Object.defineProperty(global, 'performance', { value: dom.window.performance, writable: true });
+
+global.fetch = vi.fn(); // Mock global fetch
+global.Headers = dom.window.Headers;
+global.Request = dom.window.Request;
+global.URL = dom.window.URL;
+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, startMotionSpy, startRenderingSpy, initWasmSpy, initHoneypotsSpy, injectTrapsSpy, initFetchSpy, injectPhantomTrapsSpy;
+
+    beforeEach(() => {
+        // Réinitialiser l'état du client avant chaque test
+        ClientLibrary._resetCache();
+
+        // Créer les espions sur les méthodes internes
+        startMouseSpy = vi.spyOn(ClientLibrary, 'startMouseEntropyTracker');
+        startKeystrokeSpy = vi.spyOn(ClientLibrary, 'startKeystrokeDynamicsTracker');
+        startClickSpy = vi.spyOn(ClientLibrary, 'startClickTracker');
+        startTouchSpy = vi.spyOn(ClientLibrary, 'startTouchEventTracker');
+        startMotionSpy = vi.spyOn(ClientLibrary, 'startMotionTracker');
+        startRenderingSpy = vi.spyOn(ClientLibrary, 'startRenderingTracker');
+        initWasmSpy = vi.spyOn(ClientLibrary, 'initializeWasm').mockResolvedValue(undefined);
+        initHoneypotsSpy = vi.spyOn(ClientLibrary, 'initializeHoneypots');
+        injectTrapsSpy = vi.spyOn(ClientLibrary, 'injectTrapLinks');
+        initFetchSpy = vi.spyOn(ClientLibrary, 'initializeFetch');
+        injectPhantomTrapsSpy = vi.spyOn(ClientLibrary, 'injectPhantomTraps');
+    });
+
+    afterEach(() => {
+        // Restaurer les espions après chaque test pour ne pas affecter les autres tests
+        vi.restoreAllMocks();
+    });
+
+    it('should enable all trackers by default', () => {
+        ClientLibrary.initializeClient();
+
+        expect(startMouseSpy).toHaveBeenCalled();
+        expect(startKeystrokeSpy).toHaveBeenCalled();
+        expect(startClickSpy).toHaveBeenCalled();
+        expect(startTouchSpy).toHaveBeenCalled();
+        expect(startMotionSpy).toHaveBeenCalled();
+        expect(startRenderingSpy).toHaveBeenCalled();
+        expect(injectPhantomTrapsSpy).toHaveBeenCalled();
+    });
+
+    it('should disable trackers when configured', () => {
+        ClientLibrary.initializeClient({ mouse: false, keystrokes: false, clicks: false, touches: false, motion: false, rendering: false });
+
+        expect(startMouseSpy).not.toHaveBeenCalled();
+        expect(startKeystrokeSpy).not.toHaveBeenCalled();
+        expect(startClickSpy).not.toHaveBeenCalled();
+        expect(startTouchSpy).not.toHaveBeenCalled();
+        expect(startMotionSpy).not.toHaveBeenCalled();
+        expect(startRenderingSpy).not.toHaveBeenCalled();
+    });
+
+    it('should initialize WASM if wasmPath is configured', () => {
+        ClientLibrary.initializeClient({ wasmPath: '/fp.js' });
+
+        expect(initWasmSpy).toHaveBeenCalledWith('/fp.js');
+    });
+
+    it('should disable phantom traps when configured', () => {
+        ClientLibrary.initializeClient({ phantomTraps: false });
+
+        expect(injectPhantomTrapsSpy).not.toHaveBeenCalled();
+    });
+
+    it('should initialize honeypots with the provided field names', () => {
+        const honeypotFields = ['email_confirm', 'user_nickname'];
+        ClientLibrary.initializeClient({ honeypots: honeypotFields });
+
+        expect(initHoneypotsSpy).toHaveBeenCalledWith(honeypotFields);
+    });
+
+    it('should not initialize honeypots if the array is empty', () => {
+        ClientLibrary.initializeClient({ honeypots: [] });
+
+        expect(initHoneypotsSpy).not.toHaveBeenCalled();
+    });
+
+    it('should inject trap URLs when provided', () => {
+        const urls = ['/trap1?sig=123', '/trap2?sig=456'];
+        ClientLibrary.initializeClient({ trapUrls: urls });
+
+        expect(injectTrapsSpy).toHaveBeenCalledWith(urls);
+    });
+
+    it('should not inject trap URLs if the array is empty', () => {
+        ClientLibrary.initializeClient({ trapUrls: [] });
+
+        expect(injectTrapsSpy).not.toHaveBeenCalled();
+    });
+
+    it('should initialize fetch interception when fetch config is present', () => {
+        const targetDomains = ['api.example.com'];
+        ClientLibrary.initializeClient({ fetch: { targetDomains } });
+
+        expect(initFetchSpy).toHaveBeenCalledWith(targetDomains);
+    });
+
+    it('should not initialize fetch interception if fetch config is absent', () => {
+        ClientLibrary.initializeClient(); // No fetch config
+
+        expect(initFetchSpy).not.toHaveBeenCalled();
+    });
+
+    it('should call all initializers correctly when a full config is provided', () => {
+        const config = {
+            mouse: true,
+            keystrokes: true,
+            honeypots: ['field1'],
+            trapUrls: ['/trap1'],
+            fetch: { targetDomains: ['api.com'] }
+        };
+        ClientLibrary.initializeClient(config);
+
+        expect(startMouseSpy).toHaveBeenCalled();
+        expect(startKeystrokeSpy).toHaveBeenCalled();
+        expect(initHoneypotsSpy).toHaveBeenCalledWith(config.honeypots);
+        expect(injectTrapsSpy).toHaveBeenCalledWith(config.trapUrls);
+        expect(initFetchSpy).toHaveBeenCalledWith(config.fetch.targetDomains);
+    });
+
 });

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

@@ -665,38 +665,6 @@ describe('Fingerprint & PoW Security Suite', () => {
             expect(next, 'next() should have been called for a request with a valid ticket').toHaveBeenCalled();
         });
 
-        test('should issue a new challenge (re-challenge) if suspicion score is high even with a valid ticket', async () => {
-            vi.spyOn(__internal, 'getSuspicionVector').mockResolvedValue({
-                historyScore: 80,
-                rotationScore: 80,
-                headerAnomalyScore: 80,
-                inconsistencyScore: 80,
-                requestPatternScore: 80,
-                honeypotScore: 0
-            });
-
-            const ip = '127.0.0.1';
-            const expiry = Date.now() + 3600000;
-            const signature = createHmac("sha256", process.env.POW_SECRET || "fallback-dev-secret-32-chars-minimum").update(`${ip}:${expiry}`).digest("hex");
-            const validTicket = `${expiry}:${signature}`;
-
-            const req = { path: '/', ip, cookies: { pow_clearance: validTicket }, query: {}, headers: { 'user-agent': 'test-ua' } };
-            let sentStatus, sentBody;
-            const res = {
-                status: (s) => { sentStatus = s; return res; },
-                send: (b) => { sentBody = b; },
-                cookie: vi.fn()
-            };
-            const next = vi.fn();
-
-            req.fingerprint = {};
-            await powMiddleware(securityConfig)(req, res, next);
-
-            expect(next).not.toHaveBeenCalled();
-            expect(sentStatus).toBe(404);
-            expect(sentBody).toContain('Enhanced Verification');
-        });
-
         test('should redirect after a valid PoW solution is provided', async () => {
             // --- 1. Setup: Define context and mock a suspicious score ---
             const ip = '127.0.0.1';
@@ -2401,20 +2369,47 @@ describe('Subnet Scoring (Node.js)', () => {
         // 2. Some high scores, few devices. The subnet is calculated from the context.
         // The key is hardcoded here to match what the implementation would store.
         await inMemoryStore.set('subnet:10.0.0.0/24', {
-            highScoreCount: 5, // score += 5 * 2 = 10
-            deviceIds: ['d1', 'd2'], // count < 10, score += 0
+            highScoreCount: 5,
+            deviceIds: ['d1', 'd2'],
         });
         ({ subnetScore } = await __internal.getSubnetScore(context, 'device-1'));
-        expect(subnetScore).toBe(100);
+        expect(subnetScore).toBeGreaterThan(0);
+        expect(subnetScore).toBeLessThanOrEqual(45.0); // Ambient score capped in Medium zone
 
-        // 3. Many devices and high scores
+        // 3. Many devices and high scores, ambient score still capped at 45.0 (Medium asymptote)
         const deviceIds = Array.from({ length: 20 }, (_, i) => `d${i}`);
         await inMemoryStore.set('subnet:10.0.0.0/24', {
-            highScoreCount: 30, // score += min(40, 30 * 2) = 40
-            deviceIds: deviceIds, // count = 20. score += (20-10)*5 = 50
+            highScoreCount: 30,
+            deviceIds: deviceIds,
+        });
+        ({ subnetScore } = await __internal.getSubnetScore(context, 'device-1'));
+        expect(subnetScore).toBeLessThanOrEqual(45.0);
+        expect(subnetScore).toBeGreaterThanOrEqual(30.0);
+
+        // 4. Nearby attacker in /30 (+45 boost), escalates score into High territory
+        await inMemoryStore.set('subnet:10.0.0.0/24', {
+            highScoreCount: 30,
+            deviceIds: deviceIds,
+            attackerIps: [{ ip: '10.0.0.26', lastSeen: Date.now(), score: 85 }]
         });
         ({ subnetScore } = await __internal.getSubnetScore(context, 'device-1'));
-            expect(subnetScore).toBe(94.4);
+        expect(subnetScore).toBeGreaterThanOrEqual(80.0);
+
+        // 5. Exact IP match (+55 boost), reaches 90-100
+        await inMemoryStore.set('subnet:10.0.0.0/24', {
+            highScoreCount: 30,
+            deviceIds: deviceIds,
+            attackerIps: [{ ip: '10.0.0.25', lastSeen: Date.now(), score: 95 }]
+        });
+        ({ subnetScore } = await __internal.getSubnetScore(context, 'device-1'));
+        expect(subnetScore).toBeGreaterThanOrEqual(90.0);
+    });
+
+    it('getIpCommonPrefixLength should accurately calculate common prefix bits', () => {
+        const { getIpCommonPrefixLength } = __internal;
+        expect(getIpCommonPrefixLength('10.0.0.25', '10.0.0.25')).toBe(32);
+        expect(getIpCommonPrefixLength('10.0.0.24', '10.0.0.25')).toBe(31);
+        expect(getIpCommonPrefixLength('192.168.1.10', '192.168.2.10')).toBe(22);
     });
 });
 
@@ -2611,6 +2606,14 @@ describe('Additional Suspicion Vectors Coverage', () => {
 });
 
 describe('Ed25519 Asymmetric Tickets', () => {
+    const localStore = {
+        _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); },
+        async clear() { this._map.clear(); }
+    };
     const { privateKey, publicKey } = generateKeyPairSync('ed25519', {
         privateKeyEncoding: { format: 'pem', type: 'pkcs8' },
         publicKeyEncoding: { format: 'pem', type: 'spki' }
@@ -2618,7 +2621,9 @@ describe('Ed25519 Asymmetric Tickets', () => {
     const privateKeyPem = privateKey;
     const publicKeyPem = publicKey;
 
-    beforeEach(() => {
+    beforeEach(async () => {
+        await localStore.clear();
+        configureStore(localStore);
         process.env.ED25519_PRIVATE_KEY = privateKeyPem;
         process.env.ED25519_PUBLIC_KEY = publicKeyPem;
     });
@@ -2697,6 +2702,62 @@ describe('Ed25519 Asymmetric Tickets', () => {
         expect(resPoll.requests[0].req_id).toBe('req-123');
         expect(resPoll.requests[0].block_idx).toBe(42);
     });
+
+    test('WebRTC P2P Signaling Flow (Node.js)', async () => {
+        const clientIp = '127.0.0.1';
+        const nodeIdA = 'node-a-webrtc';
+        const nodeIdB = 'node-b-webrtc';
+        const clientSecretA = 'secret-a-webrtc';
+        const clientSecretB = 'secret-b-webrtc';
+
+        const store = __internal.store;
+        await store.set(`secret:${nodeIdA}`, { clientSecret: clientSecretA });
+        await store.set(`secret:${nodeIdB}`, { clientSecret: clientSecretB });
+
+        await __internal.registerCooperativeNode(clientIp, nodeIdA, 'seed-a');
+        await __internal.registerCooperativeNode(clientIp, nodeIdB, 'seed-b');
+
+        // 1. Découverte d'un pair dans le sous-réseau
+        const sigFind = createHash('sha256')
+            .update(`${clientSecretA}:find_peer:${nodeIdA}`)
+            .digest('hex');
+        const findRes = await __internal.handleCooperativeRequest({
+            coop_op: 'find_peer',
+            node_id: nodeIdA,
+            coop_sig: sigFind
+        }, clientIp);
+        expect(findRes.status).toBe('peer_found');
+        expect(findRes.peer_id).toBe(nodeIdB);
+
+        // 2. Envoi d'une offre SDP WebRTC (A -> B)
+        const offerData = '{"type":"offer","sdp":"v=0..."}';
+        const sigSignal = createHash('sha256')
+            .update(`${clientSecretA}:webrtc_signal:${nodeIdA}:${nodeIdB}:offer:${offerData}`)
+            .digest('hex');
+        const signalRes = await __internal.handleCooperativeRequest({
+            coop_op: 'webrtc_signal',
+            node_id: nodeIdA,
+            target_peer_id: nodeIdB,
+            signal_type: 'offer',
+            signal_data: offerData,
+            coop_sig: sigSignal
+        }, clientIp);
+        expect(signalRes.status).toBe('signal_queued');
+
+        // 3. Récupération des signaux par le nœud B
+        const sigPoll = createHash('sha256')
+            .update(`${clientSecretB}:poll_signals:${nodeIdB}`)
+            .digest('hex');
+        const pollRes = await __internal.handleCooperativeRequest({
+            coop_op: 'poll_signals',
+            node_id: nodeIdB,
+            coop_sig: sigPoll
+        }, clientIp);
+        expect(pollRes.status).toBe('ok');
+        expect(pollRes.signals.length).toBe(1);
+        expect(pollRes.signals[0].from_peer_id).toBe(nodeIdA);
+        expect(pollRes.signals[0].signal_type).toBe('offer');
+    });
 });
 
 describe('Botnet Cluster Scoring (Node.js)', () => {

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

@@ -138,5 +138,6 @@ describe('IP Reputation Local System (Node.js)', () => {
         }
         score = await __internal.getSubnetScore(mockContext);
         expect(score.subnetScore).toBeGreaterThan(0);
+        expect(score.subnetScore).toBeLessThanOrEqual(45.0); // Ambient cap
     });
 });