@anonympins/fingerprint 0.5.0 → 0.5.1

package/src/php/Tests/ChallengeUtilsTest.php

@@ -10,6 +10,83 @@ use PHPUnit\Framework\TestCase;
 
 class ChallengeUtilsTest extends TestCase
 {
+    public function testGpuPowDeterministicHashing(): void
+    {
+        $seed = 'test-seed-determinism';
+        $f1 = ChallengeUtils::hashSeedToFloat($seed);
+        $f2 = ChallengeUtils::hashSeedToFloat($seed);
+        $f3 = ChallengeUtils::hashSeedToFloat('different-seed');
+
+        $this->assertEquals($f1, $f2, 'Seed hashing must be deterministic.');
+        $this->assertGreaterThanOrEqual(0, $f1);
+        $this->assertLessThan(1, $f1);
+        $this->assertNotEquals($f1, $f3);
+    }
+
+    public function testGpuPowVerificationRejectsTamperedSolution(): void
+    {
+        $seed = 'php-verification-seed';
+        $iterations = 100;
+
+        // Generate correct solutions mimicking the GPU solver trajectory
+        $numericSeed = ChallengeUtils::hashSeedToFloat($seed);
+        $r = 3.9999;
+        $solutions = [];
+        $fround = function (float $value): float {
+            return unpack('f', pack('f', $value))[1];
+        };
+
+        for ($idx = 0; $idx < 64; $idx++) {
+            $x = $fround($numericSeed + $idx * 0.015);
+            $rFloat = $fround($r);
+            for ($i = 0; $i < $iterations; $i++) {
+                $x = $fround($rFloat * $x * $fround(1.0 - $x));
+            }
+            $solutions[] = number_format($x, 6, '.', '');
+        }
+        $validSolution = implode(',', $solutions);
+
+        $this->assertTrue(ChallengeUtils::verifyGpuPow($seed, $iterations, $validSolution));
+
+        // Tamper with value on verified sample index 12
+        $tampered = $solutions;
+        $tampered[12] = (string)((float)$tampered[12] + 0.0002); // Out of tolerance
+        $this->assertFalse(ChallengeUtils::verifyGpuPow($seed, $iterations, implode(',', $tampered)));
+    }
+
+    public function testGpuPowVerification(): void
+    {
+        $seed = 'php-gpu-test-seed';
+        $iterations = 50;
+        
+        $hash = 0;
+        for ($i = 0; $i < strlen($seed); $i++) {
+            $hash = (($hash << 5) - $hash + ord($seed[$i])) & 0xffffffff;
+            if ($hash & 0x80000000) {
+                $hash = $hash - 0x100000000;
+            }
+        }
+        $numericSeed = abs($hash % 1000000) / 1000000;
+        $r = 3.9999;
+        $solutions = [];
+        $fround = function (float $value): float {
+            return unpack('f', pack('f', $value))[1];
+        };
+        for ($idx = 0; $idx < 64; $idx++) {
+            $x = $fround($numericSeed + $idx * 0.015);
+            $rFloat = $fround($r);
+            for ($i = 0; $i < $iterations; $i++) {
+                $x = $fround($rFloat * $x * $fround(1.0 - $x));
+            }
+            $solutions[] = number_format($x, 6, '.', '');
+        }
+        $solutionString = implode(',', $solutions);
+        $this->assertTrue(ChallengeUtils::verifyGpuPow($seed, $iterations, $solutionString));
+        $tamperedSolutions = $solutions;
+        $tamperedSolutions[0] = (string)((float)$tamperedSolutions[0] + 0.1);
+        $this->assertFalse(ChallengeUtils::verifyGpuPow($seed, $iterations, implode(',', $tamperedSolutions)));
+    }
+
     protected function setUp(): void
     {
         // Définir une clé secrète pour les tests

package/src/php/Tests/QuicFingerprintTest.php

@@ -0,0 +1,54 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Anonympins\Fingerprint\Tests;
+
+use Anonympins\Fingerprint\RequestContext;
+use Anonympins\Fingerprint\Utils\RequestUtils;
+use PHPUnit\Framework\TestCase;
+
+class QuicFingerprintTest extends TestCase
+{
+    public function testGetQuicAnomalyScoreReturnsZeroIfNoFp(): void
+    {
+        $context = $this->createMock(RequestContext::class);
+        $context->method('getHeader')->willReturn(null);
+        $res = RequestUtils::getQuicAnomalyScore($context);
+        $this->assertEquals(0.0, $res['quicAnomalyScore']);
+    }
+
+    public function testGetQuicAnomalyScoreDetectsSpoofedChrome(): void
+    {
+        $context = $this->createMock(RequestContext::class);
+        $context->method('getHeader')->willReturnCallback(function($name) {
+            if ($name === 'user-agent') {
+                return 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36';
+            }
+            if ($name === 'x-quic-fp') {
+                return '1;1=65536,4=50;i=0';
+            }
+            return null;
+        });
+
+        $res = RequestUtils::getQuicAnomalyScore($context);
+        $this->assertEquals(100.0, $res['quicAnomalyScore']);
+    }
+
+    public function testGetQuicAnomalyScoreAllowsLegitChrome(): void
+    {
+        $context = $this->createMock(RequestContext::class);
+        $context->method('getHeader')->willReturnCallback(function($name) {
+            if ($name === 'user-agent') {
+                return 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36';
+            }
+            if ($name === 'x-quic-fp') {
+                return '1;1=1572864,4=100;u=2,i';
+            }
+            return null;
+        });
+
+        $res = RequestUtils::getQuicAnomalyScore($context);
+        $this->assertEquals(0.0, $res['quicAnomalyScore']);
+    }
+}

package/src/php/Tests/RequestUtilsTest.php

@@ -48,6 +48,28 @@ class RequestUtilsTest extends TestCase
         $score = RequestUtils::getCrossLayerInconsistency($context);
         $this->assertEquals(20.0, $score['crossLayerInconsistencyScore']);
     }
+    public function testGetRenderingAnomalyScoreEmpty(): void
+    {
+        $context = $this->createRequestContext();
+        $res = RequestUtils::getRenderingAnomalyScore($context);
+        $this->assertEquals(0.0, $res['renderingAnomalyScore']);
+    }
+
+    public function testGetRenderingAnomalyScoreSpoofed(): void
+    {
+        $metrics = [
+            'rendering' => [
+                'fps' => 60,
+                'jitter' => 12.5,
+                'offscreenAnom' => false
+            ]
+        ];
+        $context = $this->createRequestContext([
+            'headers' => ['x-behavior-metrics' => json_encode($metrics)]
+        ]);
+        $res = RequestUtils::getRenderingAnomalyScore($context);
+        $this->assertEquals(65.0, $res['renderingAnomalyScore']);
+    }
     public function testGetClickVarianceScoreReturnsZeroForNoHistory(): void
     {
         $context = $this->createRequestContext([
@@ -185,6 +207,27 @@ class RequestUtilsTest extends TestCase
         $this->assertEquals(40.0, $scoreNoActivity['behaviorScore']);
     }
 
+    public function testGetBehaviorScoreWithBotLikeKeystrokeDynamics(): void
+    {
+        $metrics = [
+            'honeypotInteraction' => false,
+            'keystrokeLatency' => 100.0,
+            'keystrokeDwellTimes' => [50, 50, 50, 50, 50],
+            'keystrokeFlightTimes' => [
+                ['digraph' => 'ab', 'time' => 100],
+                ['digraph' => 'bc', 'time' => 100],
+                ['digraph' => 'cd', 'time' => 100],
+                ['digraph' => 'de', 'time' => 100],
+                ['digraph' => 'ef', 'time' => 100]
+            ]
+        ];
+        $context = $this->createRequestContext([
+            'headers' => ['x-behavior-metrics' => json_encode($metrics)]
+        ]);
+        $score = RequestUtils::getBehaviorScore($context);
+        $this->assertGreaterThanOrEqual(70.0, $score['behaviorScore']);
+    }
+
     public function testGetBehaviorScoreWithBotLikeTouchMovements(): void
     {
         $metrics = [

package/src/php/Utils/RequestUtils.php

@@ -436,6 +436,41 @@ class RequestUtils
         if (($metrics['keystrokeLatency'] ?? 0) > 0 && $metrics['keystrokeLatency'] < 40) $score += 25;
         if (($metrics['keystrokeLatency'] ?? 0) > 1000) $score += 15;
 
+        // NOUVEAU: Analyse de digraphie/trigraphie (dwell & flight times)
+        $dwellTimes = $metrics['keystrokeDwellTimes'] ?? [];
+        $flightTimes = $metrics['keystrokeFlightTimes'] ?? [];
+
+        if (count($dwellTimes) >= 5) {
+            $meanDwell = array_sum($dwellTimes) / count($dwellTimes);
+            $varDwell = array_reduce($dwellTimes, fn($carry, $item) => $carry + pow($item - $meanDwell, 2), 0) / count($dwellTimes);
+            $stdDevDwell = sqrt($varDwell);
+
+            if ($stdDevDwell < 2.0) {
+                $score += 35.0;
+            }
+            if ($meanDwell < 15.0) {
+                $score += 25.0;
+            }
+        }
+
+        if (count($flightTimes) >= 5) {
+            $times = array_column($flightTimes, 'time');
+            $meanFlight = array_sum($times) / count($times);
+            $varFlight = array_reduce($times, fn($carry, $item) => $carry + pow($item - $meanFlight, 2), 0) / count($times);
+            $stdDevFlight = sqrt($varFlight);
+
+            if ($stdDevFlight < 3.0) {
+                $score += 35.0;
+            }
+            if ($meanFlight < 25.0) {
+                $score += 25.0;
+            }
+            $benfordDev = Optimization::benfordTest($times);
+            if ($benfordDev > 0.18) {
+                $score += 30.0;
+            }
+        }
+
         // Analyse de Benford sur les segments de mouvement de la souris
         if (count($mouseAnalysis['segments']) > 10) {
             $benfordDeviation = Optimization::benfordTest($mouseAnalysis['segments']);
@@ -471,6 +506,42 @@ class RequestUtils
         return ['behaviorScore' => min(100.0, $score)];
     }
 
+    /**
+     * Calcule un score basé sur la régularité d'affichage (V-Sync) et l'utilisation suspecte d'OffscreenCanvas.
+     * @return array{'renderingAnomalyScore': float}
+     */
+    public static function getRenderingAnomalyScore(RequestContext $context): array
+    {
+        $behaviorHeader = $context->getHeader('x-behavior-metrics');
+        if (!$behaviorHeader) {
+            return ['renderingAnomalyScore' => 0.0];
+        }
+
+        $metrics = json_decode($behaviorHeader, true);
+        if (json_last_error() !== JSON_ERROR_NONE || !isset($metrics['rendering'])) {
+            return ['renderingAnomalyScore' => 0.0];
+        }
+
+        $rendering = $metrics['rendering'];
+        $score = 0.0;
+
+        if (!empty($rendering['offscreenAnom'])) {
+            $score += 100.0;
+        }
+
+        $fps = (float)($rendering['fps'] ?? 0.0);
+        $jitter = (float)($rendering['jitter'] ?? 0.0);
+
+        if ($fps > 250.0 || ($fps > 0.0 && $fps < 15.0)) {
+            $score += 50.0;
+        }
+        if ($jitter > 6.0) {
+            $score += min(80.0, ($jitter - 6.0) * 10.0);
+        }
+
+        return ['renderingAnomalyScore' => min(100.0, $score)];
+    }
+
     /**
      * Analyse basique d'un User-Agent.
      * @return array{browser?: string, os?: string, device?: string}
@@ -1587,6 +1658,55 @@ class RequestUtils
         return ['tcpAnomalyScore' => $tcpAnomalyScore];
     }
 
+    /**
+     * Détecte les anomalies de flux QUIC/HTTP3 par rapport au User-Agent.
+     * @param RequestContext $context
+     * @return array{'quicAnomalyScore': float}
+     */
+    public static function getQuicAnomalyScore(RequestContext $context): array
+    {
+        $quicFp = $context->getHeader('x-quic-fp') ?? $context->quicFingerprint ?? null;
+        if (empty($quicFp) || !is_string($quicFp)) {
+            return ['quicAnomalyScore' => 0.0];
+        }
+
+        $parts = explode(';', $quicFp);
+        if (count($parts) < 2) {
+            return ['quicAnomalyScore' => 0.0];
+        }
+
+        $params = [];
+        foreach (explode(',', $parts[1]) as $p) {
+            $kv = explode('=', $p, 2);
+            if (count($kv) === 2) {
+                $params[$kv[0]] = $kv[1];
+            }
+        }
+        $priorityOrder = $parts[2] ?? '';
+
+        $ua = $context->getHeader('user-agent') ?? '';
+        $uaParts = self::parseUserAgent($ua);
+        $browser = $uaParts['browser'] ?? null;
+
+        if (empty($browser)) {
+            return ['quicAnomalyScore' => 0.0];
+        }
+
+        $anomaly = 0.0;
+        if (str_starts_with($browser, 'Chrome') || str_starts_with($browser, 'Edge')) {
+            $maxData = isset($params['1']) ? (int)$params['1'] : 0;
+            $maxStreams = isset($params['4']) ? (int)$params['4'] : 0;
+            if ($maxData > 0 && $maxData < 1048576) $anomaly += 40.0;
+            if ($maxStreams > 0 && $maxStreams !== 100) $anomaly += 30.0;
+            if (!empty($priorityOrder) && !str_contains($priorityOrder, 'u=')) $anomaly += 30.0;
+        } elseif (str_starts_with($browser, 'Firefox')) {
+            $maxData = isset($params['1']) ? (int)$params['1'] : 0;
+            if ($maxData > 0 && $maxData > 5000000) $anomaly += 40.0;
+        }
+
+        return ['quicAnomalyScore' => max(0.0, min(100.0, $anomaly))];
+    }
+
     /**
      * Vérifie si un ticket de clearance (PoW) est valide, en supportant la tolérance au roaming.
      *