@anonympins/fingerprint 0.6.5 → 0.6.7

package/src/js/pow.solver.inline.js

@@ -53,6 +53,44 @@ function generateBlock(seed, blockIndex, blockSize = 1024) {
     return block;
 }
 
+async function loadTfjs() {
+    if (typeof tf !== 'undefined') return tf;
+    if (typeof window !== 'undefined') {
+        if (window.tf) return window.tf;
+        return new Promise((resolve, reject) => {
+            const script = document.createElement('script');
+            script.src = 'https://cdn.jsdelivr.net/npm/@tensorflow/tfjs/dist/tf.min.js';
+            script.onload = () => resolve(window.tf);
+            script.onerror = () => reject(new Error('Failed to load TensorFlow.js'));
+            document.head.appendChild(script);
+        });
+    }
+    try {
+        return await import('@tensorflow/tfjs');
+    } catch (e) {
+        throw new Error("TensorFlow.js is not available.");
+    }
+}
+
+async function loadOnnxRuntime() {
+    if (typeof ort !== 'undefined') return ort;
+    if (typeof window !== 'undefined') {
+        if (window.ort) return window.ort;
+        return new Promise((resolve, reject) => {
+            const script = document.createElement('script');
+            script.src = 'https://cdn.jsdelivr.net/npm/onnxruntime-web/dist/ort.min.js';
+            script.onload = () => resolve(window.ort);
+            script.onerror = () => reject(new Error('Failed to load ONNX Runtime Web'));
+            document.head.appendChild(script);
+        });
+    }
+    try {
+        return await import('onnxruntime-node');
+    } catch (e) {
+        throw new Error("ONNX Runtime is not available.");
+    }
+}
+
 async function initializeSpace(seed, sizeMb) {
     const db = await openDb();
     const transaction = db.transaction("blocks", "readwrite");
@@ -491,8 +529,8 @@ async function solveUsefulWorkTask(task) {
                     const i = Math.floor(secureRandom() * numFacilities);
                     const moveX = (secureRandom() - 0.5) * (bounds.maxX - bounds.minX) * 0.1;
                     const moveY = (secureRandom() - 0.5) * (bounds.maxY - bounds.minY) * 0.1;
-                    newFacilities[i].x = Math.max(bounds.minX, min(bounds.maxX, newFacilities[i].x + moveX));
-                    newFacilities[i].y = Math.max(bounds.minY, min(bounds.maxY, newFacilities[i].y + moveY));
+                        newFacilities[i].x = Math.max(bounds.minX, Math.min(bounds.maxX, newFacilities[i].x + moveX));
+                        newFacilities[i].y = Math.max(bounds.minY, Math.min(bounds.maxY, newFacilities[i].y + moveY));
                     return newFacilities;
                 };
                 const initialSolution = task.initialSolution || Array.from({ length: numFacilities }, () => ({
@@ -557,6 +595,94 @@ async function solveUsefulWorkTask(task) {
             return solverFunction(task.payload, { generations: task.generations, initialFront: task.initialFront });
         }
 
+        case 'pytorch_onnx_learning': {
+            const { weights, payload, modelPath } = task;
+            const inputs = payload.inputs || [];
+            const labels = payload.labels || [];
+
+            try {
+                const ort = await loadOnnxRuntime();
+                const session = await ort.InferenceSession.create(modelPath);
+                const inputName = session.inputNames[0];
+                const outputName = session.outputNames[0];
+
+                const dims = [inputs.length, inputs[0].length];
+                const inputTensor = new ort.Tensor('float32', Float32Array.from(inputs.flat()), dims);
+                const results = await session.run({ [inputName]: inputTensor });
+                const outputTensor = results[outputName];
+                const predictions = Array.from(outputTensor.data);
+
+                const gradients = new Array(weights.length).fill(0);
+                for (let i = 0; i < inputs.length; i++) {
+                    const x = inputs[i];
+                    const y = labels[i];
+                    const pred = predictions[i];
+                    const error = pred - y;
+                    for (let j = 0; j < weights.length; j++) {
+                        gradients[j] += error * x[j] / inputs.length;
+                    }
+                }
+                return { gradients, predictions };
+            } catch (err) {
+                console.warn('[Useful Work Solver] Real ONNX loading failed, using fallback simulation:', err);
+                const gradients = new Array(weights.length).fill(0);
+                for (let i = 0; i < inputs.length; i++) {
+                    const x = inputs[i];
+                    const y = labels[i];
+                    let pred = 0;
+                    for (let j = 0; j < weights.length; j++) {
+                        pred += x[j] * weights[j];
+                    }
+                    const error = pred - y;
+                    for (let j = 0; j < weights.length; j++) {
+                        gradients[j] += error * x[j] / inputs.length;
+                    }
+                }
+                return { gradients };
+            }
+        }
+
+        case 'tfjs_learning': {
+            const { weights, payload, modelPath } = task;
+            const inputs = payload.inputs || [];
+            const labels = payload.labels || [];
+            try {
+                const tf = await loadTfjs();
+                const model = await tf.loadLayersModel(modelPath);
+                
+                const xs = tf.tensor2d(inputs);
+                const ys = tf.tensor2d(labels);
+                
+                const trainableVars = model.trainableWeights.map(w => w.read());
+                const lossFn = () => {
+                    const preds = model.predict(xs);
+                    return tf.losses.meanSquaredError(ys, preds);
+                };
+                
+                const gFn = tf.grad(lossFn);
+                const grads = gFn(trainableVars);
+                
+                const flatGradients = [];
+                const arr = await grads.array();
+                flatGradients.push(...arr.flat());
+                
+                tf.dispose([xs, ys, ...grads]);
+                return { gradients: flatGradients };
+            } catch (err) {
+                console.warn('[Useful Work Solver] Real TFJS loading failed, using fallback simulation:', err);
+                const gradients = new Array(weights.length).fill(0);
+                for (let i = 0; i < inputs.length; i++) {
+                    const x = inputs[i];
+                    const y = labels[i][0] !== undefined ? labels[i][0] : labels[i];
+                    let pred = 0;
+                    for (let j = 0; j < weights.length; j++) pred += x[j] * weights[j];
+                    const error = pred - y;
+                    for (let j = 0; j < weights.length; j++) gradients[j] += error * x[j] / inputs.length;
+                }
+                return { gradients };
+            }
+        }
+
         default:
             throw new Error(`Unknown useful work type: ${task.type}`);
     }

package/src/js/pow.solver.js

@@ -32,6 +32,25 @@ function cyrb53(str, seed = 0) {
     return 4294967296 * (2097151 & h2) + (h1 >>> 0);
 }
 
+async function loadTfjs() {
+    if (typeof tf !== 'undefined') return tf;
+    if (typeof window !== 'undefined') {
+        if (window.tf) return window.tf;
+        return new Promise((resolve, reject) => {
+            const script = document.createElement('script');
+            script.src = 'https://cdn.jsdelivr.net/npm/@tensorflow/tfjs/dist/tf.min.js';
+            script.onload = () => resolve(window.tf);
+            script.onerror = () => reject(new Error('Failed to load TensorFlow.js'));
+            document.head.appendChild(script);
+        });
+    }
+    try {
+        return await import('@tensorflow/tfjs');
+    } catch (e) {
+        throw new Error("TensorFlow.js is not available.");
+    }
+}
+
 function openDb() {
     return new Promise((resolve, reject) => {
         const request = indexedDB.open("pospace-db", 1);
@@ -898,6 +917,72 @@ async function solveUsefulWorkTask(task) {
             return solverFunction(task.payload, { generations: task.generations, initialFront: task.initialFront });
         }
 
+        case 'pytorch_onnx_learning': {
+            // Dans un environnement de production réel avec ONNX Runtime Web, on chargerait le modèle .onnx 
+            // et on exécuterait un calcul de gradient (backward pass).
+            // Ici, nous simulons le calcul de gradient mathématique équivalent pour la régression/classification.
+            const { weights, payload } = task;
+            const inputs = payload.inputs || [];
+            const labels = payload.labels || [];
+            const gradients = new Array(weights.length).fill(0);
+            for (let i = 0; i < inputs.length; i++) {
+                const x = inputs[i];
+                const y = labels[i];
+                let pred = 0;
+                for (let j = 0; j < weights.length; j++) {
+                    pred += x[j] * weights[j];
+                }
+                const error = pred - y;
+                for (let j = 0; j < weights.length; j++) {
+                    gradients[j] += error * x[j] / inputs.length;
+                }
+            }
+            return { gradients };
+        }
+
+        case 'tfjs_learning': {
+            const { weights, payload, modelPath } = task;
+            const inputs = payload.inputs || [];
+            const labels = payload.labels || [];
+            try {
+                const tf = await loadTfjs();
+                // Chargement non-bloquant du modèle au format JSON
+                const model = await tf.loadLayersModel(modelPath);
+                
+                const xs = tf.tensor2d(inputs);
+                const ys = tf.tensor2d(labels);
+                
+                const trainableVars = model.trainableWeights.map(w => w.read());
+                const lossFn = () => {
+                    const preds = model.predict(xs);
+                    return tf.losses.meanSquaredError(ys, preds);
+                };
+                
+                // Dérivation automatique pour le calcul exact des gradients
+                const gFn = tf.grad(lossFn);
+                const grads = gFn(trainableVars);
+                
+                const flatGradients = [];
+                const arr = await grads.array();
+                flatGradients.push(...arr.flat());
+                
+                tf.dispose([xs, ys, grads]);
+                return { gradients: flatGradients };
+            } catch (err) {
+                console.warn('[Useful Work Solver] Real TFJS loading failed, using fallback simulation:', err);
+                const gradients = new Array(weights.length).fill(0);
+                for (let i = 0; i < inputs.length; i++) {
+                    const x = inputs[i];
+                    const y = labels[i][0] !== undefined ? labels[i][0] : labels[i];
+                    let pred = 0;
+                    for (let j = 0; j < weights.length; j++) pred += x[j] * weights[j];
+                    const error = pred - y;
+                    for (let j = 0; j < weights.length; j++) gradients[j] += error * x[j] / inputs.length;
+                }
+                return { gradients };
+            }
+        }
+
         default:
             throw new Error(`Unknown useful work type: ${task.type}`);
     }

package/src/js/problem-manager.js

@@ -318,6 +318,12 @@ class ProblemManager {
                 task.initialFront = problem.state.paretoFront;
                 task.solverName = problem.workUnit.solverName; // Le nom du solveur à utiliser (ex: 'cpc.solve')
                 break;
+
+            case 'tfjs_learning':
+                task.modelPath = problem.workUnit.modelPath;
+                task.payload = problem.payload;
+                task.weights = problem.state.weights || [];
+                break;
         }
 
         return { problemId: problem.id, task };
@@ -379,9 +385,16 @@ class ProblemManager {
                 case 'genetic_algorithm_generations':
                     // VÉRIFICATION PAR ÉCHANTILLONNAGE pour équilibrer sécurité et performance.
                     const fitnessFunction = FunctionRegistry['portfolio.calculateMetrics']; // Ou une fonction plus générique
-                    if (!fitnessFunction || !Array.isArray(solutionData.population) || solutionData.population.length === 0) {
-                        console.error(`[ProblemManager] Impossible de vérifier la population pour ${problemId}.`);
-                        return; // Ne rien faire si la vérification est impossible.
+                    if (!solutionData || !Array.isArray(solutionData.population)) {
+                        console.error(`[ProblemManager] Propriété 'population' manquante ou invalide dans solutionData pour ${problemId}.`);
+                        return;
+                    }
+                    if (solutionData.population.length === 0) {
+                        return; // Retour gracieux si la population est vide (ex: fallback de redirection)
+                    }
+                    if (!fitnessFunction) {
+                        console.error(`[ProblemManager] Impossible de vérifier la population pour ${problemId} (fonction de fitness manquante).`);
+                        return;
                     }
 
             if (solutionData.population.length > 150) {
@@ -408,7 +421,16 @@ class ProblemManager {
                         if (!individual || !individual.chromosome) {
                             throw new Error("Structure d'individu ou chromosome invalide dans la population.");
                         }
-                        totalRecalculatedFitness += fitnessFunction(individual.chromosome, problem.payload);
+                        const recalculated = fitnessFunction(individual.chromosome, problem.payload);
+                        
+                        if (individual.fitness !== undefined && individual.fitness !== -1) {
+                            if (Math.abs(individual.fitness - recalculated) > 1e-4) {
+                                console.error(`[ProblemManager] Triche détectée pour ${problemId}! Fitness déclaré: ${individual.fitness}, recalculé: ${recalculated}`);
+                                return; // Rejeter immédiatement toute la population
+                            }
+                        }
+                        individual.fitness = recalculated; // Forcer la valeur exacte recalculée
+                        totalRecalculatedFitness += recalculated;
                     }
 
                     problem.state.population = solutionData.population; // On accepte la population

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

@@ -58,7 +58,7 @@ describe('Cross-Parity Chaos PoW Floating Point Parity (JS vs WASM vs PHP)', ()
         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);
+            let x = Math.fround((numericSeed + idx * 0.015) % 1);
             for (let i = 0; i < iterations; i++) {
                 x = Math.fround(rFloat * x * Math.fround(1.0 - x));
             }
@@ -96,7 +96,7 @@ describe('Cross-Parity Chaos PoW Floating Point Parity (JS vs WASM vs PHP)', ()
         \$r = 3.9999;
         \$solutions = [];
         for (\$idx = 0; \$idx < 64; \$idx++) {
-            \$x = fround(\$numericSeed + \$idx * 0.015);
+            \$x = fround(fmod(\$numericSeed + \$idx * 0.015, 1.0));
             \$rFloat = fround(\$r);
             for (\$i = 0; \$i < \$iterations; \$i++) {
                 \$x = fround(\$rFloat * \$x * fround(1.0 - \$x));

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

@@ -130,6 +130,31 @@ describe('FingerprintEngine Challenge Validation', () => {
         expect(await inMemoryStore.has(`secret:${nonce}`)).toBe(false);
     }, 20000);
 
+    it('should generate a combined challenge page containing the correct prefix for the memory seed', async () => {
+        const originalRequestContext = {
+            clientIp: '127.0.0.1',
+            path: '/sensitive-data',
+            cookies: {},
+            query: {},
+            headers: {
+                'user-agent': 'A-Legit-Browser/1.0',
+                'x-device-fingerprint': 'fingerprint-A'
+            },
+            isStatic: false,
+            rawReq: { headers: { accept: 'text/html' } }
+        };
+
+        // Force a high score to trigger a challenge
+        vi.spyOn(engine, 'calculateFinalScore').mockReturnValueOnce(20);
+
+        const challengeDecision = await engine.processRequest(originalRequestContext);
+
+        expect(challengeDecision.action).toBe('challenge');
+        const body = challengeDecision.body;
+        // Verify that the memory seed is constructed with the correct leading colon
+        expect(body).toContain('const memSeed = ":" + nonce + ":" + clientSecret;');
+    });
+
     it('should reject a challenge solution with a mismatched fingerprint', async () => {
         // --- 1. First request: Challenge is issued to "Machine A" ---
         const originalRequestContext = {

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

@@ -2414,7 +2414,7 @@ describe('Subnet Scoring (Node.js)', () => {
             deviceIds: deviceIds, // count = 20. score += (20-10)*5 = 50
         });
         ({ subnetScore } = await __internal.getSubnetScore(context, 'device-1'));
-        expect(subnetScore).toBe(100);
+            expect(subnetScore).toBe(94.4);
     });
 });
 
@@ -2487,7 +2487,7 @@ describe('FingerprintEngine.processRequest - updateSubnetMetrics call logic', ()
     beforeEach(() => {
         inMemoryStore._map.clear();
         configureStore(inMemoryStore);
-
+        // Add a default mock for getTlsFingerprint to stabilize these tests.
         securityConfig = {
             weights: { historyScore: 1.0 },
             thresholds: { low: 20, medium: 45, high: 75, block: 95 }, // Default blockThreshold
@@ -2508,8 +2508,8 @@ describe('FingerprintEngine.processRequest - updateSubnetMetrics call logic', ()
         calculateFinalScoreSpy.mockRestore();
     });
 
-    it('should call updateSubnetMetrics if finalScore is between lowThreshold and blockThreshold', async () => {
-        calculateFinalScoreSpy.mockReturnValue(50); // Score between 20 and 95
+    it('should call updateSubnetMetrics if finalScore is between mediumThreshold and blockThreshold', async () => {
+        calculateFinalScoreSpy.mockReturnValue(50); // Score between 45 and 95
         const requestContext = { clientIp: '192.168.1.1', cookies: {}, query: {}, headers: {} };
 
         await engine.processRequest(requestContext);
@@ -2518,6 +2518,15 @@ describe('FingerprintEngine.processRequest - updateSubnetMetrics call logic', ()
         expect(updateSubnetMetricsSpy).toHaveBeenCalledWith(requestContext, expect.any(String), 50);
     });
 
+    it('should NOT call updateSubnetMetrics if finalScore is below mediumThreshold', async () => {
+        calculateFinalScoreSpy.mockReturnValue(30); // Score below 45
+        const requestContext = { clientIp: '192.168.1.1', cookies: {}, query: {}, headers: {} };
+
+        await engine.processRequest(requestContext);
+
+        expect(updateSubnetMetricsSpy).not.toHaveBeenCalled();
+    });
+
     it('should NOT call updateSubnetMetrics if finalScore is equal to or above blockThreshold', async () => {
         calculateFinalScoreSpy.mockReturnValue(95); // Score equals blockThreshold
         const requestContext = { clientIp: '192.168.1.1', cookies: {}, query: {}, headers: {} };

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

@@ -134,7 +134,7 @@ describe('IP Reputation Local System (Node.js)', () => {
         let score = await __internal.getSubnetScore(mockContext);
         expect(score.subnetScore).toBe(0);
         for (let i = 1; i <= 12; i++) {
-            await __internal.updateSubnetMetrics(mockContext, `dev-${i}`, 40);
+            await __internal.updateSubnetMetrics(mockContext, `dev-${i}`, 50);
         }
         score = await __internal.getSubnetScore(mockContext);
         expect(score.subnetScore).toBeGreaterThan(0);

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

@@ -1,16 +1,16 @@
 import { describe, expect, it } from 'vitest';
 import { __internal } from '../fingerprint.js';
 
-const { getQuicAnomalyScore } = __internal;
+const { getProtocolAnomalyScore } = __internal;
 
-describe('QUIC / HTTP/3 Flow Profiling', () => {
-    it('should return 0.0 if no QUIC fingerprint is present', () => {
+describe('Protocol Anomaly Flow Profiling', () => {
+    it('should return 0.0 if no QUIC or HTTP/2 fingerprint is present', () => {
         const context = { headers: {} };
-        const score = getQuicAnomalyScore(context);
-        expect(score.quicAnomalyScore).toBe(0.0);
+        const score = getProtocolAnomalyScore(context);
+        expect(score.protocolAnomalyScore).toBe(0.0);
     });
 
-    it('should detect Chrome spoofed with non-default stream/priority values', () => {
+    it('should detect Chrome spoofed with non-default stream/priority values (QUIC)', () => {
         // Chrome attend un initial_max_data (1) >= 1MB, initial_max_streams_bidi (4) == 100, et extensible Priority (contient u=)
         const context = {
             headers: {
@@ -18,8 +18,8 @@ describe('QUIC / HTTP/3 Flow Profiling', () => {
                 'x-quic-fp': '1;1=65536,4=50;i=0' // max_data trop bas, max_streams != 100, pas de priorité u=
             }
         };
-        const score = getQuicAnomalyScore(context);
-        expect(score.quicAnomalyScore).toBe(100.0);
+        const score = getProtocolAnomalyScore(context);
+        expect(score.protocolAnomalyScore).toBe(100.0);
     });
 
     it('should return 0.0 for a legitimate Chrome QUIC flow profile', () => {
@@ -29,7 +29,18 @@ describe('QUIC / HTTP/3 Flow Profiling', () => {
                 'x-quic-fp': '1;1=1572864,4=100;u=2,i'
             }
         };
-        const score = getQuicAnomalyScore(context);
-        expect(score.quicAnomalyScore).toBe(0.0);
+        const score = getProtocolAnomalyScore(context);
+        expect(score.protocolAnomalyScore).toBe(0.0);
+    });
+
+    it('should detect Chromium HTTP/2 header order anomalies', () => {
+        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': '1|65535|0|invalid_order'
+            }
+        };
+        const score = getProtocolAnomalyScore(context);
+        expect(score.protocolAnomalyScore).toBe(100.0);
     });
 });

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

@@ -0,0 +1,114 @@
+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).
+ */
+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
+        };
+    }
+
+    /**
+     * Récupère l'identifiant du problème.
+     * @returns {string}
+     */
+    getProblemId() {
+        return this.problemId;
+    }
+
+    /**
+     * Récupère le chemin réseau du modèle ONNX.
+     * @returns {string}
+     */
+    getModelAssetPath() {
+        return this.modelPath;
+    }
+
+    /**
+     * 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.
+     * @param {number} suspicionFactor
+     * @returns {object} Données à envoyer au 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).
+     * @param {object} taskContext 
+     * @param {object} solution 
+     * @returns {boolean}
+     */
+    verifySolution(taskContext, solution) {
+        throw new Error("Method 'verifySolution(taskContext, solution)' must be implemented.");
+    }
+
+    /**
+     * Intègre les gradients ou résultats validés dans le modèle global.
+     * Par exemple : algorithme FedAvg (Federated Averaging).
+     * @param {object} solution 
+     */
+    integrateSolution(solution) {
+        throw new Error("Method 'integrateSolution(solution)' must be implemented.");
+    }
+}
+
+/**
+ * Exemple d'implémentation d'une tâche d'entraînement (Classifieur de requêtes suspectes)
+ */
+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)
+        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
+        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 : s'assurer que les gradients ne contiennent pas de valeurs aberrantes (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];
+        }
+    }
+}

package/src/php/Challenge/ChallengeUtils.php

@@ -65,7 +65,7 @@ class ChallengeUtils
             if ($idx < 0 || $idx >= 64) {
                 return false;
             }
-            $x = self::fround($numericSeed + $idx * 0.015);
+            $x = self::fround(fmod($numericSeed + $idx * 0.015, 1.0));
             $rFloat = self::fround($r);
             for ($i = 0; $i < $iterations; $i++) {
                 $x = self::fround($rFloat * $x * self::fround(1.0 - $x));
@@ -1134,7 +1134,7 @@ JS;
             }
             let memSolution = 0;
             try {
-                const memSeed = nonce + ":" + clientSecret;
+                const memSeed = ":" + nonce + ":" + clientSecret;
                 memSolution = await window.solveMemoryChallenge(memSeed, memDifficulty);
             } catch(e) {
                 document.getElementById('loader').innerText = "Error: Insufficient memory. Please refresh.";

package/src/php/Config/SecurityProfiles.php

@@ -40,8 +40,8 @@ class SecurityProfiles
                 'clickVarianceScore' => 0.6, // Poids pour la variance des clics
                 'subnetScore' => 0.5, // Pénalise les sous-réseaux IP avec une activité suspecte agrégée
                 'botnetClusterScore' => 0.6, // NOUVEAU: Poids pour le clustering botnet
-                'tcpAnomalyScore' => 0.8, // NEW: Anomalie de pile TCP/IP
-                'quicAnomalyScore' => 0.8, // NEW: Anomalie QUIC
+                'tcpAnomalyScore' => 0.8,
+                'protocolAnomalyScore' => 0.8, // NEW: Anomalie de protocole (HTTP/2 et QUIC)
                 'renderingAnomalyScore' => 0.8, // NEW: Anomalie de rendu
                 'ipReputationScore' => 0.5, // NOUVEAU: Poids pour la réputation IP
             ],
@@ -90,7 +90,7 @@ class SecurityProfiles
                 'subnetScore' => 0.7, // Poids plus élevé en mode strict
                 'botnetClusterScore' => 0.8, // NOUVEAU: Poids pour le clustering botnet
                 'tcpAnomalyScore' => 1.0, // NEW: Anomalie de pile TCP/IP
-                'quicAnomalyScore' => 1.0, // NEW: Anomalie QUIC
+                'protocolAnomalyScore' => 1.0, // NEW: Anomalie de protocole (HTTP/2 et QUIC)
                 'renderingAnomalyScore' => 1.0, // NEW: Anomalie de rendu
 
             ],
@@ -139,7 +139,7 @@ class SecurityProfiles
                 'subnetScore' => 0.8, // Très important pour les API pour détecter les botnets
                 'botnetClusterScore' => 0.7, // NOUVEAU: Poids pour le clustering botnet
                 'tcpAnomalyScore' => 0.8, // NEW: Anomalie de pile TCP/IP
-                'quicAnomalyScore' => 0.8, // NEW: Anomalie QUIC
+                'protocolAnomalyScore' => 0.8, // NEW: Anomalie de protocole (HTTP/2 et QUIC)
 
             ],
             'thresholds' => ['low' => 25, 'medium' => 50, 'high' => 80, 'block' => 95],
@@ -190,7 +190,7 @@ class SecurityProfiles
                 'ipReputationScore' => 0.3, // NOUVEAU: Poids pour la réputation IP
                 'botnetClusterScore' => 0.5, // NOUVEAU: Poids pour le clustering botnet
                 'tcpAnomalyScore' => 0.5, // NEW: Anomalie de pile TCP/IP
-                'quicAnomalyScore' => 0.5, // NEW: Anomalie QUIC
+                'protocolAnomalyScore' => 0.5, // NEW: Anomalie de protocole (HTTP/2 et QUIC)
                 'renderingAnomalyScore' => 0.5, // NEW: Anomalie de rendu
 
             ],
@@ -240,7 +240,7 @@ class SecurityProfiles
                 'subnetScore' => 0.9, // Crucial contre les attaques de scalping distribuées
                 'botnetClusterScore' => 0.9, // NOUVEAU: Poids pour le clustering botnet
                 'tcpAnomalyScore' => 0.9, // NEW: Anomalie de pile TCP/IP
-                'quicAnomalyScore' => 0.9, // NEW: Anomalie QUIC
+                'protocolAnomalyScore' => 0.9, // NEW: Anomalie de protocole (HTTP/2 et QUIC)
                 'renderingAnomalyScore' => 0.9, // NEW: Anomalie de rendu
 
             ],