@anonympins/fingerprint 0.3.2 → 0.3.4

package/src/php/ProblemManager.php

@@ -0,0 +1,255 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Anonympins\Fingerprint;
+
+use Anonympins\Fingerprint\Store\IStore;
+use Anonympins\Fingerprint\Optimization\FunctionRegistry;
+use Anonympins\Fingerprint\Optimization\ProblemInitializers;
+
+class ProblemManager
+{
+    private static ?ProblemManager $instance = null;
+    private string $configPath;
+    private IStore $store;
+    /** @var array<int, array<string, mixed>> */
+    private array $problems = [];
+    private int $currentProblemIndex = 0;
+    private bool $initialized = false;
+    
+    /**
+     * Le constructeur est privé pour forcer l'utilisation du singleton.
+     */
+    private function __construct(string $configPath, IStore $store)
+    {
+        $this->configPath = $configPath;
+        $this->store = $store;
+        $this->loadProblems();
+    }
+
+    /**
+     * Obtient l'instance singleton du ProblemManager.
+     * Doit être initialisé une fois avec `init`.
+     */
+    public static function getInstance(?string $configPath = null, ?IStore $store = null): self
+    {
+        if (self::$instance === null) {
+            // Si on essaie d'obtenir l'instance sans l'initialiser d'abord, c'est une erreur.
+            if ($configPath === null || $store === null) {
+                throw new \RuntimeException("ProblemManager must be initialized with configPath and store.");
+            }
+            self::$instance = new self($configPath, $store);
+        }
+        return self::$instance;
+    }
+
+    public static function isInitialized(): bool
+    {
+        return self::$instance !== null && self::$instance->initialized;
+    }
+    /**
+     * Charge et parse les problèmes depuis le fichier de configuration.
+     */
+
+    private function loadProblems(): void
+    {
+        if (!file_exists($this->configPath)) {
+            error_log("[ProblemManager] Problem config file not found: {$this->configPath}");
+            return;
+        }
+        $data = file_get_contents($this->configPath);
+        if ($data === false) {
+            error_log("[ProblemManager] Failed to read problem config file: {$this->configPath}");
+            return;
+        }
+        $problemsFromFile = json_decode($data, true);
+        if (json_last_error() !== JSON_ERROR_NONE) {
+            error_log("[ProblemManager] Failed to parse problem config JSON: " . json_last_error_msg());
+            return;
+        }
+
+        foreach ($problemsFromFile as $problem) {
+            $storeKey = "problem-state:{$problem['id']}";
+            $storedState = $this->store->get($storeKey);
+
+            if ($storedState === null) {
+                $storedState = $problem['state'] ?? [];
+                $this->store->set($storeKey, $storedState); // Persist initial state
+            }
+            $problem['state'] = $storedState;
+
+            // Résolution dynamique des fonctions et des données
+            if (isset($problem['workUnit']['scoreFunction'])) {
+                $problem['workUnit']['scoreFunction'] = FunctionRegistry::get($problem['workUnit']['scoreFunction']);
+                if ($problem['workUnit']['scoreFunction'] === null) {
+                    // @codeCoverageIgnoreStart
+                    error_log("[ProblemManager] Warning: scoreFunction '{$problem['workUnit']['scoreFunction']}' not found in registry for problem '{$problem['id']}'.");
+                    // @codeCoverageIgnoreEnd
+                }
+            }
+
+            if (isset($problem['payload']) && is_array($problem['payload'])) {
+                foreach ($problem['payload'] as $key => &$value) {
+                    if (is_array($value) && isset($value['$init'])) {
+                        $initializer = ProblemInitializers::get($value['$init']);
+                        if ($initializer) {
+                            $value = $initializer($value['params'] ?? []);
+                        }
+                    }
+                }
+            }
+            $this->problems[] = $problem;
+        }
+        $this->initialized = true; // Marquer comme initialisé seulement après un chargement réussi
+    }
+
+    public function dispatchWork(float $suspicionFactor): ?array
+    {
+        if (empty($this->problems)) {
+            return null;
+        }
+
+        $problem = $this->problems[$this->currentProblemIndex];
+        $this->currentProblemIndex = ($this->currentProblemIndex + 1) % count($this->problems);
+
+        $task = ['type' => $problem['workUnit']['type']];
+        $scalingFactor = $problem['workUnit']['scalingFactor'] ?? null;
+
+        switch ($problem['workUnit']['type']) {
+            case 'simulated_annealing_iterations':
+                $baseIterations = $problem['workUnit']['baseIterations'] ?? 15000;
+                $task['iterations'] = $scalingFactor
+                    ? (int)floor($baseIterations * pow($scalingFactor, $suspicionFactor))
+                    : (int)floor($baseIterations * (0.5 + $suspicionFactor));
+                if (isset($problem['payload'])) {
+                    $task['payload'] = $problem['payload'];
+                }
+                // Ensure payload is always an array to prevent errors when accessing it.
+                $task['payload'] = $task['payload'] ?? [];
+                $task['initialSolution'] = $problem['state']['bestSolution'] ?? null;
+                break;
+            case 'multi_objective_genetic_algorithm':
+                $baseGenerationsMulti = max(30, $problem['workUnit']['baseGenerations'] ?? 0);
+                $task['generations'] = $scalingFactor
+                    ? (int)floor($baseGenerationsMulti * pow($scalingFactor, $suspicionFactor))
+                    : (int)floor($baseGenerationsMulti * (0.5 + $suspicionFactor));
+                if (isset($problem['payload'])) {
+                    $task['payload'] = $problem['payload'];
+                }
+                $task['initialFront'] = $problem['state']['paretoFront'] ?? null;
+                $task['solverName'] = $problem['workUnit']['solverName'];
+                break;
+            default:
+                error_log("[ProblemManager] Unknown useful work type: {$problem['workUnit']['type']}");
+                return null;
+        }
+
+        return ['problemId' => $problem['id'], 'task' => $task];
+    }
+
+    /**
+     * Intègre la solution d'un client dans l'état du problème.
+     *
+     * @param string $problemId L'ID du problème.
+     * @param array $solutionData La solution renvoyée par le client.
+     */
+    public function integrateSolution(string $problemId, array $solutionData): void
+    {
+        $problemIndex = array_search($problemId, array_column($this->problems, 'id'));
+        if ($problemIndex === false) {
+            return;
+        }
+        $problem = &$this->problems[$problemIndex]; // Use reference to modify in place
+
+        $stateChanged = false;
+
+        $storeKey = "problem-state:{$problem['id']}";
+
+        // La logique d'intégration dépend du type de problème.
+        switch ($problem['workUnit']['type']) {
+            case 'simulated_annealing_iterations':
+                if (isset($solutionData['solution']) && isset($solutionData['energy'])) {
+                    $scoreFunction = $problem['workUnit']['scoreFunction'] ?? null;
+                    if (!$scoreFunction) {
+                        error_log("[ProblemManager] Aucune fonction de score définie pour {$problemId}.");
+                        return;
+                    }
+                    // 1. Ne JAMAIS faire confiance au score du client. Recalculer systématiquement.
+                    $recalculatedEnergy = $scoreFunction($solutionData['solution'], $problem['payload'] ?? []);
+
+                    $currentBest = (float)($problem['state']['bestEnergy'] ?? INF);
+
+                    // 2. Comparer le score recalculé, pas celui du client.
+                    if ($recalculatedEnergy < $currentBest) { // @phpstan-ignore-line
+                        $problem['state']['bestSolution'] = $solutionData['solution'];
+                        $problem['state']['bestEnergy'] = $recalculatedEnergy; // 3. Stocker le score vérifié.
+                        $problem['state']['lastUpdate'] = (new \DateTime())->format(\DateTime::ATOM);
+                        $stateChanged = true;
+                        error_log("[ProblemManager] New best solution for {$problemId}: {$recalculatedEnergy}"); // @phpstan-ignore-line
+                    }
+                }
+                break;
+            case 'multi_objective_genetic_algorithm':
+                // Pour les algorithmes génétiques, on intègre le nouveau front de Pareto.
+                if (isset($solutionData['paretoFront']) && is_array($solutionData['paretoFront'])) {
+                    $stateChanged = $this->_integrateParetoFront($problem, $solutionData['paretoFront']);
+                }
+                break;
+            default:
+                error_log("[ProblemManager] Integration not implemented for useful work type: {$problem['workUnit']['type']}");
+                break;
+        }
+        // Sauvegarder l'état mis à jour dans le store.
+        if ($stateChanged) {
+            $this->store->set($storeKey, $problem['state']);
+        }
+    }
+
+    /**
+     * Intègre un nouveau front de Pareto dans l'état du problème.
+     *
+     * @param array &$problem Le problème à mettre à jour (passé par référence).
+     * @param array $newFront Le nouveau front de Pareto soumis par le client.
+     */
+    private function _integrateParetoFront(array &$problem, array $newFront): bool
+    {
+        // Logique de fusion et de tri non-dominé pour mettre à jour le front de Pareto.
+        // Pour cet exemple, nous remplaçons simplement le front, mais une vraie implémentation
+        // fusionnerait les deux fronts et recalculerait le meilleur.
+        // On vérifie si le nouveau front est différent de l'actuel pour éviter des écritures inutiles.
+        $currentFront = $problem['state']['paretoFront'] ?? [];
+        if (!empty($newFront) && json_encode($newFront) !== json_encode($currentFront)) {
+            $problem['state']['paretoFront'] = $newFront;
+            $problem['state']['lastUpdate'] = (new \DateTime())->format(\DateTime::ATOM);
+            error_log("[ProblemManager] New Pareto front for {$problem['id']} with " . count($newFront) . " solutions."); // @phpstan-ignore-line
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * Réinitialise l'instance singleton.
+     * @internal Uniquement pour les tests.
+     */
+    public static function resetInstanceForTests(): void
+    {
+        self::$instance = null;
+    }
+
+    /**
+     * Réinitialise l'instance singleton.
+     * @internal Uniquement pour les tests.
+     */
+    public static function __internal_resetInstance(): void {
+        self::$instance = null;
+    }
+
+    /**
+     * @internal For testing purposes only.
+     */
+    public function getProblems(): array
+    {
+        return $this->problems;
+    }
+}

package/src/php/RequestContext.php

@@ -0,0 +1,91 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Anonympins\Fingerprint;
+
+/**
+ * Représente le contexte d'une requête HTTP, fournissant un accès unifié
+ * aux informations nécessaires pour l'analyse de l'empreinte.
+ * Cette classe est conçue pour être créée à partir d'un objet de requête
+ * standard (ex: PSR-7, Symfony, Laravel).
+ */
+class RequestContext
+{
+    public string $clientIp;
+    public string $path;
+    /** @var array<string, string> */
+    public array $headers;
+    /** @var array<string, mixed> */
+    public array $query;
+    /** @var array<string, mixed>|object|null */
+    public $body;
+    /** @var array<string, string> */
+    public array $cookies;
+    public ?string $httpVersion;
+    public int $requestTimestamp;
+
+    /** @var ?array{type: string, name: string} */
+    public ?array $graphqlOperation = null;
+
+    /** @var ?array<string, mixed> */
+    public ?array $newCookieForResponse = null;
+
+    // Propriétés spécifiques qui peuvent être fournies par un proxy inverse
+    public ?string $ja3;
+    public ?string $ja4;
+    public ?string $ja4s;
+    public ?string $ja4h;
+    public ?string $http2Fingerprint;
+    public ?string $tcpFingerprint;
+
+    /**
+     * @param string $clientIp
+     * @param string $path
+     * @param array<string, string> $headers
+     * @param array<string, mixed> $query
+     * @param array<string, mixed>|object|null $body
+     * @param array<string, string> $cookies
+     * @param string|null $httpVersion
+     * @param int|null $requestTimestamp
+     */
+    public function __construct(
+        string $clientIp,
+        string $path,
+        array $headers,
+        array $query,
+        $body,
+        array $cookies,
+        ?string $httpVersion,
+        ?int $requestTimestamp = null
+    ) {
+        $this->clientIp = $clientIp;
+        $this->path = $path;
+        // Normaliser les en-têtes en minuscules pour un accès cohérent
+        $this->headers = array_change_key_case($headers, CASE_LOWER);
+        $this->query = $query;
+        $this->body = $body;
+        $this->cookies = $cookies;
+        $this->httpVersion = $httpVersion;
+        $this->requestTimestamp = $requestTimestamp ?? (int)(microtime(true) * 1000);
+
+        // Extraire les empreintes TLS/HTTP2/TCP si elles sont fournies par les en-têtes
+        $this->ja3 = $this->headers['x-ja3-hash'] ?? null;
+        $this->ja4 = $this->headers['x-ja4-hash'] ?? null;
+        $this->ja4s = $this->headers['x-ja4s-hash'] ?? null;
+        $this->ja4h = $this->headers['x-ja4h-hash'] ?? null;
+        $this->http2Fingerprint = $this->headers['x-http2-fingerprint'] ?? null;
+        $this->tcpFingerprint = $this->headers['x-tcp-fingerprint'] ?? null;
+    }
+    /**
+     * Récupère la valeur d'un en-tête HTTP de manière insensible à la casse.
+     *
+     * @param string $name Le nom de l'en-tête.
+     * @return string|null La valeur de l'en-tête ou null si non trouvé.
+     */
+
+    public function getHeader(string $name): ?string
+    {
+        return $this->headers[strtolower($name)] ?? null;
+    }
+}

package/src/php/Store/IStore.php

@@ -0,0 +1,42 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Anonympins\Fingerprint\Store;
+
+/**
+ * Interface pour un système de stockage persistant.
+ * Utilisé pour stocker les données des appareils, les secrets des challenges, etc.
+ */
+interface IStore
+{
+    /**
+     * Récupère une valeur associée à une clé.
+     * @param string $key
+     * @return mixed|null
+     */
+    public function get(string $key);
+
+    /**
+     * Stocke une valeur associée à une clé, avec une durée de vie optionnelle.
+     * @param string $key
+     * @param mixed $value
+     * @param int|null $ttl Durée de vie en secondes.
+     * @return void
+     */
+    public function set(string $key, $value, ?int $ttl = null): void;
+
+    /**
+     * Vérifie si une clé existe dans le stockage.
+     * @param string $key
+     * @return bool
+     */
+    public function has(string $key): bool;
+
+    /**
+     * Supprime une clé du stockage.
+     * @param string $key
+     * @return void
+     */
+    public function delete(string $key): void;
+}

package/src/php/Store/InMemoryStore.php

@@ -0,0 +1,67 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Anonympins\Fingerprint\Store;
+
+/**
+ * Implémentation en mémoire de l'interface IStore.
+ * Utile pour le développement ou les applications à instance unique sans persistance externe.
+ */
+class InMemoryStore implements IStore
+{
+    /**
+     * @var array<string, array{value: mixed, expiresAt: int|null}>
+     */
+    private array $data = [];
+
+    public function get(string $key)
+    {
+        if (!isset($this->data[$key])) {
+            return null;
+        }
+
+        $item = $this->data[$key];
+        if ($item['expiresAt'] !== null && $item['expiresAt'] < time()) {
+            $this->delete($key); // Supprime l'élément expiré
+            return null;
+        }
+
+        return $item['value'];
+    }
+
+    public function set(string $key, $value, ?int $ttl = null): void
+    {
+        $expiresAt = $ttl !== null ? time() + $ttl : null;
+
+        $this->data[$key] = ['value' => $value, 'expiresAt' => $expiresAt];
+    }
+
+    public function has(string $key): bool
+    {
+        if (!isset($this->data[$key])) {
+            return false;
+        }
+
+        $item = $this->data[$key];
+        if ($item['expiresAt'] !== null && $item['expiresAt'] < time()) {
+            $this->delete($key);
+            return false;
+        }
+
+        return true;
+    }
+
+    public function delete(string $key): void
+    {
+        unset($this->data[$key]);
+    }
+
+    /**
+     * Efface toutes les données du store. Utile pour les tests.
+     */
+    public function clear(): void
+    {
+        $this->data = [];
+    }
+}

package/src/php/Store/StoreManager.php

@@ -0,0 +1,36 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Anonympins\Fingerprint\Store;
+
+/**
+ * Gère l'instance du store global.
+ */
+class StoreManager
+{
+    private static ?IStore $store = null;
+
+    public static function getStore(): IStore
+    {
+        if (self::$store === null) {
+            self::$store = new InMemoryStore();
+        }
+        return self::$store;
+    }
+
+    public static function configureStore(IStore $externalStore): void
+    {
+        self::$store = $externalStore;
+    }
+
+    /**
+     * Définit l'instance active du store (utile pour l'injection de dépendances et les tests).
+     *
+     * @param mixed $store
+     */
+    public static function setStore($store): void
+    {
+        self::$store = $store;
+    }
+}

package/src/php/Tests/ChallengeUtilsTest.php

@@ -0,0 +1,82 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Anonympins\Fingerprint\Tests;
+
+use PHPUnit\Framework\TestCase;
+use Anonympins\Fingerprint\Challenge\ChallengeUtils;
+use Anonympins\Fingerprint\Utils\BigInt;
+
+class ChallengeUtilsTest extends TestCase
+{
+    protected function setUp(): void
+    {
+        // Définir une clé secrète pour les tests
+        $_ENV['POW_SECRET'] = 'test-secret-key-that-is-long-enough-for-hmac';
+    }
+
+    public function testIsTicketValid(): void
+    {
+        $ip = '127.0.0.1';
+        $expiry = (int)floor(microtime(true) * 1000) + 3600000; // 1 heure
+        $signature = hash_hmac('sha256', "{$ip}:{$expiry}", $_ENV['POW_SECRET']);
+        $validTicket = "{$expiry}:{$signature}";
+
+        $this->assertTrue(ChallengeUtils::isTicketValid($ip, $validTicket));
+        $this->assertFalse(ChallengeUtils::isTicketValid('192.168.1.1', $validTicket), "Le ticket ne doit pas être valide pour une autre IP.");
+
+        $expiredExpiry = (int)floor(microtime(true) * 1000) - 1000;
+        $expiredSignature = hash_hmac('sha256', "{$ip}:{$expiredExpiry}", $_ENV['POW_SECRET']);
+        $expiredTicket = "{$expiredExpiry}:{$expiredSignature}";
+        $this->assertFalse(ChallengeUtils::isTicketValid($ip, $expiredTicket), "Un ticket expiré doit être invalide.");
+
+        $this->assertFalse(ChallengeUtils::isTicketValid($ip, 'invalid-ticket-format'), "Un format de ticket invalide doit être rejeté.");
+    }
+
+    public function testCpuTargetCalculation(): void
+    {
+        $config = ['cpu' => ['minDifficultyBits' => 8, 'maxDifficultyBits' => 24]];
+
+        // Low suspicion -> minimum difficulty
+        $targetLow = ChallengeUtils::calculateCpuTarget(0.0, $config);
+        $expectedTargetLow = (new BigInt(1))->shiftLeft(256 - 8);
+        $this->assertEquals(0, BigInt::fromHex($targetLow)->compareTo($expectedTargetLow), "Target for 0.0 suspicion should correspond to 8 bits of difficulty.");
+
+        // High suspicion -> maximum difficulty
+        $targetHigh = ChallengeUtils::calculateCpuTarget(1.0, $config);
+        $expectedTargetHigh = (new BigInt(1))->shiftLeft(256 - 24);
+        $this->assertEquals(0, BigInt::fromHex($targetHigh)->compareTo($expectedTargetHigh), "Target for 1.0 suspicion should correspond to 24 bits of difficulty.");
+
+        // Medium suspicion -> intermediate difficulty
+        $targetMid = ChallengeUtils::calculateCpuTarget(0.5, $config);
+        $expectedBits = 8 + 0.5 * (24 - 8); // 16 bits
+        $expectedTargetMid = (new BigInt(1))->shiftLeft(256 - (int)$expectedBits);
+        $this->assertEquals(0, BigInt::fromHex($targetMid)->compareTo($expectedTargetMid), "Target for 0.5 suspicion should correspond to 16 bits of difficulty.");
+    }
+
+    public function testVerifyCpuTargetPoW(): void
+    {
+        $ip = '127.0.0.1';
+        $nonce = 'test-nonce';
+        $fingerprint = 'ua:test-fp';
+        $clientSecret = 'test-secret';
+        $baseBlock = ChallengeUtils::createCpuChallengeBaseBlock($nonce, $clientSecret, $fingerprint);
+
+        // Cible facile pour un test rapide (ex: 4 zéros hexadécimaux -> 16 bits)
+        $targetHex = '0000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff';
+        $challengeContext = ['cpuTarget' => $targetHex, 'baseBlock' => $baseBlock];
+
+        // Trouver une solution valide
+        $solution = 0;
+        while (true) {
+            $hash = hash('sha256', $baseBlock . $solution);
+            if (strcmp($hash, $targetHex) < 0) break;
+            $solution++;
+        }
+
+        $ticket = ChallengeUtils::verifyCpuTargetPoWAndGenerateTicket($ip, 3600, $nonce, (string)$solution, $challengeContext);
+        $this->assertNotNull($ticket, "Un ticket valide aurait dû être généré.");
+        $this->assertTrue(ChallengeUtils::isTicketValid($ip, $ticket));
+    }
+}

package/src/php/Tests/FingerprintBuilderTest.php

@@ -0,0 +1,58 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Anonympins\Fingerprint\Tests;
+
+use PHPUnit\Framework\TestCase;
+use Anonympins\Fingerprint\FingerprintBuilder;
+
+class FingerprintBuilderTest extends TestCase
+{
+    public function testCyrb53IsDeterministic(): void
+    {
+        $input = "test-string";
+        // Note: The PHP and JS implementations of cyrb53 produce different hash strings
+        // due to differences in large number handling, but they are internally consistent.
+        $this->assertEquals(FingerprintBuilder::cyrb53($input), FingerprintBuilder::cyrb53($input));
+        $this->assertNotEquals(FingerprintBuilder::cyrb53("a"), FingerprintBuilder::cyrb53("b"));
+    }
+
+    public function testBuilderHandlesNullAndEmptyValues(): void
+    {
+        $builder = new FingerprintBuilder();
+        $builder->add('key1', 'value1');
+        $builder->add('key2', null);
+        $builder->add('key3', '');
+
+        // The JS equivalent for this hash is '6263243896157005'
+        $this->assertEquals('key1:6263243896157005', (string)$builder);
+    }
+
+    public function testToStringSortsKeysDeterministically(): void
+    {
+        $builder1 = new FingerprintBuilder();
+        $builder1->add('b', '2')->add('a', '1');
+
+        $builder2 = new FingerprintBuilder();
+        $builder2->add('a', '1')->add('b', '2');
+
+        $this->assertEquals((string)$builder1, (string)$builder2);
+    }
+
+    public function testCompareLogic(): void
+    {
+        $fp1 = (new FingerprintBuilder())->add('hw', '8_16')->add('gpu', 'nvidia')->__toString();
+        $fp2 = (new FingerprintBuilder())->add('hw', '8_16')->add('gpu', 'nvidia')->__toString();
+        $fp3 = (new FingerprintBuilder())->add('hw', '4_8')->add('gpu', 'amd')->__toString();
+        $fp4 = (new FingerprintBuilder())->add('hw', '8_16')->add('os', 'win32')->__toString(); // Partial match
+
+        $this->assertEquals(1.0, FingerprintBuilder::compare($fp1, $fp2), "Identical FPs should return 1.0");
+        $this->assertEquals(0.0, FingerprintBuilder::compare($fp1, $fp3), "Completely different FPs should have a score of 0");
+        
+        $this->assertEqualsWithDelta(0.25, FingerprintBuilder::compare($fp1, $fp4), 0.2, "Partial match should have a specific score");
+        
+        $this->assertEquals(0.0, FingerprintBuilder::compare($fp1, ''), "Comparison with empty string should be 0.0");
+        $this->assertEquals(0.0, FingerprintBuilder::compare(null, $fp2), "Comparison with null should be 0.0");
+    }
+}