@anonympins/fingerprint 0.7.5 → 0.8.0

package/src/js/tests/obfuscation.test.js

@@ -1,13 +1,13 @@
 import { describe, expect, it } from 'vitest';
 import { __internal } from '../fingerprint.js';
 
-describe('Système de Polymorphisme et Compilateur d\'Obfuscation', () => {
+describe('Polymorphic System and Obfuscation Compiler', () => {
     
     it('should generate a valid session mapping with randomized headers and globals', () => {
         const mapping1 = __internal.generateSessionMapping();
         const mapping2 = __internal.generateSessionMapping();
 
-        // Vérification de la présence des structures attendues
+        // Verify expected mapping structure
         expect(mapping1).toBeDefined();
         expect(mapping1.headers).toHaveProperty('x-device-fingerprint');
         expect(mapping1.headers).toHaveProperty('x-behavior-metrics');
@@ -17,7 +17,7 @@ describe('Système de Polymorphisme et Compilateur d\'Obfuscation', () => {
         expect(mapping1.keys).toHaveProperty('ua');
         expect(mapping1.wasmConstants).toHaveProperty('seed');
 
-        // Vérification de l'aléa (deux sessions consécutives doivent avoir des mappings uniques)
+        // Verify randomness: two consecutive sessions must yield unique mappings
         expect(mapping1.headers['x-device-fingerprint']).not.toBe(mapping2.headers['x-device-fingerprint']);
         expect(mapping1.globals['ClientLibrary']).not.toBe(mapping2.globals['ClientLibrary']);
         expect(mapping1.keys['ua']).not.toBe(mapping2.keys['ua']);
@@ -27,22 +27,22 @@ describe('Système de Polymorphisme et Compilateur d\'Obfuscation', () => {
     it('should compile and obfuscate client script asynchronously using the obfuscation worker', async () => {
         const mapping = __internal.generateSessionMapping();
         
-        // On lance la compilation lourde qui instancie le Worker d'arrière-plan
+        // Run background worker obfuscation task
         const obfuscatedCode = await __internal.compilePolymorphicJs(mapping);
 
         expect(obfuscatedCode).toBeDefined();
         expect(typeof obfuscatedCode).toBe('string');
         expect(obfuscatedCode.length).toBeGreaterThan(0);
 
-        // Vérification que les placeholders originaux ont bien été purgés du code client final
+        // Verify original identifiers were rewritten in compiled client script
         expect(obfuscatedCode).not.toContain('X-Device-Fingerprint');
         expect(obfuscatedCode).not.toContain('X-Behavior-Metrics');
         expect(obfuscatedCode).not.toContain('ClientLibrary');
 
-        // Vérification que le code est minifié/obfusqué (ne contient pas de commentaires de développement par exemple)
+        // Verify code is obfuscated without plain dev comments
         expect(obfuscatedCode).not.toContain('// Nom trompeur aléatoire pour attirer les analyseurs');
         
-        // La structure globale de javascript-obfuscator génère typiquement un tableau de chaînes au début
+        // Obfuscator emits string array wrapper prefix
         expect(obfuscatedCode).toMatch(/_0x/);
-    }, 15000); // Augmentation du timeout à 15s car l'obfuscation via Worker thread consomme du CPU
+    }, 15000); // 15s timeout for CPU-intensive worker execution
 });

package/src/js/tests/quicFingerprint.test.js

@@ -43,4 +43,51 @@ describe('Protocol Anomaly Flow Profiling', () => {
         const score = getProtocolAnomalyScore(context);
         expect(score.protocolAnomalyScore).toBe(100.0);
     });
+
+    it('should detect RFC 9218 invalid urgency value out of range (u=9)', () => {
+        const context = {
+            headers: {
+                'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+                'x-quic-fp': '1;1=1572864,4=100;u=9,i'
+            }
+        };
+        const score = getProtocolAnomalyScore(context);
+        expect(score.quicAnomalyScore).toBeGreaterThanOrEqual(50.0);
+    });
+
+    it('should detect HTTP/2 flat dependency tree from Go net/http2 scraper', () => {
+        const context = {
+            headers: {
+                'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+                'x-http2-fingerprint': 's:1:65536,2:0,3:1000,4:6291456,6:262144|15663105|1:0:0:16|m,a,s,p|p:3,w:4,c:1'
+            },
+            httpVersion: '2.0'
+        };
+        const score = getProtocolAnomalyScore(context);
+        expect(score.http2AnomalyScore).toBeGreaterThanOrEqual(55.0);
+    });
+
+    it('should detect HTTP/2 self-dependency violation', () => {
+        const context = {
+            headers: {
+                'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+                'x-http2-fingerprint': 's:1:65536,2:0,3:1000,4:6291456,6:262144|15663105|3:0:3:256|m,a,s,p|p:3,w:4,c:1'
+            },
+            httpVersion: '2.0'
+        };
+        const score = getProtocolAnomalyScore(context);
+        expect(score.http2AnomalyScore).toBeGreaterThanOrEqual(60.0);
+    });
+
+    it('should detect scrapers with 0 dynamic table entries on repeated requests', () => {
+        const context = {
+            headers: {
+                'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+                'x-compression-info': 'req_count:5,dynamic_table_entries:0'
+            },
+            httpVersion: '2.0'
+        };
+        const score = getProtocolAnomalyScore(context);
+        expect(score.http2AnomalyScore).toBeGreaterThanOrEqual(45.0);
+    });
 });

package/src/js/tests/tcpFingerprint.test.js

@@ -5,7 +5,7 @@ const { parseTcpSyn, classifyTcpOs, getTcpAnomalyScore } = __internal;
 
 describe('Passive TCP/IP Fingerprinting (Type p0f)', () => {
     
-    // Mock d'un paquet IP + TCP SYN d'un système Linux (TTL=64, WS=7)
+    // Mock Linux IP + TCP SYN packet (TTL=64, WS=7)
     const mockLinuxSynPacket = Buffer.from([
         0x45, 0x00, 0x00, 0x3c, 0x1a, 0x2b, 0x40, 0x00, 
         0x40, 0x06, 0x3c, 0x1a, 0x7f, 0x00, 0x00, 0x01, // TTL=0x40 (64)
@@ -19,7 +19,7 @@ describe('Passive TCP/IP Fingerprinting (Type p0f)', () => {
         0x03, 0x03, 0x07        // Option WS: 7
     ]);
 
-    // Mock d'un paquet IP + TCP SYN d'un système Windows (TTL=128, WS=8)
+    // Mock Windows IP + TCP SYN packet (TTL=128, WS=8)
     const mockWindowsSynPacket = Buffer.from([
         0x45, 0x00, 0x00, 0x3c, 0x1a, 0x2b, 0x40, 0x00, 
         0x80, 0x06, 0x3c, 0x1a, 0x7f, 0x00, 0x00, 0x01, // TTL=0x80 (128)
@@ -57,7 +57,7 @@ describe('Passive TCP/IP Fingerprinting (Type p0f)', () => {
     });
 
     it('should calculate correct TCP/IP anomaly scores', () => {
-        // Cas 1 : Le User-Agent prétend être Windows, mais la pile TCP/IP est Linux
+        // Case 1: User-Agent claims Windows, but TCP/IP stack signature is Linux
         const contextAnomaly = {
             headers: {
                 'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0',
@@ -66,7 +66,7 @@ describe('Passive TCP/IP Fingerprinting (Type p0f)', () => {
         };
         expect(getTcpAnomalyScore(contextAnomaly).tcpAnomalyScore).toBe(80.1);
 
-        // Cas 2 : Cohérence complète (UA Windows et pile TCP/IP Windows)
+        // Case 2: Consistent stack (Windows UA and Windows TCP/IP stack)
         const contextCoherent = {
             headers: {
                 'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0',

package/src/js/upow-model-task.js

@@ -1,113 +1,156 @@
-import crypto from "node:crypto";
-
-/**
- * Abstract base class defining useful Proof-of-Work (uPoW) tasks based on ML training
- * or inference validation (e.g. PyTorch models exported to ONNX format).
- */
-export class UpowModelTask {
-    constructor(problemId, modelPath, config = {}) {
-        if (new.target === UpowModelTask) {
-            throw new TypeError("Cannot construct UpowModelTask instances directly");
-        }
-        this.problemId = problemId;
-        this.modelPath = modelPath;
-        this.config = {
-            batchSize: 32,
-            learningRate: 0.01,
-            validationTolerance: 0.15,
-            ...config
-        };
-    }
-
-    /**
-     * Returns the unique problem identifier.
-     * @returns {string}
-     */
-    getProblemId() {
-        return this.problemId;
-    }
-
-    /**
-     * Returns the network asset path of the model.
-     * @returns {string}
-     */
-    getModelAssetPath() {
-        return this.modelPath;
-    }
-
-    /**
-     * Dispatches task workload to the client.
-     * Transmits current model weights and mini-batch sample data.
-     * @param {number} suspicionFactor
-     * @returns {object} Task payload dispatched to client
-     */
-    dispatchTask(suspicionFactor) {
-        throw new Error("Method 'dispatchTask(suspicionFactor)' must be implemented.");
-    }
-
-    /**
-     * Validates solution returned by the client.
-     * Implements anti-poisoning guards and gradient bounds checks.
-     * @param {object} taskContext 
-     * @param {object} solution 
-     * @returns {boolean}
-     */
-    verifySolution(taskContext, solution) {
-        throw new Error("Method 'verifySolution(taskContext, solution)' must be implemented.");
-    }
-
-    /**
-     * Integrates validated gradients into global model weights (e.g. FedAvg).
-     * @param {object} solution 
-     */
-    integrateSolution(solution) {
-        throw new Error("Method 'integrateSolution(solution)' must be implemented.");
-    }
-}
-
-/**
- * Example training task implementation (suspicious request classifier).
- */
-export class RequestClassifierTask extends UpowModelTask {
-    constructor(modelPath, config) {
-        super("request_classifier_nn", modelPath, config);
-        // Initial model weights (linear neural network)
-        this.weights = [0.1, -0.2, 0.8, 0.5]; 
-    }
-
-    dispatchTask(suspicionFactor) {
-        // Anonymized sample training batch dispatched to client
-        const inputs = [
-            [1.0, 0.5, 0.0, 1.2],
-            [0.0, 1.0, -0.5, 0.8]
-        ];
-        return {
-            weights: [...this.weights],
-            inputs: inputs,
-            learningRate: this.config.learningRate,
-            batchSize: this.config.batchSize
-        };
-    }
-
-    verifySolution(taskContext, solution) {
-        const gradients = solution?.gradients;
-        if (!Array.isArray(gradients) || gradients.length !== this.weights.length) {
-            return false;
-        }
-        // Anti-poisoning guard: ensure gradients do not exceed threshold norms (gradient clipping)
-        const maxGradientNorm = 10.0;
-        for (const grad of gradients) {
-            if (typeof grad !== 'number' || isNaN(grad) || Math.abs(grad) > maxGradientNorm) {
-                return false;
-            }
-        }
-        return true;
-    }
-
-    integrateSolution(solution) {
-        const gradients = solution.gradients;
-        for (let i = 0; i < this.weights.length; i++) {
-            this.weights[i] -= this.config.learningRate * gradients[i];
-        }
-    }
+import crypto from "node:crypto";
+
+/**
+ * Abstract base class defining useful Proof-of-Work (uPoW) tasks based on ML training
+ * or inference validation (e.g. PyTorch models exported to ONNX format).
+ */
+export class UpowModelTask {
+    /**
+     * Creates a new UpowModelTask. This class is abstract and cannot be
+     * instantiated directly.
+     *
+     * @param {string} problemId - The unique identifier of the problem.
+     * @param {string} modelPath - The network asset path of the model.
+     * @param {object} [config={}] - Optional configuration overrides.
+     * @param {number} [config.batchSize=32] - Mini-batch size.
+     * @param {number} [config.learningRate=0.01] - Learning rate.
+     * @param {number} [config.validationTolerance=0.15] - Validation tolerance.
+     * @throws {TypeError} If instantiated directly.
+     */
+    constructor(problemId, modelPath, config = {}) {
+        if (new.target === UpowModelTask) {
+            throw new TypeError("Cannot construct UpowModelTask instances directly");
+        }
+        this.problemId = problemId;
+        this.modelPath = modelPath;
+        this.config = {
+            batchSize: 32,
+            learningRate: 0.01,
+            validationTolerance: 0.15,
+            ...config
+        };
+    }
+
+    /**
+     * Returns the unique problem identifier.
+     * @returns {string}
+     */
+    getProblemId() {
+        return this.problemId;
+    }
+
+    /**
+     * Returns the network asset path of the model.
+     * @returns {string}
+     */
+    getModelAssetPath() {
+        return this.modelPath;
+    }
+
+    /**
+     * Dispatches task workload to the client.
+     * Transmits current model weights and mini-batch sample data.
+     * @param {number} suspicionFactor
+     * @returns {object} Task payload dispatched to client
+     */
+    dispatchTask(suspicionFactor) {
+        throw new Error("Method 'dispatchTask(suspicionFactor)' must be implemented.");
+    }
+
+    /**
+     * Validates solution returned by the client.
+     * Implements anti-poisoning guards and gradient bounds checks.
+     * @param {object} taskContext
+     * @param {object} solution
+     * @returns {boolean}
+     */
+    verifySolution(taskContext, solution) {
+        throw new Error("Method 'verifySolution(taskContext, solution)' must be implemented.");
+    }
+
+    /**
+     * Integrates validated gradients into global model weights (e.g. FedAvg).
+     * @param {object} solution
+     */
+    integrateSolution(solution) {
+        throw new Error("Method 'integrateSolution(solution)' must be implemented.");
+    }
+}
+
+/**
+ * Example training task implementation (suspicious request classifier).
+ */
+export class RequestClassifierTask extends UpowModelTask {
+    /**
+     * Creates a new RequestClassifierTask with an initial set of linear
+     * neural network weights.
+     *
+     * @param {string} modelPath - The network asset path of the model.
+     * @param {object} config - Configuration object (batch size, learning rate, etc.).
+     */
+    constructor(modelPath, config) {
+        super("request_classifier_nn", modelPath, config);
+        // Initial model weights (linear neural network)
+        this.weights = [0.1, -0.2, 0.8, 0.5];
+    }
+
+    /**
+     * Builds and returns the task payload sent to the client, including the
+     * current model weights, an anonymized sample training batch, the learning
+     * rate, and the batch size.
+     *
+     * @param {number} suspicionFactor - The suspicion factor for this request.
+     * @returns {object} The task payload dispatched to the client.
+     */
+    dispatchTask(suspicionFactor) {
+        // Anonymized sample training batch dispatched to client
+        const inputs = [
+            [1.0, 0.5, 0.0, 1.2],
+            [0.0, 1.0, -0.5, 0.8]
+        ];
+        return {
+            weights: [...this.weights],
+            inputs: inputs,
+            learningRate: this.config.learningRate,
+            batchSize: this.config.batchSize
+        };
+    }
+
+    /**
+     * Validates the solution returned by the client. Ensures the gradients
+     * array has the expected length and applies an anti-poisoning guard by
+     * rejecting any gradient whose absolute value exceeds a fixed threshold
+     * (gradient clipping).
+     *
+     * @param {object} taskContext - The context of the dispatched task.
+     * @param {object} solution - The solution returned by the client.
+     * @returns {boolean} True if the solution is valid, false otherwise.
+     */
+    verifySolution(taskContext, solution) {
+        const gradients = solution?.gradients;
+        if (!Array.isArray(gradients) || gradients.length !== this.weights.length) {
+            return false;
+        }
+        // Anti-poisoning guard: ensure gradients do not exceed threshold norms (gradient clipping)
+        const maxGradientNorm = 10.0;
+        for (const grad of gradients) {
+            if (typeof grad !== 'number' || isNaN(grad) || Math.abs(grad) > maxGradientNorm) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * Integrates the validated gradients into the global model weights using
+     * a simple gradient descent update: w_i -= learningRate * grad_i.
+     *
+     * @param {object} solution - The validated solution containing gradients.
+     */
+    integrateSolution(solution) {
+        const gradients = solution.gradients;
+        for (let i = 0; i < this.weights.length; i++) {
+            this.weights[i] -= this.config.learningRate * gradients[i];
+        }
+    }
 }