@anonympins/fingerprint 0.4.6 → 0.5.0

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

@@ -1,5 +1,5 @@
 import {afterEach, assert, beforeEach, describe, expect, it, test, vi} from 'vitest';
-import {createHash, createHmac} from 'node:crypto';
+import {createHash, createHmac, generateKeyPairSync} from 'node:crypto';
 import {solveCpuTargetInline, solveMemory} from '../pow.solver.js';
 import {readFileSync} from 'node:fs';
 import {cyrb53, FingerprintBuilder} from '../fingerprint.builder.js';
@@ -1092,6 +1092,63 @@ describe('Fingerprint & PoW Security Suite', () => {
             stopThresholdAutoTuning(); // Ensure cleanup after each test
         });
 
+    test('should prune traffic data based on time, size, clearAfterTuning and invoke onCleanup', async () => {
+        const trafficData = [
+            { type: 'challenge_solved', timestamp: Date.now() - 10000 }, // 10s old
+            { type: 'challenge_solved', timestamp: Date.now() - 5000 },  // 5s old
+            { type: 'challenge_solved', timestamp: Date.now() }          // fresh
+        ];
+
+        const securityConfig = {
+            thresholds: { low: 20, medium: 45, high: 75, block: 95 },
+            weights: { historyScore: 1 },
+            patterns: {}
+        };
+
+        const cleanedLogs = [];
+        const onCleanup = (removed) => {
+            cleanedLogs.push(...removed);
+        };
+
+        // Test 1: Time-based pruning (older than 8 seconds)
+        __internal.pruneTrafficData(trafficData, 10, 8000, onCleanup);
+
+        expect(trafficData.length).toBe(2);
+        expect(cleanedLogs.length).toBe(1);
+        expect(cleanedLogs[0].timestamp).toBeLessThan(Date.now() - 8000);
+
+        // Test 2: Size-based pruning (max size = 1)
+        __internal.pruneTrafficData(trafficData, 1, 0, onCleanup);
+        expect(trafficData.length).toBe(1);
+        expect(cleanedLogs.length).toBe(2);
+
+        // Test 3: Clear after tuning
+        const autoTuningTraffic = [];
+        for (let i = 0; i < 110; i++) {
+            autoTuningTraffic.push({ type: 'challenge_solved', timestamp: Date.now(), deviceId: `dev-solved-${i}` });
+            autoTuningTraffic.push({ type: 'request_passed', timestamp: Date.now(), deviceId: `dev-passed-${i}` });
+        }
+
+        const tuningCleaned = [];
+        startThresholdAutoTuning({
+            securityConfig,
+            trafficData: autoTuningTraffic,
+            interval: 10000,
+            minDataPoints: 100,
+            maxDataPoints: 500,
+            clearAfterTuning: true,
+            onCleanup: (removed) => tuningCleaned.push(...removed)
+        });
+
+        const intervalCallback = setIntervalSpy.mock.calls[0][0];
+        intervalCallback();
+
+        expect(autoTuningTraffic.length).toBe(0);
+        expect(tuningCleaned.length).toBeGreaterThan(0);
+
+        stopThresholdAutoTuning();
+    });
+
         test('should start, run an optimization cycle, and update thresholds', () => {
             const trafficData = [];
             const securityConfig = {
@@ -2426,6 +2483,80 @@ describe('Additional Suspicion Vectors Coverage', () => {
     });
 });
 
+describe('Ed25519 Asymmetric Tickets', () => {
+    const { privateKey, publicKey } = generateKeyPairSync('ed25519', {
+        privateKeyEncoding: { format: 'pem', type: 'pkcs8' },
+        publicKeyEncoding: { format: 'pem', type: 'spki' }
+    });
+    const privateKeyPem = privateKey;
+    const publicKeyPem = publicKey;
+
+    beforeEach(() => {
+        process.env.ED25519_PRIVATE_KEY = privateKeyPem;
+        process.env.ED25519_PUBLIC_KEY = publicKeyPem;
+    });
+
+    afterEach(() => {
+        delete process.env.ED25519_PRIVATE_KEY;
+        delete process.env.ED25519_PUBLIC_KEY;
+    });
+
+    it('should generate and validate an Ed25519 ticket successfully', async () => {
+        const payload = {
+            expiry: Date.now() + 3600000,
+            originalIp: '127.0.0.1',
+            deviceId: 'device-123',
+            deviceHash: 'hash-abc'
+        };
+
+        const ticket = fingerprint.generateStatelessTicket(payload);
+        expect(ticket).toBeDefined();
+        expect(ticket.startsWith('ed25519.')).toBe(true);
+
+        const isValid = await fingerprint.isTicketValid('127.0.0.1', ticket, 'device-123', 'hash-abc');
+        expect(isValid).toBe(true);
+
+        const isDiffIpValid = await fingerprint.isTicketValid('192.168.1.1', ticket, 'device-123', 'hash-abc', false);
+        expect(isDiffIpValid).toBe(false);
+    });
+
+    test('Cooperative PoSpace Workflow', async () => {
+        const clientIp = '127.0.0.1';
+        const nodeIdA = 'node-a';
+        const seedA = 'seed-a';
+
+        // 1. Enregistrement du nœud A (pair)
+        await __internal.registerCooperativeNode(clientIp, nodeIdA, seedA);
+
+        // 2. Recherche de pair pour le nœud B (dans le même sous-réseau)
+        const peer = await __internal.findPeerInSubnet(clientIp, 'node-b');
+        expect(peer).not.toBeNull();
+        expect(peer.nodeId).toBe(nodeIdA);
+        expect(peer.seed).toBe(seedA);
+
+        // 3. Demande de bloc du nœud B vers le nœud A
+        const paramsReq = {
+            coop_op: 'request_peer_block',
+            node_id: 'node-b',
+            peer_id: 'node-a',
+            block_idx: '42',
+            req_id: 'req-123'
+        };
+        const resReq = await __internal.handleCooperativeRequest(paramsReq, clientIp);
+        expect(resReq.status).toBe('queued');
+
+        // 4. Récupération de la demande par le nœud A
+        const paramsPoll = {
+            coop_op: 'poll_requests',
+            node_id: 'node-a'
+        };
+        const resPoll = await __internal.handleCooperativeRequest(paramsPoll, clientIp);
+        expect(resPoll.requests.length).toBe(1);
+        expect(resPoll.requests[0].req_id).toBe('req-123');
+        expect(resPoll.requests[0].block_idx).toBe(42);
+    });
+});
+
 describe('Botnet Cluster Scoring (Node.js)', () => {
     const inMemoryStore = {
         _map: new Map(),

package/src/js/tests/ja3AnomalyDetector.test.js

@@ -1,6 +1,7 @@
 import crypto from 'crypto';
 import {getTlsSpoofingScore, parseJa3} from '../fingerprint.js';
 import {vi} from 'vitest';
+import { verifyZkpProof, decodePolymorphicFingerprint, deepMerge, getHeaderSignature, parseJa3, modPow, hashNetwork, normalizeReferer, isPrivateIp, parseUserAgent } from "../../js/fingerprint.utils.js";
 
 describe('JA3 Anomaly Detector (Node.js)', () => {
     

package/src/php/AutoTuner.php

@@ -25,6 +25,11 @@ class AutoTuner
 
     private int $minDataPoints;
     private int $maxDataPoints;
+    private ?int $maxAgeMs;
+    private bool $clearAfterTuning;
+    /** @var ?callable */
+    private $onCleanup;
+    private ?string $savePath;
 
     /**
      * @var ?array<string, mixed> La dernière meilleure solution trouvée par l'optimiseur.
@@ -42,6 +47,48 @@ class AutoTuner
         $this->trafficData = &$trafficData;
         $this->minDataPoints = $options['minDataPoints'] ?? 200;
         $this->maxDataPoints = $options['maxDataPoints'] ?? 10000;
+        $this->maxAgeMs = $options['maxAgeMs'] ?? null;
+        $this->clearAfterTuning = $options['clearAfterTuning'] ?? false;
+        $this->onCleanup = $options['onCleanup'] ?? null;
+        $this->savePath = $options['savePath'] ?? null;
+    }
+
+    /**
+     * Prunes old or excess traffic logs to prevent memory leaks.
+     */
+    private function pruneTrafficData(): void
+    {
+        $now = (int)(microtime(true) * 1000);
+        $removed = [];
+
+        // 1. Expire par temps (maxAgeMs)
+        if ($this->maxAgeMs !== null && $this->maxAgeMs > 0) {
+            $threshold = $now - $this->maxAgeMs;
+            foreach ($this->trafficData as $key => $log) {
+                $logTs = $log['timestamp'] ?? $log['requestTimestamp'] ?? $now;
+                if ($logTs < $threshold) {
+                    $removed[] = $log;
+                    unset($this->trafficData[$key]);
+                }
+            }
+            $this->trafficData = array_values($this->trafficData);
+        }
+
+        // 2. Politique de taille maximale (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
+        if ($this->onCleanup !== null && is_callable($this->onCleanup) && !empty($removed)) {
+            try {
+                call_user_func($this->onCleanup, $removed);
+            } catch (\Throwable $e) {
+                error_log("[AutoTuning] Error in onCleanup callback: " . $e->getMessage());
+            }
+        }
     }
 
     /**
@@ -49,6 +96,8 @@ class AutoTuner
      */
     public function runOptimizationCycle(): void
     {
+        $this->pruneTrafficData();
+
         $sanitizedData = RequestUtils::sanitizeTrafficData($this->trafficData);
 
         $highConfidenceLogs = count(array_filter(
@@ -176,6 +225,28 @@ class AutoTuner
         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";
+
+        // NOUVEAU: Sauvegarder la meilleure configuration si un chemin est fourni.
+        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";
+            } catch (\Throwable $e) {
+                error_log("[AutoTuning] Erreur lors de la sauvegarde de la configuration optimisée : " . $e->getMessage());
+            }
+        }
+
+        if ($this->clearAfterTuning) {
+            $cleared = array_splice($this->trafficData, 0);
+            if ($this->onCleanup !== null && is_callable($this->onCleanup) && !empty($cleared)) {
+                try {
+                    call_user_func($this->onCleanup, $cleared);
+                } catch (\Throwable $e) {
+                    error_log("[AutoTuning] Error in onCleanup callback after clearing: " . $e->getMessage());
+                }
+            }
+            echo sprintf("[AutoTuning] Explicitly cleared %d processed traffic data points.\n", count($cleared));
+        }
     }
 
     /**

package/src/php/Challenge/ChallengeUtils.php

@@ -48,6 +48,123 @@ class ChallengeUtils
         return $block;
     }
 
+    public static function registerCooperativeNode(string $clientIp, string $nodeId, string $seed): void
+    {
+        $subnet = RequestUtils::getIpSubnet($clientIp);
+        if ($subnet === null) {
+            return;
+        }
+        $store = StoreManager::getStore();
+        $key = "coop-pospace:subnet:{$subnet}";
+        $nodes = $store->get($key) ?? [];
+        
+        $now = time();
+        // Nettoyage des nœuds expirés (vieux de plus de 2 minutes)
+        $nodes = array_filter($nodes, fn($n) => ($now - $n['timestamp']) < 120);
+        
+        $nodes[$nodeId] = [
+            'nodeId' => $nodeId,
+            'seed' => $seed,
+            'timestamp' => $now
+        ];
+        
+        $store->set($key, $nodes, 120);
+    }
+
+    public static function findPeerInSubnet(string $clientIp, string $excludeNodeId): ?array
+    {
+        $subnet = RequestUtils::getIpSubnet($clientIp);
+        if ($subnet === null) {
+            return null;
+        }
+        $store = StoreManager::getStore();
+        $key = "coop-pospace:subnet:{$subnet}";
+        $nodes = $store->get($key) ?? [];
+        
+        $now = time();
+        $activePeers = [];
+        foreach ($nodes as $id => $node) {
+            if ($id !== $excludeNodeId && ($now - $node['timestamp']) < 120) {
+                $activePeers[] = $node;
+            }
+        }
+        
+        if (empty($activePeers)) {
+            return null;
+        }
+        
+        return $activePeers[array_rand($activePeers)];
+    }
+
+    public static function handleCooperativeRequest(array $params): ?array
+    {
+        $op = $params['coop_op'] ?? null;
+        if (!$op) {
+            return null;
+        }
+
+        $store = StoreManager::getStore();
+        $nodeId = $params['node_id'] ?? '';
+        if (empty($nodeId)) {
+            return ['error' => 'Missing node_id'];
+        }
+
+        switch ($op) {
+            case 'register':
+                $clientIp = $_SERVER['REMOTE_ADDR'] ?? '127.0.0.1';
+                $seed = $params['seed'] ?? '';
+                self::registerCooperativeNode($clientIp, $nodeId, $seed);
+                return ['status' => 'registered'];
+
+            case 'request_peer_block':
+                $peerId = $params['peer_id'] ?? '';
+                $blockIdx = (int)($params['block_idx'] ?? 0);
+                $requestId = $params['req_id'] ?? '';
+                if (empty($peerId) || empty($requestId)) {
+                    return ['error' => 'Invalid parameters'];
+                }
+                
+                $queueKey = "coop-mailbox:queue:{$peerId}";
+                $requests = $store->get($queueKey) ?? [];
+                $requests[] = [
+                    'req_id' => $requestId,
+                    'requester_id' => $nodeId,
+                    'block_idx' => $blockIdx
+                ];
+                $store->set($queueKey, $requests, 30);
+                return ['status' => 'queued'];
+
+            case 'poll_requests':
+                $queueKey = "coop-mailbox:queue:{$nodeId}";
+                $requests = $store->get($queueKey) ?? [];
+                $store->delete($queueKey);
+                return ['requests' => $requests];
+
+            case 'respond_block':
+                $requesterId = $params['requester_id'] ?? '';
+                $requestId = $params['req_id'] ?? '';
+                $blockData = $params['block_data'] ?? '';
+                if (empty($requesterId) || empty($requestId)) {
+                    return ['error' => 'Invalid parameters'];
+                }
+                
+                $responseKey = "coop-mailbox:res:{$requesterId}:{$requestId}";
+                $store->set($responseKey, ['block_data' => $blockData], 30);
+                return ['status' => 'delivered'];
+
+            case 'poll_response':
+                $requestId = $params['req_id'] ?? '';
+                $responseKey = "coop-mailbox:res:{$nodeId}:{$requestId}";
+                $data = $store->get($responseKey);
+                if ($data) {
+                    $store->delete($responseKey);
+                    return ['status' => 'ready', 'block_data' => $data['block_data']];
+                }
+                return ['status' => 'pending'];
+        }
+        return null;
+    }
+
     public static function generateSpaceChallenge(string $clientIp, string $nonce, float $suspicionFactor, string $originalUrl, array $securityConfig): array
     {
         $pospaceConfig = $securityConfig['pospace'] ?? [];
@@ -63,13 +180,29 @@ class ChallengeUtils
             }
         }
 
-        return [
+        $challenge = [
             'type' => 'pospace',
             'nonce' => $nonce,
             'sizeMb' => $sizeMb,
             'queries' => $queries,
             'path' => $originalUrl
         ];
+
+        // Tentative de couplage coopératif avec un nœud du même sous-réseau
+        $peer = self::findPeerInSubnet($clientIp, $nonce);
+        if ($peer !== null) {
+            $challenge['peerId'] = $peer['nodeId'];
+            $challenge['peerBlockIdx'] = random_int(0, $maxBlocks - 1);
+            
+            $store = StoreManager::getStore();
+            $store->set("coop-assoc:{$nonce}", [
+                'peerNodeId' => $peer['nodeId'],
+                'peerSeed' => $peer['seed'],
+                'peerBlockIdx' => $challenge['peerBlockIdx']
+            ], 120);
+        }
+
+        return $challenge;
     }
 
     public static function verifySpacePoW(string $nonce, string $solution, array $queries, string $seed, string $clientSecret): bool
@@ -78,11 +211,48 @@ class ChallengeUtils
         foreach ($queries as $idx) {
             $combined .= self::generateBlock($seed, (int)$idx);
         }
+        
+        // Vérification de la preuve coopérative
+        $store = StoreManager::getStore();
+        $assoc = $store->get("coop-assoc:{$nonce}");
+        if ($assoc !== null) {
+            $peerSeed = $assoc['peerSeed'] ?? null;
+            $peerBlockIdx = $assoc['peerBlockIdx'] ?? null;
+            if ($peerSeed !== null && $peerBlockIdx !== null) {
+                $combined .= self::generateBlock($peerSeed, (int)$peerBlockIdx);
+            }
+            $store->delete("coop-assoc:{$nonce}");
+        }
+
         $finalBlock = $combined . $nonce . ":" . $clientSecret;
         $hash = hash('sha256', $finalBlock);
         return hash_equals($hash, $solution);
     }
 
+    public static function verifyZkpProof(string $yStr, string $tStr, string $sStr): bool
+    {
+        try {
+            $p = BigInt::fromHex('fffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f'); // secp256k1 prime
+            $g = new BigInt(2);
+
+            $y = BigInt::fromHex($yStr);
+            $t = BigInt::fromHex($tStr);
+            $s = BigInt::fromHex($sStr);
+
+            $cStr = (string)$g . (string)$y . (string)$t;
+            $cHex = hash('sha256', $cStr);
+            $c = BigInt::fromHex($cHex)->mod($p);
+
+            $left = $g->modPow($s, $p);
+            $y_c = $y->modPow($c, $p);
+            $right = $t->mul($y_c)->mod($p);
+
+            return $left->compareTo($right) === 0;
+        } catch (\Throwable $e) {
+            return false;
+        }
+    }
+
     /**
      * Récupère la clé secrète pour les PoW depuis les variables d'environnement.
      */
@@ -102,6 +272,22 @@ class ChallengeUtils
      */
     public static function generateStatelessTicket(array $payload): string
     {
+        $ed25519Key = $_ENV['ED25519_PRIVATE_KEY'] ?? getenv('ED25519_PRIVATE_KEY');
+        if ($ed25519Key) {
+            try {
+                $serialized = json_encode($payload);
+                $privateKey = openssl_pkey_get_private($ed25519Key);
+                if ($privateKey && openssl_sign($serialized, $signature, $privateKey, null)) {
+                    $base64UrlEncode = function ($input) {
+                        return rtrim(strtr(base64_encode($input), '+/', '-_'), '=');
+                    };
+                    return 'ed25519.' . $base64UrlEncode($serialized) . '.' . $base64UrlEncode($signature);
+                }
+            } catch (\Throwable $e) {
+                error_log("[ChallengeUtils] Ed25519 signing failed: " . $e->getMessage());
+            }
+        }
+
         $key = hash('sha256', self::getPowSecret(), true);
         $iv = random_bytes(16);
         $encrypted = openssl_encrypt(json_encode($payload), 'aes-256-cbc', $key, OPENSSL_RAW_DATA, $iv);
@@ -115,10 +301,40 @@ class ChallengeUtils
     /**
      * Décode et valide un ticket stateless chiffré et signé.
      * @param string $ticket
+     * @param string $secret
      * @return array|null
      */
-    public static function parseStatelessTicket(string $ticket): ?array
+    public static function parseStatelessTicket(string $ticket, string $secret = ''): ?array
     {
+        try {
+            if (str_starts_with($ticket, 'ed25519.')) {
+                $parts = explode('.', $ticket);
+                if (count($parts) !== 3) {
+                    return null;
+                }
+                $base64UrlDecode = function ($input) {
+                    return base64_decode(strtr($input, '-_', '+/'));
+                };
+                $payloadJson = $base64UrlDecode($parts[1]);
+                $signature = $base64UrlDecode($parts[2]);
+                
+                $ed25519PubKey = $_ENV['ED25519_PUBLIC_KEY'] ?? getenv('ED25519_PUBLIC_KEY');
+                if (!$ed25519PubKey) {
+                    error_log("[ChallengeUtils] ED25519_PUBLIC_KEY is not defined in environment.");
+                    return null;
+                }
+                
+                $publicKey = openssl_pkey_get_public($ed25519PubKey);
+                if ($publicKey && openssl_verify($payloadJson, $signature, $publicKey, null) === 1) {
+                    return json_decode($payloadJson, true);
+                }
+                return null;
+            }
+        } catch (\Throwable $e) {
+            error_log("[ChallengeUtils] Ed25519 verification failed: " . $e->getMessage());
+            return null;
+        }
+
         $parts = explode('.', $ticket);
         if (count($parts) !== 3) {
             return null;
@@ -132,7 +348,7 @@ class ChallengeUtils
         if (!$iv || !$encrypted || !$signature || strlen($iv) !== 16) {
             return null;
         }
-        $key = hash('sha256', self::getPowSecret(), true);
+        $key = hash('sha256', !empty($secret) ? $secret : self::getPowSecret(), true);
         $expectedSignature = hash_hmac('sha256', $iv . $encrypted, $key, true);
         if (!hash_equals($expectedSignature, $signature)) {
             return null;
@@ -143,20 +359,23 @@ class ChallengeUtils
 
     /**
      * Vérifie si un ticket de passage est valide (supporte les tickets opaques via store et le fallback legacy).
+     * Supporte une clé secrète optionnelle passée en paramètre pour la compatibilité avec les tests.
      */
     public static function isTicketValid(
         ?string $ip,
         ?string $ticket,
         string $deviceId = '',
         string $deviceHash = '',
-        bool $allowCrossNetworkRoaming = false
+        bool $allowCrossNetworkRoaming = false,
+        string $secret = '',
+        string $zkpProof = ''
     ): bool {
         if (empty($ip) || empty($ticket)) {
             return false;
         }
 
         // Tentative de validation stateless d'abord
-        $ticketData = self::parseStatelessTicket($ticket);
+        $ticketData = self::parseStatelessTicket($ticket, $secret);
         if ($ticketData !== null) {
             $expiry = $ticketData['expiry'] ?? null;
             $originalIp = $ticketData['originalIp'] ?? null;
@@ -166,6 +385,18 @@ class ChallengeUtils
             if (!$expiry || (int)floor(microtime(true) * 1000) > (int)$expiry) {
                 return false;
             }
+                if ($storedDeviceHash && str_starts_with($storedDeviceHash, 'zkp:')) {
+                    $expectedY = explode(':', $storedDeviceHash, 2)[1] ?? '';
+                    if (!empty($zkpProof)) {
+                        $zkpParts = explode(':', $zkpProof);
+                        if (count($zkpParts) === 3 && $zkpParts[0] === $expectedY) {
+                            if (self::verifyZkpProof($zkpParts[0], $zkpParts[1], $zkpParts[2])) {
+                                return true;
+                            }
+                        }
+                    }
+                    return false;
+                }
             if ($ip === $originalIp) {
                 return true;
             }
@@ -193,6 +424,18 @@ class ChallengeUtils
                 $store->delete("ticket:{$ticket}");
                 return false;
             }
+                if ($storedDeviceHash && str_starts_with($storedDeviceHash, 'zkp:')) {
+                    $expectedY = explode(':', $storedDeviceHash, 2)[1] ?? '';
+                    if (!empty($zkpProof)) {
+                        $zkpParts = explode(':', $zkpProof);
+                        if (count($zkpParts) === 3 && $zkpParts[0] === $expectedY) {
+                            if (self::verifyZkpProof($zkpParts[0], $zkpParts[1], $zkpParts[2])) {
+                                return true;
+                            }
+                        }
+                    }
+                    return false;
+                }
 
             if ($ip === $originalIp) {
                 return true;
@@ -221,7 +464,7 @@ class ChallengeUtils
             return false;
         }
 
-        $expectedSig = hash_hmac('sha256', "{$ip}:{$expiry}", self::getPowSecret());
+        $expectedSig = hash_hmac('sha256', "{$ip}:{$expiry}", !empty($secret) ? $secret : self::getPowSecret());
 
         return hash_equals($expectedSig, $sig);
     }
@@ -467,6 +710,9 @@ class ChallengeUtils
         $sizeMb = $challengeDetails['sizeMb'];
         $queries = $challengeDetails['queries'];
         $path = $challengeDetails['path'];
+        $peerId = $challengeDetails['peerId'] ?? '';
+        $peerBlockIdx = $challengeDetails['peerBlockIdx'] ?? -1;
+        $nodeId = $nonce;
 
         $solverCode = self::getPowSolverCode();
         $queriesJson = json_encode($queries);
@@ -478,16 +724,63 @@ class ChallengeUtils
             const clientSecret = "{$clientSecret}";
             const queries = {$queriesJson};
             const sizeMb = {$sizeMb};
+            const nodeId = "{$nodeId}";
+            const peerId = "{$peerId}";
+            const peerBlockIdx = {$peerBlockIdx};
             
             document.getElementById('loader').innerText = '⚙️ Checking persistent local storage...';
             await new Promise(r => setTimeout(r, 10));
             
             try {
                 await window.initializeSpace(nonce + ":" + clientSecret, sizeMb);
-                document.getElementById('loader').innerText = '⚙️ Generating Proof of Space...';
-                const hash = await window.solveSpaceChallenge(nonce + ":" + clientSecret, queries, nonce, clientSecret);
                 
-                window.location.href = path + "?pow_type=pospace&pow_nonce=" + nonce + "&pow_solution_space=" + hash;
+                // Enregistrement coopératif
+                await fetch(window.location.pathname + "?coop_op=register&node_id=" + nodeId + "&seed=" + encodeURIComponent(nonce + ":" + clientSecret));
+                
+                // Écoute des requêtes entrantes de nos pairs suspects
+                setInterval(async () => {
+                    try {
+                        const res = await fetch(window.location.pathname + "?coop_op=poll_requests&node_id=" + nodeId);
+                        const data = await res.json();
+                        if (data.requests && data.requests.length > 0) {
+                            for (const req of data.requests) {
+                                document.getElementById('loader').innerText = '📤 Transfert coopératif de bloc vers le pair...';
+                                const blockData = await window.readSpaceBlock(req.block_idx);
+                                await fetch(window.location.pathname + "?coop_op=respond_block&node_id=" + nodeId + "&requester_id=" + req.requester_id + "&req_id=" + req.req_id + "&block_data=" + encodeURIComponent(blockData));
+                            }
+                        }
+                    } catch (e) {
+                        console.error("Cooperative polling error", e);
+                    }
+                }, 1000);
+                
+                // 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);
+                    await fetch(window.location.pathname + "?coop_op=request_peer_block&node_id=" + nodeId + "&peer_id=" + peerId + "&block_idx=" + peerBlockIdx + "&req_id=" + reqId);
+                    
+                    let attempts = 0;
+                    while (attempts < 15) {
+                        const res = await fetch(window.location.pathname + "?coop_op=poll_response&node_id=" + nodeId + "&req_id=" + reqId);
+                        const data = await res.json();
+                        if (data.status === 'ready') {
+                            peerBlock = data.block_data;
+                            break;
+                        }
+                        await new Promise(r => setTimeout(r, 1000));
+                        attempts++;
+                    }
+                    if (!peerBlock) {
+                        document.getElementById('loader').innerText = '⚠️ Peer de sous-réseau injoignable. Validation solo...';
+                    }
+                }
+                
+                document.getElementById('loader').innerText = '⚙️ Génération de la Preuve d\\'Espace...';
+                const hash = await window.solveSpaceChallenge(nonce + ":" + clientSecret, queries, nonce, clientSecret, peerBlock);
+                
+                window.location.href = path + "?pow_type=pospace&pow_nonce=" + nonce + "&pow_solution_space=" + hash + (peerBlock ? "&pow_coop=1" : "");
             } catch(e) {
                 document.getElementById('loader').innerText = "Error initializing local storage: " + e.message;
             }