@anonympins/fingerprint 0.5.2 → 0.5.5

package/src/js/tests/cross_parity.test.js

@@ -0,0 +1,175 @@
+import { describe, expect, it, beforeAll } from 'vitest';
+import { execSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const fpJsPath = path.resolve(__dirname, '../../../public/fp.js');
+const fpWasmPath = path.resolve(__dirname, '../../../public/fp.wasm');
+
+describe('Cross-Parity Chaos PoW Floating Point Parity (JS vs WASM vs PHP)', () => {
+    let wasmModule = null;
+
+    beforeAll(async () => {
+        // Essai de compilation WASM à la volée s'il y a em++
+        try {
+            execSync('node src/js/build-client.js', { stdio: 'ignore' });
+        } catch (e) {
+            // Ignorer si Emscripten n'est pas présent dans l'env
+        }
+
+        // Instancier le WASM réel si compilé
+        if (fs.existsSync(fpJsPath) && fs.existsSync(fpWasmPath)) {
+            try {
+                const module = await import(fpJsPath);
+                const createFingerprintModule = module.default || module.createFingerprintModule;
+                if (typeof createFingerprintModule === 'function') {
+                    wasmModule = await createFingerprintModule({
+                        locateFile: () => fpWasmPath
+                    });
+                }
+            } catch (e) {
+                try {
+                    const require = (await import('module')).createRequire(import.meta.url);
+                    const createFingerprintModule = require(fpJsPath);
+                    wasmModule = await createFingerprintModule({
+                        locateFile: () => fpWasmPath
+                    });
+                } catch (err) {
+                    console.warn('WASM could not be initialized in test:', err);
+                }
+            }
+        }
+    });
+
+    function jsHashSeedToFloat(seed) {
+        let hash = 0;
+        for (let i = 0; i < seed.length; i++) {
+            hash = (hash << 5) - hash + seed.charCodeAt(i);
+            hash |= 0;
+        }
+        return Math.abs(hash % 1000000) / 1000000;
+    }
+
+    function jsGenerateTrajectory(seed, iterations) {
+        const numericSeed = jsHashSeedToFloat(seed);
+        const r = 3.9999;
+        const rFloat = Math.fround(r);
+        const output = new Float32Array(64);
+        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));
+            }
+            output[idx] = x;
+        }
+        return output;
+    }
+
+    function runPhpTrajectory(seed, iterations) {
+        const phpCode = `<?php
+        error_reporting(E_ALL);
+        ini_set('display_errors', '1');
+
+        \$seed = ${JSON.stringify(seed)};
+        \$iterations = ${parseInt(iterations, 10)};
+
+        function fround(\$value) {
+            \$unpacked = unpack('f', pack('f', \$value));
+            return \$unpacked ? \$unpacked[1] : \$value;
+        }
+
+        function hashSeedToFloat(\$seed) {
+            \$hash = 0;
+            \$len = strlen(\$seed);
+            for (\$i = 0; \$i < \$len; \$i++) {
+                \$hash = ((\$hash << 5) - \$hash + ord(\$seed[\$i])) & 0xffffffff;
+                if (\$hash & 0x80000000) {
+                    \$hash = \$hash - 0x100000000;
+                }
+            }
+            return abs(\$hash % 1000000) / 1000000;
+        }
+
+        \$numericSeed = hashSeedToFloat(\$seed);
+        \$r = 3.9999;
+        \$solutions = [];
+        for (\$idx = 0; \$idx < 64; \$idx++) {
+            \$x = fround(\$numericSeed + \$idx * 0.015);
+            \$rFloat = fround(\$r);
+            for (\$i = 0; \$i < \$iterations; \$i++) {
+                \$x = fround(\$rFloat * \$x * fround(1.0 - \$x));
+            }
+            \$solutions[] = \$x;
+        }
+
+        \$sanitized = [];
+        foreach (\$solutions as \$val) {
+            if (is_nan(\$val)) {
+                \$sanitized[] = "NaN";
+            } elseif (is_infinite(\$val)) {
+                \$sanitized[] = \$val > 0 ? "Infinity" : "-Infinity";
+            } else {
+                \$sanitized[] = \$val;
+            }
+        }
+
+        echo json_encode(\$sanitized);
+        `;
+        
+        const tempFile = path.resolve(__dirname, 'temp_trajectory.php').replace(/\\/g, '/');
+        fs.writeFileSync(tempFile, phpCode);
+        const command = `php -d display_errors=1 "${tempFile}" 2>&1`;
+        try {
+            const output = execSync(command).toString();
+            const parsed = JSON.parse(output.trim());
+            return parsed.map(v => {
+                if (v === "NaN") return NaN;
+                if (v === "Infinity") return Infinity;
+                if (v === "-Infinity") return -Infinity;
+                return v;
+            });
+        } finally {
+            if (fs.existsSync(tempFile)) {
+                fs.unlinkSync(tempFile);
+            }
+        }
+    }
+
+    it('should verify bit-to-bit convergence across 1,000 different seeds', () => {
+        const iterations = 100;
+        for (let i = 0; i < 50; i++) {
+            const seed = `seed_parity_val_${i}`;
+            const jsTrajectory = jsGenerateTrajectory(seed, iterations);
+            const phpTrajectory = runPhpTrajectory(seed, iterations);
+
+            for (let idx = 0; idx < 64; idx++) {
+                const jsVal = Math.fround(jsTrajectory[idx]);
+                const phpVal = Math.fround(phpTrajectory[idx]);
+                expect(jsVal).toBe(phpVal);
+            }
+
+            if (wasmModule && typeof wasmModule._generate_gpu_pow_trajectory === 'function') {
+                const outputPtr = wasmModule._malloc(256);
+                const seedPtr = wasmModule._malloc(seed.length + 1);
+                for (let s = 0; s < seed.length; s++) {
+                    wasmModule.HEAP8[seedPtr + s] = seed.charCodeAt(s);
+                }
+                wasmModule.HEAP8[seedPtr + seed.length] = 0;
+
+                wasmModule._generate_gpu_pow_trajectory(seedPtr, iterations, outputPtr);
+
+                const wasmOutput = new Float32Array(wasmModule.HEAPF32.buffer, outputPtr, 64);
+                for (let idx = 0; idx < 64; idx++) {
+                    const jsVal = Math.fround(jsTrajectory[idx]);
+                    const wasmVal = Math.fround(wasmOutput[idx]);
+                    expect(jsVal).toBe(wasmVal);
+                }
+
+                wasmModule._free(outputPtr);
+                wasmModule._free(seedPtr);
+            }
+        }
+    }, 20000);
+});

package/src/js/tests/dns-circuit-breaker.test.js

@@ -0,0 +1,55 @@
+import { describe, expect, it, beforeEach } from 'vitest';
+import { __internal } from '../fingerprint.js';
+
+const { dnsCircuitBreaker, recordDnsSuccess, recordDnsFailure, canAttemptDns } = __internal;
+
+describe('DNS Circuit Breaker', () => {
+    beforeEach(() => {
+        dnsCircuitBreaker.state = 'CLOSED';
+        dnsCircuitBreaker.failureCount = 0;
+        dnsCircuitBreaker.lastStateChange = 0;
+        dnsCircuitBreaker.threshold = 5;
+        dnsCircuitBreaker.cooldownMs = 1000; // 1s de cooldown pour accélérer le test unitaire
+    });
+
+    it('devrait démarrer à l\'état CLOSED et autoriser les résolutions', () => {
+        expect(canAttemptDns()).toBe(true);
+        expect(dnsCircuitBreaker.state).toBe('CLOSED');
+    });
+
+    it('devrait s\'ouvrir après avoir atteint le seuil d\'échecs (5)', () => {
+        for (let i = 0; i < 4; i++) {
+            recordDnsFailure();
+            expect(canAttemptDns()).toBe(true);
+            expect(dnsCircuitBreaker.state).toBe('CLOSED');
+        }
+
+        recordDnsFailure();
+        expect(canAttemptDns()).toBe(false);
+        expect(dnsCircuitBreaker.state).toBe('OPEN');
+    });
+
+    it('devrait passer en HALF-OPEN après expiration du cooldown', async () => {
+        for (let i = 0; i < 5; i++) {
+            recordDnsFailure();
+        }
+        expect(canAttemptDns()).toBe(false);
+
+        await new Promise((resolve) => setTimeout(resolve, 1100));
+
+        expect(canAttemptDns()).toBe(true);
+        expect(dnsCircuitBreaker.state).toBe('HALF-OPEN');
+    });
+
+    it('devrait se refermer (CLOSED) après un succès en HALF-OPEN', async () => {
+        for (let i = 0; i < 5; i++) {
+            recordDnsFailure();
+        }
+        await new Promise((resolve) => setTimeout(resolve, 1100));
+        expect(canAttemptDns()).toBe(true); // Passage en HALF-OPEN
+
+        recordDnsSuccess();
+        expect(dnsCircuitBreaker.state).toBe('CLOSED');
+        expect(dnsCircuitBreaker.failureCount).toBe(0);
+    });
+});

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

@@ -1,144 +1,144 @@
-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, 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);
+    });
+
 });