@anonympins/fingerprint 0.3.4 → 0.3.6

package/src/php/Utils/RequestUtils.php

@@ -186,7 +186,7 @@ class RequestUtils
     public static function getHeaderAnomalies(RequestContext $context): array
     {
         $anomalyScore = 0;
-        $ua = $context->getHeader('user-agent');
+        $ua = $context->getHeader('user-agent') ?? '';
         if (empty($ua) || strlen($ua) < 10) {
             $anomalyScore += 60;
         }
@@ -197,6 +197,17 @@ class RequestUtils
             $anomalyScore += 15;
         }
 
+        // TE: trailers check for Firefox on Desktop
+        $uaParts = self::parseUserAgent($ua);
+        $isFirefoxDesktop = isset($uaParts['browser']) && str_starts_with($uaParts['browser'], 'Firefox') && ($uaParts['device'] ?? 'desktop') === 'desktop';
+        $te = strtolower($context->getHeader('te') ?? '');
+
+        if ($isFirefoxDesktop && $te !== 'trailers') {
+            $anomalyScore += 30;
+        } elseif (!$isFirefoxDesktop && ($uaParts['device'] ?? 'desktop') === 'desktop' && $te === 'trailers') {
+            $anomalyScore += 30;
+        }
+
         return ['headerAnomalyScore' => min(100.0, $anomalyScore)];
     }
 
@@ -520,7 +531,7 @@ class RequestUtils
             $deviceData['lastChangeTimestamp'] = $now;
         }
         $deviceData['lastFpHash'] = $currentFpHash;
-        
+
         // Enregistrement de l'IP
         if (!in_array($clientIp, $deviceData['ips'])) {
             $deviceData['ips'][] = $clientIp;
@@ -620,6 +631,25 @@ class RequestUtils
             }
         }
 
+        // Détection d'énumération de chemins (crawling/scraping de ressources séquentielles)
+        $enumerationScore = 0;
+        if (count($history) >= 3) {
+            $templates = array_map(function($h) {
+                return preg_replace('/\d+/', '{num}', $h['path']);
+            }, $history);
+
+            $uniquePaths = array_unique(array_map(function($h) {
+                return $h['path'];
+            }, $history));
+
+            $templateCounts = array_count_values($templates);
+            $maxTemplateRepetition = !empty($templateCounts) ? max($templateCounts) : 0;
+
+            if ($maxTemplateRepetition >= 3 && count($uniquePaths) === count($history)) {
+                $enumerationScore = $patternWeight * 0.8;
+            }
+        }
+
         // Logique de décroissance et de score final
         $newPatternScore = $deviceData['lastPatternScore'] ?? 0;
 
@@ -630,7 +660,7 @@ class RequestUtils
         }
         $newPatternScore = max(0, $newPatternScore);
 
-        $deviceData['lastPatternScore'] = $newPatternScore + $instantScore;
+        $deviceData['lastPatternScore'] = $newPatternScore + $instantScore + $enumerationScore;
 
         return ['requestPatternScore' => min(100.0, $deviceData['lastPatternScore'])];
     }
@@ -749,7 +779,7 @@ class RequestUtils
      * Parse une chaîne de requête GraphQL pour extraire le type et le nom de l'opération.
      * @param array<string, mixed> $body Le corps de la requête.
      * @return array{type: string, name: string}|null
-     */    
+     */
     public static function parseGraphQLQuery(array $body): ?array
     {
         $query = $body['query'] ?? null;
@@ -841,7 +871,7 @@ class RequestUtils
         if (filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_IPV4)) {
             $ipBinary = inet_pton($ip);
             if ($ipBinary === false) return null;
-            
+
             $mask = self::generateMask($ipv4Prefix, 4);
             if ($mask === null) return null;
 
@@ -850,7 +880,7 @@ class RequestUtils
         } elseif (filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_IPV6)) {
             $ipBinary = inet_pton($ip);
             if ($ipBinary === false) return null;
-            
+
             $mask = self::generateMask($ipv6Prefix, 16);
             if ($mask === null) return null;
 
@@ -959,4 +989,155 @@ class RequestUtils
         $newScore = min(100.0, max(0.0, $current + $change));
         $store->set($key, ['score' => $newScore, 'lastUpdate' => time()], 86400 * 7); // TTL de 7 jours
     }
+
+
+    /**
+     * Assainit les données de trafic pour l'auto-tuner afin de prévenir les attaques par empoisonnement.
+     * Limite la contribution de chaque deviceId à un pourcentage maximum (ex: 2%) du jeu de données total.
+     *
+     * @param array<int, array<string, mixed>> $trafficData
+     * @return array<int, array<string, mixed>>
+     */
+    public static function sanitizeTrafficData(array $trafficData): array
+    {
+        if (empty($trafficData)) {
+            return [];
+        }
+
+        $tempSanitized = [];
+        $deviceCounts = [];
+        $maxLogsPerDevice = max(3, (int)floor(count($trafficData) * 0.02));
+
+        foreach ($trafficData as $log) {
+            $deviceId = $log['deviceId'] ?? 'anonymous';
+            if (!isset($deviceCounts[$deviceId])) {
+                $deviceCounts[$deviceId] = 0;
+            }
+            if ($deviceCounts[$deviceId] < $maxLogsPerDevice) {
+                $deviceCounts[$deviceId]++;
+                $tempSanitized[] = $log;
+            }
+        }
+
+        $passedLogs = [];
+        $suspiciousLogs = [];
+        foreach ($tempSanitized as $log) {
+            if (($log['type'] ?? '') === 'request_passed') {
+                $passedLogs[] = $log;
+            } else {
+                $suspiciousLogs[] = $log;
+            }
+        }
+
+        $minDataPoints = 200; // Seuil par défaut
+        $maxPassedAllowed = max($minDataPoints, count($suspiciousLogs) * 9);
+
+        if (count($passedLogs) > $maxPassedAllowed) {
+            shuffle($passedLogs);
+            $passedLogs = array_slice($passedLogs, 0, $maxPassedAllowed);
+        }
+
+        return array_merge($suspiciousLogs, $passedLogs);
+    }
+
+    /**
+     * Génère une signature HMAC-SHA256 pour sécuriser les données du challenge stockées.
+     * @param string $secret Le secret global (POW_SECRET).
+     * @param array<string, mixed> $payload Les données du challenge.
+     * @param string $clientIp L'IP du client pour lier la signature.
+     * @return string
+     */
+    public static function signChallengePayload(string $secret, array $payload, string $clientIp): string
+    {
+        $dataToSign = implode(':', [
+            $payload['clientSecret'] ?? '',
+            $payload['cpuTarget'] ?? '',
+            $payload['fingerprint'] ?? '',
+            $payload['memDifficulty'] ?? '',
+            $payload['originalPath'] ?? '',
+            $clientIp
+        ]);
+
+        return hash_hmac('sha256', $dataToSign, $secret);
+    }
+
+    /**
+     * Vérifie la signature HMAC-SHA256 des données de challenge récupérées du store.
+     * @param string $secret Le secret global (POW_SECRET).
+     * @param array<string, mixed> $payload Les données du challenge contenant la signature.
+     * @param string $clientIp L'IP du client.
+     * @return bool True si la signature est valide, false sinon.
+     */
+    public static function verifyChallengePayload(string $secret, array $payload, string $clientIp): bool
+    {
+        if (empty($payload['signature'])) {
+            return false;
+        }
+
+        $storedSignature = $payload['signature'];
+        $payloadWithoutSig = $payload;
+        unset($payloadWithoutSig['signature']);
+
+        $expectedSignature = self::signChallengePayload($secret, $payloadWithoutSig, $clientIp);
+
+        return hash_equals($expectedSignature, $storedSignature);
+    }
+
+    /**
+     * Vérifie si un ticket de clearance (PoW) est valide, en supportant la tolérance au roaming.
+     *
+     * @param string $ip L'adresse IP de la requête courante.
+     * @param string|null $ticket Le ticket de clearance extrait du cookie.
+     * @param string $deviceId L'identifiant du cookie de l'appareil.
+     * @param string $deviceHash L'empreinte matérielle calculée côté serveur.
+     * @param string $secret La clé secrète (POW_SECRET).
+     * @return bool True si le ticket est valide et correspond aux contraintes de sécurité.
+     */
+    public static function isTicketValid(string $ip, ?string $ticket, string $deviceId = '', string $deviceHash = '', string $secret = ''): bool
+    {
+        if (empty($ticket)) {
+            return false;
+        }
+
+        if (str_contains($ticket, '|')) {
+            $parts = explode('|', $ticket);
+            if (count($parts) < 3) return false;
+            [$expiry, $originalIp, $sig] = $parts;
+        } elseif (str_contains($ticket, ':')) {
+            // Fallback rétrocompatible pour les anciens tickets
+            $parts = explode(':', $ticket);
+            if (count($parts) < 2) return false;
+            [$expiry, $sig] = $parts;
+            $originalIp = $ip;
+        } else {
+            return false;
+        }
+
+        if (empty($expiry) || empty($sig) || (time() * 1000) > (int)$expiry) {
+            return false;
+        }
+
+        if (str_contains($ticket, '|')) {
+            $expectedSig = hash_hmac('sha256', "{$expiry}:{$originalIp}:{$deviceId}:{$deviceHash}", $secret);
+        } else {
+            $expectedSig = hash_hmac('sha256', "{$ip}:{$expiry}", $secret);
+        }
+
+        if (!hash_equals($expectedSig, $sig)) {
+            return false;
+        }
+
+        if (!str_contains($ticket, '|')) {
+            return $ip === $originalIp;
+        }
+
+        if ($ip === $originalIp) return true;
+        $currentSubnet = self::getIpSubnet($ip);
+        $originalSubnet = self::getIpSubnet($originalIp);
+        if ($currentSubnet !== null && $originalSubnet !== null && $currentSubnet === $originalSubnet) {
+            return true;
+        }
+
+        return !empty($deviceId) && !empty($deviceHash); // Match d'identité matérielle stricte (deviceId + deviceHash validés par HMAC)
+    }
 }

package/src/php/bin/auto-tune.php

@@ -0,0 +1,118 @@
+<?php
+
+declare(strict_types=1);
+
+/**
+ * CLI Script d'auto-tuning périodique des configurations de sécurité.
+ * Ce script lit la configuration courante, récupère les logs, les assainit,
+ * exécute l'optimiseur génétique, et écrase le fichier JSON d'origine.
+ */
+
+$autoloaderPaths = [
+    __DIR__ . '/../../vendor/autoload.php',
+    __DIR__ . '/../vendor/autoload.php',
+    __DIR__ . '/../../../autoload.php',
+];
+
+$autoloaded = false;
+foreach ($autoloaderPaths as $path) {
+    if (file_exists($path)) {
+        require_once $path;
+        $autoloaded = true;
+        break;
+    }
+}
+
+if (!$autoloaded) {
+    fwrite(STDERR, "Erreur : Impossible de charger l'autoloader. Exécutez 'composer install'.\n");
+    exit(1);
+}
+
+use Anonympins\Fingerprint\Utils\RequestUtils;
+use Anonympins\Fingerprint\Store\StoreManager;
+use Anonympins\Fingerprint\Optimization\Optimization;
+
+// 1. Récupération des arguments CLI
+$configPath = $argv[1] ?? null;
+if (!$configPath) {
+    echo "Usage: php auto-tune.php [chemin_vers_security-config.json]\n";
+    exit(1);
+}
+
+if (!file_exists($configPath)) {
+    fwrite(STDERR, "Erreur : Fichier de configuration introuvable : {$configPath}\n");
+    exit(1);
+}
+
+$config = json_decode(file_get_contents($configPath), true);
+if (json_last_error() !== JSON_ERROR_NONE) {
+    fwrite(STDERR, "Erreur : Fichier de configuration JSON invalide.\n");
+    exit(1);
+}
+
+// 2. Connexion au store pour récupérer les logs accumulés
+$store = StoreManager::getStore();
+if (!$store) {
+    fwrite(STDERR, "Erreur : Aucun store de persistance actif.\n");
+    exit(1);
+}
+
+$rawTrafficLogs = $store->get('traffic_logs') ?? [];
+if (empty($rawTrafficLogs)) {
+    echo "[AutoTuning] Aucun log de trafic disponible pour l'optimisation.\n";
+    exit(0);
+}
+
+// 3. Nettoyage des données pour prévenir l'empoisonnement (Sybil attacks)
+$sanitizedLogs = RequestUtils::sanitizeTrafficData($rawTrafficLogs);
+
+$minDataPoints = $config['autotuning']['minDataPoints'] ?? 200;
+if (count($sanitizedLogs) < $minDataPoints) {
+    echo "[AutoTuning] Reporté : Pas assez de données assainies (" . count($sanitizedLogs) . "/{$minDataPoints}).\n";
+    exit(0);
+}
+
+echo "[AutoTuning] Lancement de l'optimisation sur " . count($sanitizedLogs) . " données de trafic...\n";
+
+// 4. Résolution du Front de Pareto
+$paretoFront = Optimization::solveFullSecurityTuning(['trafficData' => $sanitizedLogs]);
+if (empty($paretoFront)) {
+    fwrite(STDERR, "[AutoTuning] L'optimisation n'a retourné aucun résultat.\n");
+    exit(1);
+}
+
+// 5. Sélection de la solution la plus équilibrée
+$bestSolution = $paretoFront[0];
+$minDistance = sqrt(pow($bestSolution['objectives'][0], 2) + pow($bestSolution['objectives'][1], 2));
+foreach ($paretoFront as $candidate) {
+    $distance = sqrt(pow($candidate['objectives'][0], 2) + pow($candidate['objectives'][1], 2));
+    if ($distance < $minDistance) {
+        $minDistance = $distance;
+        $bestSolution = $candidate;
+    }
+}
+
+$newConfig = $bestSolution['solution'];
+$maxChangeVelocity = 0.15; // Inertie de 15% maximum par cycle
+
+$applyInertialUpdate = function (array &$current, array $target) use ($maxChangeVelocity) {
+    $sumCurrent = array_sum($current);
+    if ($sumCurrent === 0) return;
+    $sumTarget = 0;
+    foreach ($current as $k => $v) {
+        if (isset($target[$k])) $sumTarget += $target[$k];
+    }
+    $ratio = ($sumTarget - $sumCurrent) / $sumCurrent;
+    $factor = 1 + max(-$maxChangeVelocity, min($maxChangeVelocity, $ratio));
+    foreach ($current as $k => &$v) {
+        if (isset($target[$k])) $v *= $factor;
+    }
+};
+
+$applyInertialUpdate($config['thresholds'], $newConfig['thresholds']);
+$applyInertialUpdate($config['weights'], $newConfig['weights']);
+$applyInertialUpdate($config['patterns'], $newConfig['patterns']);
+
+// 6. Écrasement propre du fichier de configuration original
+file_put_contents($configPath, json_encode($config, JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES));
+echo "[AutoTuning] Succès : Fichier {$configPath} mis à jour avec les paramètres optimisés.\n";