See Release Notes
Long Term Support Release
<?php namespace Firebase\JWT; use ArrayAccess;> use DateTime;use DomainException; use Exception; use InvalidArgumentException; use OpenSSLAsymmetricKey;> use OpenSSLCertificate; use UnexpectedValueException; > use stdClass;< use DateTime;/** * 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 static $asn1Integer = 0x02; < private static $asn1Sequence = 0x10; < private static $asn1BitString = 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 intpublic 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 ?intpublic static $timestamp = null;< public static $supported_algs = array( < 'ES384' => array('openssl', 'SHA384'), < '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'), < 'EdDSA' => array('sodium_crypto', 'EdDSA'), < );> /** > * @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 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 * 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 DomainException Provided JWT is malformed * @throws UnexpectedValueException Provided JWT was invalid * @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, $keyOrKeyArray) < {> public static function decode( > string $jwt, > $keyOrKeyArray > ): stdClass {// Validate JWT $timestamp = \is_null(static::$timestamp) ? \time() : static::$timestamp; 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) { if (empty($header->alg)) { > throw new UnexpectedValueException('Payload must be a JSON object'); throw new UnexpectedValueException('Empty algorithm'); > } } > $sig = static::urlsafeB64Decode($cryptob64);if (empty(static::$supported_algs[$header->alg])) { throw new UnexpectedValueException('Algorithm not supported'); }< $key = self::getKey($keyOrKeyArray, empty($header->kid) ? null : $header->kid);> $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); }< if (!static::verify("$headb64.$bodyb64", $sig, $key->getKeyMaterial(), $header->alg)) {> if (!self::verify("${headb64}.${bodyb64}", $sig, $key->getKeyMaterial(), $header->alg)) {throw new SignatureInvalidException('Signature verification failed'); } // 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|resource $key The secret key. < * If the algorithm used is asymmetric, this is the private key < * @param string $alg The signing algorithm. < * Supported algorithms are 'ES384','ES256', 'HS256', 'HS384',> * @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 mixed $keyId < * @param array $head An array with header elements to attach> * @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, $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 'ES384','ES256', 'HS256', 'HS384',> * @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 or bad key was specified */< public static function sign($msg, $key, $alg) < {> 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-lineif (!$success) {< throw new DomainException("OpenSSL unable to sign data");> 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')) {> if (!\function_exists('sodium_crypto_sign_detached')) {throw new DomainException('libsodium is not available'); }> if (!\is_string($key)) { try { > throw new InvalidArgumentException('key must be a string when using EdDSA'); // The last non-empty line is used as the key. > }$lines = array_filter(explode("\n", $key));< $key = base64_decode(end($lines));> $key = base64_decode((string) end($lines));return sodium_crypto_sign_detached($msg, $key); } catch (Exception $e) { throw new DomainException($e->getMessage(), 0, $e); } }> } > throw new DomainException('Algorithm not supported');/** * Verify a signature with the message, key and method. Not all methods * are symmetric, so we must have a separate verify and sign method. * * @param string $msg The original message (header and body) * @param string $signature The original signature< * @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* @param string $alg The algorithm * * @return bool * * @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-lineif ($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':< if (!function_exists('sodium_crypto_sign_verify_detached')) {> if (!\function_exists('sodium_crypto_sign_verify_detached')) {throw new DomainException('libsodium is not available'); }> if (!\is_string($keyMaterial)) { try { > throw new InvalidArgumentException('key must be a string when using EdDSA'); // The last non-empty line is used as the key. > }< $lines = array_filter(explode("\n", $key)); < $key = base64_decode(end($lines));> $lines = array_filter(explode("\n", $keyMaterial)); > $key = base64_decode((string) end($lines));return sodium_crypto_sign_verify_detached($signature, $msg, $key); } catch (Exception $e) { throw new DomainException($e->getMessage(), 0, $e); } case 'hash_hmac': default:< $hash = \hash_hmac($algorithm, $msg, $key, true); < return self::constantTimeEquals($signature, $hash);> if (!\is_string($keyMaterial)) { > throw new InvalidArgumentException('key must be a string when using hmac'); > } > $hash = \hash_hmac($algorithm, $msg, $keyMaterial, true); > return self::constantTimeEquals($hash, $signature);} } /** * Decode a JSON string into a PHP object. * * @param string $input JSON string *< * @return object Object representation of JSON string> * @return mixed The decoded JSON string* * @throws DomainException Provided string was invalid JSON */< 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_UNESCAPED_SLASHES); } else { // PHP 5.3 only $json = \json_encode($input); } if ($errno = \json_last_error()) {< static::handleJsonError($errno);> self::handleJsonError($errno);} elseif ($json === 'null' && $input !== null) { throw new DomainException('Null result with non-null input'); }> 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), '+/', '-_')); } /** * Determine if an algorithm has been provided for each Key *< * @param Key|array<string, Key> $keyOrKeyArray> * @param Key|ArrayAccess<string,Key>|array<string,Key> $keyOrKeyArray* @param string|null $kid * * @throws UnexpectedValueException *< * @return array containing the keyMaterial and algorithm> * @return Key*/< private static function getKey($keyOrKeyArray, $kid = null) < {> private static function getKey( > $keyOrKeyArray, > ?string $kid > ): Key {if ($keyOrKeyArray instanceof Key) { return $keyOrKeyArray; }< if (is_array($keyOrKeyArray) || $keyOrKeyArray instanceof ArrayAccess) { < foreach ($keyOrKeyArray as $keyId => $key) { < if (!$key instanceof Key) { < throw new UnexpectedValueException( < '$keyOrKeyArray must be an instance of Firebase\JWT\Key key or an ' < . 'array of Firebase\JWT\Key keys' < ); < }> if ($keyOrKeyArray instanceof CachedKeySet) { > // Skip "isset" check, as this will automatically refresh if not set > return $keyOrKeyArray[$kid];}< if (!isset($kid)) {> > if (empty($kid)) {throw new UnexpectedValueException('"kid" empty, unable to lookup correct key'); } if (!isset($keyOrKeyArray[$kid])) { throw new UnexpectedValueException('"kid" invalid, unable to lookup correct key'); } return $keyOrKeyArray[$kid]; }< throw new UnexpectedValueException( < '$keyOrKeyArray must be an instance of Firebase\JWT\Key key or an ' < . 'array of Firebase\JWT\Key keys' < ); < } </**< * @param string $left < * @param string $right> * @param string $left The string of known length to compare against > * @param string $right The user-supplied string* @return bool */< public static function constantTimeEquals($left, $right)> public static function constantTimeEquals(string $left, string $right): bool{ if (\function_exists('hash_equals')) { return \hash_equals($left, $right); }< $len = \min(static::safeStrlen($left), static::safeStrlen($right));> $len = \min(self::safeStrlen($left), self::safeStrlen($right));$status = 0; for ($i = 0; $i < $len; $i++) { $status |= (\ord($left[$i]) ^ \ord($right[$i])); }< $status |= (static::safeStrlen($left) ^ static::safeStrlen($right));> $status |= (self::safeStrlen($left) ^ self::safeStrlen($right));return ($status === 0); } /** * Helper method to create a JSON error. * * @param int $errno An error number from json_last_error() *> * @throws DomainException * @return void > **/< private static function handleJsonError($errno)> private static function handleJsonError(int $errno): void{< $messages = array(> $messages = [JSON_ERROR_DEPTH => 'Maximum stack depth exceeded', JSON_ERROR_STATE_MISMATCH => 'Invalid or malformed JSON', JSON_ERROR_CTRL_CHAR => 'Unexpected control character found', JSON_ERROR_SYNTAX => 'Syntax error, malformed JSON', JSON_ERROR_UTF8 => 'Malformed UTF-8 characters' //PHP >= 5.3.3< );> ];throw new DomainException( isset($messages[$errno]) ? $messages[$errno] : 'Unknown JSON error: ' . $errno ); } /** * Get the number of bytes in cryptographic strings. * * @param string $str * * @return int */< private static function safeStrlen($str)> private static function safeStrlen(string $str): int{ if (\function_exists('mb_strlen')) { return \mb_strlen($str, '8bit'); } return \strlen($str); } /** * Convert an ECDSA signature to an ASN.1 DER sequence * * @param string $sig The ECDSA signature to convert * @return string The encoded DER object */< private static function signatureToDER($sig)> private static function signatureToDER(string $sig): string{ // Separate the signature into r-value and s-value< list($r, $s) = \str_split($sig, (int) (\strlen($sig) / 2));> $length = max(1, (int) (\strlen($sig) / 2)); > list($r, $s) = \str_split($sig, $length);// Trim leading zeros $r = \ltrim($r, "\x00"); $s = \ltrim($s, "\x00"); // Convert r-value and s-value from unsigned big-endian integers to // signed two's complement if (\ord($r[0]) > 0x7f) { $r = "\x00" . $r; } if (\ord($s[0]) > 0x7f) { $s = "\x00" . $s; } return self::encodeDER(< self::$asn1Sequence, < self::encodeDER(self::$asn1Integer, $r) . < self::encodeDER(self::$asn1Integer, $s)> 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::$asn1Sequence) {> 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::$asn1BitString) {> 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];} }