FirebaseClient.php

Go to the documentation of this file.

<?php
 
namespace ILIAS\LTI\ToolProvider\Jwt;
 
use Firebase\JWT\JWT;
use Firebase\JWT\JWK;
use Firebase\JWT\Key;
use ILIAS\LTI\ToolProvider\Http\HttpMessage;
use ILIAS\LTI\ToolProvider\Util;
 
class FirebaseClient implements ClientInterface
{
    public const SUPPORTED_ALGORITHMS = array('RS256', 'RS384', 'RS512');
 
    private ?string $jwtString = null;
    private ?array $jwtHeaders = null;
    private ?array $jwtPayload = null;
    private static ?array $lastHeaders = null;
    private static ?array $lastPayload = null;
 
    public static function getSupportedAlgorithms(): array
    {
        return self::SUPPORTED_ALGORITHMS;
    }
 
    public function hasJwt(): bool
    {
        return !empty($this->jwtString);
    }
 
    public function isEncrypted(): bool
    {
        return false;  // Not supported by this client
    }
 
    public function load(string $jwtString, string $privateKey = null): bool
    {
        $sections = explode('.', $jwtString);
        $ok = count($sections) === 3;
        if ($ok) {
            $headers = json_decode(JWT::urlsafeB64Decode($sections[0]), true); //changed
            $payload = json_decode(JWT::urlsafeB64Decode($sections[1]), true); //changed
            $ok = !is_null($headers) && !is_null($payload);
        }
        if ($ok) {
            $this->jwtString = $jwtString;
            $this->jwtHeaders = $headers;
            $this->jwtPayload = $payload;
        } else {
            $this->jwtString = null;
            $this->jwtHeaders = null;
            $this->jwtPayload = null;
        }
 
        return $ok;
    }
 
    public function getJweHeaders(): array
    {
        return array();  // Encryption not supported by this client
    }
 
    public function hasHeader(string $name): bool
    {
        return !empty($this->jwtHeaders) && isset($this->jwtHeaders[$name]); //changed
    }
 
    public function getHeader(string $name, string $defaultValue = null): string
    {
        if ($this->hasHeader($name)) {
            $value = $this->jwtHeaders[$name]; //changed
        } else {
            $value = $defaultValue;
        }
 
        return $value;
    }
 
    public function getHeaders(): array
    {
        return $this->jwtHeaders;
    }
 
    public static function getLastHeaders(): array
    {
        return self::$lastHeaders;
    }
 
    public function hasClaim(string $name): bool
    {
        return !empty($this->jwtPayload) && isset($this->jwtPayload[$name]); //changed
    }
 
    public function getClaim(string $name, string $defaultValue = null)
    {
        if ($this->hasClaim($name)) {
            $value = $this->jwtPayload[$name]; //changed
        } else {
            $value = $defaultValue;
        }
 
        return $value;
    }
 
    public function getPayload(): array
    {
        return $this->jwtPayload;
    }
 
    public static function getLastPayload(): array
    {
        return self::$lastPayload;
    }
 
    public function verify(string $publicKey, string $jku = null): bool
    {
        $ok = false;
        $hasPublicKey = !empty($publicKey);
        if ($hasPublicKey) {
            if (is_string($publicKey)) {
                $json = json_decode($publicKey, true);
                if (!is_null($json)) {
                    try {
                        $jwks = array('keys' => array($json));
                        $publicKey = static::parseKeySet($jwks);
                    } catch (\Exception $e) {
                    }
                } else {
                    $publicKey = new Key($publicKey, $this->getHeader('alg'));
                }
            }
        } elseif (!empty($jku)) {
            $publicKey = $this->fetchPublicKey($jku);
        }
        JWT::$leeway = Jwt::$leeway;
        $retry = false;
 
        do {
            try {
                JWT::decode($this->jwtString, $publicKey);
                $ok = true;
            } catch (\Exception $e) {
                Util::logError($e->getMessage());
                if ($retry) {
                    $retry = false;
                } elseif ($hasPublicKey && !empty($jku)) {
                    try {
                        $publicKey = $this->fetchPublicKey($jku);
                        $retry = true;
                    } catch (\Exception $e) {
                    }
                }
            }
        } while (!$ok && $retry);
 
        return $ok;
    }
 
    public static function sign(
        array $payload,
        string $signatureMethod,
        string $privateKey,
        string $kid = null,
        string $jku = null,
        string $encryptionMethod = null,
        string $publicKey = null
    ): string {
        if (!empty($encryptionMethod)) {
            $errorMessage = 'Encrypted tokens not supported by the Firebase JWT client';
            Util::logError($errorMessage);
            throw new \Exception($errorMessage);
        }
        $jwtString = JWT::encode($payload, $privateKey, $signatureMethod, $kid);
        $sections = explode('.', $jwtString);
        self::$lastHeaders = json_decode(JWT::urlsafeB64Decode($sections[0]));
        self::$lastPayload = json_decode(JWT::urlsafeB64Decode($sections[1]));
 
        return $jwtString;
    }
 
    public static function generateKey(string $signatureMethod = 'RS256'): ?string
    {
        $privateKey = null;
        switch ($signatureMethod) {
            case 'RS512':
                $size = 4096;
                break;
            case 'RS384':
                $size = 3072;
                break;
            default:
                $size = 2048;
                break;
        }
        $config = array(
            "private_key_bits" => $size,
            "private_key_type" => OPENSSL_KEYTYPE_RSA
        );
        $res = openssl_pkey_new($config);
        if (openssl_pkey_export($res, $privateKey)) {
            $privateKey = str_replace('-----BEGIN PRIVATE KEY-----', '-----BEGIN RSA PRIVATE KEY-----', $privateKey);
            $privateKey = str_replace('-----END PRIVATE KEY-----', '-----END RSA PRIVATE KEY-----', $privateKey);
        }
 
        return $privateKey;
    }
 
    public static function getPublicKey(string $privateKey): string
    {
        $publicKey = null;
        $res = openssl_pkey_get_private($privateKey);
        if ($res !== false) {
            $details = openssl_pkey_get_details($res);
            $publicKey = $details['key'];
        }
 
        return $publicKey;
    }
 
    public static function getJWKS(string $pemKey, string $signatureMethod, string $kid = null): array
    {
        $keys['keys'] = array();
        $res = openssl_pkey_get_private($pemKey);
        if ($res === false) {
            $res = openssl_pkey_get_public($pemKey);
        }
        if ($res !== false) {
            $details = openssl_pkey_get_details($res);
            $key = [
                'kty' => 'RSA',
                'n' => JWT::urlsafeB64Encode($details['rsa']['n']),
                'e' => JWT::urlsafeB64Encode($details['rsa']['e']),
                'alg' => $signatureMethod,
                'use' => 'sig'
            ];
            if (!empty($kid)) {
                $key['kid'] = $kid;
            }
            $keys['keys'][] = $key;
        }
 
        return $keys;
    }
 
    ###
    ###  PRIVATE METHODS
    ###
 
    private function fetchPublicKey(string $jku): array
    {
        $publicKey = array();
        $http = new HttpMessage($jku);
        if ($http->send()) {
            $keys = json_decode($http->response, true);
            $publicKey = static::parseKeySet($keys);
        }
        return $publicKey;
    }
 
    private static function parseKeySet(array $jwks): array
    {
        $keys = array();
        if (!isset($jwks['keys'])) {
            throw new \UnexpectedValueException('"keys" member must exist in the JWK Set');
        }
        if (empty($jwks['keys'])) {
            throw new \InvalidArgumentException('JWK Set did not contain any keys');
        }
 
        foreach ($jwks['keys'] as $k => $v) {
            if (!empty($v['alg'])) {
                $kid = isset($v['kid']) ? $v['kid'] : $k;
                if ($key = JWK::parseKey($v)) {
                    $keys[$kid] = $key;  //changed from
                    //$keys[$kid] = new Key($key, $v['alg']);
                }
            }
        }
 
        if (empty($keys)) {
            throw new \UnexpectedValueException('No supported algorithms found in JWK Set');
        }
 
        return $keys;
    }
}