vendor/lcobucci/jwt/src/Token/Parser.php line 54

  1. <?php
  2. declare(strict_types=1);
  4. namespace Lcobucci\JWT\Token;
  6. use DateTimeImmutable;
  7. use Lcobucci\JWT\Decoder;
  8. use Lcobucci\JWT\Parser as ParserInterface;
  9. use Lcobucci\JWT\Token as TokenInterface;
  11. use function array_key_exists;
  12. use function count;
  13. use function explode;
  14. use function is_array;
  15. use function is_numeric;
  16. use function number_format;
  18. final class Parser implements ParserInterface
  19. {
  20.     private const MICROSECOND_PRECISION = 6;
  22.     private Decoder $decoder;
  24.     public function __construct(Decoder $decoder)
  25.     {
  26.         $this->decoder = $decoder;
  27.     }
  29.     public function parse(string $jwt): TokenInterface
  30.     {
  31.         [$encodedHeaders, $encodedClaims, $encodedSignature] = $this->splitJwt($jwt);
  33.         $header = $this->parseHeader($encodedHeaders);
  35.         return new Plain(
  36.             new DataSet($header, $encodedHeaders),
  37.             new DataSet($this->parseClaims($encodedClaims), $encodedClaims),
  38.             $this->parseSignature($header, $encodedSignature)
  39.         );
  40.     }
  42.     /**
  43.      * Splits the JWT string into an array
  44.      *
  45.      * @return string[]
  46.      *
  47.      * @throws InvalidTokenStructure When JWT doesn't have all parts.
  48.      */
  49.     private function splitJwt(string $jwt): array
  50.     {
  51.         $data = explode('.', $jwt);
  53.         if (count($data) !== 3) {
  54.             throw InvalidTokenStructure::missingOrNotEnoughSeparators();
  55.         }
  57.         return $data;
  58.     }
  60.     /**
  61.      * Parses the header from a string
  62.      *
  63.      * @return mixed[]
  64.      *
  65.      * @throws UnsupportedHeaderFound When an invalid header is informed.
  66.      * @throws InvalidTokenStructure  When parsed content isn't an array.
  67.      */
  68.     private function parseHeader(string $data): array
  69.     {
  70.         $header = $this->decoder->jsonDecode($this->decoder->base64UrlDecode($data));
  72.         if (! is_array($header)) {
  73.             throw InvalidTokenStructure::arrayExpected('headers');
  74.         }
  76.         if (array_key_exists('enc', $header)) {
  77.             throw UnsupportedHeaderFound::encryption();
  78.         }
  80.         if (! array_key_exists('typ', $header)) {
  81.             $header['typ'] = 'JWT';
  82.         }
  84.         return $header;
  85.     }
  87.     /**
  88.      * Parses the claim set from a string
  89.      *
  90.      * @return mixed[]
  91.      *
  92.      * @throws InvalidTokenStructure When parsed content isn't an array or contains non-parseable dates.
  93.      */
  94.     private function parseClaims(string $data): array
  95.     {
  96.         $claims = $this->decoder->jsonDecode($this->decoder->base64UrlDecode($data));
  98.         if (! is_array($claims)) {
  99.             throw InvalidTokenStructure::arrayExpected('claims');
  100.         }
  102.         if (array_key_exists(RegisteredClaims::AUDIENCE, $claims)) {
  103.             $claims[RegisteredClaims::AUDIENCE] = (array) $claims[RegisteredClaims::AUDIENCE];
  104.         }
  106.         foreach (RegisteredClaims::DATE_CLAIMS as $claim) {
  107.             if (! array_key_exists($claim, $claims)) {
  108.                 continue;
  109.             }
  111.             $claims[$claim] = $this->convertDate($claims[$claim]);
  112.         }
  114.         return $claims;
  115.     }
  117.     /**
  118.      * @param int|float|string $timestamp
  119.      *
  120.      * @throws InvalidTokenStructure
  121.      */
  122.     private function convertDate($timestamp): DateTimeImmutable
  123.     {
  124.         if (! is_numeric($timestamp)) {
  125.             throw InvalidTokenStructure::dateIsNotParseable($timestamp);
  126.         }
  128.         $normalizedTimestamp = number_format((float) $timestamp, self::MICROSECOND_PRECISION, '.', '');
  130.         $date = DateTimeImmutable::createFromFormat('U.u', $normalizedTimestamp);
  132.         if ($date === false) {
  133.             throw InvalidTokenStructure::dateIsNotParseable($normalizedTimestamp);
  134.         }
  136.         return $date;
  137.     }
  139.     /**
  140.      * Returns the signature from given data
  141.      *
  142.      * @param mixed[] $header
  143.      */
  144.     private function parseSignature(array $header, string $data): Signature
  145.     {
  146.         if ($data === '' || ! array_key_exists('alg', $header) || $header['alg'] === 'none') {
  147.             return Signature::fromEmptyData();
  148.         }
  150.         $hash = $this->decoder->base64UrlDecode($data);
  152.         return new Signature($hash, $data);
  153.     }
  154. }