@anonympins/fingerprint 0.4.4 → 0.4.6

package/src/php/Optimization/Optimization.php

@@ -1,256 +1,258 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Anonympins\Fingerprint\Optimization;
-
-/**
- * Bibliothèque d'algorithmes d'optimisation.
- */
-class Optimization
-{
-    /**
-     * Génère un nombre flottant aléatoire cryptographiquement sûr entre 0 (inclus) et 1 (exclus).
-     */
-    private static function secureRandom(): float
-    {
-        try {
-            return random_int(0, PHP_INT_MAX - 1) / PHP_INT_MAX;
-        } catch (\Exception $e) {
-            return (float)mt_rand() / (float)mt_getrandmax(); // Fallback
-        }
-    }
-
-    /**
-     * Algorithme génétique multi-objectifs (inspiré de NSGA-II).
-     * @param callable $createIndividual
-     * @param callable $fitnessFunction
-     * @param callable $crossover
-     * @param callable $mutate
-     * @param array $options
-     * @return array<int, array{solution: mixed, objectives: array<float>}>
-     */
-    public static function geneticAlgorithmMultiObjective(
-        callable $createIndividual,
-        callable $fitnessFunction,
-        callable $crossover,
-        callable $mutate,
-        array $options = []
-    ): array {
-        $generations = $options['generations'] ?? 150;
-        $populationSize = $options['populationSize'] ?? 60;
-        $mutationRate = $options['mutationRate'] ?? 0.1;
-
-        $population = [];
-        for ($i = 0; $i < $populationSize; $i++) {
-            $individual = $createIndividual();
-            $population[] = [
-                'individual' => $individual,
-                'objectives' => $fitnessFunction($individual)
-            ];
-        }
-
-        for ($gen = 0; $gen < $generations; $gen++) {
-            // 1. Créer une population d'enfants
-            $offspring = [];
-            for ($i = 0; $i < $populationSize; $i++) {
-                $parent1 = $population[random_int(0, count($population) - 1)];
-                $parent2 = $population[random_int(0, count($population) - 1)];
-                $childIndividual = $crossover($parent1['individual'], $parent2['individual']);
-                if (self::secureRandom() < $mutationRate) {
-                    $childIndividual = $mutate($childIndividual);
-                }
-                $offspring[] = [
-                    'individual' => $childIndividual,
-                    'objectives' => $fitnessFunction($childIndividual)
-                ];
-            }
-
-            // 2. Combiner parents et enfants
-            $combinedPopulation = array_merge($population, $offspring);
-
-            // 3. Trier la population combinée en fronts
-            $fronts = self::nonDominatedSort($combinedPopulation);
-
-            // 4. Construire la nouvelle population
-            $newPopulation = [];
-            foreach ($fronts as $front) {
-                if (count($newPopulation) + count($front) <= $populationSize) {
-                    $newPopulation = array_merge($newPopulation, $front);
-                } else {
-                    self::calculateCrowdingDistance($front);
-                    // Trier par distance décroissante
-                    usort($front, fn ($a, $b) => $b['crowdingDistance'] <=> $a['crowdingDistance']);
-                    $remaining = $populationSize - count($newPopulation);
-                    $newPopulation = array_merge($newPopulation, array_slice($front, 0, $remaining));
-                    break;
-                }
-            }
-            $population = $newPopulation;
-        }
-
-        // Retourner le premier front de la population finale
-        $finalFronts = self::nonDominatedSort($population);
-        $bestFront = $finalFronts[0] ?? [];
-
-        // Filtrer pour ne garder que les solutions avec des objectifs uniques
-        $uniqueSolutionsMap = [];
-        foreach ($bestFront as $p) {
-            $key = json_encode($p['objectives']);
-            if (!isset($uniqueSolutionsMap[$key])) {
-                $uniqueSolutionsMap[$key] = [
-                    'solution' => $p['individual'],
-                    'objectives' => $p['objectives'],
-                ];
-            }
-        }
-        return array_values($uniqueSolutionsMap);
-    }
-
-    /**
-     * Détermine si la solution A domine la solution B.
-     * @param array<float> $objectivesA
-     * @param array<float> $objectivesB
-     */
-    private static function paretoDominates(array $objectivesA, array $objectivesB): bool
-    {
-        $aIsBetterInOne = false;
-        for ($i = 0; $i < count($objectivesA); $i++) {
-            if ($objectivesA[$i] > $objectivesB[$i]) {
-                return false; // A est pire sur au moins un objectif
-            }
-            if ($objectivesA[$i] < $objectivesB[$i]) {
-                $aIsBetterInOne = true; // A est strictement meilleur sur au moins un
-            }
-        }
-        return $aIsBetterInOne;
-    }
-
-    /**
-     * Trie une population en fronts de Pareto non-dominés.
-     * @param array<int, array> &$populationWithObjectives
-     * @return array<int, array>
-     */
-    private static function nonDominatedSort(array &$populationWithObjectives): array
-    {
-        $fronts = [[]];
-        $n = count($populationWithObjectives);
-
-        for ($i = 0; $i < $n; $i++) {
-            $p1 = &$populationWithObjectives[$i];
-            $p1['dominationCount'] = 0;
-            $p1['dominatedSolutions'] = [];
-
-            for ($j = 0; $j < $n; $j++) {
-                if ($i === $j) continue;
-                $p2 = &$populationWithObjectives[$j];
-
-                if (self::paretoDominates($p1['objectives'], $p2['objectives'])) {
-                    $p1['dominatedSolutions'][] = $j;
-                } elseif (self::paretoDominates($p2['objectives'], $p1['objectives'])) {
-                    $p1['dominationCount']++;
-                }
-            }
-
-            if ($p1['dominationCount'] === 0) {
-                $p1['rank'] = 0;
-                $fronts[0][] = $p1;
-            }
-        }
-
-        $i = 0;
-        while (!empty($fronts[$i])) {
-            $nextFront = [];
-            foreach ($fronts[$i] as $p1) {
-                foreach ($p1['dominatedSolutions'] as $p2_idx) {
-                    $p2 = &$populationWithObjectives[$p2_idx];
-                    $p2['dominationCount']--;
-                    if ($p2['dominationCount'] === 0) {
-                        $p2['rank'] = $i + 1;
-                        $nextFront[] = $p2;
-                    }
-                }
-            }
-            $i++;
-            if (!empty($nextFront)) {
-                $fronts[$i] = $nextFront;
-            }
-        }
-        return $fronts;
-    }
-
-    /**
-     * Calcule la distance de promiscuité (crowding distance) pour un front.
-     * @param array<int, array> &$front
-     */
-    private static function calculateCrowdingDistance(array &$front): void
-    {
-        if (empty($front)) return;
-
-        $numObjectives = count($front[0]['objectives']);
-        $l = count($front);
-
-        foreach ($front as &$p) {
-            $p['crowdingDistance'] = 0;
-        }
-
-        for ($i = 0; $i < $numObjectives; $i++) {
-            // Trier le front par l'objectif courant
-            usort($front, fn ($a, $b) => $a['objectives'][$i] <=> $b['objectives'][$i]);
-
-            $minObj = $front[0]['objectives'][$i];
-            $maxObj = $front[$l - 1]['objectives'][$i];
-
-            // Les solutions aux extrémités ont une distance infinie
-            $front[0]['crowdingDistance'] = INF;
-            $front[$l - 1]['crowdingDistance'] = INF;
-
-            if ($maxObj === $minObj) continue;
-
-            for ($j = 1; $j < $l - 1; $j++) {
-                $front[$j]['crowdingDistance'] +=
-                    ($front[$j + 1]['objectives'][$i] - $front[$j - 1]['objectives'][$i]) /
-                    ($maxObj - $minObj);
-            }
-        }
-    }
-
-    /**
-     * Calcule la déviation d'une série de chiffres par rapport à la loi de Benford.
-     * @public
-     * @param array<int|float> $numbers
-     */
-    public static function benfordTest(array $numbers): float // Rendre la méthode publique et statique
-    {
-        if (count($numbers) < 10) {
-            return 0.0; // Pas assez de données
-        }
-
-        $leadingDigits = array_map(function ($n) {
-            $str = ltrim((string)$n, '0.');
-            return $str[0] ?? '';
-        }, $numbers);
-
-        $leadingDigits = array_filter($leadingDigits, fn ($d) => $d >= '1' && $d <= '9');
-
-        if (count($leadingDigits) < 10) {
-            return 0.0;
-        }
-
-        $counts = array_fill(1, 9, 0);
-        foreach ($leadingDigits as $digit) {
-            $counts[(int)$digit]++;
-        }
-
-        $benfordDistribution = [1 => 30.1, 2 => 17.6, 3 => 12.5, 4 => 9.7, 5 => 7.9, 6 => 6.7, 7 => 5.8, 8 => 5.1, 9 => 4.6];
-
-        $totalDeviation = 0.0;
-        for ($i = 1; $i <= 9; $i++) {
-            $observedFrequency = ($counts[$i] / count($leadingDigits)) * 100;
-            $expectedFrequency = $benfordDistribution[$i];
-            $totalDeviation += pow($observedFrequency - $expectedFrequency, 2);
-        }
-
-        return sqrt($totalDeviation) / 50.0;
-    }
+<?php
+
+declare(strict_types=1);
+
+namespace Anonympins\Fingerprint\Optimization;
+
+/**
+ * Bibliothèque d'algorithmes d'optimisation.
+ */
+class Optimization
+{
+    /**
+     * Génère un nombre flottant aléatoire cryptographiquement sûr entre 0 (inclus) et 1 (exclus).
+     */
+    private static function secureRandom(): float
+    {
+        try {
+            return random_int(0, PHP_INT_MAX - 1) / PHP_INT_MAX;
+        } catch (\Exception $e) {
+            return (float)mt_rand() / (float)mt_getrandmax(); // Fallback
+        }
+    }
+
+    /**
+     * Algorithme génétique multi-objectifs (inspiré de NSGA-II).
+     * @param callable $createIndividual
+     * @param callable $fitnessFunction
+     * @param callable $crossover
+     * @param callable $mutate
+     * @param array|null $currentConfig La configuration actuelle pour guider l'initialisation et la mutation.
+     * @param array $options
+     * @return array<int, array{solution: mixed, objectives: array<float>}>
+     */
+    public static function geneticAlgorithmMultiObjective(
+        callable $createIndividual,
+        callable $fitnessFunction,
+        callable $crossover,
+        callable $mutate, // La fonction mutate doit maintenant accepter $currentConfig
+        ?array $currentConfig = null, // NOUVEAU: La configuration actuelle
+        array $options = []
+    ): array {
+        $generations = $options['generations'] ?? 150;
+        $populationSize = $options['populationSize'] ?? 60;
+        $mutationRate = $options['mutationRate'] ?? 0.1;
+
+        $population = [];
+        for ($i = 0; $i < $populationSize; $i++) {
+            $individual = $createIndividual();
+            $population[] = [
+                'individual' => $individual,
+                'objectives' => $fitnessFunction($individual)
+            ];
+        }
+
+        for ($gen = 0; $gen < $generations; $gen++) {
+            // 1. Créer une population d'enfants
+            $offspring = [];
+            for ($i = 0; $i < $populationSize; $i++) {
+                $parent1 = $population[random_int(0, count($population) - 1)];
+                $parent2 = $population[random_int(0, count($population) - 1)];
+                $childIndividual = $crossover($parent1['individual'], $parent2['individual']);
+                if (self::secureRandom() < $mutationRate) {
+                    $childIndividual = $mutate($childIndividual, $currentConfig); // Passer $currentConfig à mutate
+                }
+                $offspring[] = [
+                    'individual' => $childIndividual,
+                    'objectives' => $fitnessFunction($childIndividual)
+                ];
+            }
+
+            // 2. Combiner parents et enfants
+            $combinedPopulation = array_merge($population, $offspring);
+
+            // 3. Trier la population combinée en fronts
+            $fronts = self::nonDominatedSort($combinedPopulation);
+
+            // 4. Construire la nouvelle population
+            $newPopulation = [];
+            foreach ($fronts as $front) {
+                if (count($newPopulation) + count($front) <= $populationSize) {
+                    $newPopulation = array_merge($newPopulation, $front);
+                } else {
+                    self::calculateCrowdingDistance($front);
+                    // Trier par distance décroissante
+                    usort($front, fn ($a, $b) => $b['crowdingDistance'] <=> $a['crowdingDistance']);
+                    $remaining = $populationSize - count($newPopulation);
+                    $newPopulation = array_merge($newPopulation, array_slice($front, 0, $remaining));
+                    break;
+                }
+            }
+            $population = $newPopulation;
+        }
+
+        // Retourner le premier front de la population finale
+        $finalFronts = self::nonDominatedSort($population);
+        $bestFront = $finalFronts[0] ?? [];
+
+        // Filtrer pour ne garder que les solutions avec des objectifs uniques
+        $uniqueSolutionsMap = [];
+        foreach ($bestFront as $p) {
+            $key = json_encode($p['objectives']);
+            if (!isset($uniqueSolutionsMap[$key])) {
+                $uniqueSolutionsMap[$key] = [
+                    'solution' => $p['individual'],
+                    'objectives' => $p['objectives'],
+                ];
+            }
+        }
+        return array_values($uniqueSolutionsMap);
+    }
+
+    /**
+     * Détermine si la solution A domine la solution B.
+     * @param array<float> $objectivesA
+     * @param array<float> $objectivesB
+     */
+    private static function paretoDominates(array $objectivesA, array $objectivesB): bool
+    {
+        $aIsBetterInOne = false;
+        for ($i = 0; $i < count($objectivesA); $i++) {
+            if ($objectivesA[$i] > $objectivesB[$i]) {
+                return false; // A est pire sur au moins un objectif
+            }
+            if ($objectivesA[$i] < $objectivesB[$i]) {
+                $aIsBetterInOne = true; // A est strictement meilleur sur au moins un
+            }
+        }
+        return $aIsBetterInOne;
+    }
+
+    /**
+     * Trie une population en fronts de Pareto non-dominés.
+     * @param array<int, array> &$populationWithObjectives
+     * @return array<int, array>
+     */
+    private static function nonDominatedSort(array &$populationWithObjectives): array
+    {
+        $fronts = [[]];
+        $n = count($populationWithObjectives);
+
+        for ($i = 0; $i < $n; $i++) {
+            $p1 = &$populationWithObjectives[$i];
+            $p1['dominationCount'] = 0;
+            $p1['dominatedSolutions'] = [];
+
+            for ($j = 0; $j < $n; $j++) {
+                if ($i === $j) continue;
+                $p2 = &$populationWithObjectives[$j];
+
+                if (self::paretoDominates($p1['objectives'], $p2['objectives'])) {
+                    $p1['dominatedSolutions'][] = $j;
+                } elseif (self::paretoDominates($p2['objectives'], $p1['objectives'])) {
+                    $p1['dominationCount']++;
+                }
+            }
+
+            if ($p1['dominationCount'] === 0) {
+                $p1['rank'] = 0;
+                $fronts[0][] = $p1;
+            }
+        }
+
+        $i = 0;
+        while (!empty($fronts[$i])) {
+            $nextFront = [];
+            foreach ($fronts[$i] as $p1) {
+                foreach ($p1['dominatedSolutions'] as $p2_idx) {
+                    $p2 = &$populationWithObjectives[$p2_idx];
+                    $p2['dominationCount']--;
+                    if ($p2['dominationCount'] === 0) {
+                        $p2['rank'] = $i + 1;
+                        $nextFront[] = $p2;
+                    }
+                }
+            }
+            $i++;
+            if (!empty($nextFront)) {
+                $fronts[$i] = $nextFront;
+            }
+        }
+        return $fronts;
+    }
+
+    /**
+     * Calcule la distance de promiscuité (crowding distance) pour un front.
+     * @param array<int, array> &$front
+     */
+    private static function calculateCrowdingDistance(array &$front): void
+    {
+        if (empty($front)) return;
+
+        $numObjectives = count($front[0]['objectives']);
+        $l = count($front);
+
+        foreach ($front as &$p) {
+            $p['crowdingDistance'] = 0;
+        }
+
+        for ($i = 0; $i < $numObjectives; $i++) {
+            // Trier le front par l'objectif courant
+            usort($front, fn ($a, $b) => $a['objectives'][$i] <=> $b['objectives'][$i]);
+
+            $minObj = $front[0]['objectives'][$i];
+            $maxObj = $front[$l - 1]['objectives'][$i];
+
+            // Les solutions aux extrémités ont une distance infinie
+            $front[0]['crowdingDistance'] = INF;
+            $front[$l - 1]['crowdingDistance'] = INF;
+
+            if ($maxObj === $minObj) continue;
+
+            for ($j = 1; $j < $l - 1; $j++) {
+                $front[$j]['crowdingDistance'] +=
+                    ($front[$j + 1]['objectives'][$i] - $front[$j - 1]['objectives'][$i]) /
+                    ($maxObj - $minObj);
+            }
+        }
+    }
+
+    /**
+     * Calcule la déviation d'une série de chiffres par rapport à la loi de Benford.
+     * @public
+     * @param array<int|float> $numbers
+     */
+    public static function benfordTest(array $numbers): float // Rendre la méthode publique et statique
+    {
+        if (count($numbers) < 10) {
+            return 0.0; // Pas assez de données
+        }
+
+        $leadingDigits = array_map(function ($n) {
+            $str = ltrim((string)$n, '0.');
+            return $str[0] ?? '';
+        }, $numbers);
+
+        $leadingDigits = array_filter($leadingDigits, fn ($d) => $d >= '1' && $d <= '9');
+
+        if (count($leadingDigits) < 10) {
+            return 0.0;
+        }
+
+        $counts = array_fill(1, 9, 0);
+        foreach ($leadingDigits as $digit) {
+            $counts[(int)$digit]++;
+        }
+
+        $benfordDistribution = [1 => 30.1, 2 => 17.6, 3 => 12.5, 4 => 9.7, 5 => 7.9, 6 => 6.7, 7 => 5.8, 8 => 5.1, 9 => 4.6];
+
+        $totalDeviation = 0.0;
+        for ($i = 1; $i <= 9; $i++) {
+            $observedFrequency = ($counts[$i] / count($leadingDigits)) * 100;
+            $expectedFrequency = $benfordDistribution[$i];
+            $totalDeviation += pow($observedFrequency - $expectedFrequency, 2);
+        }
+
+        return sqrt($totalDeviation) / 50.0;
+    }
 }

package/src/php/Optimization/OptimizationOperators.php

@@ -104,39 +104,6 @@ class OptimizationOperators
     {
         $fitnessFunction = self::createFullSecurityConfigEvaluator($context);
 
-        $createIndividual = function (): array {
-            return [
-                'thresholds' => [
-                    'low' => 15 + self::secureRandom() * 20,
-                    'medium' => 40 + self::secureRandom() * 25,
-                    'high' => 70 + self::secureRandom() * 20,
-                ],
-                'weights' => [
-                    'historyScore' => self::secureRandom(),
-                    'rotationScore' => self::secureRandom(),
-                    'headerAnomalyScore' => self::secureRandom(),
-                    'requestPatternScore' => 0.5 + self::secureRandom(),
-                    'inconsistencyScore' => self::secureRandom(),
-                    'honeypotScore' => 1.0,
-                    'behaviorScore' => self::secureRandom(),
-                    'crossLayerInconsistencyScore' => self::secureRandom(),
-                    'timeInconsistencyScore' => self::secureRandom(),
-                    'tlsSpoofingScore' => self::secureRandom(),
-                    'botScore' => self::secureRandom(),
-                    'cookieDroppingScore' => self::secureRandom(),
-                    'threatIntelScore' => self::secureRandom(),
-                ],
-                'patterns' => [
-                    'velocityThreshold' => 100 + self::secureRandom() * 400,
-                    'burstThreshold' => 300 + self::secureRandom() * 700,
-                    'scrapeThreshold' => 500 + self::secureRandom() * 1000,
-                    'regularityThreshold' => 50 + self::secureRandom() * 200,
-                    'decayFactor' => 0.85 + self::secureRandom() * 0.14,
-                    'inactivityReset' => 15000 + self::secureRandom() * 45000,
-                ]
-            ];
-        };
-
         $crossover = function (array $c1, array $c2): array {
             $child = $c1;
             foreach (['thresholds', 'weights', 'patterns'] as $section) {
@@ -148,8 +115,35 @@ class OptimizationOperators
             }
             return $child;
         };
+        $createIndividual = function () use ($currentConfig): array {
+            if ($currentConfig) {
+                $ind = [
+                    'thresholds' => [],
+                    'weights' => [],
+                    'patterns' => []
+                ];
+                foreach (['thresholds', 'weights', 'patterns'] as $section) {
+                    if (isset($currentConfig[$section]) && is_array($currentConfig[$section])) {
+                        foreach ($currentConfig[$section] as $k => $v) {
+                            if (is_numeric($v) && $k !== 'honeypotScore') {
+                                $randomVariation = 1.0 + (self::secureRandom() - 0.5) * 0.5; // Variation de +/- 25%
+                                $ind[$section][$k] = $v * $randomVariation;
+                            } else {
+                                $ind[$section][$k] = $v;
+                            }
+                        }
+                    }
+                }
+                if (isset($ind['thresholds']['low'], $ind['thresholds']['medium'], $ind['thresholds']['high'])) {
+                    $ind['thresholds']['low'] = max(10.0, min(35.0, (float)$ind['thresholds']['low']));
+                    $ind['thresholds']['medium'] = max($ind['thresholds']['low'] + 5.0, min(70.0, (float)$ind['thresholds']['medium']));
+                    $ind['thresholds']['high'] = max($ind['thresholds']['medium'] + 5.0, min(90.0, (float)$ind['thresholds']['high']));
+                }
+                return $ind;
+            }
+        };
 
-        $mutate = function (array $c): array {
+        $mutate = function (array $c, ?array $currentConfigRef = null) use ($currentConfig): array {
             $newConfig = $c;
             $sections = [
                 ['name' => 'patterns', 'weight' => 0.5],
@@ -179,15 +173,27 @@ class OptimizationOperators
                 $newConfig[$sectionToMutate][$keyToMutate] = max(0, min(1.5, $newConfig[$sectionToMutate][$keyToMutate]));
             }
 
+            $refConfig = $currentConfigRef ?? $currentConfig;
+            if ($refConfig && isset($refConfig[$sectionToMutate][$keyToMutate])) {
+                $originalValue = $refConfig[$sectionToMutate][$keyToMutate];
+                if (is_numeric($originalValue) && $originalValue != 0) {
+                    $minAllowed = $originalValue * 0.7; // -30%
+                    $maxAllowed = $originalValue * 1.3; // +30%
+                    $newConfig[$sectionToMutate][$keyToMutate] = max($minAllowed, min($maxAllowed, $newConfig[$sectionToMutate][$keyToMutate]));
+                }
+            }
+
             return $newConfig;
         };
+        $gaOptions = array_merge(['generations' => 50, 'populationSize' => 50], $options);
 
         return Optimization::geneticAlgorithmMultiObjective(
             $createIndividual,
             $fitnessFunction,
             $crossover,
             $mutate,
-            array_merge(['generations' => 50, 'populationSize' => 50], $options)
+            $currentConfig,
+            $gaOptions
         );
     }
 

package/src/php/RequestContext.php

@@ -24,6 +24,7 @@ class RequestContext
     public array $cookies = [];
     public ?string $httpVersion = null;
     public int $requestTimestamp = 0;
+    public ?string $tlsSessionId = null;
 
     /** @var ?array{type: string, name: string} */
     public ?array $graphqlOperation = null;
@@ -76,6 +77,7 @@ class RequestContext
         $this->ja4h = $this->headers['x-ja4h-hash'] ?? null;
         $this->http2Fingerprint = $this->headers['x-http2-fingerprint'] ?? null;
         $this->tcpFingerprint = $this->headers['x-tcp-fingerprint'] ?? null;
+        $this->tlsSessionId = $this->headers['x-tls-session-id'] ?? $this->headers['x-ssl-session-id'] ?? null;
     }
     /**
      * Récupère la valeur d'un en-tête HTTP de manière insensible à la casse.