@anonympins/fingerprint 0.3.4 → 0.3.6

package/src/php/FingerprintEngine.php

@@ -324,6 +324,68 @@
 
          // Score de spoofing TLS
          $tlsSpoofing = RequestUtils::getTlsSpoofingScore($context);
+         $tlsSpoofingScore = (float)($tlsSpoofing['tlsSpoofingScore'] ?? 0.0);
+
+         // Advanced JA4 TLS Inconsistency checks
+         $ja4 = $context->getHeader('x-ja4-hash');
+         if ($ja4) {
+             $spoofedJa4s = [
+                 't13d1516h2_8daaf6152771_390237aa04be', // Chrome classique (curl-impersonate / tls-client)
+                 't13d1413h2_bc66258908f0_bc2531da1615', // Firefox statique (curl-impersonate-ff / curl_cffi)
+                 't13d1515h2_8daaf6152771_a729e2f67de4', // Safari statique (curl-impersonate-safari / tls-client)
+                 't13d1516h2_8daaf6152771_4be0df930c2c', // Alternatif Chrome (tls-client Go)
+                 't12d1516h2_8daaf6152771_390237aa04be', // Chrome usurpé dégradé en TLS 1.2
+                 't13d1516h2_e822d36d892d_93ec3f0b2f5b'  // Scraping bot OpenSSL customisé
+             ];
+             if (in_array($ja4, $spoofedJa4s, true)) {
+                 $tlsSpoofingScore = max($tlsSpoofingScore, 100.0);
+             }
+
+             $parsedJa4 = $this->parseJa4($ja4);
+             if ($parsedJa4) {
+                 $ua = $context->getHeader('user-agent') ?? '';
+                 $uaParts = $this->parseUserAgent($ua);
+
+                 // Check 1: Incohérence ALPN / HTTP Version
+                 $httpVersion = $context->httpVersion ?? '1.1';
+                 if ($parsedJa4['alpn'] === 'h2' && ($httpVersion === '1.1' || $httpVersion === '1.0')) {
+                     $hasProxy = $context->getHeader('via') || $context->getHeader('forwarded') || $context->getHeader('x-forwarded-proto') || $context->getHeader('x-forwarded-for');
+                     if (!$hasProxy) {
+                         $tlsSpoofingScore = max($tlsSpoofingScore, 40.0);
+                     }
+                 }
+
+                 // Check 2: Incohérence OS/Plateforme vs Capabilities TLS
+                 if ($parsedJa4['version'] === '12' && ($uaParts['os'] === 'iOS' || $uaParts['os'] === 'macOS') && ($uaParts['browser'] && str_starts_with($uaParts['browser'], 'Safari'))) {
+                     $tlsSpoofingScore = max($tlsSpoofingScore, 60.0);
+                 }
+
+                 // Check 3: Incohérence User-Agent vs Signature JA4
+                 if ($uaParts['browser'] && str_starts_with($uaParts['browser'], 'Chrome') && $parsedJa4['alpn'] === '00') {
+                     $tlsSpoofingScore = max($tlsSpoofingScore, 50.0);
+                 }
+                 if ($uaParts['browser'] && str_starts_with($uaParts['browser'], 'Firefox') && $parsedJa4['extensionsCount'] > 15) {
+                     $tlsSpoofingScore = max($tlsSpoofingScore, 50.0);
+                 }
+
+                 // Check 4: La stagnation (Lack of Entropy / Genericity)
+                 if ($uaParts['browser']) {
+                     $ja4Key = "ja4-browsers:{$ja4}";
+                     $seenBrowsers = $store->get($ja4Key) ?: [];
+                     if (!is_array($seenBrowsers)) {
+                         $seenBrowsers = [];
+                     }
+                     $browserFamily = explode('/', $uaParts['browser'])[0] ?? null;
+                     if ($browserFamily && !in_array($browserFamily, $seenBrowsers, true)) {
+                         $seenBrowsers[] = $browserFamily;
+                         $store->set($ja4Key, $seenBrowsers, 86400);
+                     }
+                     if (count($seenBrowsers) > 1) {
+                         $tlsSpoofingScore = max($tlsSpoofingScore, 80.0);
+                     }
+                 }
+             }
+         }
 
          // Score d'incohérence temporelle (attaque par rejeu)
          $timeInconsistency = RequestUtils::getTimeInconsistencyScore($context);
@@ -346,9 +408,6 @@
          // Score de variance des clics
          $clickVariance = RequestUtils::getClickVarianceScore($context);
 
-         // Score de variance des clics
-         $clickVariance = RequestUtils::getClickVarianceScore($context);
-
          // Score basé sur les listes de menaces (Threat Intelligence)
          $threatIntel = RequestUtils::getThreatIntelScore($context, $this->securityConfig['threatIntel'] ?? []);
 
@@ -364,7 +423,7 @@
              'historyScore' => $behavioral['historyScore'],
              'rotationScore' => $behavioral['rotationScore'],
              'headerAnomalyScore' => $headerAnomalies['headerAnomalyScore'],
-             'tlsSpoofingScore' => $tlsSpoofing['tlsSpoofingScore'],
+             'tlsSpoofingScore' => $tlsSpoofingScore,
              'timeInconsistencyScore' => $timeInconsistency['timeInconsistencyScore'],
              'crossLayerInconsistencyScore' => $crossLayerInconsistency['crossLayerInconsistencyScore'],
              'requestPatternScore' => $requestPattern['requestPatternScore'], // Ce score est maintenant calculé
@@ -383,6 +442,66 @@
          return $suspicionVector;
      }
 
+     /**
+      * Parse a basic User-Agent string.
+      */
+     private function parseUserAgent(string $ua): array
+     {
+         $result = ['browser' => null, 'os' => null];
+         
+         if (str_contains($ua, 'Chrome') && !str_contains($ua, 'Edg')) {
+             $result['browser'] = 'Chrome';
+             if (preg_match('/Chrome\/(\d+)/', $ua, $matches)) {
+                 $result['browser'] .= '/' . $matches[1];
+             }
+         } elseif (str_contains($ua, 'Firefox')) {
+             $result['browser'] = 'Firefox';
+             if (preg_match('/Firefox\/(\d+)/', $ua, $matches)) {
+                 $result['browser'] .= '/' . $matches[1];
+             }
+         } elseif (str_contains($ua, 'Safari') && !str_contains($ua, 'Chrome')) {
+             $result['browser'] = 'Safari';
+             if (preg_match('/Version\/(\d+)/', $ua, $matches)) {
+                 $result['browser'] .= '/' . $matches[1];
+             }
+         } elseif (str_contains($ua, 'Edg')) {
+             $result['browser'] = 'Edge';
+             if (preg_match('/Edg\/(\d+)/', $ua, $matches)) {
+                 $result['browser'] .= '/' . $matches[1];
+             }
+         }
+
+         if (str_contains($ua, 'Windows NT 10.0')) $result['os'] = 'Windows 10';
+         elseif (str_contains($ua, 'Windows NT 6.1')) $result['os'] = 'Windows 7';
+         elseif (str_contains($ua, 'Mac OS X')) $result['os'] = 'macOS';
+         elseif (str_contains($ua, 'Linux') && !str_contains($ua, 'Android')) $result['os'] = 'Linux';
+         elseif (str_contains($ua, 'Android')) $result['os'] = 'Android';
+         elseif (str_contains($ua, 'iPhone') || str_contains($ua, 'iPad')) $result['os'] = 'iOS';
+
+         return $result;
+     }
+
+     /**
+      * Parse JA4 string into protocol, version, ALPN etc.
+      */
+     private function parseJa4(?string $ja4): ?array
+     {
+         if (empty($ja4)) return null;
+         $parts = explode('_', $ja4);
+         $ja4a = $parts[0];
+         if (strlen($ja4a) < 10) return null;
+         return [
+             'protocol' => $ja4a[0],
+             'version' => substr($ja4a, 1, 2),
+             'sni' => $ja4a[3],
+             'ciphersCount' => (int)substr($ja4a, 4, 2),
+             'extensionsCount' => (int)substr($ja4a, 6, 2),
+             'alpn' => substr($ja4a, 8, 2),
+             'ja4b' => $parts[1] ?? null,
+             'ja4c' => $parts[2] ?? null
+         ];
+     }
+
      /**
       * Traite une requête entrante et retourne une décision.
       * @param RequestContext $context Le contexte de la requête.
@@ -840,9 +959,17 @@
  
              // 2. Forward DNS lookup
              $addresses = array_merge(dns_get_record($validHostname, DNS_A) ?: [], dns_get_record($validHostname, DNS_AAAA) ?: []);
-             $ips = array_column($addresses, 'ip');
+             $ips = [];
+             foreach ($addresses as $address) {
+                 if (isset($address['ip'])) {
+                     $ips[] = $address['ip'];
+                 }
+                 if (isset($address['ipv6'])) {
+                     $ips[] = $address['ipv6'];
+                 }
+             }
  
-             if (in_array($context->clientIp, $addresses)) {
+             if (in_array($context->clientIp, $ips, true)) {
                  $store->set($cacheKey, 'verified', 86400);
                  return true;
              }

package/src/php/Ja3AnomalyDetector.php

@@ -0,0 +1,228 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Anonympins\Fingerprint;
+
+/**
+ * Classe de détection d'anomalies et d'usurpation TLS (JA3) en PHP.
+ */
+class Ja3AnomalyDetector
+{
+    // Liste décimale des valeurs GREASE (RFC 8701) utilisées par les moteurs Chromium/Safari récents
+    private const GREASE_VALUES = [
+        2570, 6682, 10794, 14906, 19018, 23130, 27242, 31354,
+        35466, 39578, 43690, 47802, 51914, 55926, 60038, 64150
+    ];
+
+    // Base de données locale de signatures JA3 MD5 connues pour la corroboration de base
+    private const TLS_FINGERPRINT_DB = [
+        'e188a442b87f422c5a1e80b05399435b' => ['Chrome'],
+        'd8e35855049321c6042a4325c697858f' => ['Chrome'],
+        'a9f90958d44533748c139a5d1895b925' => ['Chrome'],
+        '3b5379916d2b3882253c42885956a350' => ['Chrome'],
+        '59822058c95c33d2d06e52f410855c8c' => ['Chrome'],
+        'b386946a5a586163c7c533636b45c355' => ['Firefox'],
+        '66236495a523c1785f8f3a105b248b11' => ['Firefox'],
+        'b73d470006575b5e35167a0b5a8540e2' => ['Firefox'],
+        '8443d7562933834333943465d52363cf' => ['Firefox'],
+        'b633f21d532d35967c8753c38536b4d3' => ['Safari'],
+        '4d7a28d5f55b359b69100a311013f03e' => ['Safari', 'Chrome', 'Firefox'],
+        '8dd3d7532873575314df23c447543001' => ['Safari', 'Chrome', 'Firefox'],
+        // Bibliothèques et scrapers automatisés connus
+        '47344a349b75c4e82333475553b5f358' => ['Python'],
+        'b29587b8a143c42546133ad7704b3310' => ['Go'],
+        'd435b5223b2884c5a832b842637e245f' => ['Java'],
+        'c72366b9551263d990b7fa574225332c' => ['curl'],
+    ];
+
+    /**
+     * Analyse une chaîne JA3 brute non hachée.
+     * Format attendu : "TLSVersion,Ciphers,Extensions,EllipticCurves,EllipticCurveFormats"
+     */
+    public static function parseJa3(string $ja3String): ?array
+    {
+        if (empty($ja3String)) {
+            return null;
+        }
+
+        $parts = explode(',', $ja3String);
+        if (count($parts) !== 5) {
+            return null;
+        }
+
+        return [
+            'tlsVersion' => (int)$parts[0],
+            'ciphers'    => $parts[1] !== '' ? array_map('intval', explode('-', $parts[1])) : [],
+            'extensions' => $parts[2] !== '' ? array_map('intval', explode('-', $parts[2])) : [],
+            'curves'     => $parts[3] !== '' ? array_map('intval', explode('-', $parts[3])) : [],
+            'points'     => $parts[4] !== '' ? array_map('intval', explode('-', $parts[4])) : []
+        ];
+    }
+
+    /**
+     * Vérifie si un tableau contient au moins une valeur GREASE.
+     */
+    public static function hasGrease(array $values): bool
+    {
+        foreach ($values as $val) {
+            if (in_array($val, self::GREASE_VALUES, true)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Parse sommairement le User-Agent pour en extraire la famille de navigateur.
+     */
+    public static function getBrowserFamily(string $userAgent): ?string
+    {
+        $ua = strtolower($userAgent);
+        if (strpos($ua, 'edg') !== false) {
+            return 'Edge';
+        }
+        if (strpos($ua, 'chrome') !== false) {
+            return 'Chrome';
+        }
+        if (strpos($ua, 'firefox') !== false) {
+            return 'Firefox';
+        }
+        if (strpos($ua, 'safari') !== false) {
+            return 'Safari';
+        }
+        return null;
+    }
+
+    /**
+     * Calcule le score global d'anomalie et d'usurpation JA3.
+     * 
+     * @param string|null $ja3Hash L'empreinte MD5 du JA3 (32 caractères)
+     * @param string|null $ja3Raw L'empreinte brute non hachée (si disponible)
+     * @param string $userAgent Le User-Agent de la requête
+     * @param string $httpVersion La version HTTP de la requête (ex: "HTTP/2", "HTTP/1.1", ou "2.0")
+     * @param object|null $cacheInstance Un driver de cache (ex: instance Redis) supportant get() et set() pour la détection de stagnation
+     * @return int Un score de suspicion compris entre 0 et 100
+     */
+    public static function getJa3AnomalyScore(
+        ?string $ja3Hash,
+        ?string $ja3Raw,
+        string $userAgent,
+        string $httpVersion,
+        ?object $cacheInstance = null
+    ): int {
+        $score = 0;
+        $claimedBrowser = self::getBrowserFamily($userAgent);
+        $isHumanBrowser = in_array($claimedBrowser, ['Chrome', 'Firefox', 'Safari', 'Edge'], true);
+
+        // --- ANALYSE 1 : CONTRÔLE SUR LE MD5 DU JA3 ---
+        if ($ja3Hash && strlen($ja3Hash) === 32) {
+            if (isset(self::TLS_FINGERPRINT_DB[$ja3Hash])) {
+                $expectedBrowsers = self::TLS_FINGERPRINT_DB[$ja3Hash];
+
+                // Cas A : L'empreinte correspond à un outil de scraping mais le UA prétend être humain
+                $isLibrary = array_intersect($expectedBrowsers, ['Python', 'Go', 'Java', 'curl']);
+                if (!empty($isLibrary) && $isHumanBrowser) {
+                    $score = max($score, 90); // Suspicion maximale : usurpation évidente
+                }
+                
+                // Cas B : Incohérence directe entre le UA prétendu et la stack TLS correspondante
+                if ($claimedBrowser !== null) {
+                    $matched = false;
+                    foreach ($expectedBrowsers as $expected) {
+                        if (stripos($claimedBrowser, $expected) === 0) {
+                            $matched = true;
+                            break;
+                        }
+                    }
+                    if (!$matched) {
+                        $score = max($score, 80); // Le navigateur déclaré ne correspond pas au client TLS utilisé
+                    }
+                }
+            }
+
+            // Cas C : Tracking de stagnation multi-UA (Stateful)
+            if ($cacheInstance && $claimedBrowser !== null && method_exists($cacheInstance, 'get') && method_exists($cacheInstance, 'set')) {
+                $cacheKey = "ja3-browsers:" . $ja3Hash;
+                
+                try {
+                    $rawCached = $cacheInstance->get($cacheKey);
+                    $seenBrowsers = $rawCached ? json_decode((string)$rawCached, true) : [];
+                    if (!is_array($seenBrowsers)) {
+                        $seenBrowsers = [];
+                    }
+
+                    if (!in_array($claimedBrowser, $seenBrowsers, true)) {
+                        $seenBrowsers[] = $claimedBrowser;
+                        // Cache pendant 24 heures (86400 secondes)
+                        if (method_exists($cacheInstance, 'setex')) {
+                            $cacheInstance->setex($cacheKey, 86400, json_encode($seenBrowsers));
+                        } else {
+                            $cacheInstance->set($cacheKey, json_encode($seenBrowsers), 86400);
+                        }
+                    }
+
+                    // Si une seule stack TLS génère des requêtes avec différents navigateurs, c'est un bot en rotation de UA
+                    if (count($seenBrowsers) > 1) {
+                        $score = max($score, 85);
+                    }
+                } catch (\Throwable $e) {
+                    // Tolérance aux pannes du cache
+                }
+            }
+        }
+
+        // --- ANALYSE 2 : CONTRÔLE PROFOND SUR L'EMPREINTE BRUTE (RAW JA3) ---
+        if ($ja3Raw) {
+            $parsed = self::parseJa3($ja3Raw);
+            if ($parsed) {
+                // Contrôle A : Mécanisme GREASE pour Chrome / Edge (obligatoire)
+                if ($claimedBrowser === 'Chrome' || $claimedBrowser === 'Edge') {
+                    $hasCiphersGrease = self::hasGrease($parsed['ciphers']);
+                    $hasExtensionsGrease = self::hasGrease($parsed['extensions']);
+                    
+                    if (!$hasCiphersGrease && !$hasExtensionsGrease) {
+                        // Chrome ou Edge moderne sans GREASE = spoofing de bas niveau (ex: python-requests déguisé)
+                        $score = max($score, 75);
+                    }
+                }
+
+                // Contrôle B : HTTP/2 ou HTTP/3 sans négociation ALPN (Extension 16)
+                $isH2OrHigher = (
+                    strpos($httpVersion, '2.0') !== false || 
+                    strpos($httpVersion, 'HTTP/2') !== false || 
+                    strpos($httpVersion, 'HTTP/3') !== false
+                );
+                $hasAlpnExtension = in_array(16, $parsed['extensions'], true);
+                
+                if ($isH2OrHigher && !$hasAlpnExtension) {
+                    // Négociation HTTP/2 active au niveau serveur mais absente au niveau des extensions TLS du client
+                    $score = max($score, 70);
+                }
+
+                // Contrôle C : Version TLS obsolète négociée par un navigateur moderne (ex: TLS < 1.2, id < 771)
+                if ($isHumanBrowser && $parsed['tlsVersion'] < 771) {
+                    $score = max($score, 80);
+                }
+            }
+        }
+
+        return $score;
+    }
+}
+
+// --- EXEMPLE D'UTILISATION PRATIQUE ---
+/*
+$userAgent = $_SERVER['HTTP_USER_AGENT'] ?? '';
+$httpVersion = $_SERVER['SERVER_PROTOCOL'] ?? '';
+
+// Récupération des en-têtes injectés par votre Reverse-Proxy (Nginx, HAProxy, etc.)
+$ja3Hash = $_SERVER['HTTP_X_JA3_HASH'] ?? null;
+$ja3Raw  = $_SERVER['HTTP_X_JA3_RAW'] ?? null; 
+
+// Redis facultatif pour la détection stateful de rotation UA
+$redis = new \Redis();
+$redis->connect('127.0.0.1', 6379);
+
+$suspicionScore = Ja3AnomalyDetector::getJa3AnomalyScore($ja3Hash, $ja3Raw, $userAgent, $httpVersion, $redis);
+*/

package/src/php/Tests/Ja3AnomalyDetectorTest.php

@@ -0,0 +1,180 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Anonympins\Fingerprint\Tests;
+
+use PHPUnit\Framework\TestCase;
+use Anonympins\Fingerprint\Ja3AnomalyDetector;
+
+/**
+ * Tests unitaires pour la classe Ja3AnomalyDetector.
+ */
+class Ja3AnomalyDetectorTest extends TestCase
+{
+    /**
+     * Teste le parsing d'une chaîne JA3 brute valide.
+     */
+    public function testParseJa3ValidString(): void
+    {
+        $ja3 = '771,4865-4866-4867,0-23-65281-10-11,29-23-24,0';
+        $parsed = Ja3AnomalyDetector::parseJa3($ja3);
+
+        $this->assertNotNull($parsed);
+        $this->assertSame(771, $parsed['tlsVersion']);
+        $this->assertSame([4865, 4866, 4867], $parsed['ciphers']);
+        $this->assertSame([0, 23, 65281, 10, 11], $parsed['extensions']);
+        $this->assertSame([29, 23, 24], $parsed['curves']);
+        $this->assertSame([0], $parsed['points']);
+    }
+
+    /**
+     * Teste le parsing avec des valeurs manquantes ou malformées.
+     */
+    public function testParseJa3InvalidString(): void
+    {
+        $this->assertNull(Ja3AnomalyDetector::parseJa3(''));
+        $this->assertNull(Ja3AnomalyDetector::parseJa3('771,4865,0-23')); // Moins de 5 parties
+    }
+
+    /**
+     * Teste la détection du mécanisme GREASE.
+     */
+    public function testHasGrease(): void
+    {
+        // Contient la valeur GREASE 2570 (0x0A0A)
+        $this->assertTrue(Ja3AnomalyDetector::hasGrease([4865, 2570, 4866]));
+        // Ne contient pas de valeur GREASE
+        $this->assertFalse(Ja3AnomalyDetector::hasGrease([4865, 4866, 4867]));
+    }
+
+    /**
+     * Teste l'extraction de la famille du User-Agent.
+     */
+    public function testGetBrowserFamily(): void
+    {
+        $this->assertSame('Chrome', Ja3AnomalyDetector::getBrowserFamily('Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'));
+        $this->assertSame('Edge', Ja3AnomalyDetector::getBrowserFamily('Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36 Edg/120.0.0.0'));
+        $this->assertSame('Firefox', Ja3AnomalyDetector::getBrowserFamily('Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:120.0) Gecko/20100101 Firefox/120.0'));
+        $this->assertSame('Safari', Ja3AnomalyDetector::getBrowserFamily('Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Safari/605.1.15'));
+        $this->assertNull(Ja3AnomalyDetector::getBrowserFamily('curl/7.68.0'));
+    }
+
+    /**
+     * Teste la détection d'usurpation d'une bibliothèque connue (ex: Python/Go/curl).
+     */
+    public function testSpoofingLibraryDetected(): void
+    {
+        $pythonJa3 = '47344a349b75c4e82333475553b5f358'; // Signature Python dans DB
+        $userAgent = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36';
+
+        $score = Ja3AnomalyDetector::getJa3AnomalyScore($pythonJa3, null, $userAgent, 'HTTP/2');
+
+        // Devrait retourner un score élevé (90) car une signature python se fait passer pour Chrome
+        $this->assertEquals(90, $score);
+    }
+
+    /**
+     * Teste la détection d'une incohérence de navigateur (ex: signature Firefox avec UA Chrome).
+     */
+    public function testBrowserMismatchDetected(): void
+    {
+        $firefoxJa3 = 'b386946a5a586163c7c533636b45c355'; // Signature Firefox dans DB
+        $userAgent = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36';
+
+        $score = Ja3AnomalyDetector::getJa3AnomalyScore($firefoxJa3, null, $userAgent, 'HTTP/2');
+
+        $this->assertEquals(80, $score);
+    }
+
+    /**
+     * Teste la détection de stagnation de hash avec rotation d'User-Agents.
+     */
+    public function testStagnationWithRotatingUserAgents(): void
+    {
+        // Mock d'un stockage de cache minimal en mémoire
+        $cache = new class {
+            private array $store = [];
+            public function get(string $key): ?string { return $this->store[$key] ?? null; }
+            public function set(string $key, string $val, int $ttl = 0): void { $this->store[$key] = $val; }
+            public function setex(string $key, int $ttl, string $val): void { $this->store[$key] = $val; }
+        };
+
+        $unknownJa3 = '00000000000000000000000000000000';
+        $chromeUA = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/120.0.0.0';
+        $firefoxUA = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) Firefox/120.0';
+
+        // Premier appel avec Chrome -> pas d'anomalie de stagnation encore
+        $score1 = Ja3AnomalyDetector::getJa3AnomalyScore($unknownJa3, null, $chromeUA, 'HTTP/2', $cache);
+        $this->assertLessThan(85, $score1);
+
+        // Deuxième appel avec la même stack TLS mais un UA Firefox -> Détection de rotation !
+        $score2 = Ja3AnomalyDetector::getJa3AnomalyScore($unknownJa3, null, $firefoxUA, 'HTTP/2', $cache);
+        $this->assertEquals(85, $score2);
+    }
+
+    /**
+     * Teste l'absence de valeurs GREASE pour un navigateur Chromium.
+     */
+    public function testMissingGreaseForChrome(): void
+    {
+        $chromeUA = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/120.0.0.0';
+        // JA3 brut valide mais sans AUCUNE valeur GREASE dans les extensions ou les ciphers
+        $ja3RawWithoutGrease = '771,4865-4866,0-23-10,29,0';
+
+        $score = Ja3AnomalyDetector::getJa3AnomalyScore(null, $ja3RawWithoutGrease, $chromeUA, 'HTTP/2');
+        $this->assertEquals(75, $score);
+    }
+
+    /**
+     * Teste le cas légitime d'un navigateur Chromium disposant de GREASE.
+     */
+    public function testLegitimateChromeWithGrease(): void
+    {
+        $chromeUA = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/120.0.0.0';
+        // 2570 est une valeur GREASE valide
+        $ja3RawWithGrease = '771,4865-2570,0-23-10,29,0';
+
+        $score = Ja3AnomalyDetector::getJa3AnomalyScore(null, $ja3RawWithGrease, $chromeUA, 'HTTP/2');
+        $this->assertLessThan(75, $score);
+    }
+
+    /**
+     * Teste la détection d'absence d'ALPN lors de connexions HTTP/2.
+     */
+    public function testHttp2WithoutAlpnExtension(): void
+    {
+        $chromeUA = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/120.0.0.0';
+        // Pas d'extension 16 (ALPN) dans les extensions
+        $ja3RawNoAlpn = '771,4865-2570,0-23-10,29,0';
+
+        $score = Ja3AnomalyDetector::getJa3AnomalyScore(null, $ja3RawNoAlpn, $chromeUA, 'HTTP/2');
+        $this->assertEquals(70, $score);
+    }
+
+    /**
+     * Teste la présence d'ALPN lors de connexions HTTP/2 (cas normal).
+     */
+    public function testHttp2WithAlpnExtension(): void
+    {
+        $chromeUA = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/120.0.0.0';
+        // L'extension 16 est présente
+        $ja3RawWithAlpn = '771,4865-2570,0-23-10-16,29,0';
+
+        $score = Ja3AnomalyDetector::getJa3AnomalyScore(null, $ja3RawWithAlpn, $chromeUA, 'HTTP/2');
+        $this->assertLessThan(70, $score);
+    }
+
+    /**
+     * Teste l'utilisation d'une version obsolète de TLS par un navigateur récent.
+     */
+    public function testObsoleteTlsVersionWithModernBrowser(): void
+    {
+        $chromeUA = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/120.0.0.0';
+        // Version TLS 769 (TLS 1.0) initiée par un Chrome récent
+        $obsoleteTlsJa3 = '769,4865-2570,0-23-10-16,29,0';
+
+        $score = Ja3AnomalyDetector::getJa3AnomalyScore(null, $obsoleteTlsJa3, $chromeUA, 'HTTP/2');
+        $this->assertEquals(80, $score);
+    }
+}

package/src/php/Tests/RequestUtilsTest.php

@@ -78,4 +78,69 @@ class RequestUtilsTest extends TestCase
         $result = RequestUtils::getClickVarianceScore($context);
         $this->assertEquals(0.0, $result['clickVarianceScore']);
     }
+
+    public function testSanitizeTrafficDataFiltersSybilAttacks(): void
+    {
+        $trafficData = [];
+        // Ajout de 100 logs provenant d'un attaquant (Sybil)
+        for ($i = 0; $i < 100; $i++) {
+            $trafficData[] = ['deviceId' => 'attacker_device', 'type' => 'trap_triggered'];
+        }
+        // Ajout de 10 logs d'utilisateurs légitimes distincts
+        for ($i = 0; $i < 10; $i++) {
+            $trafficData[] = ['deviceId' => "legit_device_{$i}", 'type' => 'challenge_solved'];
+        }
+
+        $sanitized = RequestUtils::sanitizeTrafficData($trafficData);
+
+        $attackerLogs = array_filter($sanitized, fn($log) => $log['deviceId'] === 'attacker_device');
+
+        // Total de 110 logs. 2% de 110 est 2.2 -> max(3, 2) = 3 logs maximum autorisés pour l'attaquant.
+        $this->assertLessThanOrEqual(3, count($attackerLogs));
+    }
+
+    public function testChallengePayloadSigningAndVerification(): void
+    {
+        $secret = 'test-fallback-dev-secret-32-chars-minimum';
+        $clientIp = '203.0.113.42';
+        $payload = [
+            'clientSecret' => 'some_client_secret',
+            'cpuTarget' => '00000000ffffffff',
+            'fingerprint' => 'os:hash|gpu:hash2',
+            'memDifficulty' => '16',
+            'originalPath' => '/submit',
+        ];
+
+        // 1. Cas nominal : Signature et vérification réussies
+        $signature = RequestUtils::signChallengePayload($secret, $payload, $clientIp);
+        $this->assertNotEmpty($signature);
+
+        $payloadWithSig = $payload;
+        $payloadWithSig['signature'] = $signature;
+
+        $isValid = RequestUtils::verifyChallengePayload($secret, $payloadWithSig, $clientIp);
+        $this->assertTrue($isValid, "La signature valide doit être acceptée.");
+
+        // 2. Détection de modification (tampering) sur cpuTarget
+        $tamperedPayload = $payloadWithSig;
+        $tamperedPayload['cpuTarget'] = 'ffffffffffffffff'; // Tentative de baisse de la difficulté
+        
+        $isTamperedValid = RequestUtils::verifyChallengePayload($secret, $tamperedPayload, $clientIp);
+        $this->assertFalse($isTamperedValid, "Un payload modifié doit être rejeté.");
+
+        // 3. Détection de modification sur le fingerprint
+        $tamperedFpPayload = $payloadWithSig;
+        $tamperedFpPayload['fingerprint'] = 'os:another_hash|gpu:hash2';
+        
+        $isTamperedFpValid = RequestUtils::verifyChallengePayload($secret, $tamperedFpPayload, $clientIp);
+        $this->assertFalse($isTamperedFpValid, "Un fingerprint modifié doit être rejeté.");
+
+        // 4. Détection d'usurpation d'adresse IP (IP mismatch)
+        $isIpMismatchValid = RequestUtils::verifyChallengePayload($secret, $payloadWithSig, '198.51.100.1');
+        $this->assertFalse($isIpMismatchValid, "Le payload ne doit pas être valide pour une autre adresse IP.");
+
+        // 5. Absence de signature
+        $isMissingSigValid = RequestUtils::verifyChallengePayload($secret, $payload, $clientIp);
+        $this->assertFalse($isMissingSigValid, "Un payload sans signature doit être rejeté.");
+    }
 }