FM / src

/home/techb158/ileadtechnology.com/SSM/vendor/lcobucci/jwt/src/

/home/techb158/ileadtechnology.com/SSM/vendor/lcobucci/jwt/src

Name	Size	Mode	Actions
Claim/	-	0755	rm
Parsing/	-	0755	rm
Signer/	-	0755	rm
Builder.php	11011	0644	edit dl rm
Claim.php	733	0644	edit dl rm
Parser.php	3623	0644	edit dl rm
Signature.php	1182	0644	edit dl rm
Signer.php	1286	0644	edit dl rm
Token.php	5710	0644	edit dl rm
ValidationData.php	2600	0644	edit dl rm

Edit: /home/techb158/ileadtechnology.com/SSM/vendor/lcobucci/jwt/src/Parser.php (3623B)

<?php
/**
 * This file is part of Lcobucci\JWT, a simple library to handle JWT and JWS
 *
 * @license http://opensource.org/licenses/BSD-3-Clause BSD-3-Clause
 */

namespace Lcobucci\JWT;

use InvalidArgumentException;
use Lcobucci\JWT\Claim\Factory as ClaimFactory;
use Lcobucci\JWT\Parsing\Decoder;

/**
 * This class parses the JWT strings and convert them into tokens
 *
 * @author Luís Otávio Cobucci Oblonczyk <lcobucci@gmail.com>
 * @since 0.1.0
 */
class Parser
{
    /**
     * The data decoder
     *
     * @var Decoder
     */
    private $decoder;

/**
     * The claims factory
     *
     * @var ClaimFactory
     */
    private $claimFactory;

/**
     * Initializes the object
     *
     * @param Decoder $decoder
     * @param ClaimFactory $claimFactory
     */
    public function __construct(
        Decoder $decoder = null,
        ClaimFactory $claimFactory = null
    ) {
        $this->decoder = $decoder ?: new Decoder();
        $this->claimFactory = $claimFactory ?: new ClaimFactory();
    }

/**
     * Parses the JWT and returns a token
     *
     * @param string $jwt
     *
     * @return Token
     */
    public function parse($jwt)
    {
        $data = $this->splitJwt($jwt);
        $header = $this->parseHeader($data[0]);
        $claims = $this->parseClaims($data[1]);
        $signature = $this->parseSignature($header, $data[2]);

foreach ($claims as $name => $value) {
            if (isset($header[$name])) {
                $header[$name] = $value;
            }
        }

if ($signature === null) {
            unset($data[2]);
        }

return new Token($header, $claims, $signature, $data);
    }

/**
     * Splits the JWT string into an array
     *
     * @param string $jwt
     *
     * @return array
     *
     * @throws InvalidArgumentException When JWT is not a string or is invalid
     */
    protected function splitJwt($jwt)
    {
        if (!is_string($jwt)) {
            throw new InvalidArgumentException('The JWT string must have two dots');
        }

$data = explode('.', $jwt);

if (count($data) != 3) {
            throw new InvalidArgumentException('The JWT string must have two dots');
        }

return $data;
    }

/**
     * Parses the header from a string
     *
     * @param string $data
     *
     * @return array
     *
     * @throws InvalidArgumentException When an invalid header is informed
     */
    protected function parseHeader($data)
    {
        $header = (array) $this->decoder->jsonDecode($this->decoder->base64UrlDecode($data));

if (isset($header['enc'])) {
            throw new InvalidArgumentException('Encryption is not supported yet');
        }

return $header;
    }

/**
     * Parses the claim set from a string
     *
     * @param string $data
     *
     * @return array
     */
    protected function parseClaims($data)
    {
        $claims = (array) $this->decoder->jsonDecode($this->decoder->base64UrlDecode($data));

foreach ($claims as $name => &$value) {
            $value = $this->claimFactory->create($name, $value);
        }

return $claims;
    }

/**
     * Returns the signature from given data
     *
     * @param array $header
     * @param string $data
     *
     * @return Signature
     */
    protected function parseSignature(array $header, $data)
    {
        if ($data == '' || !isset($header['alg']) || $header['alg'] == 'none') {
            return null;
        }

$hash = $this->decoder->base64UrlDecode($data);

return new Signature($hash);
    }
}

cmd: