@anonympins/fingerprint 0.7.0 → 0.7.2

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

@@ -10,6 +10,8 @@ import * as fingerprint from '../fingerprint.js';
 vi.mock('import-meta-env', () => ({
     env: { NODE_ENV: 'test', POW_SECRET: 'fallback-dev-secret-32-chars-minimum' },
 }));
+// Mock the entire dns module
+vi.mock('node:dns/promises');
 // Mock readFileSync for custom challenge page tests
 vi.mock('node:fs', async () => {
     const actualFs = await vi.importActual('node:fs');
@@ -35,9 +37,8 @@ const {
 } = fingerprint;
 const { store, getRequestPatternScore, getDeviceHash } = __internal;
 const { getRenderingAnomalyScore } = __internal;
-let { getBehaviorScore, getClickVarianceScore } = __internal;
-// Mock the entire dns module
-vi.mock('node:dns/promises');
+let { getBehaviorScore, getClickVarianceScore } = __internal; // eslint-disable-line prefer-const
+
 
 describe('Fingerprint & PoW Security Suite', () => {
     test('cyrb53 should be deterministic', () => {
@@ -1764,6 +1765,92 @@ describe('Fingerprint & PoW Security Suite', () => {
         });
     });
 });
+describe('Googlebot Whitelisting (Node.js)', () => {
+    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); },
+    };
+
+    const securityConfig = {
+        weights: { headerAnomalyScore: 1.0, tlsSpoofingScore: 1.0 }, // Simple config for testing
+        thresholds: { low: 20, medium: 45, high: 75, block: 95 },
+        whitelist: [
+            { userAgent: 'Googlebot', hostnameSuffix: '.googlebot.com' }
+        ]
+    };
+
+    let engine;
+
+    beforeEach(() => {
+        inMemoryStore._map.clear();
+        configureStore(inMemoryStore);
+        vi.clearAllMocks(); // Clear mocks before each test
+        engine = new FingerprintEngine(securityConfig);
+    });
+
+    it('should correctly identify and allow a legitimate Googlebot request', async () => {
+        const googleIp = '::ffff:66.249.66.39'; // An IP from the official list
+        const googleHostname = 'crawl-66-249-66-39.googlebot.com';
+        const googleUa = 'Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)';
+
+        // Mock the DNS verification process
+        vi.mocked(dns.reverse).mockResolvedValue([googleHostname]);
+        vi.mocked(dns.resolve).mockResolvedValue([googleIp]);
+
+        const requestContext = {
+            clientIp: googleIp,
+            path: '/',
+            headers: { 'user-agent': googleUa },
+            isStatic: false,
+            cookies: {},
+            query: {},
+            body: null,
+            httpVersion: '1.1',
+            rawHeaders: ['user-agent', googleUa]
+        };
+
+        const decision = await engine.processRequest(requestContext);
+
+        expect(decision.action).toBe('next');
+        expect(decision.score).toBe(0);
+        expect(decision.vector.whitelisted).toBe(100);
+        expect(decision.vector.type).toBe('bot');
+
+        expect(dns.reverse).toHaveBeenCalledWith(googleIp);
+        expect(dns.resolve).toHaveBeenCalledWith(googleHostname);
+    });
+
+    it('should challenge or block a request spoofing a Googlebot User-Agent from a non-Google IP', async () => {
+        const fakeGoogleIp = '1.2.3.4';
+        const googleUa = 'Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)';
+
+        vi.mocked(dns.reverse).mockRejectedValue(new Error('Host not found'));
+
+        const requestContext = {
+            clientIp: fakeGoogleIp,
+            path: '/',
+            headers: { 'user-agent': googleUa, 'accept-language': 'en-US' },
+            isStatic: false,
+            cookies: {},
+            query: {},
+            body: null,
+            httpVersion: '1.1',
+            rawHeaders: ['user-agent', googleUa, 'accept-language', 'en-US']
+        };
+
+        const decision = await engine.processRequest(requestContext);
+
+        expect(decision.action).toBe('block');
+        expect(decision.score).toBeGreaterThan(0);
+        expect(decision.vector.whitelisted).toBeUndefined();
+
+        expect(dns.reverse).toHaveBeenCalledWith(fakeGoogleIp);
+        expect(dns.resolve).not.toHaveBeenCalled();
+    });
+});
 
 describe('TLS Session Resumption (Cookieless Identity)', () => {
     const inMemoryStore = {
@@ -2369,20 +2456,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(58.6);
+        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).toBe(99.4);
+        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).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);
     });
 });
 

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
     });
 });

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

@@ -1,8 +1,8 @@
 import crypto from "node:crypto";
 
 /**
- * Classe de base abstraite pour définir des tâches uPoW basées sur l'entraînement
- * ou l'évaluation de modèles IA (PyTorch exportés au format ONNX).
+ * 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 = {}) {
@@ -20,7 +20,7 @@ export class UpowModelTask {
     }
 
     /**
-     * Récupère l'identifiant du problème.
+     * Returns the unique problem identifier.
      * @returns {string}
      */
     getProblemId() {
@@ -28,7 +28,7 @@ export class UpowModelTask {
     }
 
     /**
-     * Récupère le chemin réseau du modèle ONNX.
+     * Returns the network asset path of the model.
      * @returns {string}
      */
     getModelAssetPath() {
@@ -36,18 +36,18 @@ export class UpowModelTask {
     }
 
     /**
-     * Génère la charge utile de travail pour le client.
-     * Envoie l'état actuel des poids du modèle et un lot de données (mini-batch) à traiter.
+     * Dispatches task workload to the client.
+     * Transmits current model weights and mini-batch sample data.
      * @param {number} suspicionFactor
-     * @returns {object} Données à envoyer au client
+     * @returns {object} Task payload dispatched to client
      */
     dispatchTask(suspicionFactor) {
         throw new Error("Method 'dispatchTask(suspicionFactor)' must be implemented.");
     }
 
     /**
-     * Vérifie la validité de la solution retournée par le client.
-     * Implémente des gardes-fous contre l'empoisonnement (ex: vérification des gradients).
+     * Validates solution returned by the client.
+     * Implements anti-poisoning guards and gradient bounds checks.
      * @param {object} taskContext 
      * @param {object} solution 
      * @returns {boolean}
@@ -57,8 +57,7 @@ export class UpowModelTask {
     }
 
     /**
-     * Intègre les gradients ou résultats validés dans le modèle global.
-     * Par exemple : algorithme FedAvg (Federated Averaging).
+     * Integrates validated gradients into global model weights (e.g. FedAvg).
      * @param {object} solution 
      */
     integrateSolution(solution) {
@@ -67,17 +66,17 @@ export class UpowModelTask {
 }
 
 /**
- * Exemple d'implémentation d'une tâche d'entraînement (Classifieur de requêtes suspectes)
+ * Example training task implementation (suspicious request classifier).
  */
 export class RequestClassifierTask extends UpowModelTask {
     constructor(modelPath, config) {
         super("request_classifier_nn", modelPath, config);
-        // Poids initiaux du modèle (Réseau de neurones linéaire simple)
+        // Initial model weights (linear neural network)
         this.weights = [0.1, -0.2, 0.8, 0.5]; 
     }
 
     dispatchTask(suspicionFactor) {
-        // Génération de données d'entraînement anonymisées pour le client
+        // 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]
@@ -95,7 +94,7 @@ export class RequestClassifierTask extends UpowModelTask {
         if (!Array.isArray(gradients) || gradients.length !== this.weights.length) {
             return false;
         }
-        // Anti-poisoning : s'assurer que les gradients ne contiennent pas de valeurs aberrantes (clipping)
+        // 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) {