CMS-CSE/core/class/jwt.class.php

<?php

class jwt
{
    private static $jwtToken;
    private static $jwtSecret = JWT_PRIVATE_KEY; // Clé secrète pour signer les tokens
    private static $jwtAlgorithm = "HS256"; // Algorithme utilisé pour signer le JWT (HS256)
    
    /**
     * Initialiser les configurations pour l'authentification
     */
    public static function init($loginUrl, $apiBaseUrl, $email, $password)
    {
        // Le JWT sera stocké dans cette propriété statique
        self::$jwtToken = null;
    }

    public static function checkSession()
    {
        // Vérifie si le JWT existe et n'est pas expiré
        if (self::$jwtToken && self::validateToken(self::$jwtToken)) {
            return json_encode(['authenticated' => true, 'token' => self::$jwtToken]);
        } else {
            return json_encode(['authenticated' => false]);
        }
    }

    /**
     * Authentifier l'utilisateur et récupérer le JWT
     */
    public static function authenticate(array $_input)
    {
        $user = user::authenticator($_input);

        if ($user["status"] == "success") { 
            
            // Générer le JWT
            $user["token"] = self::generateToken($user);
            self::$jwtToken = $user["token"];
            return $user;

        } else {
            return FALSE;
        }
    }

    /**
     * Faire une requête API authentifiée avec le JWT
     */
    public static function makeAuthenticatedRequest($endpoint, $method = 'GET', $data = [])
    {
        if (!self::$jwtToken) {
            throw new Exception('Aucun jeton JWT disponible. Veuillez vous authentifier.');
        }

        // Vérification du token avant d'effectuer une requête
        if (!self::validateToken(self::$jwtToken)) {
            throw new Exception('Jeton JWT invalide ou expiré. Veuillez vous authentifier à nouveau.');
        }

        $ch = curl_init();

        $url = DOMAIN_API . $endpoint;
        curl_setopt($ch, CURLOPT_URL, $url . "/");
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

        // Ajouter le JWT dans l'en-tête d'autorisation
        curl_setopt($ch, CURLOPT_HTTPHEADER, [
            'Authorization: Bearer ' . self::$jwtToken,
            'Content-Type: application/json'
        ]);

        // Configuration des méthodes GET/POST/PUT/DELETE
        if ($method === 'POST') {
            curl_setopt($ch, CURLOPT_POST, true);
            curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
        } elseif ($method === 'PUT') {
            curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'PUT');
            curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
        } elseif ($method === 'DELETE') {
            curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'DELETE');
        }

        $response = curl_exec($ch);
        curl_close($ch);

        if ($response === false) {
            throw new Exception('Erreur lors de la requête API.');
        }

        return json_decode($response, true);
    }

    public static function refreshToken(string $expiredToken)
    {
        // Décoder le token sans vérifier son expiration
        $tokenParts = explode('.', $expiredToken);
        if (count($tokenParts) !== 3) {
            return null; // Token incorrect
        }

        $header = $tokenParts[0];
        $payload = $tokenParts[1];
        $signatureProvided = $tokenParts[2];

        // Vérifier la signature
        $signatureValid = hash_hmac('sha256', $header . '.' . $payload, self::$jwtSecret, true);
        $base64UrlSignature = self::base64UrlEncode($signatureValid);

        if ($base64UrlSignature !== $signatureProvided) {
            return null; // Signature incorrecte
        }

        // Décoder le payload
        $payloadDecoded = json_decode(self::base64UrlDecode($payload), true);

        // Vérifier si le token est expiré
        if (isset($payloadDecoded['exp']) && time() < $payloadDecoded['exp']) {
            return $expiredToken; // Le token n'est pas encore expiré, inutile de le rafraîchir
        }

        // Le token est expiré, régénérer un nouveau token avec les mêmes données mais une nouvelle expiration
        unset($payloadDecoded['exp']); // On enlève l'expiration actuelle
        $new = self::generateToken($payloadDecoded); // Générer un nouveau token

        user::updateJWTbyMd5(md5($expiredToken), $new);
        return $new;
    }

    /**
     * Déconnexion (facultatif) : Révoquer le token
     */
    public static function logout()
    {
        self::$jwtToken = null; // Supprimer le JWT
    }

    /**
     * Générer un JWT avec un payload
     */
    private static function generateToken($payload)
    {
        $header = json_encode([
            'typ' => 'JWT',
            'alg' => self::$jwtAlgorithm
        ]);

        $base64UrlHeader = self::base64UrlEncode($header);
        $base64UrlPayload = self::base64UrlEncode(json_encode($payload));

        // Créer la signature
        $signature = hash_hmac('sha256', $base64UrlHeader . "." . $base64UrlPayload, self::$jwtSecret, true);
        $base64UrlSignature = self::base64UrlEncode($signature);

        // Retourner le token complet
        return $base64UrlHeader . "." . $base64UrlPayload . "." . $base64UrlSignature;
    }

    /**
     * Valider un JWT
     */
    public static function validateToken(string $token)
    {
        $baseJWT = user::getInfosByJWT($token);
        if($baseJWT == FALSE){
            return false; // Token en base expirée
        }

        $tokenParts = explode('.', $token);
        if (count($tokenParts) !== 3) {
            return false; // Token incorrect
        }

        $header = $tokenParts[0];
        $payload = $tokenParts[1];
        $signatureProvided = $tokenParts[2];

        // Vérifier la signature
        $signatureValid = hash_hmac('sha256', $header . '.' . $payload, self::$jwtSecret, true);
        $base64UrlSignature = self::base64UrlEncode($signatureValid);

        if ($base64UrlSignature !== $signatureProvided) {
            return false; // Signature incorrecte
        }

        // Décoder le payload
        $payloadDecoded = json_decode(self::base64UrlDecode($payload), true);

        // Vérifier l'expiration du token
        if (isset($payloadDecoded['exp']) && time() >= $payloadDecoded['exp']) {
            return false; // Token expiré
        }

        return true; // Token valide
    }

    /**
     * Méthode utilitaire pour Base64 URL encoding
     */
    private static function base64UrlEncode($data)
    {
        return rtrim(strtr(base64_encode($data), '+/', '-_'), '=');
    }

    /**
     * Méthode utilitaire pour Base64 URL decoding
     */
    private static function base64UrlDecode($data)
    {
        return base64_decode(strtr($data, '-_', '+/'));
    }
}