Search moodle.org's
Developer Documentation

See Release Notes
Long Term Support Release

  • Bug fixes for general core bugs in 4.1.x will end 13 November 2023 (12 months).
  • Bug fixes for security issues in 4.1.x will end 10 November 2025 (36 months).
  • PHP version: minimum PHP 7.4.0 Note: minimum PHP version has increased since Moodle 4.0. PHP 8.0.x is supported too.
<?php

namespace Firebase\JWT;

< use \DomainException; < use \InvalidArgumentException; < use \UnexpectedValueException; < use \DateTime;
> use ArrayAccess; > use DateTime; > use DomainException; > use Exception; > use InvalidArgumentException; > use OpenSSLAsymmetricKey; > use OpenSSLCertificate; > use stdClass; > use UnexpectedValueException;
/** * JSON Web Token implementation, based on this spec: * https://tools.ietf.org/html/rfc7519 * * PHP version 5 * * @category Authentication * @package Authentication_JWT * @author Neuman Vong <neuman@twilio.com> * @author Anant Narayanan <anant@php.net> * @license http://opensource.org/licenses/BSD-3-Clause 3-clause BSD * @link https://github.com/firebase/php-jwt */ class JWT {
< const ASN1_INTEGER = 0x02; < const ASN1_SEQUENCE = 0x10; < const ASN1_BIT_STRING = 0x03;
> private const ASN1_INTEGER = 0x02; > private const ASN1_SEQUENCE = 0x10; > private const ASN1_BIT_STRING = 0x03;
/** * When checking nbf, iat or expiration times, * we want to provide some extra leeway time to * account for clock skew.
> * */ > * @var int
< public static $leeway = 180;
> public static $leeway = 0;
/** * Allow the current timestamp to be specified. * Useful for fixing a value within unit testing.
< *
* Will default to PHP time() value if null.
> * */ > * @var ?int
public static $timestamp = null;
< public static $supported_algs = array( < 'ES256' => array('openssl', 'SHA256'), < 'HS256' => array('hash_hmac', 'SHA256'), < 'HS384' => array('hash_hmac', 'SHA384'), < 'HS512' => array('hash_hmac', 'SHA512'), < 'RS256' => array('openssl', 'SHA256'), < 'RS384' => array('openssl', 'SHA384'), < 'RS512' => array('openssl', 'SHA512'), < );
> /** > * @var array<string, string[]> > */ > public static $supported_algs = [ > 'ES384' => ['openssl', 'SHA384'], > 'ES256' => ['openssl', 'SHA256'], > 'HS256' => ['hash_hmac', 'SHA256'], > 'HS384' => ['hash_hmac', 'SHA384'], > 'HS512' => ['hash_hmac', 'SHA512'], > 'RS256' => ['openssl', 'SHA256'], > 'RS384' => ['openssl', 'SHA384'], > 'RS512' => ['openssl', 'SHA512'], > 'EdDSA' => ['sodium_crypto', 'EdDSA'], > ];
/** * Decodes a JWT string into a PHP object. * * @param string $jwt The JWT
< * @param string|array|resource $key The key, or map of keys.
> * @param Key|array<string,Key> $keyOrKeyArray The Key or associative array of key IDs (kid) to Key objects.
* If the algorithm used is asymmetric, this is the public key
< * @param array $allowed_algs List of supported verification algorithms < * Supported algorithms are 'ES256', 'HS256', 'HS384', 'HS512', 'RS256', 'RS384', and 'RS512'
> * Each Key object contains an algorithm and matching key. > * Supported algorithms are 'ES384','ES256', 'HS256', 'HS384', > * 'HS512', 'RS256', 'RS384', and 'RS512'
*
< * @return object The JWT's payload as a PHP object
> * @return stdClass The JWT's payload as a PHP object
*
> * @throws InvalidArgumentException Provided key/key-array was empty * @throws UnexpectedValueException Provided JWT was invalid > * @throws DomainException Provided JWT is malformed
* @throws SignatureInvalidException Provided JWT was invalid because the signature verification failed * @throws BeforeValidException Provided JWT is trying to be used before it's eligible as defined by 'nbf' * @throws BeforeValidException Provided JWT is trying to be used before it's been created as defined by 'iat' * @throws ExpiredException Provided JWT has since expired, as defined by the 'exp' claim * * @uses jsonDecode * @uses urlsafeB64Decode */
< public static function decode($jwt, $key, array $allowed_algs = array()) < {
> public static function decode( > string $jwt, > $keyOrKeyArray > ): stdClass { > // Validate JWT
$timestamp = \is_null(static::$timestamp) ? \time() : static::$timestamp;
< if (empty($key)) {
> if (empty($keyOrKeyArray)) {
throw new InvalidArgumentException('Key may not be empty'); } $tks = \explode('.', $jwt);
< if (\count($tks) != 3) {
> if (\count($tks) !== 3) {
throw new UnexpectedValueException('Wrong number of segments'); } list($headb64, $bodyb64, $cryptob64) = $tks;
< if (null === ($header = static::jsonDecode(static::urlsafeB64Decode($headb64)))) {
> $headerRaw = static::urlsafeB64Decode($headb64); > if (null === ($header = static::jsonDecode($headerRaw))) {
throw new UnexpectedValueException('Invalid header encoding'); }
< if (null === $payload = static::jsonDecode(static::urlsafeB64Decode($bodyb64))) {
> $payloadRaw = static::urlsafeB64Decode($bodyb64); > if (null === ($payload = static::jsonDecode($payloadRaw))) {
throw new UnexpectedValueException('Invalid claims encoding'); }
< if (false === ($sig = static::urlsafeB64Decode($cryptob64))) { < throw new UnexpectedValueException('Invalid signature encoding');
> if (\is_array($payload)) { > // prevent PHP Fatal Error in edge-cases when payload is empty array > $payload = (object) $payload; > } > if (!$payload instanceof stdClass) { > throw new UnexpectedValueException('Payload must be a JSON object');
}
> $sig = static::urlsafeB64Decode($cryptob64);
if (empty($header->alg)) { throw new UnexpectedValueException('Empty algorithm'); } if (empty(static::$supported_algs[$header->alg])) { throw new UnexpectedValueException('Algorithm not supported'); }
< if (!\in_array($header->alg, $allowed_algs)) { < throw new UnexpectedValueException('Algorithm not allowed'); < } < if ($header->alg === 'ES256') { < // OpenSSL expects an ASN.1 DER sequence for ES256 signatures < $sig = self::signatureToDER($sig); < }
< if (\is_array($key) || $key instanceof \ArrayAccess) { < if (isset($header->kid)) { < if (!isset($key[$header->kid])) { < throw new UnexpectedValueException('"kid" invalid, unable to lookup correct key'); < } < $key = $key[$header->kid]; < } else { < throw new UnexpectedValueException('"kid" empty, unable to lookup correct key');
> $key = self::getKey($keyOrKeyArray, property_exists($header, 'kid') ? $header->kid : null); > > // Check the algorithm > if (!self::constantTimeEquals($key->getAlgorithm(), $header->alg)) { > // See issue #351 > throw new UnexpectedValueException('Incorrect key for this algorithm');
}
> if ($header->alg === 'ES256' || $header->alg === 'ES384') { } > // OpenSSL expects an ASN.1 DER sequence for ES256/ES384 signatures > $sig = self::signatureToDER($sig);
< < // Check the signature < if (!static::verify("$headb64.$bodyb64", $sig, $key, $header->alg)) {
> if (!self::verify("${headb64}.${bodyb64}", $sig, $key->getKeyMaterial(), $header->alg)) {
} // Check the nbf if it is defined. This is the time that the // token can actually be used. If it's not yet that time, abort. if (isset($payload->nbf) && $payload->nbf > ($timestamp + static::$leeway)) { throw new BeforeValidException( 'Cannot handle token prior to ' . \date(DateTime::ISO8601, $payload->nbf) ); } // Check that this token has been created before 'now'. This prevents // using tokens that have been created for later use (and haven't // correctly used the nbf claim). if (isset($payload->iat) && $payload->iat > ($timestamp + static::$leeway)) { throw new BeforeValidException( 'Cannot handle token prior to ' . \date(DateTime::ISO8601, $payload->iat) ); } // Check if this token has expired. if (isset($payload->exp) && ($timestamp - static::$leeway) >= $payload->exp) { throw new ExpiredException('Expired token'); } return $payload; } /** * Converts and signs a PHP object or array into a JWT string. *
< * @param object|array $payload PHP object or array < * @param string $key The secret key. < * If the algorithm used is asymmetric, this is the private key < * @param string $alg The signing algorithm. < * Supported algorithms are 'ES256', 'HS256', 'HS384', 'HS512', 'RS256', 'RS384', and 'RS512' < * @param mixed $keyId < * @param array $head An array with header elements to attach
> * @param array<mixed> $payload PHP array > * @param string|resource|OpenSSLAsymmetricKey|OpenSSLCertificate $key The secret key. > * @param string $alg Supported algorithms are 'ES384','ES256', 'HS256', 'HS384', > * 'HS512', 'RS256', 'RS384', and 'RS512' > * @param string $keyId > * @param array<string, string> $head An array with header elements to attach
* * @return string A signed JWT * * @uses jsonEncode * @uses urlsafeB64Encode */
< public static function encode($payload, $key, $alg = 'HS256', $keyId = null, $head = null) < { < $header = array('typ' => 'JWT', 'alg' => $alg);
> public static function encode( > array $payload, > $key, > string $alg, > string $keyId = null, > array $head = null > ): string { > $header = ['typ' => 'JWT', 'alg' => $alg];
if ($keyId !== null) { $header['kid'] = $keyId; } if (isset($head) && \is_array($head)) { $header = \array_merge($head, $header); }
< $segments = array(); < $segments[] = static::urlsafeB64Encode(static::jsonEncode($header)); < $segments[] = static::urlsafeB64Encode(static::jsonEncode($payload));
> $segments = []; > $segments[] = static::urlsafeB64Encode((string) static::jsonEncode($header)); > $segments[] = static::urlsafeB64Encode((string) static::jsonEncode($payload));
$signing_input = \implode('.', $segments); $signature = static::sign($signing_input, $key, $alg); $segments[] = static::urlsafeB64Encode($signature); return \implode('.', $segments); } /** * Sign a string with a given key and algorithm. * * @param string $msg The message to sign
< * @param string|resource $key The secret key < * @param string $alg The signing algorithm. < * Supported algorithms are 'ES256', 'HS256', 'HS384', 'HS512', 'RS256', 'RS384', and 'RS512'
> * @param string|resource|OpenSSLAsymmetricKey|OpenSSLCertificate $key The secret key. > * @param string $alg Supported algorithms are 'ES384','ES256', 'HS256', 'HS384', > * 'HS512', 'RS256', 'RS384', and 'RS512'
* * @return string An encrypted message *
< * @throws DomainException Unsupported algorithm was specified
> * @throws DomainException Unsupported algorithm or bad key was specified
*/
< public static function sign($msg, $key, $alg = 'HS256') < {
> public static function sign( > string $msg, > $key, > string $alg > ): string {
if (empty(static::$supported_algs[$alg])) { throw new DomainException('Algorithm not supported'); } list($function, $algorithm) = static::$supported_algs[$alg]; switch ($function) { case 'hash_hmac':
> if (!\is_string($key)) { return \hash_hmac($algorithm, $msg, $key, true); > throw new InvalidArgumentException('key must be a string when using hmac'); case 'openssl': > }
$signature = '';
< $success = \openssl_sign($msg, $signature, $key, $algorithm);
> $success = \openssl_sign($msg, $signature, $key, $algorithm); // @phpstan-ignore-line
if (!$success) {
< throw new DomainException("OpenSSL unable to sign data"); < } else {
> throw new DomainException('OpenSSL unable to sign data'); > }
if ($alg === 'ES256') { $signature = self::signatureFromDER($signature, 256);
> } elseif ($alg === 'ES384') { } > $signature = self::signatureFromDER($signature, 384);
return $signature;
> case 'sodium_crypto': } > if (!\function_exists('sodium_crypto_sign_detached')) { } > throw new DomainException('libsodium is not available'); } > } > if (!\is_string($key)) { /** > throw new InvalidArgumentException('key must be a string when using EdDSA'); * Verify a signature with the message, key and method. Not all methods > } * are symmetric, so we must have a separate verify and sign method. > try { * > // The last non-empty line is used as the key. * @param string $msg The original message (header and body) > $lines = array_filter(explode("\n", $key)); * @param string $signature The original signature > $key = base64_decode((string) end($lines)); * @param string|resource $key For HS*, a string key works. for RS*, must be a resource of an openssl public key > return sodium_crypto_sign_detached($msg, $key); * @param string $alg The algorithm > } catch (Exception $e) { * > throw new DomainException($e->getMessage(), 0, $e);
* @return bool
> * > throw new DomainException('Algorithm not supported');
< * @param string|resource $key For HS*, a string key works. for RS*, must be a resource of an openssl public key
> * @param string|resource|OpenSSLAsymmetricKey|OpenSSLCertificate $keyMaterial For HS*, a string key works. for RS*, must be an instance of OpenSSLAsymmetricKey
< * @throws DomainException Invalid Algorithm or OpenSSL failure
> * @throws DomainException Invalid Algorithm, bad key, or OpenSSL failure
< private static function verify($msg, $signature, $key, $alg) < {
> private static function verify( > string $msg, > string $signature, > $keyMaterial, > string $alg > ): bool {
if (empty(static::$supported_algs[$alg])) { throw new DomainException('Algorithm not supported'); } list($function, $algorithm) = static::$supported_algs[$alg]; switch ($function) { case 'openssl':
< $success = \openssl_verify($msg, $signature, $key, $algorithm);
> $success = \openssl_verify($msg, $signature, $keyMaterial, $algorithm); // @phpstan-ignore-line
if ($success === 1) { return true;
< } elseif ($success === 0) {
> } > if ($success === 0) {
return false; } // returns 1 on success, 0 on failure, -1 on error. throw new DomainException( 'OpenSSL error: ' . \openssl_error_string() );
> case 'sodium_crypto': case 'hash_hmac': > if (!\function_exists('sodium_crypto_sign_verify_detached')) { default: > throw new DomainException('libsodium is not available'); $hash = \hash_hmac($algorithm, $msg, $key, true); > } if (\function_exists('hash_equals')) { > if (!\is_string($keyMaterial)) { return \hash_equals($signature, $hash); > throw new InvalidArgumentException('key must be a string when using EdDSA'); } > } $len = \min(static::safeStrlen($signature), static::safeStrlen($hash)); > try { > // The last non-empty line is used as the key. $status = 0; > $lines = array_filter(explode("\n", $keyMaterial)); for ($i = 0; $i < $len; $i++) { > $key = base64_decode((string) end($lines)); $status |= (\ord($signature[$i]) ^ \ord($hash[$i])); > return sodium_crypto_sign_verify_detached($signature, $msg, $key); } > } catch (Exception $e) { $status |= (static::safeStrlen($signature) ^ static::safeStrlen($hash)); > throw new DomainException($e->getMessage(), 0, $e); > }
< $hash = \hash_hmac($algorithm, $msg, $key, true); < if (\function_exists('hash_equals')) { < return \hash_equals($signature, $hash);
> if (!\is_string($keyMaterial)) { > throw new InvalidArgumentException('key must be a string when using hmac');
< $len = \min(static::safeStrlen($signature), static::safeStrlen($hash)); < < $status = 0; < for ($i = 0; $i < $len; $i++) { < $status |= (\ord($signature[$i]) ^ \ord($hash[$i])); < } < $status |= (static::safeStrlen($signature) ^ static::safeStrlen($hash)); < < return ($status === 0);
> $hash = \hash_hmac($algorithm, $msg, $keyMaterial, true); > return self::constantTimeEquals($hash, $signature);
< * @return object Object representation of JSON string
> * @return mixed The decoded JSON string
< public static function jsonDecode($input)
> public static function jsonDecode(string $input)
{
< if (\version_compare(PHP_VERSION, '5.4.0', '>=') && !(\defined('JSON_C_VERSION') && PHP_INT_SIZE > 4)) { < /** In PHP >=5.4.0, json_decode() accepts an options parameter, that allows you < * to specify that large ints (like Steam Transaction IDs) should be treated as < * strings, rather than the PHP default behaviour of converting them to floats. < */
$obj = \json_decode($input, false, 512, JSON_BIGINT_AS_STRING);
< } else { < /** Not all servers will support that, however, so for older versions we must < * manually detect large ints in the JSON string and quote them (thus converting < *them to strings) before decoding, hence the preg_replace() call. < */ < $max_int_length = \strlen((string) PHP_INT_MAX) - 1; < $json_without_bigints = \preg_replace('/:\s*(-?\d{'.$max_int_length.',})/', ': "$1"', $input); < $obj = \json_decode($json_without_bigints); < }
if ($errno = \json_last_error()) {
< static::handleJsonError($errno);
> self::handleJsonError($errno);
} elseif ($obj === null && $input !== 'null') { throw new DomainException('Null result with non-null input'); } return $obj; } /**
< * Encode a PHP object into a JSON string.
> * Encode a PHP array into a JSON string.
*
< * @param object|array $input A PHP object or array
> * @param array<mixed> $input A PHP array
*
< * @return string JSON representation of the PHP object or array
> * @return string JSON representation of the PHP array
* * @throws DomainException Provided object could not be encoded to valid JSON */
< public static function jsonEncode($input)
> public static function jsonEncode(array $input): string
{
> if (PHP_VERSION_ID >= 50400) { $json = \json_encode($input); > $json = \json_encode($input, \JSON_UNESCAPED_SLASHES); if ($errno = \json_last_error()) { > } else { static::handleJsonError($errno); > // PHP 5.3 only
} elseif ($json === 'null' && $input !== null) {
> }
< static::handleJsonError($errno);
> self::handleJsonError($errno);
}
> if ($json === false) { return $json; > throw new DomainException('Provided object could not be encoded to valid JSON'); } > }
/** * Decode a string with URL-safe Base64. * * @param string $input A Base64 encoded string * * @return string A decoded string
> * */ > * @throws InvalidArgumentException invalid base64 characters
< public static function urlsafeB64Decode($input)
> public static function urlsafeB64Decode(string $input): string
{ $remainder = \strlen($input) % 4; if ($remainder) { $padlen = 4 - $remainder; $input .= \str_repeat('=', $padlen); } return \base64_decode(\strtr($input, '-_', '+/')); } /** * Encode a string with URL-safe Base64. * * @param string $input The string you want encoded * * @return string The base64 encode of what you passed in */
< public static function urlsafeB64Encode($input)
> public static function urlsafeB64Encode(string $input): string
{ return \str_replace('=', '', \strtr(\base64_encode($input), '+/', '-_')); }
> /** > /** * Helper method to create a JSON error. > * Determine if an algorithm has been provided for each Key * > * * @param int $errno An error number from json_last_error() > * @param Key|ArrayAccess<string,Key>|array<string,Key> $keyOrKeyArray * > * @param string|null $kid * @return void > * */ > * @throws UnexpectedValueException private static function handleJsonError($errno) > * { > * @return Key $messages = array( > */ JSON_ERROR_DEPTH => 'Maximum stack depth exceeded', > private static function getKey( JSON_ERROR_STATE_MISMATCH => 'Invalid or malformed JSON', > $keyOrKeyArray, JSON_ERROR_CTRL_CHAR => 'Unexpected control character found', > ?string $kid JSON_ERROR_SYNTAX => 'Syntax error, malformed JSON', > ): Key { JSON_ERROR_UTF8 => 'Malformed UTF-8 characters' //PHP >= 5.3.3 > if ($keyOrKeyArray instanceof Key) { ); > return $keyOrKeyArray; throw new DomainException( > } isset($messages[$errno]) > ? $messages[$errno] > if ($keyOrKeyArray instanceof CachedKeySet) { : 'Unknown JSON error: ' . $errno > // Skip "isset" check, as this will automatically refresh if not set ); > return $keyOrKeyArray[$kid]; } > } > /** > if (empty($kid)) { * Get the number of bytes in cryptographic strings. > throw new UnexpectedValueException('"kid" empty, unable to lookup correct key'); * > } * @param string $str > if (!isset($keyOrKeyArray[$kid])) { * > throw new UnexpectedValueException('"kid" invalid, unable to lookup correct key'); * @return int > } */ > private static function safeStrlen($str) > return $keyOrKeyArray[$kid]; { > } if (\function_exists('mb_strlen')) { > return \mb_strlen($str, '8bit'); > /** } > * @param string $left The string of known length to compare against return \strlen($str); > * @param string $right The user-supplied string } > * @return bool > */ /** > public static function constantTimeEquals(string $left, string $right): bool * Convert an ECDSA signature to an ASN.1 DER sequence > { * > if (\function_exists('hash_equals')) { * @param string $sig The ECDSA signature to convert > return \hash_equals($left, $right); * @return string The encoded DER object > } */ > $len = \min(self::safeStrlen($left), self::safeStrlen($right)); private static function signatureToDER($sig) > { > $status = 0; // Separate the signature into r-value and s-value > for ($i = 0; $i < $len; $i++) { list($r, $s) = \str_split($sig, (int) (\strlen($sig) / 2)); > $status |= (\ord($left[$i]) ^ \ord($right[$i])); > } // Trim leading zeros > $status |= (self::safeStrlen($left) ^ self::safeStrlen($right)); $r = \ltrim($r, "\x00"); > $s = \ltrim($s, "\x00"); > return ($status === 0); > } // Convert r-value and s-value from unsigned big-endian integers to >
// signed two's complement
> * @throws DomainException if (\ord($r[0]) > 0x7f) { > *
< private static function handleJsonError($errno)
> private static function handleJsonError(int $errno): void
< $messages = array(
> $messages = [
< );
> ];
< private static function safeStrlen($str)
> private static function safeStrlen(string $str): int
< private static function signatureToDER($sig)
> private static function signatureToDER(string $sig): string
< list($r, $s) = \str_split($sig, (int) (\strlen($sig) / 2));
> $length = max(1, (int) (\strlen($sig) / 2)); > list($r, $s) = \str_split($sig, $length);
return self::encodeDER( self::ASN1_SEQUENCE, self::encodeDER(self::ASN1_INTEGER, $r) . self::encodeDER(self::ASN1_INTEGER, $s) ); } /** * Encodes a value into a DER object. * * @param int $type DER tag * @param string $value the value to encode
> *
* @return string the encoded object */
< private static function encodeDER($type, $value)
> private static function encodeDER(int $type, string $value): string
{ $tag_header = 0; if ($type === self::ASN1_SEQUENCE) { $tag_header |= 0x20; } // Type $der = \chr($tag_header | $type); // Length $der .= \chr(\strlen($value)); return $der . $value; } /** * Encodes signature from a DER object. * * @param string $der binary signature in DER format * @param int $keySize the number of bits in the key
> *
* @return string the signature */
< private static function signatureFromDER($der, $keySize)
> private static function signatureFromDER(string $der, int $keySize): string
{ // OpenSSL returns the ECDSA signatures as a binary ASN.1 DER SEQUENCE list($offset, $_) = self::readDER($der); list($offset, $r) = self::readDER($der, $offset); list($offset, $s) = self::readDER($der, $offset); // Convert r-value and s-value from signed two's compliment to unsigned // big-endian integers $r = \ltrim($r, "\x00"); $s = \ltrim($s, "\x00"); // Pad out r and s so that they are $keySize bits long $r = \str_pad($r, $keySize / 8, "\x00", STR_PAD_LEFT); $s = \str_pad($s, $keySize / 8, "\x00", STR_PAD_LEFT); return $r . $s; } /** * Reads binary DER-encoded data and decodes into a single object * * @param string $der the binary data in DER format * @param int $offset the offset of the data stream containing the object * to decode
< * @return array [$offset, $data] the new offset and the decoded object
> * > * @return array{int, string|null} the new offset and the decoded object
*/
< private static function readDER($der, $offset = 0)
> private static function readDER(string $der, int $offset = 0): array
{ $pos = $offset; $size = \strlen($der); $constructed = (\ord($der[$pos]) >> 5) & 0x01; $type = \ord($der[$pos++]) & 0x1f; // Length $len = \ord($der[$pos++]); if ($len & 0x80) { $n = $len & 0x1f; $len = 0; while ($n-- && $pos < $size) { $len = ($len << 8) | \ord($der[$pos++]); } } // Value
< if ($type == self::ASN1_BIT_STRING) {
> if ($type === self::ASN1_BIT_STRING) {
$pos++; // Skip the first contents octet (padding indicator) $data = \substr($der, $pos, $len - 1); $pos += $len - 1; } elseif (!$constructed) { $data = \substr($der, $pos, $len); $pos += $len; } else { $data = null; }
< return array($pos, $data);
> return [$pos, $data];
} }