@anonympins/fingerprint 0.4.4 → 0.4.6

package/src/js/pow.solver.js

@@ -9,6 +9,98 @@
 
 'use strict';
 
+function cyrb53(str, seed = 0) {
+    let h1 = 0xdeadbeef ^ seed,
+        h2 = 0x41c6ce57 ^ seed;
+    for (let i = 0, ch; i < str.length; i++) {
+        ch = str.charCodeAt(i);
+        h1 = Math.imul(h1 ^ ch, 2654435761);
+        h2 = Math.imul(h2 ^ ch, 1597334677);
+    }
+    h1 = Math.imul(h1 ^ (h1 >>> 16), 2246822507) ^ Math.imul(h2 ^ (h2 >>> 13), 3266489909);
+    h2 = Math.imul(h2 ^ (h2 >>> 16), 2246822507) ^ Math.imul(h1 ^ (h1 >>> 13), 3266489909);
+    return 4294967296 * (2097151 & h2) + (h1 >>> 0);
+}
+
+function openDb() {
+    return new Promise((resolve, reject) => {
+        const request = indexedDB.open("pospace-db", 1);
+        request.onupgradeneeded = (e) => {
+            const db = e.target.result;
+            if (!db.objectStoreNames.contains("blocks")) {
+                db.createObjectStore("blocks");
+            }
+        };
+        request.onsuccess = (e) => resolve(e.target.result);
+        request.onerror = (e) => reject(e.target.error);
+    });
+}
+
+function generateBlock(seed, blockIndex, blockSize = 1024) {
+    const block = new Uint8Array(blockSize);
+    let h = cyrb53(seed + ":" + blockIndex);
+    for (let i = 0; i < blockSize; i++) {
+        h = Math.imul(h ^ i, 1597334677);
+        block[i] = h & 0xff;
+    }
+    return block;
+}
+
+export async function initializeSpace(seed, sizeMb) {
+    const db = await openDb();
+    const transaction = db.transaction("blocks", "readwrite");
+    const store = transaction.objectStore("blocks");
+    const numBlocks = sizeMb * 1024;
+    const metadataKey = "pospace-metadata";
+
+    const metaReq = store.get(metadataKey);
+    const meta = await new Promise((resolve) => {
+        metaReq.onsuccess = () => resolve(metaReq.result);
+    });
+    if (meta && meta.sizeMb === sizeMb && meta.seed === seed) {
+        return;
+    }
+
+    const CHUNK_SIZE = 1000;
+    for (let i = 0; i < numBlocks; i += CHUNK_SIZE) {
+        const end = Math.min(numBlocks, i + CHUNK_SIZE);
+        for (let j = i; j < end; j++) {
+            const block = generateBlock(seed, j);
+            store.put(block, j);
+        }
+        await new Promise(r => setTimeout(r, 0));
+    }
+    store.put({ sizeMb, seed }, metadataKey);
+}
+
+export async function solveSpaceChallenge(seed, queries, nonce, clientSecret) {
+    const db = await openDb();
+    const transaction = db.transaction("blocks", "readonly");
+    const store = transaction.objectStore("blocks");
+    
+    let combined = new Uint8Array(queries.length * 1024);
+    for (let i = 0; i < queries.length; i++) {
+        const idx = queries[i];
+        const getReq = store.get(idx);
+        let block = await new Promise((resolve) => {
+            getReq.onsuccess = () => resolve(getReq.result);
+        });
+        if (!block) {
+            block = generateBlock(seed, idx);
+        }
+        combined.set(block, i * 1024);
+    }
+    
+    const encoder = new TextEncoder();
+    const nonceBytes = encoder.encode(nonce + ":" + clientSecret);
+    const finalBlock = new Uint8Array(combined.length + nonceBytes.length);
+    finalBlock.set(combined);
+    finalBlock.set(nonceBytes, combined.length);
+    
+    const buf = await crypto.subtle.digest("SHA-256", finalBlock);
+    return Array.from(new Uint8Array(buf)).map(b => b.toString(16).padStart(2, '0')).join('');
+}
+
 /**
  * Résout un challenge CPU basé sur une cible en utilisant un bloc de base binaire.
  * @param {Uint8Array} baseBlock - Le bloc de données initial (nonce, secret, fp) fourni par le serveur.
@@ -458,7 +550,7 @@ class ChallengeSolution {
  * @returns {Promise<ChallengeSolution>} Un objet `ChallengeSolution` encapsulant le résultat.
  */
 export async function solveChallenge(challenge, fingerprint = '') { // The fingerprint is now passed from the client library
-    const { type, nonce, clientSecret, cpuTarget, memDifficulty, cities, clientIp, targetMaxDistance, optimizationTask, usefulWorkTask } = challenge;
+    const { type, nonce, clientSecret, cpuTarget, memDifficulty, cities, clientIp, targetMaxDistance, optimizationTask, usefulWorkTask, queries, sizeMb } = challenge;
     let rawSolution = {};
 
     switch (type) {
@@ -515,6 +607,10 @@ export async function solveChallenge(challenge, fingerprint = '') { // The finge
             rawSolution.work_result = workResult;
             rawSolution.problem_id = usefulWorkTask.problemId;
             break;
+        case 'pospace':
+            await initializeSpace(nonce + ":" + clientSecret, sizeMb || 100);
+            rawSolution.hash = await solveSpaceChallenge(nonce + ":" + clientSecret, queries, nonce, clientSecret);
+            break;
         default:
             throw new Error(`Unknown challenge type: ${type}`);
     }

package/src/js/tests/dynamic-wasm.test.js

@@ -0,0 +1,78 @@
+import { describe, expect, it } from 'vitest';
+import { DynamicWasmGenerator } from '../dynamic-wasm.js';
+
+// Helper function to decode ULEB128 (for verification)
+function decodeULEB128(bytes) {
+    let result = 0;
+    let shift = 0;
+    for (const byte of bytes) {
+        result |= (byte & 0x7f) << shift;
+        if (!(byte & 0x80)) {
+            break;
+        }
+        shift += 7;
+    }
+    return result;
+}
+
+describe('DynamicWasmGenerator', () => {
+    it('should generate a valid WASM module buffer', () => {
+        const constants = { seed: 123, multiplier: 33, adder: 7 };
+        const wasmBuffer = DynamicWasmGenerator.generate(constants);
+
+        // Basic check: ensure it's a Buffer and starts with WASM magic number
+        expect(wasmBuffer).toBeInstanceOf(Buffer);
+        expect(wasmBuffer.slice(0, 4).toString('hex')).toBe('0061736d'); // \0asm
+        expect(wasmBuffer.slice(4, 8).toString('hex')).toBe('01000000'); // Version 1
+
+        // Attempt to compile and instantiate the module to ensure validity
+        let instance;
+        try {
+            const module = new WebAssembly.Module(wasmBuffer);
+            instance = new WebAssembly.Instance(module, {});
+        } catch (e) {
+            // If compilation/instantiation fails, it's an invalid WASM module
+            expect.fail(`Generated WASM module is invalid: ${e.message}`);
+        }
+
+        // Verify the exported hash function exists
+        expect(instance.exports.hash).toBeInstanceOf(Function);
+        expect(instance.exports.memory).toBeInstanceOf(WebAssembly.Memory);
+    });
+
+    it('should produce a consistent hash result with the JS fallback', () => {
+        const constants = { seed: 42, multiplier: 1597334677, adder: 12345 };
+        const testString = "hello world";
+
+        const wasmBuffer = DynamicWasmGenerator.generate(constants);
+        const module = new WebAssembly.Module(wasmBuffer);
+        const instance = new WebAssembly.Instance(module, {});
+        const exports = instance.exports;
+        const memory = exports.memory;
+
+        // Write string to WASM memory
+        const encoder = new TextEncoder();
+        const bytes = encoder.encode(testString);
+        const view = new Uint8Array(memory.buffer);
+        view.set(bytes, 0); // Assuming hash function expects string at address 0
+
+        // Calculate hash using WASM
+        const wasmHash = exports.hash(0, bytes.length);
+
+        // Calculate hash using JS fallback
+        const jsHash = DynamicWasmGenerator.hashJs(testString, constants);
+
+        // The WASM and JS implementations should yield the same result
+        expect(wasmHash).toBe(jsHash);
+    });
+
+    it('should generate different WASM modules for different constants', () => {
+        const constants1 = { seed: 1, multiplier: 2, adder: 3 };
+        const constants2 = { seed: 4, multiplier: 5, adder: 6 };
+
+        const wasmBuffer1 = DynamicWasmGenerator.generate(constants1);
+        const wasmBuffer2 = DynamicWasmGenerator.generate(constants2);
+
+        expect(wasmBuffer1.toString('hex')).not.toBe(wasmBuffer2.toString('hex'));
+    });
+});

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

@@ -1,105 +1,129 @@
-/**
- * @vitest-environment jsdom
- */
-
-import {afterEach, beforeEach, describe, expect, it, vi} from 'vitest';
-import ClientLibrary from '../fingerprint.client.js';
-
-describe('ClientLibrary WASM Integration', () => {
-    beforeEach(() => {
-        // Réinitialise le cache et les mocks avant chaque test
-        ClientLibrary._resetCache();
-        vi.spyOn(console, 'log').mockImplementation(() => {});
-        vi.spyOn(console, 'warn').mockImplementation(() => {});
-
-        // Supprime les mocks globaux pour éviter les fuites entre les tests
-        delete window.createFingerprintModule;
-    });
-
-    afterEach(() => {
-        vi.restoreAllMocks();
-    });
-
-    it('should successfully load WASM module and switch hasher', async () => {
-        // 1. Simuler un module WASM fonctionnel
-        const mockWasmModule = {
-            _hash_string: vi.fn((str) => 99999), // Un mock qui retourne une valeur distincte
-        };
-
-        // 2. Simuler le chargement du script et l'initialisation du module
-        // On attache les fonctions de simulation à `window` car c'est ce que le code cherche
-        window.createFingerprintModule = vi.fn().mockResolvedValue(mockWasmModule);
-
-        // On simule l'injection du script en appelant directement `onload`
-        vi.spyOn(document.head, 'appendChild').mockImplementation((script) => {
-            // Simule le chargement réussi du script
-            script.onload();
-            return script;
-        });
-
-        // 3. Appeler la fonction d'initialisation
-        await ClientLibrary.initializeWasm('/fake/path/to/fp.js');
-
-        // 4. Vérifier que le hasher a été remplacé
-        const wasmHash = ClientLibrary._hasher("test");
-        expect(wasmHash).toBe(99999);
-        expect(mockWasmModule._hash_string).toHaveBeenCalledWith("test");
-        expect(console.log).toHaveBeenCalledWith(expect.stringContaining('WASM module loaded successfully'));
-    });
-
-    it('should gracefully fall back to JS hasher if WASM module fails to load', async () => {
-        // 1. Simuler un échec de chargement du script
-        vi.spyOn(document.head, 'appendChild').mockImplementation((script) => {
-            script.onerror(new Error('Script loading failed'));
-            return script;
-        });
-
-        // 2. Appeler la fonction d'initialisation
-        await ClientLibrary.initializeWasm('/fake/path/to/fp.js');
-
-        // 3. Vérifier que le hasher est toujours l'implémentation JS
-        const jsHash = ClientLibrary._hasher("test");
-        const originalJsHash = (await import('../fingerprint.builder.js')).cyrb53("test");
-        
-        expect(jsHash).toBe(originalJsHash);
-        expect(console.warn).toHaveBeenCalledWith(expect.stringContaining('WASM module failed to load'), expect.any(Error));
-    });
-
-    it('should gracefully fall back if WASM module does not export _hash_string', async () => {
-        // 1. Simuler un module WASM malformé (sans la fonction attendue)
-        const mockWasmModule = {};
-        window.createFingerprintModule = vi.fn().mockResolvedValue(mockWasmModule);
-
-        vi.spyOn(document.head, 'appendChild').mockImplementation((script) => {
-            script.onload();
-            return script;
-        });
-
-        // 2. Appeler la fonction d'initialisation
-        await ClientLibrary.initializeWasm('/fake/path/to/fp.js');
-
-        // 3. Vérifier le fallback
-        const jsHash = ClientLibrary._hasher("test");
-        const originalJsHash = (await import('../fingerprint.builder.js')).cyrb53("test");
-        expect(jsHash).toBe(originalJsHash); 
-        // L'assertion est maintenant plus précise : elle vérifie le message générique ET le message d'erreur spécifique.
-        expect(console.warn).toHaveBeenCalledWith(
-            expect.stringContaining('WASM module failed to load'), 
-            expect.objectContaining({ message: 'WASM module did not export _hash_string.' })
-        );
-    });
-
-    it('should use the default JS hasher if WASM is not configured', async () => {
-        // Ensure no WASM path is provided in the config
-        ClientLibrary.initializeClient({});
-
-        // Verify that the active hasher is the original JS implementation
-        const jsHash = ClientLibrary._hasher("another test string");
-        const originalJsHash = (await import('../fingerprint.builder.js')).cyrb53("another test string");
-
-        expect(jsHash).toBe(originalJsHash);
-        // Ensure no WASM-related console logs or warnings were made
-        expect(console.log).not.toHaveBeenCalledWith(expect.stringContaining('WASM module loaded successfully'));
-        expect(console.warn).not.toHaveBeenCalledWith(expect.stringContaining('WASM module failed to load'));
-    });
+/**
+ * @vitest-environment jsdom
+ */
+
+import {afterEach, beforeEach, describe, expect, it, vi} from 'vitest';
+import ClientLibrary from '../fingerprint.client.js';
+
+describe('ClientLibrary WASM Integration', () => {
+    beforeEach(() => {
+        // Réinitialise le cache et les mocks avant chaque test
+        ClientLibrary._resetCache();
+        vi.spyOn(console, 'log').mockImplementation(() => {});
+        vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+        // Supprime les mocks globaux pour éviter les fuites entre les tests
+        delete window.createFingerprintModule;
+    });
+
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+
+    it('should successfully load WASM module and switch hasher', async () => {
+        // 1. Simuler un module WASM fonctionnel
+        const mockWasmModule = {
+            _hash_string: vi.fn((str) => 99999), // Un mock qui retourne une valeur distincte
+        };
+
+        // 2. Simuler le chargement du script et l'initialisation du module
+        // On attache les fonctions de simulation à `window` car c'est ce que le code cherche
+        window.createFingerprintModule = vi.fn().mockResolvedValue(mockWasmModule);
+
+        // On simule l'injection du script en appelant directement `onload`
+        vi.spyOn(document.head, 'appendChild').mockImplementation((script) => {
+            // Simule le chargement réussi du script
+            script.onload();
+            return script;
+        });
+
+        // 3. Appeler la fonction d'initialisation
+        await ClientLibrary.initializeWasm('/fake/path/to/fp.js');
+
+        // 4. Vérifier que le hasher a été remplacé
+        const wasmHash = ClientLibrary._hasher("test");
+        expect(wasmHash).toBe(99999);
+        expect(mockWasmModule._hash_string).toHaveBeenCalledWith("test");
+        expect(console.log).toHaveBeenCalledWith(expect.stringContaining('WASM module loaded successfully'));
+    });
+
+    it('should gracefully fall back to JS hasher if WASM module fails to load', async () => {
+        // 1. Simuler un échec de chargement du script
+        vi.spyOn(document.head, 'appendChild').mockImplementation((script) => {
+            script.onerror(new Error('Script loading failed'));
+            return script;
+        });
+
+        // 2. Appeler la fonction d'initialisation
+        await ClientLibrary.initializeWasm('/fake/path/to/fp.js');
+
+        // 3. Vérifier que le hasher est toujours l'implémentation JS
+        const jsHash = ClientLibrary._hasher("test");
+        const originalJsHash = (await import('../fingerprint.builder.js')).cyrb53("test");
+        
+        expect(jsHash).toBe(originalJsHash);
+        expect(console.warn).toHaveBeenCalledWith(expect.stringContaining('WASM module failed to load'), expect.any(Error));
+    });
+
+    it('should gracefully fall back if WASM module does not export _hash_string', async () => {
+        // 1. Simuler un module WASM malformé (sans la fonction attendue)
+        const mockWasmModule = {};
+        window.createFingerprintModule = vi.fn().mockResolvedValue(mockWasmModule);
+
+        vi.spyOn(document.head, 'appendChild').mockImplementation((script) => {
+            script.onload();
+            return script;
+        });
+
+        // 2. Appeler la fonction d'initialisation
+        await ClientLibrary.initializeWasm('/fake/path/to/fp.js');
+
+        // 3. Vérifier le fallback
+        const jsHash = ClientLibrary._hasher("test");
+        const originalJsHash = (await import('../fingerprint.builder.js')).cyrb53("test");
+        expect(jsHash).toBe(originalJsHash); 
+        // L'assertion est maintenant plus précise : elle vérifie le message générique ET le message d'erreur spécifique.
+        expect(console.warn).toHaveBeenCalledWith(
+            expect.stringContaining('WASM module failed to load'), 
+            expect.objectContaining({ message: 'WASM module did not export _hash_string.' })
+        );
+    });
+
+    it('should successfully load raw WASM and use standalone polymorphic hasher', async () => {
+        const mockWasmInstance = {
+            exports: {
+                memory: { buffer: new ArrayBuffer(65536) },
+                hash: vi.fn().mockReturnValue(123456)
+            }
+        };
+        
+        global.WebAssembly = {
+            compile: vi.fn().mockResolvedValue({}),
+            instantiate: vi.fn().mockResolvedValue(mockWasmInstance)
+        };
+        
+        global.fetch = vi.fn().mockResolvedValue({
+            arrayBuffer: vi.fn().mockResolvedValue(new ArrayBuffer(100))
+        });
+
+        await ClientLibrary.initializeWasm('/fp.wasm');
+
+        const hash = ClientLibrary._hasher("test");
+        expect(hash).toBe(123456);
+        expect(mockWasmInstance.exports.hash).toHaveBeenCalledWith(0, 4);
+    });
+
+    it('should use the default JS hasher if WASM is not configured', async () => {
+        // Ensure no WASM path is provided in the config
+        ClientLibrary.initializeClient({});
+
+        // Verify that the active hasher is the original JS implementation
+        const jsHash = ClientLibrary._hasher("another test string");
+        const originalJsHash = (await import('../fingerprint.builder.js')).cyrb53("another test string");
+
+        expect(jsHash).toBe(originalJsHash);
+        // Ensure no WASM-related console logs or warnings were made
+        expect(console.log).not.toHaveBeenCalledWith(expect.stringContaining('WASM module loaded successfully'));
+        expect(console.warn).not.toHaveBeenCalledWith(expect.stringContaining('WASM module failed to load'));
+    });
 });

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

@@ -66,6 +66,18 @@ describe('Fingerprint & PoW Security Suite', () => {
             expect(FingerprintBuilder.compare(fp1, ''), "Comparison with empty string should be 0").toBe(0);
             expect(FingerprintBuilder.compare(null, fp2), "Comparison with null should be 0").toBe(0);
         });
+
+      it('should calculate a high crossLayerInconsistencyScore when viewport width exceeds screen width', () => {
+          const context = {
+              headers: {
+                  'x-device-fingerprint': `scr:${cyrb53("1920x1080_24")}`,
+                  'sec-ch-viewport-width': '2560'
+              }
+          };
+
+          const { crossLayerInconsistencyScore } = __internal.getCrossLayerInconsistency(context);
+          expect(crossLayerInconsistencyScore).toBe(20);
+      });
     });
 
     describe('JA3 Fingerprinting', () => {
@@ -1635,6 +1647,53 @@ describe('Fingerprint & PoW Security Suite', () => {
     });
 });
 
+describe('TLS Session Resumption (Cookieless Identity)', () => {
+    const inMemoryStore = {
+        _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); },
+    };
+
+    beforeEach(() => {
+        inMemoryStore._map.clear();
+        configureStore(inMemoryStore);
+    });
+
+    it('should resume device ID using TLS Session ID even if cookies are cleared', async () => {
+        const securityConfig = {
+            weights: { historyScore: 1.0 },
+            thresholds: { low: 20, block: 95 }
+        };
+        const engine = new FingerprintEngine(securityConfig);
+
+        const req1 = {
+            clientIp: '1.2.3.4',
+            path: '/',
+            cookies: {},
+            headers: { 'x-tls-session-id': 'session-xyz-123', 'user-agent': 'test-agent' },
+            rawHeaders: [],
+            httpVersion: '1.1'
+        };
+        const decision1 = await engine.processRequest(req1);
+        const deviceId = decision1.newCookieForResponse.value;
+        expect(deviceId).toBeDefined();
+
+        const req2 = {
+            clientIp: '1.2.3.4',
+            path: '/',
+            cookies: {}, // Cookies cleared!
+            headers: { 'x-tls-session-id': 'session-xyz-123', 'user-agent': 'test-agent' },
+            rawHeaders: [],
+            httpVersion: '1.1'
+        };
+
+        const decision2 = await engine.processRequest(req2);
+        expect(decision2.newCookieForResponse).toBeUndefined(); // Resumed successfully, no new cookie needed
+    });
+});
+
 describe('getTlsSpoofingScore', () => {
     let getTlsFingerprintMock; // Renamed to reflect it's the mock function
     let getTlsSpoofingScore;
@@ -2069,7 +2128,7 @@ describe('getClientHintsInconsistencyScore', () => {
             }
         };
         const { clientHintsInconsistencyScore } = getClientHintsInconsistencyScore(context);
-        expect(clientHintsInconsistencyScore).toBe(80);
+        expect(clientHintsInconsistencyScore).toBe(97);
     });
 
     it('should return 40 for a small version mismatch', () => {
@@ -2449,3 +2508,22 @@ describe('Botnet Cluster Scoring (Node.js)', () => {
             }
         });
 });
+
+    test('Stateless Ticket Generation and Validation', async () => {
+        const payload = {
+            expiry: Date.now() + 3600000,
+            originalIp: '127.0.0.1',
+            deviceId: 'device-123',
+            deviceHash: 'hash-abc'
+        };
+        
+        const ticket = fingerprint.generateStatelessTicket(payload);
+        expect(ticket).toBeTruthy();
+        expect(ticket.split('.').length).toBe(3);
+        
+        const isValid = await fingerprint.isTicketValid('127.0.0.1', ticket, 'device-123', 'hash-abc');
+        expect(isValid).toBe(true);
+
+        const isDiffIpValid = await fingerprint.isTicketValid('192.168.1.1', ticket, 'device-123', 'hash-abc', false);
+        expect(isDiffIpValid).toBe(false);
+    });