@anonympins/fingerprint 0.6.4 → 0.6.6

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 };
@@ -408,7 +414,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.test.js

@@ -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/gpu_pow.test.js

@@ -27,7 +27,7 @@ describe('GpuPowSolver - Chaotic Logistic Map PoW', () => {
         const solutions = [];
 
         for (let idx = 0; idx < 64; idx++) {
-            let x = Math.fround(numericSeed + idx * 0.015);
+            let x = Math.fround((numericSeed + idx * 0.015) % 1); // Ensure x starts in [0, 1)
             for (let i = 0; i < iterations; i++) {
                 x = Math.fround(rFloat * x * Math.fround(1.0 - x));
             }
@@ -53,19 +53,21 @@ describe('GpuPowSolver - Chaotic Logistic Map PoW', () => {
         const solutions = [];
 
         for (let idx = 0; idx < 64; idx++) {
-            let x = Math.fround(numericSeed + idx * 0.015);
+            let x = Math.fround((numericSeed + idx * 0.015) % 1); // Ensure x starts in [0, 1)
             for (let i = 0; i < iterations; i++) {
                 x = Math.fround(rFloat * x * Math.fround(1.0 - x));
             }
             solutions.push(x.toFixed(6));
         }
 
-        // Tamper with the 12th channel (one of the default sample indices [0, 12, 35, 57])
+        // Tamper with one of the dynamically derived sample indices
+        const sampleIndices = GpuPowSolver.deriveSampleIndices('127.0.0.1', 'gpu-pow-salt');
+        const tamperedIndex = sampleIndices[0];
         const tamperedSolutions = [...solutions];
-        const originalVal = parseFloat(tamperedSolutions[12]);
-        tamperedSolutions[12] = (originalVal + 0.0002).toFixed(6); // exceeding 1e-4 tolerance
-
-        expect(GpuPowSolver.verify(seed, iterations, tamperedSolutions.join(','))).toBe(false);
+        const originalVal = parseFloat(tamperedSolutions[tamperedIndex]);
+        tamperedSolutions[tamperedIndex] = (originalVal + 0.1).toFixed(6); // exceeding tolerance
+        const verificationResult = GpuPowSolver.verify(seed, iterations, tamperedSolutions.join(','), '127.0.0.1', 'gpu-pow-salt');
+        expect(verificationResult).toBe(false);
     });
 
     it('should fallback to WebGL2 if WebGPU is not supported', async () => {

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/AutoTuner.php

@@ -53,6 +53,47 @@ class AutoTuner
         $this->onCleanup = $options['onCleanup'] ?? null;
         $this->savePath = $options['savePath'] ?? null;
         $this->validationTolerance = $options['validationTolerance'] ?? 0.15;
+
+        if (isset($this->securityConfig['logger']) && is_callable($this->securityConfig['logger']) && !isset($this->securityConfig['logger_wrapped'])) {
+            $originalLogger = $this->securityConfig['logger'];
+            $maxPercentage = $this->securityConfig['autotuning']['maxDensityPercentage'] ?? 0.02;
+
+            $this->securityConfig['logger'] = function (array $log) use ($originalLogger, $maxPercentage) {
+                $ip = $log['clientIp'] ?? $log['ip'] ?? null;
+                $subnet = $ip ? RequestUtils::getIpSubnet($ip, 24, 48) : null;
+                $fp = $log['deviceHash'] ?? $log['fingerprint'] ?? $log['deviceFingerprint'] ?? null;
+                $stableFp = $fp ? RequestUtils::extractStablePart($fp) : null;
+
+                if (count($this->trafficData) > 0) {
+                    $total = count($this->trafficData);
+                    $ipMatchCount = 0;
+                    $fpMatchCount = 0;
+                    $matchedKey = null;
+
+                    foreach ($this->trafficData as $key => $existingLog) {
+                        $logIp = $existingLog['clientIp'] ?? $existingLog['ip'] ?? null;
+                        $logSubnet = $logIp ? RequestUtils::getIpSubnet($logIp, 24, 48) : null;
+                        $logFp = $existingLog['deviceHash'] ?? $existingLog['fingerprint'] ?? $existingLog['deviceFingerprint'] ?? null;
+                        $logStableFp = $logFp ? RequestUtils::extractStablePart($logFp) : null;
+
+                        $isIpMatch = $subnet && $logSubnet === $subnet;
+                        $isFpMatch = $stableFp && $logStableFp === $stableFp;
+                        if ($isIpMatch) $ipMatchCount++;
+                        if ($isFpMatch) $fpMatchCount++;
+                        if ($isIpMatch || $isFpMatch) $matchedKey = $key;
+                    }
+                    if (($subnet && ($ipMatchCount / $total) > $maxPercentage) || ($stableFp && ($fpMatchCount / $total) > $maxPercentage)) {
+                        if ($matchedKey !== null) {
+                            $this->trafficData[$matchedKey]['instancesCount'] = ($this->trafficData[$matchedKey]['instancesCount'] ?? 1) + 1;
+                            $this->trafficData[$matchedKey]['weight'] = ($this->trafficData[$matchedKey]['weight'] ?? 1.0) + 1.0;
+                        }
+                        return;
+                    }
+                }
+                $originalLogger($log);
+            };
+            $this->securityConfig['logger_wrapped'] = true;
+        }
     }
 
     /**

package/src/php/Challenge/ChallengeUtils.php

@@ -32,19 +32,40 @@ class ChallengeUtils
         return abs($hash % 1000000) / 1000000;
     }
 
-    public static function verifyGpuPow(string $seed, int $iterations, string $solution, array $sampleIndices = [0, 12, 35, 57]): bool
+    public static function deriveSampleIndices(string $clientIp, string $secret): array
+    {
+        $timeWindow = (int)floor(time() / (60 * 5));
+        $message = "{$clientIp}:{$timeWindow}";
+        $hmacHex = hash_hmac('sha256', $message, $secret ?: 'gpu-pow-salt');
+        $hmacBytes = array_values(unpack('C*', hex2bin($hmacHex)));
+
+        $indices = [];
+        for ($i = 0; $i < 4; $i++) {
+            $offset = ($i * 2) % count($hmacBytes);
+            $value = ($hmacBytes[$offset] << 8) | $hmacBytes[($offset + 1) % count($hmacBytes)];
+            $idx = $value % 64;
+            while (in_array($idx, $indices, true)) {
+                $idx = ($idx + 1) % 64;
+            }
+            $indices[] = $idx;
+        }
+        return $indices;
+    }
+
+    public static function verifyGpuPow(string $seed, int $iterations, string $solution, string $clientIp = '127.0.0.1', string $secret = 'gpu-pow-salt'): bool
     {
         $values = explode(',', $solution);
         if (count($values) !== 64) {
             return false;
         }
+        $sampleIndices = self::deriveSampleIndices($clientIp, $secret);
         $numericSeed = self::hashSeedToFloat($seed);
         $r = 3.9999;
         foreach ($sampleIndices as $idx) {
             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));
@@ -203,9 +224,22 @@ class ChallengeUtils
                 return ['error' => 'Missing signature'];
             }
 
-            // Ban the ZKP public key for 30 days
-            $store->set("banned-zkp-y:{$zkpY}", true, 86400 * 30);
-            return ['status' => 'synchronized'];
+            $peersKey = "fed-peers:{$zkpY}";
+            $reportedPeers = $store->get($peersKey) ?: [];
+            if (!is_array($reportedPeers)) {
+                $reportedPeers = [];
+            }
+            if (!in_array($clientIp, $reportedPeers, true)) {
+                $reportedPeers[] = $clientIp;
+                $store->set($peersKey, $reportedPeers, 86400 * 30);
+            }
+
+            $threshold = $config['federationConsensusThreshold'] ?? 3;
+            if (count($reportedPeers) >= $threshold) {
+                $store->set("banned-zkp-y:{$zkpY}", true, 86400 * 30);
+                return ['status' => 'synchronized', 'banned' => true];
+            }
+            return ['status' => 'synchronized', 'banned' => false, 'reportsCount' => count($reportedPeers)];
         }
 
         $nodeId = $params['node_id'] ?? '';

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
 
             ],

package/src/php/FingerprintEngine.php

@@ -803,8 +803,8 @@
          // Score d'anomalie de pile TCP/IP
          $tcpAnomaly = RequestUtils::getTcpAnomalyScore($context);
 
-         // Score d'anomalie de flux QUIC/HTTP3
-         $quicAnomaly = RequestUtils::getQuicAnomalyScore($context);
+         // Score d'anomalie de protocole (HTTP/2 et QUIC)
+         $protocolAnomaly = RequestUtils::getProtocolAnomalyScore($context);
 
          // Score d'anomalie de rendu d'affichage (V-Sync)
          $renderingAnomaly = RequestUtils::getRenderingAnomalyScore($context);
@@ -828,7 +828,7 @@
              'subnetScore' => $subnetScore['subnetScore'],
              'botnetClusterScore' => $botnetCluster['botnetClusterScore'],
              'tcpAnomalyScore' => $tcpAnomaly['tcpAnomalyScore'],
-             'quicAnomalyScore' => $quicAnomaly['quicAnomalyScore'],
+             'protocolAnomalyScore' => $protocolAnomaly['protocolAnomalyScore'],
              'renderingAnomalyScore' => $renderingAnomaly['renderingAnomalyScore'],
          ]);
  
@@ -1197,7 +1197,7 @@
          ]);
 
          // Mettre à jour les métriques du sous-réseau après le calcul du score final
-         if ($finalScore > ($thresholds['low'] ?? 20)) {
+         if ($finalScore >= ($thresholds['medium'] ?? 45)) {
             RequestUtils::updateSubnetMetrics($context, $deviceId, $finalScore);
             MetricsManager::observeValue('suspicion_score', $finalScore, ['action' => 'high_score_subnet_update']);
          }
@@ -1249,10 +1249,21 @@
                  // 1. Valider cryptographiquement la preuve avant de bannir/diffuser
                  if (ChallengeUtils::verifyZkpProof($zkpY, $zkpT, $zkpS)) {
                      // 2. Dédoublonner : Ne diffuser que si la clé n'est pas déjà bannie
-                     if (!$store->has("banned-zkp-y:{$zkpY}")) {
+                     $peersKey = "fed-peers:{$zkpY}";
+                     $reportedPeers = $store->get($peersKey) ?: [];
+                     if (!is_array($reportedPeers)) {
+                         $reportedPeers = [];
+                     }
+                     if (!in_array('local', $reportedPeers, true)) {
+                         $reportedPeers[] = 'local';
+                         $store->set($peersKey, $reportedPeers, 86400 * 30);
+                     }
+
+                     $threshold = $this->securityConfig['federationConsensusThreshold'] ?? 3;
+                     if (count($reportedPeers) >= $threshold) {
                          $store->set("banned-zkp-y:{$zkpY}", true, 86400 * 30);
-                         $this->broadcastBannedZkp($zkpY);
                      }
+                     $this->broadcastBannedZkp($zkpY);
                  }
              }
 

package/src/php/Optimization/FunctionRegistry.php

@@ -20,7 +20,7 @@ class FunctionRegistry
         if (empty(self::$functions)) {
             // Fonctions de "Scoring"
             self::$functions['tsp.calculateEnergy'] = [OptimizationUtils::class, 'evaluatePathDistance'];
-            self::$functions['portfolio.calculateMetrics'] = [OptimizationOperators::class, 'createPortfolioAllocator'];
+            self::$functions['portfolio.calculateMetrics'] = [OptimizationOperators::class, 'calculatePortfolioMetrics'];
             self::$functions['facility.calculateEnergy'] = [OptimizationOperators::class, 'evaluateFacilityLocation'];
 
             // Fonctions de "Résolution"