@anonympins/fingerprint 0.3.2 → 0.3.4

package/src/php/Tests/ProblemManagerTest.php

@@ -0,0 +1,295 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Anonympins\Fingerprint\Tests;
+
+use PHPUnit\Framework\TestCase;
+use Anonympins\Fingerprint\ProblemManager;
+use Anonympins\Fingerprint\Store\IStore;
+use Anonympins\Fingerprint\Store\InMemoryStore;
+use Anonympins\Fingerprint\Optimization\FunctionRegistry; // Assurez-vous que cette classe est autoloadable
+
+class ProblemManagerTest extends TestCase
+{
+    private ?string $configPath = null;
+
+    protected function setUp(): void
+    {
+        // Réinitialise le singleton avant chaque test pour garantir l'isolation
+        ProblemManager::__internal_resetInstance();
+        FunctionRegistry::__internal_resetRegistry(); // Assure un registre de fonctions propre
+        $this->configPath = dirname(__FILE__).'/problems.config.json';
+    }
+
+    protected function tearDown(): void
+    {
+        ProblemManager::__internal_resetInstance();
+        FunctionRegistry::__internal_resetRegistry();
+    }
+
+    private function createConfigFile(array $content): void
+    {
+        // S'assurer que le répertoire existe
+        if (!is_dir(dirname($this->configPath))) {
+            mkdir(dirname($this->configPath), 0777, true);
+        }
+        file_put_contents($this->configPath, json_encode($content, JSON_PRETTY_PRINT));
+    }
+
+    public function testGetInstanceThrowsExceptionIfNotInitialized(): void
+    {
+        $this->expectException(\RuntimeException::class);
+        $this->expectExceptionMessage('ProblemManager must be initialized with configPath and store.');
+        ProblemManager::getInstance();
+    }
+
+    public function testGetInstanceCreatesAndReturnsInstance(): void
+    {
+        $storeMock = $this->createMock(IStore::class);
+
+        $instance1 = ProblemManager::getInstance($this->configPath, $storeMock);
+        $this->assertInstanceOf(ProblemManager::class, $instance1);
+
+        // Les appels suivants doivent retourner la même instance
+        $instance2 = ProblemManager::getInstance();
+        $this->assertSame($instance1, $instance2);
+        $this->assertTrue(ProblemManager::isInitialized());
+    }
+
+    public function testLoadProblemsHandlesMissingFile(): void
+    {
+        $storeMock = $this->createMock(IStore::class);
+        $missingConfigPath = dirname(__FILE__).'/non_existent_config.json';
+        if (file_exists($missingConfigPath)) {
+            unlink($missingConfigPath); // S'assurer que le fichier n'existe pas
+        }
+
+        // Ne doit pas lever d'exception, mais simplement ne pas initialiser de problèmes
+        $manager = ProblemManager::getInstance($missingConfigPath, $storeMock);
+        $this->assertNull($manager->dispatchWork(0.5));
+    }
+
+    public function testDispatchWorkCyclesThroughProblems(): void
+    {
+        $storeMock = $this->createMock(IStore::class);
+        $storeMock->method('get')->willReturn(null);
+
+        // Créer un fichier de configuration avec plusieurs problèmes pour tester le cycle
+        $this->createConfigFile([
+            [
+                "id" => "problem-1",
+                "workUnit" => ["type" => "simulated_annealing_iterations", "baseIterations" => 10000, "scalingFactor" => 2.0]
+            ],
+            [
+                "id" => "problem-2",
+                "workUnit" => ["type" => "simulated_annealing_iterations", "baseIterations" => 20000]
+            ],
+            [
+                "id" => "scaling-problem",
+                "workUnit" => ["type" => "multi_objective_genetic_algorithm", "baseGenerations" => 100, "scalingFactor" => 2.0, "solverName" => "test.solver"]
+            ],
+            [
+                "id" => "pareto-challenge",
+                "workUnit" => ["type" => "multi_objective_genetic_algorithm", "solverName" => "test.solver"]
+            ],
+            [
+                "id" => "problem-1",
+                "workUnit" => ["type" => "simulated_annealing_iterations", "baseIterations" => 10000, "scalingFactor" => 2.0]
+            ]
+        ]);
+
+        $manager = ProblemManager::getInstance($this->configPath, $storeMock);
+
+        $work1 = $manager->dispatchWork(0.5);
+        $this->assertEquals('problem-1', $work1['problemId']);
+
+        $work2 = $manager->dispatchWork(0.5);
+        $this->assertEquals('problem-2', $work2['problemId']);
+
+        // Cycle through a few more times to ensure it loops
+        $work3 = $manager->dispatchWork(0.5);
+        $this->assertEquals('scaling-problem', $work3['problemId']);
+
+        $work4 = $manager->dispatchWork(0.5);
+        $this->assertEquals('pareto-challenge', $work4['problemId']);
+
+        $work5 = $manager->dispatchWork(0.5);
+        $this->assertEquals('problem-1', $work5['problemId']); // Back to the start
+    }
+
+    public function testDispatchWorkScalesDifficulty(): void
+    {
+        $storeMock = $this->createMock(IStore::class);
+        $storeMock->method('get')->willReturn(null);
+
+        $this->createConfigFile([
+            [
+                "id" => "problem-1",
+                "workUnit" => ["type" => "simulated_annealing_iterations", "baseIterations" => 10000, "scalingFactor" => 2.0]
+            ],
+            [
+                "id" => "problem-1",
+                "workUnit" => ["type" => "simulated_annealing_iterations", "baseIterations" => 10000, "scalingFactor" => 2.0]
+            ],
+            [
+                "id" => "scaling-problem",
+                "workUnit" => ["type" => "multi_objective_genetic_algorithm", "baseGenerations" => 100, "scalingFactor" => 2.0, "solverName" => "test.solver"]
+            ]
+        ]);
+
+        $manager = ProblemManager::getInstance($this->configPath, $storeMock);
+
+        // Facteur de suspicion faible
+        $workLow = $manager->dispatchWork(0.1);
+        $this->assertLessThan(12000, $workLow['task']['iterations']); // 10000 * 2^0.1 ≈ 10717
+
+        // Facteur de suspicion moyen - dispatch 'problem-1'
+        $workMedium = $manager->dispatchWork(0.5);
+        $this->assertEquals(14142, $workMedium['task']['iterations']); // 10000 * 2^0.5
+
+        // Facteur de suspicion élevé - dispatch 'scaling-problem'
+        $workHigh = $manager->dispatchWork(1.0);
+        $this->assertEquals(200, $workHigh['task']['generations']); // 100 * 2^1.0
+    }
+
+    public function testIntegrateSolutionUpdatesStateForBetterSolution(): void
+    {
+        $problemId = 'problem-1';
+
+        $storeMock = $this->createMock(IStore::class);
+
+        $this->createConfigFile([
+            [
+                "id" => $problemId,
+                "workUnit" => [
+                    "type" => "simulated_annealing_iterations", // @phpstan-ignore-line
+                    "baseIterations" => 10000,
+                    // **LA CORRECTION** : La fonction de score est requise pour la vérification.
+                    "scoreFunction" => "test.calculateEnergy"
+                ]
+            ]
+        ]);
+
+        // Enregistrer une fonction de score factice pour le test.
+        FunctionRegistry::register('test.calculateEnergy', function ($solution, $payload) { // @phpstan-ignore-line
+            return 800.0; // Retourne la nouvelle "meilleure" énergie attendue.
+        });
+
+        $storeMock->method('get')
+            ->with("problem-state:{$problemId}")
+            ->willReturn(['bestEnergy' => 1000.0]);
+
+        // On s'attend à ce que le store soit mis à jour avec la nouvelle meilleure solution
+        $storeMock->expects($this->once())
+            ->method('set')
+            ->with(
+                "problem-state:{$problemId}",
+                $this->callback(function ($state) {
+                    return isset($state['bestEnergy']) && $state['bestEnergy'] === 800.0 && isset($state['bestSolution']);
+                })
+            );
+
+        $manager = ProblemManager::getInstance($this->configPath, $storeMock);
+
+        $newSolution = [
+            'solution' => [1, 2, 3],
+            'energy' => 800.0 // C'est une meilleure solution (score plus bas)
+        ];
+        $manager->integrateSolution($problemId, $newSolution);
+    }
+
+    public function testIntegrateSolutionDoesNotUpdateStateForWorseSolution(): void
+    {
+        $problemId = 'problem-1';
+
+        $storeMock = $this->createMock(IStore::class);
+
+        $this->createConfigFile([
+            [
+                "id" => $problemId,
+                "workUnit" => [
+                    "type" => "simulated_annealing_iterations", // @phpstan-ignore-line
+                    "baseIterations" => 10000,
+                    "scoreFunction" => "test.calculateEnergy"
+                ]
+            ]
+        ]);
+
+        // La fonction de score factice retourne une énergie *pire* que celle existante. // @phpstan-ignore-line
+        FunctionRegistry::register('test.calculateEnergy', function ($solution, $payload) {
+            return 1200.0;
+        });
+
+        $storeMock->method('get') // @phpstan-ignore-line
+            ->with("problem-state:{$problemId}")
+            ->willReturn(['bestEnergy' => 1000.0]);
+
+        // On s'attend à ce que `set` ne soit JAMAIS appelé car la solution n'est pas meilleure
+        $storeMock->expects($this->never())->method('set');
+
+        $manager = ProblemManager::getInstance($this->configPath, $storeMock);
+
+        $worseSolution = [
+            'solution' => [3, 2, 1], // Le contenu de la solution n'a pas d'importance pour ce test
+            'energy' => 1200.0 // C'est une moins bonne solution
+        ];
+        $manager->integrateSolution($problemId, $worseSolution);
+    }
+
+    public function testIntegrateParetoFront(): void
+    {
+        $problemId = 'pareto-challenge';
+
+        $storeMock = $this->createMock(IStore::class);
+
+        $this->createConfigFile([
+            [
+                "id" => "pareto-challenge",
+                "workUnit" => ["type" => "multi_objective_genetic_algorithm", "solverName" => "test.solver"]
+            ]
+        ]);
+        // Simule le comportement réel : le store contient déjà l'état initial.
+        $initialState = ['paretoFront' => [['solution' => 'A', 'objectives' => [10, 20]]]];
+        $storeMock->method('get')
+            ->with("problem-state:{$problemId}")
+            ->willReturn($initialState);
+
+        // A new solution that dominates the existing one.
+        $newFront = [['solution' => 'B', 'objectives' => [5, 15]]];
+
+        $storeMock->expects($this->once())
+            ->method('set')
+            ->with(
+                "problem-state:{$problemId}",
+                $this->callback(function ($state) {
+                    // The new front should contain only the new, dominant solution 'B'.
+                    return isset($state['paretoFront']) && count($state['paretoFront']) === 1 && $state['paretoFront'][0]['solution'] === 'B';
+                })
+            );
+
+        $manager = ProblemManager::getInstance($this->configPath, $storeMock);
+        $manager->integrateSolution($problemId, ['paretoFront' => $newFront]);
+    }
+
+    public function testLoadProblemsFromStore(): void
+    {
+        $store = new InMemoryStore();
+        $problemId = 'problem-1';
+
+        $this->createConfigFile([
+            [
+                "id" => "problem-1",
+                "workUnit" => ["type" => "simulated_annealing_iterations", "baseIterations" => 10000]
+            ]
+        ]);
+        $initialState = ['bestEnergy' => 5000.0, 'bestSolution' => [1, 2, 3]];
+        $store->set("problem-state:{$problemId}", $initialState);
+
+        $manager = ProblemManager::getInstance($this->configPath, $store);
+        $work = $manager->dispatchWork(0.1); // Dispatch 'problem-1'
+
+        $this->assertEquals($problemId, $work['problemId']);
+        $this->assertEquals($initialState['bestSolution'], $work['task']['initialSolution']);
+    }
+}

package/src/php/Tests/RequestUtilsTest.php

@@ -0,0 +1,81 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Anonympins\Fingerprint\Tests;
+
+use PHPUnit\Framework\TestCase;
+use Anonympins\Fingerprint\RequestContext;
+use Anonympins\Fingerprint\Utils\RequestUtils;
+
+class RequestUtilsTest extends TestCase
+{
+    private function createRequestContext(array $overrides = []): RequestContext
+    {
+        $defaults = [
+            'clientIp' => '127.0.0.1',
+            'path' => '/',
+            'headers' => ['user-agent' => 'Test UA'],
+            'query' => [],
+            'body' => null,
+            'cookies' => [],
+            'httpVersion' => '1.1',
+        ];
+        $params = array_merge($defaults, $overrides);
+        return new RequestContext(
+            $params['clientIp'], $params['path'], $params['headers'],
+            $params['query'], $params['body'], $params['cookies'], $params['httpVersion']
+        );
+    }
+
+    public function testGetClickVarianceScoreReturnsZeroForNoHistory(): void
+    {
+        $context = $this->createRequestContext([
+            'headers' => ['x-behavior-metrics' => json_encode([])]
+        ]);
+        $result = RequestUtils::getClickVarianceScore($context);
+        $this->assertEquals(0.0, $result['clickVarianceScore']);
+    }
+
+    public function testGetClickVarianceScoreReturnsZeroForInsufficientClicks(): void
+    {
+        $metrics = [
+            'clicksHistory' => [
+                ['x' => 10, 'y' => 10, 'targetId' => 'hash1'],
+                ['x' => 11, 'y' => 11, 'targetId' => 'hash1'],
+                ['x' => 100, 'y' => 100, 'targetId' => 'hash2']
+            ]
+        ];
+        $context = $this->createRequestContext(['headers' => ['x-behavior-metrics' => json_encode($metrics)]]);
+        $result = RequestUtils::getClickVarianceScore($context);
+        $this->assertEquals(0.0, $result['clickVarianceScore']);
+    }
+
+    public function testGetClickVarianceScoreReturnsHighScoreForLowVariance(): void
+    {
+        $metrics = [
+            'clicksHistory' => [
+                ['x' => 100, 'y' => 100, 'targetId' => 'hash1'],
+                ['x' => 100.1, 'y' => 100.2, 'targetId' => 'hash1'],
+                ['x' => 99.9, 'y' => 99.8, 'targetId' => 'hash1']
+            ]
+        ];
+        $context = $this->createRequestContext(['headers' => ['x-behavior-metrics' => json_encode($metrics)]]);
+        $result = RequestUtils::getClickVarianceScore($context);
+        $this->assertGreaterThan(90, $result['clickVarianceScore']);
+    }
+
+    public function testGetClickVarianceScoreReturnsLowScoreForHighVariance(): void
+    {
+        $metrics = [
+            'clicksHistory' => [
+                ['x' => 105, 'y' => 110, 'targetId' => 'hash1'],
+                ['x' => 98, 'y' => 102, 'targetId' => 'hash1'],
+                ['x' => 112, 'y' => 95, 'targetId' => 'hash1']
+            ]
+        ];
+        $context = $this->createRequestContext(['headers' => ['x-behavior-metrics' => json_encode($metrics)]]);
+        $result = RequestUtils::getClickVarianceScore($context);
+        $this->assertEquals(0.0, $result['clickVarianceScore']);
+    }
+}

package/src/php/Tests/problems.config.json

@@ -0,0 +1,9 @@
+[
+    {
+        "id": "problem-1",
+        "workUnit": {
+            "type": "simulated_annealing_iterations",
+            "baseIterations": 10000
+        }
+    }
+]

package/src/php/Utils/BigInt.php

@@ -0,0 +1,145 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Anonympins\Fingerprint\Utils;
+
+class BigInt
+{
+    private static bool $useGmp;
+    /** @var \GMP|string */
+    private $value;
+
+    /**
+     * @param \GMP|string|int $number Le nombre initial.
+     */
+    public function __construct($number)
+    {
+        if (!isset(self::$useGmp)) {
+            self::$useGmp = extension_loaded('gmp');
+        }
+
+        if (self::$useGmp) {
+            if ($number instanceof \GMP) {
+                $this->value = $number;
+            } else {
+                $this->value = gmp_init($number);
+            }
+        } else {
+            if ($number instanceof BigInt) {
+                $this->value = $number->value;
+            } else {
+                $this->value = (string)$number;
+            }
+        }
+    }
+
+    /**
+     * Crée une instance à partir d'une chaîne hexadécimale.
+     */
+    public static function fromHex(string $hex): BigInt
+    {
+        if (self::$useGmp) {
+            return new self(gmp_init($hex, 16));
+        } else {
+            $dec = '0';
+            $len = strlen($hex);
+            for ($i = 0; $i < $len; $i++) {
+                $dec = bcadd(bcmul($dec, '16'), (string)hexdec($hex[$i]));
+            }
+            return new self($dec);
+        }
+    }
+
+    /**
+     * Compare cette instance avec une autre.
+     * @return int < 0 si this < other, 0 si this == other, > 0 si this > other.
+     */
+    public function compareTo(BigInt $other): int
+    {
+        if (self::$useGmp) {
+            return gmp_cmp($this->value, $other->value);
+        } else {
+            return bccomp($this->value, $other->value);
+        }
+    }
+
+    /**
+     * Effectue un décalage de bits vers la gauche (<<).
+     */
+    public function shiftLeft(int $bits): BigInt
+    {
+        if (self::$useGmp) {
+            return new self(gmp_mul($this->value, gmp_pow("2", $bits)));
+        } else {
+            return new self(bcmul($this->value, bcpow("2", (string)$bits)));
+        }
+    }
+
+    /**
+     * Effectue un décalage de bits vers la droite (>>).
+     */
+    public function shiftRight(int $bits): BigInt
+    {
+        if (self::$useGmp) {
+            return new self(gmp_div_q($this->value, gmp_pow("2", $bits)));
+        } else {
+            return new self(bcdiv($this->value, bcpow("2", (string)$bits)));
+        }
+    }
+
+    /**
+     * Retourne la représentation en chaîne de caractères.
+     */
+    public function __toString(): string
+    {
+        if (self::$useGmp) {
+            return gmp_strval($this->value);
+        } else {
+            return $this->value;
+        }
+    }
+
+    /**
+     * Retourne la représentation hexadécimale.
+     */
+    public function toHex(): string
+    {
+        if (self::$useGmp) {
+            return gmp_strval($this->value, 16);
+        } else {
+            $hex = '';
+            $dec = $this->value;
+            while (bccomp($dec, '0') > 0) {
+                $rem = bcmod($dec, '16');
+                $hex = dechex((int)$rem) . $hex;
+                $dec = bcdiv($dec, '16');
+            }
+            return $hex ?: '0';
+        }
+    }
+
+    /**
+     * Crée une instance à partir d'une puissance de 2.
+     */
+    public static function pow(int $base, int $exp): BigInt
+    {
+        if (self::$useGgmp) {
+            return new self(gmp_pow((string)$base, $exp));
+        } else {
+            return new self(bcpow((string)$base, (string)$exp));
+        }
+    }
+
+    /**
+     * Soustrait un autre BigInt.
+     */
+    public function sub(BigInt $other): BigInt
+    {
+        if (self::$useGmp) {
+            return new self(gmp_sub($this->value, $other->value));
+        } else {
+            return new self(bcsub($this->value, $other->value));
+        }
+    }
+}

package/src/php/Utils/BlockList.php

@@ -0,0 +1,100 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Anonympins\Fingerprint\Utils;
+
+/**
+ * Implémentation PHP d'une liste de blocage IP/CIDR, similaire à Node.js `net.BlockList`.
+ */
+class BlockList
+{
+    /**
+     * @var array<string> Liste des IPs ou CIDR à bloquer.
+     */
+    private array $entries = [];
+
+    /**
+     * Ajoute une adresse IP ou une plage CIDR à la liste.
+     * @param string $entry Une adresse IP (ex: '192.168.1.1') ou une plage CIDR (ex: '192.168.1.0/24').
+     * @return void
+     */
+    public function add(string $entry): void
+    {
+        $this->entries[] = $entry;
+    }
+
+    /**
+     * Vérifie si une adresse IP est présente dans la liste de blocage.
+     * @param string $ip L'adresse IP à vérifier.
+     * @return bool True si l'IP est bloquée, false sinon.
+     */
+    public function check(string $ip): bool
+    {
+        foreach ($this->entries as $entry) {
+            if (str_contains($entry, '/')) {
+                // C'est une plage CIDR
+                if ($this->ipInCidr($ip, $entry)) {
+                    return true;
+                }
+            } else {
+                // C'est une IP directe
+                if ($ip === $entry) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Vérifie si une adresse IP se trouve dans une plage CIDR donnée.
+     * @param string $ip L'adresse IP à vérifier.
+     * @param string $cidr La plage CIDR (ex: '192.168.1.0/24').
+     * @return bool True si l'IP est dans la plage, false sinon.
+     */
+    private function ipInCidr(string $ip, string $cidr): bool
+    {
+        [$network, $mask] = explode('/', $cidr);
+        $mask = (int)$mask;
+
+        if (filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_IPV6) && filter_var($network, FILTER_VALIDATE_IP, FILTER_FLAG_IPV6)) {
+            // IPv6
+            $ipBinary = inet_pton($ip);
+            $networkBinary = inet_pton($network);
+
+            if ($ipBinary === false || $networkBinary === false) {
+                return false;
+            }
+
+            $ipHex = bin2hex($ipBinary);
+            $networkHex = bin2hex($networkBinary);
+
+            $numBytes = (int)ceil($mask / 8);
+            $compareLength = $numBytes * 2;
+
+            if (substr($ipHex, 0, $compareLength) !== substr($networkHex, 0, $compareLength)) {
+                return false;
+            }
+
+            if ($mask % 8 !== 0) {
+                $bitMask = (0xFF << (8 - ($mask % 8))) & 0xFF;
+                $ipByte = hexdec(substr($ipHex, $numBytes * 2 - 2, 2));
+                $networkByte = hexdec(substr($networkHex, $numBytes * 2 - 2, 2));
+                return ($ipByte & $bitMask) === ($networkByte & $bitMask);
+            }
+
+            return true;
+
+        } elseif (filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_IPV4) && filter_var($network, FILTER_VALIDATE_IP, FILTER_FLAG_IPV4)) {
+            // IPv4
+            $ipLong = ip2long($ip);
+            $networkLong = ip2long($network);
+            $wildcard = pow(2, (32 - $mask)) - 1;
+            $netmask = ~$wildcard;
+            return (($ipLong & $netmask) === ($networkLong & $netmask));
+        }
+
+        return false;
+    }
+}

package/src/php/Utils/Logger.php

@@ -0,0 +1,30 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Anonympins\Fingerprint\Utils;
+
+/**
+ * Un simple wrapper de logger pour passer les données à une fonction de rappel.
+ */
+class Logger
+{
+    /**
+     * @var callable
+     */
+    private $callback;
+
+    public function __construct(callable $callback)
+    {
+        $this->callback = $callback;
+    }
+
+    public function log(string $level, string $type, array $data): void
+    {
+        $logEntry = array_merge($data, [
+            'type' => $type,
+            'timestamp' => (int)floor(microtime(true) * 1000),
+        ]);
+        ($this->callback)($logEntry);
+    }
+}