@anonympins/fingerprint 0.3.2 → 0.3.3

package/src/php/Utils/BigInt.php

@@ -0,0 +1,102 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Anonympins\Fingerprint\Utils;
+
+/**
+ * Classe d'émulation pour les opérations sur de grands entiers (BigInt),
+ * similaire au BigInt de JavaScript. Utilise l'extension GMP.
+ * @internal
+ */
+class BigInt
+{
+    /** @var \GMP */
+    private \GMP $gmp;
+
+    /**
+     * @param \GMP|string|int $number
+     */
+    public function __construct($number)
+    {
+        if ($number instanceof \GMP) {
+            $this->gmp = $number;
+        } else {
+            $this->gmp = gmp_init($number);
+        }
+    }
+
+    /**
+     * Crée une instance à partir d'une chaîne hexadécimale.
+     */
+    public static function fromHex(string $hex): self
+    {
+        return new self(gmp_init($hex, 16));
+    }
+
+    /**
+     * Compare cette instance avec une autre.
+     * @return int < 0 si this < other, 0 si this == other, > 0 si this > other.
+     */
+    public function compareTo(self $other): int
+    {
+        return gmp_cmp($this->gmp, $other->gmp);
+    }
+
+    /**
+     * Effectue un décalage de bits vers la gauche (<<).
+     */
+    public function shiftLeft(int $bits): self
+    {
+        return new self(gmp_mul($this->gmp, gmp_pow(2, $bits)));
+    }
+
+    /**
+     * Effectue un décalage de bits vers la droite (>>).
+     */
+    public function shiftRight(int $bits): self
+    {
+        return new self(gmp_div_q($this->gmp, gmp_pow(2, $bits)));
+    }
+
+    /**
+     * Retourne la représentation en chaîne de caractères.
+     */
+    public function __toString(): string
+    {
+        return gmp_strval($this->gmp);
+    }
+
+    /**
+     * Retourne la représentation hexadécimale.
+     */
+    public function toHex(): string
+    {
+        return gmp_strval($this->gmp, 16);
+    }
+
+    /**
+     * Retourne la valeur GMP sous-jacente.
+     * @return \GMP
+     */
+    public function getGmpValue(): \GMP
+    {
+        return $this->gmp;
+    }
+
+    /**
+     * Crée une instance à partir d'une puissance de 2.
+     */
+    public static function pow(int $base, int $exp): self
+    {
+        return new self(gmp_pow($base, $exp));
+    }
+
+    /**
+     * Soustrait un autre BigInt.
+     */
+    public function sub(self $other): self
+    {
+        return new self(gmp_sub($this->gmp, $other->gmp));
+    }
+}

package/src/php/Utils/BlockList.php

@@ -0,0 +1,100 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Anonympins\Fingerprint\Utils;
+
+/**
+ * Implémentation PHP d'une liste de blocage IP/CIDR, similaire à Node.js `net.BlockList`.
+ */
+class BlockList
+{
+    /**
+     * @var array<string> Liste des IPs ou CIDR à bloquer.
+     */
+    private array $entries = [];
+
+    /**
+     * Ajoute une adresse IP ou une plage CIDR à la liste.
+     * @param string $entry Une adresse IP (ex: '192.168.1.1') ou une plage CIDR (ex: '192.168.1.0/24').
+     * @return void
+     */
+    public function add(string $entry): void
+    {
+        $this->entries[] = $entry;
+    }
+
+    /**
+     * Vérifie si une adresse IP est présente dans la liste de blocage.
+     * @param string $ip L'adresse IP à vérifier.
+     * @return bool True si l'IP est bloquée, false sinon.
+     */
+    public function check(string $ip): bool
+    {
+        foreach ($this->entries as $entry) {
+            if (str_contains($entry, '/')) {
+                // C'est une plage CIDR
+                if ($this->ipInCidr($ip, $entry)) {
+                    return true;
+                }
+            } else {
+                // C'est une IP directe
+                if ($ip === $entry) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Vérifie si une adresse IP se trouve dans une plage CIDR donnée.
+     * @param string $ip L'adresse IP à vérifier.
+     * @param string $cidr La plage CIDR (ex: '192.168.1.0/24').
+     * @return bool True si l'IP est dans la plage, false sinon.
+     */
+    private function ipInCidr(string $ip, string $cidr): bool
+    {
+        [$network, $mask] = explode('/', $cidr);
+        $mask = (int)$mask;
+
+        if (filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_IPV6) && filter_var($network, FILTER_VALIDATE_IP, FILTER_FLAG_IPV6)) {
+            // IPv6
+            $ipBinary = inet_pton($ip);
+            $networkBinary = inet_pton($network);
+
+            if ($ipBinary === false || $networkBinary === false) {
+                return false;
+            }
+
+            $ipHex = bin2hex($ipBinary);
+            $networkHex = bin2hex($networkBinary);
+
+            $numBytes = (int)ceil($mask / 8);
+            $compareLength = $numBytes * 2;
+
+            if (substr($ipHex, 0, $compareLength) !== substr($networkHex, 0, $compareLength)) {
+                return false;
+            }
+
+            if ($mask % 8 !== 0) {
+                $bitMask = (0xFF << (8 - ($mask % 8))) & 0xFF;
+                $ipByte = hexdec(substr($ipHex, $numBytes * 2 - 2, 2));
+                $networkByte = hexdec(substr($networkHex, $numBytes * 2 - 2, 2));
+                return ($ipByte & $bitMask) === ($networkByte & $bitMask);
+            }
+
+            return true;
+
+        } elseif (filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_IPV4) && filter_var($network, FILTER_VALIDATE_IP, FILTER_FLAG_IPV4)) {
+            // IPv4
+            $ipLong = ip2long($ip);
+            $networkLong = ip2long($network);
+            $wildcard = pow(2, (32 - $mask)) - 1;
+            $netmask = ~$wildcard;
+            return (($ipLong & $netmask) === ($networkLong & $netmask));
+        }
+
+        return false;
+    }
+}

package/src/php/Utils/Logger.php

@@ -0,0 +1,30 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Anonympins\Fingerprint\Utils;
+
+/**
+ * Un simple wrapper de logger pour passer les données à une fonction de rappel.
+ */
+class Logger
+{
+    /**
+     * @var callable
+     */
+    private $callback;
+
+    public function __construct(callable $callback)
+    {
+        $this->callback = $callback;
+    }
+
+    public function log(string $level, string $type, array $data): void
+    {
+        $logEntry = array_merge($data, [
+            'type' => $type,
+            'timestamp' => (int)floor(microtime(true) * 1000),
+        ]);
+        ($this->callback)($logEntry);
+    }
+}

package/src/php/Utils/MaliciousPatterns.php

@@ -0,0 +1,59 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Anonympins\Fingerprint\Utils;
+
+/**
+ * Fournit des fonctions pour détecter les patterns d'injection malveillants.
+ */
+class MaliciousPatterns
+{
+    /**
+     * @var array<string, string> Map des patterns malveillants regroupés par type.
+     */
+    private const INJECTION_PATTERNS = [
+        // SQL/NoSQL injections, including time-based attacks
+        'sql' => '/(\$ne|\' *OR *\'1\'=\'1|[\'";]\s*--|; ?(DROP|TRUNCATE|DELETE)|UNION SELECT|(?:SLEEP|BENCHMARK)\s*\(|WAITFOR DELAY)/i',
+        // Log4Shell (JNDI injection)
+        'log4shell' => '/\$\{jndi:(ldap|rmi|dns):/i',
+        // Server-Side Template Injection (SSTI) for engines like Jinja2, Twig, etc.
+        'ssti' => '/\{\{.*\}\}|\{%.*%\}/',
+        // XML External Entity (XXE) injection
+        'xxe' => '/<!ENTITY\s+.*SYSTEM/i',
+        // Path Traversal
+        'traversal' => '/(\.\.\/|\.\.)/',
+        // Remote Command Execution (RCE)
+        // The original regex had an issue with `|cmd` being interpreted as a modifier in some PCRE versions.
+        // Using a non-capturing group (?:...) makes it more robust and fixes the compilation error.
+        'rce' => '/`.*`|(?:^|[\n;&|]\s*)(?:ping|ls|whoami|cat|rm|ncat|nc|bash|sh|powershell|cmd)\b/i',
+    ];
+
+    /**
+     * Vérifie si une chaîne de caractères contient des patterns d'injection connus.
+     * @param string $str La chaîne à vérifier.
+     * @param array<string> $typesToDetect Les types d'injections à détecter (par défaut, tous).
+     * @return bool True si un pattern malveillant est détecté, false sinon.
+     */
+    public static function isMalicious(string $str, array $typesToDetect = []): bool
+    {
+        if (empty($typesToDetect)) {
+            $typesToDetect = array_keys(self::INJECTION_PATTERNS);
+        }
+
+        foreach ($typesToDetect as $type) {
+            if (isset(self::INJECTION_PATTERNS[$type])) {
+               try {
+                   if (preg_match(self::INJECTION_PATTERNS[$type], $str)) {
+                       return true;
+                   }
+               }catch (\Exception $e){
+                   error_log($type);
+                   error_log($e->getMessage());
+                }
+            }
+        }
+
+        return false;
+    }
+}