@anonympins/fingerprint 0.3.2 → 0.3.3

package/src/php/Optimization/FunctionRegistry.php

@@ -0,0 +1,63 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Anonympins\Fingerprint\Optimization;
+
+/**
+ * Registre pour exposer de manière contrôlée les fonctions de la bibliothèque d'optimisation.
+ */
+class FunctionRegistry
+{
+    /** @var array<string, callable> */
+    private static array $functions = [];
+
+    /**
+     * Initialise le registre avec les fonctions disponibles.
+     */
+    private static function initialize(): void
+    {
+        if (empty(self::$functions)) {
+            // Fonctions de "Scoring"
+            self::$functions['tsp.calculateEnergy'] = [OptimizationUtils::class, 'evaluatePathDistance'];
+            self::$functions['portfolio.calculateMetrics'] = [OptimizationOperators::class, 'createPortfolioAllocator'];
+
+            // Fonctions de "Résolution"
+            self::$functions['tsp.solve'] = [OptimizationOperators::class, 'solveTSP'];
+            self::$functions['portfolio.solve'] = [OptimizationOperators::class, 'solvePortfolio'];
+            self::$functions['fraud.solve'] = [OptimizationOperators::class, 'solveFraudDetection'];
+            self::$functions['facility.solve'] = [OptimizationOperators::class, 'solveFacilityLocation'];
+            self::$functions['security.tune'] = [OptimizationOperators::class, 'solveFullSecurityTuning'];
+        }
+    }
+
+    /**
+     * Récupère une fonction depuis le registre.
+     */
+    public static function get(string $name): ?callable
+    {
+        self::initialize();
+        return self::$functions[$name] ?? null;
+    }
+    /**
+     * Enregistre une nouvelle fonction. Principalement pour les tests.
+     * @internal
+     * @param string $name
+     * @param callable $function
+     * @return void
+     */
+    public static function register(string $name, callable $function): void
+    {
+        self::initialize();
+        self::$functions[$name] = $function;
+    }
+
+    /**
+     * Réinitialise le registre. Uniquement pour les tests.
+     * @internal
+     */
+    public static function __internal_resetRegistry(): void
+    {
+        self::$functions = [];
+    }
+}

package/src/php/Optimization/Optimization.php

@@ -0,0 +1,256 @@
+<?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;
+    }
+}

package/src/php/Optimization/OptimizationOperators.php

@@ -0,0 +1,305 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Anonympins\Fingerprint\Optimization;
+
+/**
+ * Opérateurs pour les problèmes d'optimisation.
+ */
+class OptimizationOperators
+{
+    /**
+     * 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
+        }
+    }
+
+    /**
+     * Crée un évaluateur pour l'optimisation de portefeuille.
+     * @param array $config
+     * @return callable
+     */
+    public static function createPortfolioAllocator(array $config): callable
+    {
+        // Cette fonction est un placeholder. Une implémentation complète nécessiterait
+        // une logique de calcul de rendement et de volatilité de portefeuille.
+        return function (array $weights) use ($config): float {
+            // Minimiser le rendement négatif (donc maximiser le rendement)
+            return -array_sum($weights);
+        };
+    }
+
+    /**
+     * Crée un évaluateur pour l'auto-tuning complet de la configuration de sécurité.
+     * @param array $context
+     * @return callable
+     */
+    public static function createFullSecurityConfigEvaluator(array $context): callable
+    {
+        $trafficData = $context['trafficData'];
+
+        return function (array $config) use ($trafficData): array {
+            $falsePositives = 0;
+            $falseNegatives = 0;
+            $totalHumans = 0;
+            $totalBots = 0;
+
+            $calculateScore = function (array $log) use ($config): float {
+                $score = 0.0;
+                foreach ($config['weights'] as $key => $weight) {
+                    $score += ($log['vector'][$key] ?? 0) * $weight;
+                }
+                return $score;
+            };
+
+            $confidenceWeights = [
+                'request_passed' => 0.7,
+                'challenge_issued' => 1.0,
+                'request_blocked' => 1.0,
+                'challenge_solved' => 1.5,
+                'trap_triggered' => 2.0,
+            ];
+
+            foreach ($trafficData as $log) {
+                $confidence = $confidenceWeights[$log['type']] ?? 1.0;
+                $isLikelyBot = in_array($log['type'], ['challenge_issued', 'request_blocked', 'trap_triggered']);
+                $isLikelyHuman = in_array($log['type'], ['request_passed', 'challenge_solved']);
+
+                if ($isLikelyBot) {
+                    $totalBots += $confidence;
+                    $score = $calculateScore($log);
+                    if ($score < $config['thresholds']['low']) {
+                        $falseNegatives += $confidence;
+                    }
+                } elseif ($isLikelyHuman) {
+                    $totalHumans += $confidence;
+                    $score = $calculateScore($log);
+                    if ($score >= $config['thresholds']['low']) {
+                        $falsePositives += $confidence;
+                    }
+                }
+            }
+
+            $falsePositiveRate = $totalHumans > 0 ? $falsePositives / $totalHumans : 0;
+            $falseNegativeRate = $totalBots > 0 ? $falseNegatives / $totalBots : 0;
+
+            return [$falsePositiveRate, $falseNegativeRate];
+        };
+    }
+
+    /**
+     * Résout le problème de l'auto-tuning complet de la configuration de sécurité.
+     * @param array $context
+     * @param array $options
+     * @return array
+     */
+    public static function solveFullSecurityTuning(array $context, array $options = []): array
+    {
+        $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) {
+                foreach ($child[$section] as $key => $value) {
+                    if ($key !== 'honeypotScore') {
+                        $child[$section][$key] = ($c1[$section][$key] + $c2[$section][$key]) / 2;
+                    }
+                }
+            }
+            return $child;
+        };
+
+        $mutate = function (array $c): array {
+            $newConfig = $c;
+            $sections = [
+                ['name' => 'patterns', 'weight' => 0.5],
+                ['name' => 'weights', 'weight' => 0.35],
+                ['name' => 'thresholds', 'weight' => 0.15]
+            ];
+            $rand = self::secureRandom();
+            $cumulativeWeight = 0;
+            $sectionToMutate = 'patterns';
+            foreach ($sections as $section) {
+                $cumulativeWeight += $section['weight'];
+                if ($rand < $cumulativeWeight) {
+                    $sectionToMutate = $section['name'];
+                    break;
+                }
+            }
+
+            $keys = array_keys($newConfig[$sectionToMutate]);
+            $keyToMutate = $keys[random_int(0, count($keys) - 1)];
+
+            if ($keyToMutate === 'honeypotScore') return $newConfig;
+
+            $mutationAmount = (self::secureRandom() - 0.5) * 0.4;
+            $newConfig[$sectionToMutate][$keyToMutate] *= (1 + $mutationAmount);
+
+            if ($sectionToMutate === 'weights') {
+                $newConfig[$sectionToMutate][$keyToMutate] = max(0, min(1.5, $newConfig[$sectionToMutate][$keyToMutate]));
+            }
+
+            return $newConfig;
+        };
+
+        return Optimization::geneticAlgorithmMultiObjective(
+            $createIndividual,
+            $fitnessFunction,
+            $crossover,
+            $mutate,
+            array_merge(['generations' => 50, 'populationSize' => 50], $options)
+        );
+    }
+
+    /**
+     * Crée un évaluateur pour trouver les seuils de détection de fraude optimaux.
+     * @param array $context
+     * @return callable
+     */
+    public static function createFraudThresholdEvaluator(array $context): callable
+    {
+        $legitimateClicks = $context['legitimateClicks'] ?? [];
+        $fraudulentClicks = $context['fraudulentClicks'] ?? [];
+
+        return function (array $solution) use ($legitimateClicks, $fraudulentClicks): array {
+            [$minTimeToClick, $maxClickVariance, $minMouseEntropy, $minScrollEvents] = $solution;
+
+            $truePositives = 0;
+            $falsePositives = 0;
+
+            foreach ($fraudulentClicks as $click) {
+                if (
+                    ($click['timeToClick'] < $minTimeToClick) ||
+                    ($click['mouseEntropy'] < $minMouseEntropy)
+                ) {
+                    $truePositives++;
+                }
+            }
+
+            foreach ($legitimateClicks as $click) {
+                if (
+                    ($click['timeToClick'] < $minTimeToClick) ||
+                    ($click['mouseEntropy'] < $minMouseEntropy)
+                ) {
+                    $falsePositives++;
+                }
+            }
+
+            $totalFraudulent = count($fraudulentClicks) ?: 1;
+            $totalLegitimate = count($legitimateClicks) ?: 1;
+
+            $objective1 = 1 - ($truePositives / $totalFraudulent);
+            $objective2 = $falsePositives / $totalLegitimate;
+
+            return [$objective1, $objective2];
+        };
+    }
+
+    /**
+     * Résout le problème de la détection de fraude.
+     * @param array $context
+     * @param array $options
+     * @return array
+     */
+    public static function solveFraudDetection(array $context, array $options = []): array
+    {
+        $fitnessFunction = self::createFraudThresholdEvaluator($context);
+
+        $createIndividual = function (): array {
+            return [
+                100 + self::secureRandom() * 4900, // minTimeToClick
+                1 + self::secureRandom() * 9999,   // maxClickVariance
+                self::secureRandom() * 0.5,        // minMouseEntropy
+                floor(self::secureRandom() * 10) // minScrollEvents
+            ];
+        };
+
+        $crossover = fn ($s1, $s2) => array_map(fn ($a, $b) => ($a + $b) / 2, $s1, $s2);
+
+        $mutate = function (array $solution): array {
+            $i = random_int(0, 3);
+            $mutationFactors = [500, 1000, 0.1, 2];
+            $solution[$i] += (self::secureRandom() - 0.5) * $mutationFactors[$i];
+            return $solution;
+        };
+
+        return Optimization::geneticAlgorithmMultiObjective(
+            $createIndividual,
+            $fitnessFunction,
+            $crossover,
+            $mutate,
+            array_merge(['generations' => 80, 'populationSize' => 60], $options)
+        );
+    }
+
+    /**
+     * Placeholder pour le solveur TSP.
+     * @param array $cities
+     * @param array $options
+     * @return array
+     */
+    public static function solveTSP(array $cities, array $options = []): array
+    {
+        // Implémentation factice pour la complétude
+        return ['solution' => array_keys($cities), 'energy' => 100];
+    }
+
+    /**
+     * Placeholder pour le solveur de portefeuille.
+     * @param array $assets
+     * @param float $maxVolatility
+     * @param array $options
+     * @return array
+     */
+    public static function solvePortfolio(array $assets, float $maxVolatility, array $options = []): array
+    {
+        // Implémentation factice pour la complétude
+        return ['solution' => array_fill(0, count($assets), 1 / count($assets)), 'fitness' => -0.1];
+    }
+
+    public static function solveFacilityLocation(array $customers, int $numFacilities, array $bounds, array $options = []): array
+    {
+        // Implémentation factice pour la complétude
+        return ['solution' => [], 'energy' => 0];
+    }
+}

package/src/php/Optimization/ProblemInitializers.php

@@ -0,0 +1,53 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Anonympins\Fingerprint\Optimization;
+
+/**
+ * Fonctions pour générer dynamiquement les données d'un problème.
+ */
+class ProblemInitializers
+{
+    /** @var array<string, callable> */
+    private static array $initializers = [];
+
+    private static function initialize(): void
+    {
+        if (empty(self::$initializers)) {
+            self::$initializers['generate:randomPoints'] = function (array $params): array {
+                $count = $params['count'] ?? 0;
+                $bounds = $params['bounds'] ?? ['x' => 1000, 'y' => 1000];
+                if (!is_numeric($count)) return [];
+                $points = [];
+                for ($i = 0; $i < $count; $i++) {
+                    $points[] = [
+                        'x' => mt_rand() / mt_getrandmax() * $bounds['x'],
+                        'y' => mt_rand() / mt_getrandmax() * $bounds['y']
+                    ];
+                }
+                return $points;
+            };
+
+            self::$initializers['generate:randomAssets'] = function (array $params): array {
+                $count = $params['count'] ?? 0;
+                if (!is_numeric($count)) return [];
+                $assets = [];
+                for ($i = 0; $i < $count; $i++) {
+                    $assets[] = [
+                        'name' => 'Asset ' . ($i + 1),
+                        'expectedReturn' => mt_rand() / mt_getrandmax() * 0.2,
+                        'volatility' => 0.1 + mt_rand() / mt_getrandmax() * 0.3
+                    ];
+                }
+                return $assets;
+            };
+        }
+    }
+
+    public static function get(string $name): ?callable
+    {
+        self::initialize();
+        return self::$initializers[$name] ?? null;
+    }
+}