@anonympins/fingerprint 0.6.7 → 0.7.1

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) {

package/src/php/AutoTuner.php

@@ -8,18 +8,18 @@ use Anonympins\Fingerprint\Optimization\OptimizationOperators;
 use Anonympins\Fingerprint\Utils\RequestUtils;
 
 /**
- * Gère le processus d'auto-ajustement en arrière-plan pour les seuils et poids de sécurité.
- * Conçu pour être exécuté périodiquement (par exemple, via une tâche cron).
+ * Manages the background auto-tuning process for security thresholds and weights.
+ * Designed to be executed periodically (e.g. via a cron job).
  */
 class AutoTuner
 {
     /**
-     * @var array<string, mixed> La configuration de sécurité en direct qui sera mutée.
+     * @var array<string, mixed> Live security configuration that will be mutated.
      */
     private array $securityConfig;
 
     /**
-     * @var array<int, array<string, mixed>> Les données de trafic collectées.
+     * @var array<int, array<string, mixed>> Collected traffic data log.
      */
     private array $trafficData;
 
@@ -33,14 +33,14 @@ class AutoTuner
     private float $validationTolerance;
 
     /**
-     * @var ?array<string, mixed> La dernière meilleure solution trouvée par l'optimiseur.
+     * @var ?array<string, mixed> Last best solution found by the optimizer.
      */
     private static ?array $lastBestSolution = null;
 
     /**
-     * @param array<string, mixed> &$securityConfig La configuration de sécurité (passée par référence).
-     * @param array<int, array<string, mixed>> &$trafficData Les données de trafic (passées par référence).
-     * @param array<string, int> $options Options pour l'auto-ajustement.
+     * @param array<string, mixed> &$securityConfig Security configuration passed by reference.
+     * @param array<int, array<string, mixed>> &$trafficData Traffic logs passed by reference.
+     * @param array<string, int> $options Auto-tuning options.
      */
     public function __construct(array &$securityConfig, array &$trafficData, array $options = [])
     {
@@ -104,7 +104,7 @@ class AutoTuner
         $now = (int)(microtime(true) * 1000);
         $removed = [];
 
-        // 1. Expire par temps (maxAgeMs)
+        // 1. Time-based expiration (maxAgeMs)
         if ($this->maxAgeMs !== null && $this->maxAgeMs > 0) {
             $threshold = $now - $this->maxAgeMs;
             foreach ($this->trafficData as $key => $log) {
@@ -117,14 +117,14 @@ class AutoTuner
             $this->trafficData = array_values($this->trafficData);
         }
 
-        // 2. Politique de taille maximale (maxDataPoints)
+        // 2. Maximum dataset size enforcement (maxDataPoints)
         if ($this->maxDataPoints > 0 && count($this->trafficData) > $this->maxDataPoints) {
             $overflowCount = count($this->trafficData) - $this->maxDataPoints;
             $spliced = array_splice($this->trafficData, 0, $overflowCount);
             $removed = array_merge($removed, $spliced);
         }
 
-        // 3. Invocation du callback onCleanup
+        // 3. Execute cleanup callback
         if ($this->onCleanup !== null && is_callable($this->onCleanup) && !empty($removed)) {
             try {
                 call_user_func($this->onCleanup, $removed);
@@ -135,7 +135,7 @@ class AutoTuner
     }
 
     /**
-     * Exécute un cycle d'optimisation des seuils.
+     * Executes a threshold optimization cycle.
      */
     public function runOptimizationCycle(): void
     {
@@ -148,35 +148,35 @@ class AutoTuner
             fn ($log) => in_array($log['type'] ?? '', ['challenge_solved', 'trap_triggered'])
         ));
         $highConfidenceRatio = count($sanitizedData) > 0 ? $highConfidenceLogs / count($sanitizedData) : 0;
-        $minConfidenceRatio = 0.05; // Exiger au moins 5% de signaux forts.
-        $minHighConfidenceCount = 10; // Absolu de secours pour éviter le gel lors de floods
+        $minConfidenceRatio = 0.05; // Require at least 5% high-confidence signals
+        $minHighConfidenceCount = 10; // Fallback absolute count to avoid starvation during floods
 
         $hasEnoughSignal = $highConfidenceRatio >= $minConfidenceRatio || $highConfidenceLogs >= $minHighConfidenceCount;
 
         if (count($sanitizedData) < $this->minDataPoints || !$hasEnoughSignal) {
             if (count($sanitizedData) < $this->minDataPoints) {
-                echo sprintf("[AutoTuning] Reporté : %d/%d points de données.\n", count($sanitizedData), $this->minDataPoints);
+                echo sprintf("[AutoTuning] Postponed: %d/%d data points collected.\n", count($sanitizedData), $this->minDataPoints);
             } else {
-                echo sprintf("[AutoTuning] Reporté : Signaux de confiance insuffisants (Ratio: %.2f%% < %.2f%% et absolu: %d < %d).\n", $highConfidenceRatio * 100, $minConfidenceRatio * 100, $highConfidenceLogs, $minHighConfidenceCount);
+                echo sprintf("[AutoTuning] Postponed: Insufficient confidence signals (Ratio: %.2f%% < %.2f%% and count: %d < %d).\n", $highConfidenceRatio * 100, $minConfidenceRatio * 100, $highConfidenceLogs, $minHighConfidenceCount);
             }
             return;
         }
 
         if (count($this->trafficData) > $this->maxDataPoints) {
-            echo sprintf("[AutoTuning] Le journal de trafic a atteint %d entrées (max: %d). Troncation des données les plus anciennes.\n", count($this->trafficData), $this->maxDataPoints);
+            echo sprintf("[AutoTuning] Traffic log reached %d entries (max: %d). Truncating oldest logs.\n", count($this->trafficData), $this->maxDataPoints);
             $this->trafficData = array_slice($this->trafficData, count($this->trafficData) - $this->maxDataPoints);
         }
 
-        echo sprintf("[AutoTuning] Démarrage du cycle d'optimisation complet avec %d points de données assainis.\n", count($sanitizedData));
+        echo sprintf("[AutoTuning] Starting complete optimization cycle with %d sanitized data points.\n", count($sanitizedData));
 
         $paretoFront = OptimizationOperators::solveFullSecurityTuning(['trafficData' => $sanitizedData, 'currentConfig' => $this->securityConfig], []);
 
         if (empty($paretoFront)) {
-            echo "[AutoTuning] L'optimisation n'a retourné aucune solution.\n";
+            echo "[AutoTuning] Optimization returned no solutions.\n";
             return;
         }
 
-        // Règles de gardiennage (Sanity Guardrails) pour filtrer le front de Pareto
+        // Sanity guardrails to filter candidate Pareto solutions
         $isValidSecurityConfig = function (array $config): bool {
             if (!isset($config['weights']) || !isset($config['thresholds'])) return false;
             $w = $config['weights'];
@@ -192,13 +192,13 @@ class AutoTuner
 
         $filteredFront = array_filter($paretoFront, fn ($p) => $isValidSecurityConfig($p['solution']));
         if (empty($filteredFront)) {
-            echo "[AutoTuning] Attention : Toutes les solutions ont été rejetées par les règles de gardiennage. Rétablissement du front brut.\n";
+            echo "[AutoTuning] Warning: All Pareto solutions violated sanity guardrails. Restoring raw front.\n";
             $filteredFront = $paretoFront;
         } else {
             $filteredFront = array_values($filteredFront);
         }
 
-        // Stratégie de sélection : choisir la solution la plus équilibrée (la plus proche de l'origine).
+        // Selection strategy: pick the most balanced solution (closest to origin in objective space)
         $bestSolution = $filteredFront[0];
         $minDistance = sqrt(pow($bestSolution['objectives'][0], 2) + pow($bestSolution['objectives'][1], 2));
 
@@ -210,7 +210,7 @@ class AutoTuner
             }
         }
 
-        // Logique d'inertie pour l'application de la configuration.
+        // Inertial update logic to prevent drastic parameter jumps
         $newConfig = $bestSolution['solution'];
         $trafficConfidence = min(1.5, max(0.3, $highConfidenceRatio * 4));
 
@@ -254,7 +254,7 @@ class AutoTuner
             }
         };
 
-        // --- VALIDATION POST-CALCUL (PHP Rollback & Seuil de Tolérance) ---
+        // --- POST-COMPUTATION VALIDATION (Rollback guard & tolerance threshold) ---
         $tempConfig = [
             'thresholds' => $this->securityConfig['thresholds'],
             'weights' => $this->securityConfig['weights'],
@@ -300,22 +300,22 @@ class AutoTuner
 
         self::$lastBestSolution = $bestSolution;
 
-        echo "[AutoTuning] Nouvelle configuration de sécurité optimisée appliquée.\n";
-        echo "[AutoTuning] Objectifs atteints : " . json_encode([
+        echo "[AutoTuning] New optimized security configuration applied.\n";
+        echo "[AutoTuning] Objectives achieved: " . json_encode([
             'falsePositiveRate' => round($bestSolution['objectives'][0], 4),
             'falseNegativeRate' => round($bestSolution['objectives'][1], 4)
         ]) . "\n";
-        echo "[AutoTuning] Nouveaux seuils : " . json_encode($this->securityConfig['thresholds']) . "\n";
-        echo "[AutoTuning] Nouveaux poids : " . json_encode($this->securityConfig['weights']) . "\n";
-        echo "[AutoTuning] Nouveaux patterns : " . json_encode($this->securityConfig['patterns']) . "\n";
+        echo "[AutoTuning] New thresholds: " . json_encode($this->securityConfig['thresholds']) . "\n";
+        echo "[AutoTuning] New weights: " . json_encode($this->securityConfig['weights']) . "\n";
+        echo "[AutoTuning] New patterns: " . json_encode($this->securityConfig['patterns']) . "\n";
 
-        // NOUVEAU: Sauvegarder la meilleure configuration si un chemin est fourni.
+        // Persist best configuration if savePath is configured
         if ($this->savePath !== null) {
             try {
                 file_put_contents($this->savePath, json_encode($bestSolution['solution'], JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES));
-                echo "[AutoTuning] Meilleure configuration sauvegardée dans : {$this->savePath}\n";
+                echo "[AutoTuning] Best configuration saved to: {$this->savePath}\n";
             } catch (\Throwable $e) {
-                error_log("[AutoTuning] Erreur lors de la sauvegarde de la configuration optimisée : " . $e->getMessage());
+                error_log("[AutoTuning] Error saving optimized configuration: " . $e->getMessage());
             }
         }
 
@@ -333,7 +333,7 @@ class AutoTuner
     }
 
     /**
-     * Retourne la dernière meilleure solution trouvée par l'auto-tuner.
+     * Returns the latest best solution found by the auto-tuner.
      * @return array<string, mixed>|null
      */
     public static function getBestTuningSolution(): ?array
@@ -342,7 +342,7 @@ class AutoTuner
     }
 
     /**
-     * Réinitialise la meilleure solution statique. Utile pour les tests.
+     * Resets the static best solution. Intended for testing.
      * @internal
      */
     public static function resetBestTuningSolution(): void

package/src/php/Challenge/ChallengeUtils.php

@@ -15,9 +15,13 @@ use Anonympins\Fingerprint\Utils\RequestUtils;
  */
 class ChallengeUtils
 {
+    /** @var array<string, float> Cache local des floats convertis pour éviter les appels système pack/unpack */
+    private static array $froundCache = [];
+
     private static function fround(float $value): float
     {
-        return unpack('f', pack('f', $value))[1];
+        $key = (string)$value;
+        return self::$froundCache[$key] ?? (self::$froundCache[$key] = unpack('f', pack('f', $value))[1]);
     }
 
     public static function hashSeedToFloat(string $seed): float
@@ -261,6 +265,15 @@ class ChallengeUtils
             case 'register':
                 $expectedMsg = "{$clientSecret}:register:{$nodeId}:" . ($params['seed'] ?? '');
                 break;
+            case 'find_peer':
+                $expectedMsg = "{$clientSecret}:find_peer:{$nodeId}";
+                break;
+            case 'webrtc_signal':
+                $expectedMsg = "{$clientSecret}:webrtc_signal:{$nodeId}:" . ($params['target_peer_id'] ?? '') . ":" . ($params['signal_type'] ?? '') . ":" . ($params['signal_data'] ?? '');
+                break;
+            case 'poll_signals':
+                $expectedMsg = "{$clientSecret}:poll_signals:{$nodeId}";
+                break;
             case 'request_peer_block':
                 $expectedMsg = "{$clientSecret}:request_peer_block:{$nodeId}:" . ($params['peer_id'] ?? '') . ":" . ($params['block_idx'] ?? '0') . ":" . ($params['req_id'] ?? '');
                 break;
@@ -290,6 +303,38 @@ class ChallengeUtils
                 self::registerCooperativeNode($clientIp, $nodeId, $seed);
                 return ['status' => 'registered'];
 
+            case 'find_peer':
+                $peer = self::findPeerInSubnet($clientIp, $nodeId);
+                if ($peer !== null) {
+                    return ['status' => 'peer_found', 'peer_id' => $peer['nodeId'], 'seed' => $peer['seed']];
+                }
+                return ['status' => 'no_peers'];
+
+            case 'webrtc_signal':
+                $targetPeerId = $params['target_peer_id'] ?? '';
+                $signalType = $params['signal_type'] ?? '';
+                $signalData = $params['signal_data'] ?? '';
+                if (empty($targetPeerId) || empty($signalType) || empty($signalData)) {
+                    return ['error' => 'Invalid parameters'];
+                }
+                $signalQueueKey = "coop-webrtc:signals:{$targetPeerId}";
+                $signals = $store->get($signalQueueKey) ?? [];
+                $signals[] = [
+                    'from_peer_id' => $nodeId,
+                    'signal_type' => $signalType,
+                    'signal_data' => $signalData
+                ];
+                $store->set($signalQueueKey, $signals, 30);
+                return ['status' => 'signal_queued'];
+
+            case 'poll_signals':
+                $pollSignalKey = "coop-webrtc:signals:{$nodeId}";
+                $signals = $store->get($pollSignalKey) ?? [];
+                if (!empty($signals)) {
+                    $store->delete($pollSignalKey);
+                }
+                return ['status' => 'ok', 'signals' => $signals];
+
             case 'request_peer_block':
                 $peerId = $params['peer_id'] ?? '';
                 $blockIdx = (int)($params['block_idx'] ?? 0);
@@ -650,8 +695,8 @@ class ChallengeUtils
     public static function calculateCpuTarget(float $suspicionFactor, array $securityConfig): string
     {
         $cpuConfig = $securityConfig['cpu'] ?? [];
-        $minDifficultyBits = $cpuConfig['minDifficultyBits'] ?? 8;
-        $maxDifficultyBits = $cpuConfig['maxDifficultyBits'] ?? 24;
+        $minDifficultyBits = (float)($cpuConfig['minDifficultyBits'] ?? 4);
+        $maxDifficultyBits = (float)($cpuConfig['maxDifficultyBits'] ?? 22);
 
         $totalDifficultyBits = $minDifficultyBits + $suspicionFactor * ($maxDifficultyBits - $minDifficultyBits);
 
@@ -690,6 +735,18 @@ class ChallengeUtils
         string $deviceId = '',
         string $deviceHash = ''
     ): ?string {
+        // En mode HTTP (non sécurisé), aucun calcul SHA-256 n'est exigé
+        if (!empty($challengeContext['isHttp'])) {
+            error_log('[FP Server Verify] Mode HTTP détecté (insecure policy) : validation sans SHA-256 acceptée.');
+            $expiry = (int)floor(microtime(true) * 1000) + $ticketTtl;
+            return self::generateStatelessTicket([
+                'expiry' => $expiry,
+                'originalIp' => $clientIp,
+                'deviceId' => $deviceId,
+                'deviceHash' => $deviceHash
+            ]);
+        }
+
         $cpuTargetHex = $challengeContext['cpuTarget'] ?? null;
         $baseBlock = $challengeContext['baseBlock'] ?? null;
 
@@ -826,6 +883,9 @@ class ChallengeUtils
         int $difficulty,
         string $clientSecret
     ): bool {
+        if ($difficulty === 0) {
+            return true;
+        }
         $maxAllowedMemDifficulty = 128; // 128MB
         if ($difficulty > $maxAllowedMemDifficulty) {
             error_log("[Security] Memory PoW verification attempt with excessive difficulty: {$difficulty}MB. Denied.");
@@ -951,13 +1011,27 @@ class ChallengeUtils
      */
     private static function getPowSolverCode(): string
     {
-        // Le chemin doit être relatif à ce fichier ou absolu.
-        $solverPath = __DIR__ . '/../../js/pow.solver.inline.js';
-        if (!file_exists($solverPath)) {
-            error_log("[ChallengeUtils] Erreur: Le fichier pow.solver.inline.js n'a pas été trouvé à l'emplacement attendu.");
-            return '';
+        $candidates = [
+            __DIR__ . '/../../js/pow.solver.inline.js',
+            __DIR__ . '/../assets/pow.solver.inline.js',
+            __DIR__ . '/../js/pow.solver.inline.js',
+            dirname(__DIR__, 2) . '/assets/pow.solver.inline.js',
+            dirname(__DIR__, 2) . '/js/pow.solver.inline.js',
+            dirname(__DIR__, 1) . '/assets/pow.solver.inline.js',
+        ];
+        if (defined('ABSPATH')) {
+            $wpPluginSolver = ABSPATH . 'wp-content/plugins/fingerprint-wordpress/assets/pow.solver.inline.js';
+            if (file_exists($wpPluginSolver)) {
+                return file_get_contents($wpPluginSolver) ?: '';
+            }
         }
-        return file_get_contents($solverPath) ?: '';
+        foreach ($candidates as $solverPath) {
+            if (file_exists($solverPath)) {
+                return file_get_contents($solverPath) ?: '';
+            }
+        }
+        error_log("[ChallengeUtils] Erreur: Le fichier pow.solver.inline.js n'a pas été trouvé à l'emplacement attendu.");
+        return '';
     }
 
     public static function generateSpaceChallengePage(array $challengeDetails, string $clientSecret, array $securityConfig): string
@@ -998,6 +1072,11 @@ class ChallengeUtils
               return Array.from(new Uint8Array(hashBuffer)).map(b => b.toString(16).padStart(2, '0')).join('');
             }
             
+            async function sendWebRtcSignal(targetId, type, data) {
+              const sig = await signCoop("webrtc_signal", nodeId, targetId + ":" + type + ":" + data);
+              await fetch(window.location.pathname + "?coop_op=webrtc_signal&node_id=" + nodeId + "&target_peer_id=" + targetId + "&signal_type=" + type + "&signal_data=" + encodeURIComponent(data) + "&coop_sig=" + sig);
+            }
+
             document.getElementById('loader').innerText = '⚙️ Checking persistent local storage...';
             await new Promise(r => setTimeout(r, 10));
             
@@ -1009,9 +1088,50 @@ class ChallengeUtils
                     const sig = await signCoop("register", nodeId, nonce + ":" + clientSecret);
                     await fetch(window.location.pathname + "?coop_op=register&node_id=" + nodeId + "&seed=" + encodeURIComponent(nonce + ":" + clientSecret) + "&coop_sig=" + sig);
                 }
+
+                const peerConnections = {};
                 
-                // Écoute des requêtes entrantes de nos pairs suspects
+                // Écoute des signaux WebRTC et requêtes entrantes
                 setInterval(async () => {
+                    try {
+                        const sigWebrtc = await signCoop("poll_signals", nodeId);
+                        const resWebrtc = await fetch(window.location.pathname + "?coop_op=poll_signals&node_id=" + nodeId + "&coop_sig=" + sigWebrtc);
+                        const dataWebrtc = await resWebrtc.json();
+                        if (dataWebrtc.signals && dataWebrtc.signals.length > 0) {
+                            for (const sig of dataWebrtc.signals) {
+                                const fromId = sig.from_peer_id;
+                                if (sig.signal_type === 'offer') {
+                                    const pc = new RTCPeerConnection({ iceServers: [] });
+                                    peerConnections[fromId] = pc;
+                                    pc.onicecandidate = (e) => {
+                                        if (e.candidate) sendWebRtcSignal(fromId, 'candidate', JSON.stringify(e.candidate));
+                                    };
+                                    pc.ondatachannel = (e) => {
+                                        const dc = e.channel;
+                                        dc.onmessage = async (evt) => {
+                                            try {
+                                                const req = JSON.parse(evt.data);
+                                                if (req.type === 'get_block') {
+                                                    document.getElementById('loader').innerText = '📤 Transfert direct P2P (WebRTC) du bloc vers le pair...';
+                                                    const blockData = await window.readSpaceBlock(req.block_idx);
+                                                    dc.send(JSON.stringify({ type: 'block_data', block_data: blockData }));
+                                                }
+                                            } catch (err) {}
+                                        };
+                                    };
+                                    await pc.setRemoteDescription(new RTCSessionDescription(JSON.parse(sig.signal_data)));
+                                    const answer = await pc.createAnswer();
+                                    await pc.setLocalDescription(answer);
+                                    await sendWebRtcSignal(fromId, 'answer', JSON.stringify(answer));
+                                } else if (sig.signal_type === 'answer' && peerConnections[fromId]) {
+                                    await peerConnections[fromId].setRemoteDescription(new RTCSessionDescription(JSON.parse(sig.signal_data)));
+                                } else if (sig.signal_type === 'candidate' && peerConnections[fromId]) {
+                                    await peerConnections[fromId].addIceCandidate(new RTCIceCandidate(JSON.parse(sig.signal_data)));
+                                }
+                            }
+                        }
+                    } catch (e) {}
+
                     try {
                         const sig = await signCoop("poll_requests", nodeId);
                         const res = await fetch(window.location.pathname + "?coop_op=poll_requests&node_id=" + nodeId + "&coop_sig=" + sig);
@@ -1027,30 +1147,65 @@ class ChallengeUtils
                     } catch (e) {
                         console.error("Cooperative polling error", e);
                     }
-                }, 1000);
+                }, 800);
                 
-                // Téléchargement du bloc du pair si configuré
                 let peerBlock = "";
                 if (peerId && peerBlockIdx !== -1) {
-                    document.getElementById('loader').innerText = '📥 Téléchargement du bloc de validation du pair (' + peerId + ')...';
-                    const reqId = Math.random().toString(36).substring(2);
-                    const reqSig = await signCoop("request_peer_block", nodeId, peerId + ":" + peerBlockIdx + ":" + reqId);
-                    await fetch(window.location.pathname + "?coop_op=request_peer_block&node_id=" + nodeId + "&peer_id=" + peerId + "&block_idx=" + peerBlockIdx + "&req_id=" + reqId + "&coop_sig=" + reqSig);
-                    
-                    let attempts = 0;
-                    while (attempts < coopTimeout) {
-                        const pollSig = await signCoop("poll_response", nodeId, reqId);
-                        const res = await fetch(window.location.pathname + "?coop_op=poll_response&node_id=" + nodeId + "&req_id=" + reqId + "&coop_sig=" + pollSig);
-                        const data = await res.json();
-                        if (data.status === 'ready') {
-                            peerBlock = data.block_data;
-                            break;
+                    document.getElementById('loader').innerText = '📥 Connexion WebRTC P2P directe au pair (' + peerId + ')...';
+
+                    // 1. Échange direct P2P via WebRTC DataChannel (charge serveur = 0)
+                    const webrtcTransferPromise = new Promise(async (resolve) => {
+                        if (!window.RTCPeerConnection) return resolve(null);
+                        try {
+                            const pc = new RTCPeerConnection({ iceServers: [] });
+                            peerConnections[peerId] = pc;
+                            const dc = pc.createDataChannel("pospace-transfer");
+                            pc.onicecandidate = (e) => {
+                                if (e.candidate) sendWebRtcSignal(peerId, 'candidate', JSON.stringify(e.candidate));
+                            };
+                            dc.onopen = () => {
+                                dc.send(JSON.stringify({ type: 'get_block', block_idx: peerBlockIdx }));
+                            };
+                            dc.onmessage = (e) => {
+                                try {
+                                    const msg = JSON.parse(e.data);
+                                    if (msg.type === 'block_data' && msg.block_data) {
+                                        resolve(msg.block_data);
+                                    }
+                                } catch (err) {}
+                            };
+                            const offer = await pc.createOffer();
+                            await pc.setLocalDescription(offer);
+                            await sendWebRtcSignal(peerId, 'offer', JSON.stringify(offer));
+                        } catch (err) {
+                            resolve(null);
+                        }
+                    });
+
+                    const webrtcTimeoutPromise = new Promise((resolve) => setTimeout(() => resolve(null), 5000));
+                    peerBlock = await Promise.race([webrtcTransferPromise, webrtcTimeoutPromise]);
+
+                    if (peerBlock) {
+                        document.getElementById('loader').innerText = '⚡ Bloc reçu en direct via WebRTC P2P sans transit serveur !';
+                    } else {
+                        // 2. Repli vers le relais HTTP si WebRTC échoue
+                        document.getElementById('loader').innerText = '⚠️ WebRTC indisponible. Téléchargement via relais HTTP...';
+                        const reqId = Math.random().toString(36).substring(2);
+                        const reqSig = await signCoop("request_peer_block", nodeId, peerId + ":" + peerBlockIdx + ":" + reqId);
+                        await fetch(window.location.pathname + "?coop_op=request_peer_block&node_id=" + nodeId + "&peer_id=" + peerId + "&block_idx=" + peerBlockIdx + "&req_id=" + reqId + "&coop_sig=" + reqSig);
+                        
+                        let attempts = 0;
+                        while (attempts < coopTimeout) {
+                            const pollSig = await signCoop("poll_response", nodeId, reqId);
+                            const res = await fetch(window.location.pathname + "?coop_op=poll_response&node_id=" + nodeId + "&req_id=" + reqId + "&coop_sig=" + pollSig);
+                            const data = await res.json();
+                            if (data.status === 'ready') {
+                                peerBlock = data.block_data;
+                                break;
+                            }
+                            await new Promise(r => setTimeout(r, 1000));
+                            attempts++;
                         }
-                        await new Promise(r => setTimeout(r, 1000));
-                        attempts++;
-                    }
-                    if (!peerBlock) {
-                        document.getElementById('loader').innerText = '⚠️ Peer de sous-réseau injoignable. Validation solo...';
                     }
                 }
                 
@@ -1084,14 +1239,21 @@ JS;
         string $clientSecret,
         array $securityConfig,
         array $trapUrls,
-        string $originalFingerprint
+        string $originalFingerprint,
+        string $clientIp = '',
+        string $tlsSessionId = '',
+        ?string $baseBlock = null,
+        bool $isHttps = true
     ): string {
         $nonce = $cpuChallengeDetails['nonce'];
         $target = $cpuChallengeDetails['target']; // @phpstan-ignore-line
         $path = $cpuChallengeDetails['path'];
+        $isHttp = !$isHttps;
 
         $solverCode = self::getPowSolverCode();
-        $baseBlock = self::createCpuChallengeBaseBlock($nonce, $clientSecret, $originalFingerprint);
+        if ($baseBlock === null || $baseBlock === '') {
+            $baseBlock = self::createCpuChallengeBaseBlock($nonce, $clientSecret, $originalFingerprint, $clientIp, $tlsSessionId);
+        }
         $baseBlockBytes = '[' . implode(',', array_values(unpack('C*', $baseBlock))) . ']';
 
         $trapTags = ['div', 'span', 'p', 'section'];
@@ -1115,16 +1277,26 @@ JS;
         $safePath = json_encode($path, JSON_HEX_TAG | JSON_HEX_AMP | JSON_HEX_APOS | JSON_HEX_QUOT | JSON_UNESCAPED_SLASHES);
         $safeNonce = json_encode($nonce, JSON_HEX_TAG | JSON_HEX_AMP | JSON_HEX_APOS | JSON_HEX_QUOT | JSON_UNESCAPED_SLASHES);
         $safeClientSecret = json_encode($clientSecret, JSON_HEX_TAG | JSON_HEX_AMP | JSON_HEX_APOS | JSON_HEX_QUOT | JSON_UNESCAPED_SLASHES);
+        $isHttpJs = $isHttp ? 'true' : 'false';
 
         $challengeScript = <<<JS
           async function solve() {
             const nonce = {$safeNonce};
             const path = {$safePath};
             const clientSecret = {$safeClientSecret};
+            const isHttp = {$isHttpJs};
             const cpuTarget = BigInt("0x" + "{$target}");
             const memDifficulty = {$memoryDifficulty};
             const baseBlock = new Uint8Array({$baseBlockBytes});
 
+            if (isHttp) {
+                document.getElementById('loader').innerText = '⚠️ Connexion HTTP non sécurisée : validation simplifiée en cours...';
+                await new Promise(r => setTimeout(r, 150));
+                const finalUrl = path + "?pow_type=cpu_mem&pow_nonce=" + nonce + "&pow_solution_cpu=http_simulacre_ack&pow_solution_mem=0";
+                window.location.href = finalUrl;
+                return;
+            }
+
             document.getElementById('loader').innerText = '⚙️ Performing CPU security calculation...';
             const cpuSolution = await window.solveCpuChallengeInline(baseBlock, cpuTarget, (progress) => {});