Renew

.env

+APP_ENV=local
+APP_KEY=base64:PYpgHHGl4uu9e47KBcSblh6QGgp48HawdpFxrzqzxm0=
+APP_DEBUG=true
+APP_LOG_LEVEL=debug
+APP_URL=http://localhost
+
+DB_CONNECTION=mysql
+DB_HOST=127.0.0.1
+DB_PORT=3306
+DB_DATABASE=p2d4ti06_test
+DB_USERNAME=root
+DB_PASSWORD=
+
+BROADCAST_DRIVER=log
+CACHE_DRIVER=file
+SESSION_DRIVER=file
+QUEUE_DRIVER=sync
+
+REDIS_HOST=127.0.0.1
+REDIS_PASSWORD=null
+REDIS_PORT=6379
+
+MAIL_DRIVER=smtp
+MAIL_HOST=mailtrap.io
+MAIL_PORT=2525
+MAIL_USERNAME=null
+MAIL_PASSWORD=null
+MAIL_ENCRYPTION=null
+
+PUSHER_APP_ID=
+PUSHER_KEY=
+PUSHER_SECRET=

vendor/acacha/admin-lte-template-laravel/resources/views/page.blade.php

+@extends('adminlte::layouts.app')
+

vendor/lcobucci/jwt/.gitignore

+vendor
+phpunit.xml

vendor/lcobucci/jwt/.scrutinizer.yml

+build:
+    environment:
+        mysql: false
+        postgresql: false
+        redis: false
+        rabbitmq: false
+        php:
+            version: 5.6
+tools:
+    php_sim: true
+    php_pdepend: true
+    php_analyzer: true
+    php_changetracking: true
+    php_code_sniffer:
+        config:
+            standard: "PSR2"
+    php_mess_detector: true
+checks:
+    php:
+        code_rating: true
+        duplication: true
+        argument_type_checks: true
+        assignment_of_null_return: true
+        avoid_conflicting_incrementers: true
+        avoid_useless_overridden_methods: true
+        catch_class_exists: true
+        closure_use_modifiable: true
+        closure_use_not_conflicting: true
+        deprecated_code_usage: true
+        method_calls_on_non_object: true
+        missing_arguments: true
+        no_duplicate_arguments: true
+        no_non_implemented_abstract_methods: true
+        no_property_on_interface: true
+        parameter_non_unique: true
+        precedence_in_conditions: true
+        precedence_mistakes: true
+        require_php_tag_first: true
+        security_vulnerabilities: true
+        sql_injection_vulnerabilities: true
+        too_many_arguments: true
+        unreachable_code: true
+        unused_methods: true
+        unused_parameters: true
+        unused_properties: true
+        unused_variables: true
+        use_statement_alias_conflict: true
+        useless_calls: true
+        variable_existence: true
+        verify_access_scope_valid: true
+        verify_argument_usable_as_reference: true
+        verify_property_names: true
+
+filter:
+    excluded_paths:
+        - test/*

vendor/lcobucci/jwt/.travis.yml

+language: php
+php:
+  - 5.5
+  - 5.6
+  - 7.0
+  - hhvm
+  - hhvm-nightly
+
+matrix:
+  allow_failures:
+    - php: hhvm-nightly
+
+before_script:
+  - composer selfupdate
+  - composer install --prefer-dist -o

vendor/lcobucci/jwt/LICENSE

+Copyright (c) 2014-2015, Luís Otávio Cobucci Oblonczyk
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the {organization} nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

vendor/lcobucci/jwt/README.md

+# JWT
+[![Gitter](https://img.shields.io/badge/GITTER-JOIN%20CHAT%20%E2%86%92-brightgreen.svg?style=flat-square)](https://gitter.im/lcobucci/jwt?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) [![Total Downloads](https://img.shields.io/packagist/dt/lcobucci/jwt.svg?style=flat-square)](https://packagist.org/packages/lcobucci/jwt) [![Latest Stable Version](https://img.shields.io/packagist/v/lcobucci/jwt.svg?style=flat-square)](https://packagist.org/packages/lcobucci/jwt)
+
+![Branch master](https://img.shields.io/badge/branch-master-brightgreen.svg?style=flat-square)
+[![Build Status](https://img.shields.io/travis/lcobucci/jwt/master.svg?style=flat-square)](http://travis-ci.org/#!/lcobucci/jwt)
+[![Scrutinizer Code Quality](https://img.shields.io/scrutinizer/g/lcobucci/jwt/master.svg?style=flat-square)](https://scrutinizer-ci.com/g/lcobucci/jwt/?branch=master)
+[![Code Coverage](https://img.shields.io/scrutinizer/coverage/g/lcobucci/jwt/master.svg?style=flat-square)](https://scrutinizer-ci.com/g/lcobucci/jwt/?branch=master)
+
+A simple library to work with JSON Web Token and JSON Web Signature (requires PHP 5.5+).
+The implementation is based on the [current draft](http://tools.ietf.org/html/draft-ietf-oauth-json-web-token-32).
+
+## Installation
+
+Package is available on [Packagist](http://packagist.org/packages/lcobucci/jwt),
+you can install it using [Composer](http://getcomposer.org).
+
+```shell
+composer require lcobucci/jwt
+```
+
+### Dependencies
+
+- PHP 5.5+
+- OpenSSL Extension
+
+## Basic usage
+
+### Creating
+
+Just use the builder to create a new JWT/JWS tokens:
+
+```php
+use Lcobucci\JWT\Builder;
+
+$token = (new Builder())->setIssuer('http://example.com') // Configures the issuer (iss claim)
+                        ->setAudience('http://example.org') // Configures the audience (aud claim)
+                        ->setId('4f1g23a12aa', true) // Configures the id (jti claim), replicating as a header item
+                        ->setIssuedAt(time()) // Configures the time that the token was issue (iat claim)
+                        ->setNotBefore(time() + 60) // Configures the time that the token can be used (nbf claim)
+                        ->setExpiration(time() + 3600) // Configures the expiration time of the token (nbf claim)
+                        ->set('uid', 1) // Configures a new claim, called "uid"
+                        ->getToken(); // Retrieves the generated token
+
+
+$token->getHeaders(); // Retrieves the token headers
+$token->getClaims(); // Retrieves the token claims
+
+echo $token->getHeader('jti'); // will print "4f1g23a12aa"
+echo $token->getClaim('iss'); // will print "http://example.com"
+echo $token->getClaim('uid'); // will print "1"
+echo $token; // The string representation of the object is a JWT string (pretty easy, right?)
+```
+
+### Parsing from strings
+
+Use the parser to create a new token from a JWT string (using the previous token as example):
+
+```php
+use Lcobucci\JWT\Parser;
+
+$token = (new Parser())->parse((string) $token); // Parses from a string
+$token->getHeaders(); // Retrieves the token header
+$token->getClaims(); // Retrieves the token claims
+
+echo $token->getHeader('jti'); // will print "4f1g23a12aa"
+echo $token->getClaim('iss'); // will print "http://example.com"
+echo $token->getClaim('uid'); // will print "1"
+```
+
+### Validating
+
+We can easily validate if the token is valid (using the previous token as example):
+
+```php
+use Lcobucci\JWT\ValidationData;
+
+$data = new ValidationData(); // It will use the current time to validate (iat, nbf and exp)
+$data->setIssuer('http://example.com');
+$data->setAudience('http://example.org');
+$data->setId('4f1g23a12aa');
+
+var_dump($token->validate($data)); // false, because we created a token that cannot be used before of `time() + 60`
+
+$data->setCurrentTime(time() + 60); // changing the validation time to future
+
+var_dump($token->validate($data)); // true, because validation information is equals to data contained on the token
+
+$data->setCurrentTime(time() + 4000); // changing the validation time to future
+
+var_dump($token->validate($data)); // false, because token is expired since current time is greater than exp
+```
+
+## Token signature
+
+We can use signatures to be able to verify if the token was not modified after its generation. This library implements Hmac, RSA and ECDSA signatures (using 256, 384 and 512).
+
+### Hmac
+
+Hmac signatures are really simple to be used:
+
+```php
+use Lcobucci\JWT\Builder;
+use Lcobucci\JWT\Signer\Hmac\Sha256;
+
+$signer = new Sha256();
+
+$token = (new Builder())->setIssuer('http://example.com') // Configures the issuer (iss claim)
+                        ->setAudience('http://example.org') // Configures the audience (aud claim)
+                        ->setId('4f1g23a12aa', true) // Configures the id (jti claim), replicating as a header item
+                        ->setIssuedAt(time()) // Configures the time that the token was issue (iat claim)
+                        ->setNotBefore(time() + 60) // Configures the time that the token can be used (nbf claim)
+                        ->setExpiration(time() + 3600) // Configures the expiration time of the token (nbf claim)
+                        ->set('uid', 1) // Configures a new claim, called "uid"
+                        ->sign($signer, 'testing') // creates a signature using "testing" as key
+                        ->getToken(); // Retrieves the generated token
+
+
+var_dump($token->verify($signer, 'testing 1')); // false, because the key is different
+var_dump($token->verify($signer, 'testing')); // true, because the key is the same
+```
+
+### RSA and ECDSA
+
+RSA and ECDSA signatures are based on public and private keys so you have to generate using the private key and verify using the public key:
+
+```php
+use Lcobucci\JWT\Builder;
+use Lcobucci\JWT\Signer\Keychain; // just to make our life simpler
+use Lcobucci\JWT\Signer\Rsa\Sha256; // you can use Lcobucci\JWT\Signer\Ecdsa\Sha256 if you're using ECDSA keys
+
+$signer = new Sha256();
+
+$keychain = new Keychain();
+
+$token = (new Builder())->setIssuer('http://example.com') // Configures the issuer (iss claim)
+                        ->setAudience('http://example.org') // Configures the audience (aud claim)
+                        ->setId('4f1g23a12aa', true) // Configures the id (jti claim), replicating as a header item
+                        ->setIssuedAt(time()) // Configures the time that the token was issue (iat claim)
+                        ->setNotBefore(time() + 60) // Configures the time that the token can be used (nbf claim)
+                        ->setExpiration(time() + 3600) // Configures the expiration time of the token (nbf claim)
+                        ->set('uid', 1) // Configures a new claim, called "uid"
+                        ->sign($signer,  $keychain->getPrivateKey('file://{path to your private key}')) // creates a signature using your private key
+                        ->getToken(); // Retrieves the generated token
+
+
+var_dump($token->verify($signer, $keychain->getPublicKey('file://{path to your public key}')); // true when the public key was generated by the private one =)
+```
+
+**It's important to say that if you're using RSA keys you shouldn't invoke ECDSA signers (and vice-versa), otherwise ```sign()``` and ```verify()``` will raise an exception!**

vendor/lcobucci/jwt/composer.json

+{
+    "name": "lcobucci/jwt",
+    "description": "A simple library to work with JSON Web Token and JSON Web Signature",
+    "type": "library",
+    "authors": [
+        {
+            "name": "Luís Otávio Cobucci Oblonczyk",
+            "email": "lcobucci@gmail.com",
+            "role": "Developer"
+        }
+    ],
+    "keywords": [
+        "JWT",
+        "JWS"
+    ],
+    "license": [
+        "BSD-3-Clause"
+    ],
+    "require": {
+        "php": ">=5.5",
+        "ext-openssl": "*"
+    },
+    "require-dev": {
+        "phpunit/phpunit": "~4.5",
+        "squizlabs/php_codesniffer": "~2.3",
+        "phpmd/phpmd": "~2.2",
+        "phpunit/php-invoker": "~1.1",
+        "mikey179/vfsStream": "~1.5",
+        "mdanter/ecc": "~0.3.1"
+    },
+    "suggest":{
+        "mdanter/ecc": "Required to use Elliptic Curves based algorithms."
+    },
+    "autoload": {
+        "psr-4": {
+            "Lcobucci\\JWT\\": "src"
+        }
+    },
+    "autoload-dev": {
+        "psr-4": {
+            "Lcobucci\\JWT\\": [
+                "test/unit", 
+                "test/functional"
+            ]
+        }
+    },
+    "extra": {
+        "branch-alias": {
+            "dev-master": "3.1-dev"
+        }
+    }
+}

vendor/lcobucci/jwt/phpunit.xml.dist

+<?xml version="1.0" encoding="UTF-8"?>
+<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:noNamespaceSchemaLocation="vendor/phpunit/phpunit/phpunit.xsd"
+    backupGlobals="false" 
+    backupStaticAttributes="false" 
+    bootstrap="vendor/autoload.php"
+    colors="true" 
+    verbose="true"
+    beStrictAboutOutputDuringTests="true"
+    beStrictAboutTestSize="true"
+    beStrictAboutTestsThatDoNotTestAnything="true"
+    beStrictAboutTodoAnnotatedTests="true"
+    checkForUnintentionallyCoveredCode="true"
+    forceCoversAnnotation="true">
+	<testsuites>
+		<testsuite name="Unit Test Suite">
+			<directory>test/unit</directory>
+		</testsuite>
+		<testsuite name="Integration Test Suite">
+			<directory>test/functional</directory>
+		</testsuite>
+	</testsuites>
+    
+    <filter>
+        <whitelist processUncoveredFilesFromWhitelist="true">
+            <directory suffix=".php">src</directory>
+        </whitelist>
+        
+        <blacklist>
+            <directory suffix=".php">vendor</directory>
+        </blacklist>
+    </filter>
+</phpunit>

vendor/lcobucci/jwt/src/Builder.php

+<?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 BadMethodCallException;
+use Lcobucci\JWT\Claim\Factory as ClaimFactory;
+use Lcobucci\JWT\Parsing\Encoder;
+
+/**
+ * This class makes easier the token creation process
+ *
+ * @author Luís Otávio Cobucci Oblonczyk <lcobucci@gmail.com>
+ * @since 0.1.0
+ */
+class Builder
+{
+    /**
+     * The token header
+     *
+     * @var array
+     */
+    private $headers;
+
+    /**
+     * The token claim set
+     *
+     * @var array
+     */
+    private $claims;
+
+    /**
+     * The token signature
+     *
+     * @var Signature
+     */
+    private $signature;
+
+    /**
+     * The data encoder
+     *
+     * @var Encoder
+     */
+    private $encoder;
+
+    /**
+     * The factory of claims
+     *
+     * @var ClaimFactory
+     */
+    private $claimFactory;
+
+    /**
+     * Initializes a new builder
+     *
+     * @param Encoder $encoder
+     * @param ClaimFactory $claimFactory
+     */
+    public function __construct(
+        Encoder $encoder = null,
+        ClaimFactory $claimFactory = null
+    ) {
+        $this->encoder = $encoder ?: new Encoder();
+        $this->claimFactory = $claimFactory ?: new ClaimFactory();
+        $this->headers = ['typ'=> 'JWT', 'alg' => 'none'];
+        $this->claims = [];
+    }
+
+    /**
+     * Configures the audience
+     *
+     * @param string $audience
+     * @param boolean $replicateAsHeader
+     *
+     * @return Builder
+     */
+    public function setAudience($audience, $replicateAsHeader = false)
+    {
+        return $this->setRegisteredClaim('aud', (string) $audience, $replicateAsHeader);
+    }
+
+    /**
+     * Configures the expiration time
+     *
+     * @param int $expiration
+     * @param boolean $replicateAsHeader
+     *
+     * @return Builder
+     */
+    public function setExpiration($expiration, $replicateAsHeader = false)
+    {
+        return $this->setRegisteredClaim('exp', (int) $expiration, $replicateAsHeader);
+    }
+
+    /**
+     * Configures the token id
+     *
+     * @param string $id
+     * @param boolean $replicateAsHeader
+     *
+     * @return Builder
+     */
+    public function setId($id, $replicateAsHeader = false)
+    {
+        return $this->setRegisteredClaim('jti', (string) $id, $replicateAsHeader);
+    }
+
+    /**
+     * Configures the time that the token was issued
+     *
+     * @param int $issuedAt
+     * @param boolean $replicateAsHeader
+     *
+     * @return Builder
+     */
+    public function setIssuedAt($issuedAt, $replicateAsHeader = false)
+    {
+        return $this->setRegisteredClaim('iat', (int) $issuedAt, $replicateAsHeader);
+    }
+
+    /**
+     * Configures the issuer
+     *
+     * @param string $issuer
+     * @param boolean $replicateAsHeader
+     *
+     * @return Builder
+     */
+    public function setIssuer($issuer, $replicateAsHeader = false)
+    {
+        return $this->setRegisteredClaim('iss', (string) $issuer, $replicateAsHeader);
+    }
+
+    /**
+     * Configures the time before which the token cannot be accepted
+     *
+     * @param int $notBefore
+     * @param boolean $replicateAsHeader
+     *
+     * @return Builder
+     */
+    public function setNotBefore($notBefore, $replicateAsHeader = false)
+    {
+        return $this->setRegisteredClaim('nbf', (int) $notBefore, $replicateAsHeader);
+    }
+
+    /**
+     * Configures the subject
+     *
+     * @param string $subject
+     * @param boolean $replicateAsHeader
+     *
+     * @return Builder
+     */
+    public function setSubject($subject, $replicateAsHeader = false)
+    {
+        return $this->setRegisteredClaim('sub', (string) $subject, $replicateAsHeader);
+    }
+
+    /**
+     * Configures a registed claim
+     *
+     * @param string $name
+     * @param mixed $value
+     * @param boolean $replicate
+     *
+     * @return Builder
+     */
+    protected function setRegisteredClaim($name, $value, $replicate)
+    {
+        $this->set($name, $value);
+
+        if ($replicate) {
+            $this->headers[$name] = $this->claims[$name];
+        }
+
+        return $this;
+    }
+
+    /**
+     * Configures a header item
+     *
+     * @param string $name
+     * @param mixed $value
+     *
+     * @return Builder
+     *
+     * @throws BadMethodCallException When data has been already signed
+     */
+    public function setHeader($name, $value)
+    {
+        if ($this->signature) {
+            throw new BadMethodCallException('You must unsign before make changes');
+        }
+
+        $this->headers[(string) $name] = $this->claimFactory->create($name, $value);
+
+        return $this;
+    }
+
+    /**
+     * Configures a claim item
+     *
+     * @param string $name
+     * @param mixed $value
+     *
+     * @return Builder
+     *
+     * @throws BadMethodCallException When data has been already signed
+     */
+    public function set($name, $value)
+    {
+        if ($this->signature) {
+            throw new BadMethodCallException('You must unsign before making changes');
+        }
+
+        $this->claims[(string) $name] = $this->claimFactory->create($name, $value);
+
+        return $this;
+    }
+
+    /**
+     * Signs the data
+     *
+     * @param Signer $signer
+     * @param string $key
+     *
+     * @return Builder
+     */
+    public function sign(Signer $signer, $key)
+    {
+        $signer->modifyHeader($this->headers);
+
+        $this->signature = $signer->sign(
+            $this->getToken()->getPayload(),
+            $key
+        );
+
+        return $this;
+    }
+
+    /**
+     * Removes the signature from the builder
+     *
+     * @return Builder
+     */
+    public function unsign()
+    {
+        $this->signature = null;
+
+        return $this;
+    }
+
+    /**
+     * Returns the resultant token
+     *
+     * @return Token
+     */
+    public function getToken()
+    {
+        $payload = [
+            $this->encoder->base64UrlEncode($this->encoder->jsonEncode($this->headers)),
+            $this->encoder->base64UrlEncode($this->encoder->jsonEncode($this->claims))
+        ];
+
+        if ($this->signature !== null) {
+            $payload[] = $this->encoder->base64UrlEncode($this->signature);
+        }
+
+        return new Token($this->headers, $this->claims, $this->signature, $payload);
+    }
+}

vendor/lcobucci/jwt/src/Claim.php

+<?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 JsonSerializable;
+
+/**
+ * Basic interface for token claims
+ *
+ * @author Luís Otávio Cobucci Oblonczyk <lcobucci@gmail.com>
+ * @since 2.0.0
+ */
+interface Claim extends JsonSerializable
+{
+    /**
+     * Returns the claim name
+     *
+     * @return string
+     */
+    public function getName();
+
+    /**
+     * Returns the claim value
+     *
+     * @return string
+     */
+    public function getValue();
+
+    /**
+     * Returns the string representation of the claim
+     *
+     * @return string
+     */
+    public function __toString();
+}

vendor/lcobucci/jwt/src/Claim/Basic.php

+<?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\Claim;
+
+use Lcobucci\JWT\Claim;
+
+/**
+ * The default claim
+ *
+ * @author Luís Otávio Cobucci Oblonczyk <lcobucci@gmail.com>
+ * @since 2.0.0
+ */
+class Basic implements Claim
+{
+    /**
+     * @var string
+     */
+    private $name;
+
+    /**
+     * @var mixed
+     */
+    private $value;
+
+    /**
+     * Initializes the claim
+     *
+     * @param string $name
+     * @param mixed $value
+     */
+    public function __construct($name, $value)
+    {
+        $this->name = $name;
+        $this->value = $value;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getName()
+    {
+        return $this->name;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getValue()
+    {
+        return $this->value;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function jsonSerialize()
+    {
+        return $this->value;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function __toString()
+    {
+        return (string) $this->value;
+    }
+}

vendor/lcobucci/jwt/src/Claim/EqualsTo.php

+<?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\Claim;
+
+use Lcobucci\JWT\Claim;
+use Lcobucci\JWT\ValidationData;
+
+/**
+ * Validatable claim that checks if value is strictly equals to the given data
+ *
+ * @author Luís Otávio Cobucci Oblonczyk <lcobucci@gmail.com>
+ * @since 2.0.0
+ */
+class EqualsTo extends Basic implements Claim, Validatable
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function validate(ValidationData $data)
+    {
+        if ($data->has($this->getName())) {
+            return $this->getValue() === $data->get($this->getName());
+        }
+
+        return true;
+    }
+}

vendor/lcobucci/jwt/src/Claim/Factory.php

+<?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\Claim;
+
+use Lcobucci\JWT\Claim;
+
+/**
+ * Class that create claims
+ *
+ * @author Luís Otávio Cobucci Oblonczyk <lcobucci@gmail.com>
+ * @since 2.0.0
+ */
+class Factory
+{
+    /**
+     * The list of claim callbacks
+     *
+     * @var array
+     */
+    private $callbacks;
+
+    /**
+     * Initializes the factory, registering the default callbacks
+     *
+     * @param array $callbacks
+     */
+    public function __construct(array $callbacks = [])
+    {
+        $this->callbacks = array_merge(
+            [
+                'iat' => [$this, 'createLesserOrEqualsTo'],
+                'nbf' => [$this, 'createLesserOrEqualsTo'],
+                'exp' => [$this, 'createGreaterOrEqualsTo'],
+                'iss' => [$this, 'createEqualsTo'],
+                'aud' => [$this, 'createEqualsTo'],
+                'sub' => [$this, 'createEqualsTo'],
+                'jti' => [$this, 'createEqualsTo']
+            ],
+            $callbacks
+        );
+    }
+
+    /**
+     * Create a new claim
+     *
+     * @param string $name
+     * @param mixed $value
+     *
+     * @return Claim
+     */
+    public function create($name, $value)
+    {
+        if (!empty($this->callbacks[$name])) {
+            return call_user_func($this->callbacks[$name], $name, $value);
+        }
+
+        return $this->createBasic($name, $value);
+    }
+
+    /**
+     * Creates a claim that can be compared (greator or equals)
+     *
+     * @param string $name
+     * @param mixed $value
+     *
+     * @return GreaterOrEqualsTo
+     */
+    private function createGreaterOrEqualsTo($name, $value)
+    {
+        return new GreaterOrEqualsTo($name, $value);
+    }
+
+    /**
+     * Creates a claim that can be compared (greator or equals)
+     *
+     * @param string $name
+     * @param mixed $value
+     *
+     * @return LesserOrEqualsTo
+     */
+    private function createLesserOrEqualsTo($name, $value)
+    {
+        return new LesserOrEqualsTo($name, $value);
+    }
+
+    /**
+     * Creates a claim that can be compared (equals)
+     *
+     * @param string $name
+     * @param mixed $value
+     *
+     * @return EqualsTo
+     */
+    private function createEqualsTo($name, $value)
+    {
+        return new EqualsTo($name, $value);
+    }
+
+    /**
+     * Creates a basic claim
+     *
+     * @param string $name
+     * @param mixed $value
+     *
+     * @return Basic
+     */
+    private function createBasic($name, $value)
+    {
+        return new Basic($name, $value);
+    }
+}

vendor/lcobucci/jwt/src/Claim/GreaterOrEqualsTo.php

+<?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\Claim;
+
+use Lcobucci\JWT\Claim;
+use Lcobucci\JWT\ValidationData;
+
+/**
+ * Validatable claim that checks if value is greater or equals the given data
+ *
+ * @author Luís Otávio Cobucci Oblonczyk <lcobucci@gmail.com>
+ * @since 2.0.0
+ */
+class GreaterOrEqualsTo extends Basic implements Claim, Validatable
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function validate(ValidationData $data)
+    {
+        if ($data->has($this->getName())) {
+            return $this->getValue() >= $data->get($this->getName());
+        }
+
+        return true;
+    }
+}

vendor/lcobucci/jwt/src/Claim/LesserOrEqualsTo.php

+<?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\Claim;
+
+use Lcobucci\JWT\Claim;
+use Lcobucci\JWT\ValidationData;
+
+/**
+ * Validatable claim that checks if value is lesser or equals to the given data
+ *
+ * @author Luís Otávio Cobucci Oblonczyk <lcobucci@gmail.com>
+ * @since 2.0.0
+ */
+class LesserOrEqualsTo extends Basic implements Claim, Validatable
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function validate(ValidationData $data)
+    {
+        if ($data->has($this->getName())) {
+            return $this->getValue() <= $data->get($this->getName());
+        }
+
+        return true;
+    }
+}

vendor/lcobucci/jwt/src/Claim/Validatable.php

+<?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\Claim;
+
+use Lcobucci\JWT\ValidationData;
+
+/**
+ * Basic interface for validatable token claims
+ *
+ * @author Luís Otávio Cobucci Oblonczyk <lcobucci@gmail.com>
+ * @since 2.0.0
+ */
+interface Validatable
+{
+    /**
+     * Returns if claim is valid according with given data
+     *
+     * @param ValidationData $data
+     *
+     * @return boolean
+     */
+    public function validate(ValidationData $data);
+}

vendor/lcobucci/jwt/src/Parser.php

+<?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);
+    }
+}

vendor/lcobucci/jwt/src/Parsing/Decoder.php

+<?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\Parsing;
+
+use RuntimeException;
+
+/**
+ * Class that decodes data according with the specs of RFC-4648
+ *
+ * @author Luís Otávio Cobucci Oblonczyk <lcobucci@gmail.com>
+ * @since 0.1.0
+ *
+ * @link http://tools.ietf.org/html/rfc4648#section-5
+ */
+class Decoder
+{
+    /**
+     * Decodes from JSON, validating the errors (will return an associative array
+     * instead of objects)
+     *
+     * @param string $json
+     * @return mixed
+     *
+     * @throws RuntimeException When something goes wrong while decoding
+     */
+    public function jsonDecode($json)
+    {
+        $data = json_decode($json);
+
+        if (json_last_error() != JSON_ERROR_NONE) {
+            throw new RuntimeException('Error while decoding to JSON: ' . json_last_error_msg());
+        }
+
+        return $data;
+    }
+
+    /**
+     * Decodes from base64url
+     *
+     * @param string $data
+     * @return string
+     */
+    public function base64UrlDecode($data)
+    {
+        if ($remainder = strlen($data) % 4) {
+            $data .= str_repeat('=', 4 - $remainder);
+        }
+
+        return base64_decode(strtr($data, '-_', '+/'));
+    }
+}

vendor/lcobucci/jwt/src/Parsing/Encoder.php

+<?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\Parsing;
+
+use RuntimeException;
+
+/**
+ * Class that encodes data according with the specs of RFC-4648
+ *
+ * @author Luís Otávio Cobucci Oblonczyk <lcobucci@gmail.com>
+ * @since 0.1.0
+ *
+ * @link http://tools.ietf.org/html/rfc4648#section-5
+ */
+class Encoder
+{
+    /**
+     * Encodes to JSON, validating the errors
+     *
+     * @param mixed $data
+     * @return string
+     *
+     * @throws RuntimeException When something goes wrong while encoding
+     */
+    public function jsonEncode($data)
+    {
+        $json = json_encode($data);
+
+        if (json_last_error() != JSON_ERROR_NONE) {
+            throw new RuntimeException('Error while encoding to JSON: ' . json_last_error_msg());
+        }
+
+        return $json;
+    }
+
+    /**
+     * Encodes to base64url
+     *
+     * @param string $data
+     * @return string
+     */
+    public function base64UrlEncode($data)
+    {
+        return str_replace('=', '', strtr(base64_encode($data), '+/', '-_'));
+    }
+}

vendor/lcobucci/jwt/src/Signature.php

+<?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;
+
+/**
+ * This class represents a token signature
+ *
+ * @author Luís Otávio Cobucci Oblonczyk <lcobucci@gmail.com>
+ * @since 0.1.0
+ */
+class Signature
+{
+    /**
+     * The resultant hash
+     *
+     * @var string
+     */
+    protected $hash;
+
+    /**
+     * Initializes the object
+     *
+     * @param string $hash
+     */
+    public function __construct($hash)
+    {
+        $this->hash = $hash;
+    }
+
+    /**
+     * Verifies if the current hash matches with with the result of the creation of
+     * a new signature with given data
+     *
+     * @param Signer $signer
+     * @param string $payload
+     * @param string $key
+     *
+     * @return boolean
+     */
+    public function verify(Signer $signer, $payload, $key)
+    {
+        return $signer->verify($this->hash, $payload, $key);
+    }
+
+    /**
+     * Returns the current hash as a string representation of the signature
+     *
+     * @return string
+     */
+    public function __toString()
+    {
+        return $this->hash;
+    }
+}

vendor/lcobucci/jwt/src/Signer.php

+<?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\Signer\Key;
+
+/**
+ * Basic interface for token signers
+ *
+ * @author Luís Otávio Cobucci Oblonczyk <lcobucci@gmail.com>
+ * @since 0.1.0
+ */
+interface Signer
+{
+    /**
+     * Returns the algorithm id
+     *
+     * @return string
+     */
+    public function getAlgorithmId();
+
+    /**
+     * Apply changes on headers according with algorithm
+     *
+     * @param array $headers
+     */
+    public function modifyHeader(array &$headers);
+
+    /**
+     * Returns a signature for given data
+     *
+     * @param string $payload
+     * @param Key|string $key
+     *
+     * @return Signature
+     *
+     * @throws InvalidArgumentException When given key is invalid
+     */
+    public function sign($payload, $key);
+
+    /**
+     * Returns if the expected hash matches with the data and key
+     *
+     * @param string $expected
+     * @param string $payload
+     * @param Key|string $key
+     *
+     * @return boolean
+     *
+     * @throws InvalidArgumentException When given key is invalid
+     */
+    public function verify($expected, $payload, $key);
+}

vendor/lcobucci/jwt/src/Signer/BaseSigner.php

+<?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\Signer;
+
+use Lcobucci\JWT\Signature;
+use Lcobucci\JWT\Signer;
+
+/**
+ * Base class for signers
+ *
+ * @author Luís Otávio Cobucci Oblonczyk <lcobucci@gmail.com>
+ * @since 0.1.0
+ */
+abstract class BaseSigner implements Signer
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function modifyHeader(array &$headers)
+    {
+        $headers['alg'] = $this->getAlgorithmId();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function sign($payload, $key)
+    {
+        return new Signature($this->createHash($payload, $this->getKey($key)));
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function verify($expected, $payload, $key)
+    {
+        return $this->doVerify($expected, $payload, $this->getKey($key));
+    }
+
+    /**
+     * @param Key|string $key
+     *
+     * @return Key
+     */
+    private function getKey($key)
+    {
+        if (is_string($key)) {
+            $key = new Key($key);
+        }
+
+        return $key;
+    }
+
+    /**
+     * Creates a hash with the given data
+     *
+     * @param string $payload
+     * @param Key $key
+     *
+     * @return string
+     */
+    abstract public function createHash($payload, Key $key);
+
+    /**
+     * Creates a hash with the given data
+     *
+     * @param string $payload
+     * @param Key $key
+     *
+     * @return boolean
+     */
+    abstract public function doVerify($expected, $payload, Key $key);
+}

vendor/lcobucci/jwt/src/Signer/Ecdsa.php

+<?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\Signer;
+
+use Lcobucci\JWT\Signer\Ecdsa\KeyParser;
+use Mdanter\Ecc\Crypto\Signature\Signature;
+use Mdanter\Ecc\Crypto\Signature\Signer;
+use Mdanter\Ecc\EccFactory;
+use Mdanter\Ecc\Math\MathAdapterInterface as Adapter;
+use Mdanter\Ecc\Random\RandomGeneratorFactory;
+use Mdanter\Ecc\Random\RandomNumberGeneratorInterface;
+
+/**
+ * Base class for ECDSA signers
+ *
+ * @author Luís Otávio Cobucci Oblonczyk <lcobucci@gmail.com>
+ * @since 2.1.0
+ */
+abstract class Ecdsa extends BaseSigner
+{
+    /**
+     * @var Adapter
+     */
+    private $adapter;
+
+    /**
+     * @var Signer
+     */
+    private $signer;
+
+    /**
+     * @var KeyParser
+     */
+    private $parser;
+
+    /**
+     * @param Adapter $adapter
+     * @param EcdsaSigner $signer
+     * @param KeyParser $parser
+     */
+    public function __construct(Adapter $adapter = null, Signer $signer = null, KeyParser $parser = null)
+    {
+        $this->adapter = $adapter ?: EccFactory::getAdapter();
+        $this->signer = $signer ?: EccFactory::getSigner($this->adapter);
+        $this->parser = $parser ?: new KeyParser($this->adapter);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function createHash(
+        $payload,
+        Key $key,
+        RandomNumberGeneratorInterface $generator = null
+    ) {
+        $privateKey = $this->parser->getPrivateKey($key);
+        $generator = $generator ?: RandomGeneratorFactory::getRandomGenerator();
+
+        return $this->createSignatureHash(
+            $this->signer->sign(
+                $privateKey,
+                $this->createSigningHash($payload),
+                $generator->generate($privateKey->getPoint()->getOrder())
+            )
+        );
+    }
+
+    /**
+     * Creates a binary signature with R and S coordinates
+     *
+     * @param Signature $signature
+     *
+     * @return string
+     */
+    private function createSignatureHash(Signature $signature)
+    {
+        $length = $this->getSignatureLength();
+
+        return pack(
+            'H*',
+            sprintf(
+                '%s%s',
+                str_pad($this->adapter->decHex($signature->getR()), $length, '0', STR_PAD_LEFT),
+                str_pad($this->adapter->decHex($signature->getS()), $length, '0', STR_PAD_LEFT)
+            )
+        );
+    }
+
+    /**
+     * Creates a hash using the signer algorithm with given payload
+     *
+     * @param string $payload
+     *
+     * @return int|string
+     */
+    private function createSigningHash($payload)
+    {
+        return $this->adapter->hexDec(hash($this->getAlgorithm(), $payload));
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function doVerify($expected, $payload, Key $key)
+    {
+        return $this->signer->verify(
+            $this->parser->getPublicKey($key),
+            $this->extractSignature($expected),
+            $this->createSigningHash($payload)
+        );
+    }
+
+    /**
+     * Extracts R and S values from given data
+     *
+     * @param string $value
+     *
+     * @return \Mdanter\Ecc\Crypto\Signature\Signature
+     */
+    private function extractSignature($value)
+    {
+        $length = $this->getSignatureLength();
+        $value = unpack('H*', $value)[1];
+
+        return new Signature(
+            $this->adapter->hexDec(substr($value, 0, $length)),
+            $this->adapter->hexDec(substr($value, $length))
+        );
+    }
+
+    /**
+     * Returns the lenght of signature parts
+     *
+     * @return int
+     */
+    abstract public function getSignatureLength();
+
+    /**
+     * Returns the name of algorithm to be used to create the signing hash
+     *
+     * @return string
+     */
+    abstract public function getAlgorithm();
+}

vendor/lcobucci/jwt/src/Signer/Ecdsa/KeyParser.php

+<?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\Signer\Ecdsa;
+
+use InvalidArgumentException;
+use Lcobucci\JWT\Signer\Key;
+use Mdanter\Ecc\Math\MathAdapterInterface;
+use Mdanter\Ecc\Serializer\PrivateKey\DerPrivateKeySerializer;
+use Mdanter\Ecc\Serializer\PrivateKey\PemPrivateKeySerializer;
+use Mdanter\Ecc\Serializer\PrivateKey\PrivateKeySerializerInterface;
+use Mdanter\Ecc\Serializer\PublicKey\DerPublicKeySerializer;
+use Mdanter\Ecc\Serializer\PublicKey\PemPublicKeySerializer;
+use Mdanter\Ecc\Serializer\PublicKey\PublicKeySerializerInterface;
+
+/**
+ * Base class for ECDSA signers
+ *
+ * @author Luís Otávio Cobucci Oblonczyk <lcobucci@gmail.com>
+ * @since 3.0.4
+ */
+class KeyParser
+{
+    /**
+     * @var PrivateKeySerializerInterface
+     */
+    private $privateKeySerializer;
+
+    /**
+     * @var PublicKeySerializerInterface
+     */
+    private $publicKeySerializer;
+
+    /**
+     * @param MathAdapterInterface $adapter
+     * @param PrivateKeySerializerInterface $privateKeySerializer
+     * @param PublicKeySerializerInterface $publicKeySerializer
+     */
+    public function __construct(
+        MathAdapterInterface $adapter,
+        PrivateKeySerializerInterface $privateKeySerializer = null,
+        PublicKeySerializerInterface $publicKeySerializer = null
+    ) {
+        $this->privateKeySerializer = $privateKeySerializer ?: new PemPrivateKeySerializer(new DerPrivateKeySerializer($adapter));
+        $this->publicKeySerializer = $publicKeySerializer ?: new PemPublicKeySerializer(new DerPublicKeySerializer($adapter));
+    }
+
+    /**
+     * Parses a public key from the given PEM content
+     *
+     * @param Key $key
+     *
+     * @return \Mdanter\Ecc\Crypto\Key\PublicKeyInterface
+     */
+    public function getPublicKey(Key $key)
+    {
+        return $this->publicKeySerializer->parse($this->getKeyContent($key, 'PUBLIC KEY'));
+    }
+
+    /**
+     * Parses a private key from the given PEM content
+     *
+     * @param Key $key
+     *
+     * @return \Mdanter\Ecc\Crypto\Key\PrivateKeyInterface
+     */
+    public function getPrivateKey(Key $key)
+    {
+        return $this->privateKeySerializer->parse($this->getKeyContent($key, 'EC PRIVATE KEY'));
+    }
+
+    /**
+     * Extracts the base 64 value from the PEM certificate
+     *
+     * @param Key $key
+     * @param string $header
+     *
+     * @return string
+     *
+     * @throws InvalidArgumentException When given key is not a ECDSA key
+     */
+    private function getKeyContent(Key $key, $header)
+    {
+        $match = null;
+
+        preg_match(
+            '/[\-]{5}BEGIN ' . $header . '[\-]{5}(.*)[\-]{5}END ' . $header . '[\-]{5}/',
+            str_replace([PHP_EOL, "\n", "\r"], '', $key->getContent()),
+            $match
+        );
+
+        if (isset($match[1])) {
+            return $match[1];
+        }
+
+        throw new InvalidArgumentException('This is not a valid ECDSA key.');
+    }
+}

vendor/lcobucci/jwt/src/Signer/Ecdsa/Sha256.php

+<?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\Signer\Ecdsa;
+
+use Lcobucci\JWT\Signer\Ecdsa;
+
+/**
+ * Signer for ECDSA SHA-256
+ *
+ * @author Luís Otávio Cobucci Oblonczyk <lcobucci@gmail.com>
+ * @since 2.1.0
+ */
+class Sha256 extends Ecdsa
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getAlgorithmId()
+    {
+        return 'ES256';
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getAlgorithm()
+    {
+        return 'sha256';
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getSignatureLength()
+    {
+        return 64;
+    }
+}

vendor/lcobucci/jwt/src/Signer/Ecdsa/Sha384.php

+<?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\Signer\Ecdsa;
+
+use Lcobucci\JWT\Signer\Ecdsa;
+
+/**
+ * Signer for ECDSA SHA-384
+ *
+ * @author Luís Otávio Cobucci Oblonczyk <lcobucci@gmail.com>
+ * @since 2.1.0
+ */
+class Sha384 extends Ecdsa
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getAlgorithmId()
+    {
+        return 'ES384';
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getAlgorithm()
+    {
+        return 'sha384';
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getSignatureLength()
+    {
+        return 96;
+    }
+}

vendor/lcobucci/jwt/src/Signer/Ecdsa/Sha512.php

+<?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\Signer\Ecdsa;
+
+use Lcobucci\JWT\Signer\Ecdsa;
+
+/**
+ * Signer for ECDSA SHA-512
+ *
+ * @author Luís Otávio Cobucci Oblonczyk <lcobucci@gmail.com>
+ * @since 2.1.0
+ */
+class Sha512 extends Ecdsa
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getAlgorithmId()
+    {
+        return 'ES512';
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getAlgorithm()
+    {
+        return 'sha512';
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getSignatureLength()
+    {
+        return 132;
+    }
+}

vendor/lcobucci/jwt/src/Signer/Hmac.php

+<?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\Signer;
+
+/**
+ * Base class for hmac signers
+ *
+ * @author Luís Otávio Cobucci Oblonczyk <lcobucci@gmail.com>
+ * @since 0.1.0
+ */
+abstract class Hmac extends BaseSigner
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function createHash($payload, Key $key)
+    {
+        return hash_hmac($this->getAlgorithm(), $payload, $key->getContent(), true);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function doVerify($expected, $payload, Key $key)
+    {
+        if (!is_string($expected)) {
+            return false;
+        }
+
+        $callback = function_exists('hash_equals') ? 'hash_equals' : [$this, 'hashEquals'];
+
+        return call_user_func($callback, $expected, $this->createHash($payload, $key));
+    }
+
+    /**
+     * PHP < 5.6 timing attack safe hash comparison
+     *
+     * @param string $expected
+     * @param string $generated
+     *
+     * @return boolean
+     */
+    public function hashEquals($expected, $generated)
+    {
+        $expectedLength = strlen($expected);
+
+        if ($expectedLength !== strlen($generated)) {
+            return false;
+        }
+
+        $res = 0;
+
+        for ($i = 0; $i < $expectedLength; ++$i) {
+            $res |= ord($expected[$i]) ^ ord($generated[$i]);
+        }
+
+        return $res === 0;
+    }
+
+    /**
+     * Returns the algorithm name
+     *
+     * @return string
+     */
+    abstract public function getAlgorithm();
+}

vendor/lcobucci/jwt/src/Signer/Hmac/Sha256.php

+<?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\Signer\Hmac;
+
+use Lcobucci\JWT\Signer\Hmac;
+
+/**
+ * Signer for HMAC SHA-256
+ *
+ * @author Luís Otávio Cobucci Oblonczyk <lcobucci@gmail.com>
+ * @since 0.1.0
+ */
+class Sha256 extends Hmac
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getAlgorithmId()
+    {
+        return 'HS256';
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getAlgorithm()
+    {
+        return 'sha256';
+    }
+}

vendor/lcobucci/jwt/src/Signer/Hmac/Sha384.php

+<?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\Signer\Hmac;
+
+use Lcobucci\JWT\Signer\Hmac;
+
+/**
+ * Signer for HMAC SHA-384
+ *
+ * @author Luís Otávio Cobucci Oblonczyk <lcobucci@gmail.com>
+ * @since 0.1.0
+ */
+class Sha384 extends Hmac
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getAlgorithmId()
+    {
+        return 'HS384';
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getAlgorithm()
+    {
+        return 'sha384';
+    }
+}

vendor/lcobucci/jwt/src/Signer/Hmac/Sha512.php

+<?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\Signer\Hmac;
+
+use Lcobucci\JWT\Signer\Hmac;
+
+/**
+ * Signer for HMAC SHA-512
+ *
+ * @author Luís Otávio Cobucci Oblonczyk <lcobucci@gmail.com>
+ * @since 0.1.0
+ */
+class Sha512 extends Hmac
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getAlgorithmId()
+    {
+        return 'HS512';
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getAlgorithm()
+    {
+        return 'sha512';
+    }
+}

vendor/lcobucci/jwt/src/Signer/Key.php

+<?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\Signer;
+
+use InvalidArgumentException;
+
+/**
+ * @author Luís Otávio Cobucci Oblonczyk <lcobucci@gmail.com>
+ * @since 3.0.4
+ */
+final class Key
+{
+    /**
+     * @var string
+     */
+    private $content;
+
+    /**
+     * @var string
+     */
+    private $passphrase;
+
+    /**
+     * @param string $content
+     * @param string $passphrase
+     */
+    public function __construct($content, $passphrase = null)
+    {
+        $this->setContent($content);
+        $this->passphrase = $passphrase;
+    }
+
+    /**
+     * @param string $content
+     *
+     * @throws InvalidArgumentException
+     */
+    private function setContent($content)
+    {
+        if (strpos($content, 'file://') === 0) {
+            $content = $this->readFile($content);
+        }
+
+        $this->content = $content;
+    }
+
+    /**
+     * @param string $content
+     *
+     * @return string
+     *
+     * @throws \InvalidArgumentException
+     */
+    private function readFile($content)
+    {
+        $file = substr($content, 7);
+
+        if (!is_readable($file)) {
+            throw new \InvalidArgumentException('You must inform a valid key file');
+        }
+
+        return file_get_contents($file);
+    }
+
+    /**
+     * @return string
+     */
+    public function getContent()
+    {
+        return $this->content;
+    }
+
+    /**
+     * @return string
+     */
+    public function getPassphrase()
+    {
+        return $this->passphrase;
+    }
+}

vendor/lcobucci/jwt/src/Signer/Keychain.php

+<?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\Signer;
+
+/**
+ * A utilitarian class that encapsulates the retrieval of public and private keys
+ *
+ * @author Luís Otávio Cobucci Oblonczyk <lcobucci@gmail.com>
+ * @since 2.1.0
+ *
+ * @deprecated Since we've removed OpenSSL from ECDSA there's no reason to use this class
+ */
+class Keychain
+{
+    /**
+     * Returns a private key from file path or content
+     *
+     * @param string $key
+     * @param string $passphrase
+     *
+     * @return Key
+     */
+    public function getPrivateKey($key, $passphrase = null)
+    {
+        return new Key($key, $passphrase);
+    }
+
+    /**
+     * Returns a public key from file path or content
+     *
+     * @param string $certificate
+     *
+     * @return Key
+     */
+    public function getPublicKey($certificate)
+    {
+        return new Key($certificate);
+    }
+}

vendor/lcobucci/jwt/src/Signer/Rsa.php

+<?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\Signer;
+
+use InvalidArgumentException;
+
+/**
+ * Base class for RSASSA-PKCS1 signers
+ *
+ * @author Luís Otávio Cobucci Oblonczyk <lcobucci@gmail.com>
+ * @since 2.1.0
+ */
+abstract class Rsa extends BaseSigner
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function createHash($payload, Key $key)
+    {
+        $key = openssl_get_privatekey($key->getContent(), $key->getPassphrase());
+        $this->validateKey($key);
+
+        $signature = '';
+
+        if (!openssl_sign($payload, $signature, $key, $this->getAlgorithm())) {
+            throw new InvalidArgumentException(
+                'There was an error while creating the signature: ' . openssl_error_string()
+            );
+        }
+
+        return $signature;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function doVerify($expected, $payload, Key $key)
+    {
+        $key = openssl_get_publickey($key->getContent());
+        $this->validateKey($key);
+
+        return openssl_verify($payload, $expected, $key, $this->getAlgorithm()) === 1;
+    }
+
+    /**
+     * Validates if the given key is a valid RSA public/private key
+     *
+     * @param resource $key
+     *
+     * @throws InvalidArgumentException
+     */
+    private function validateKey($key)
+    {
+        if ($key === false) {
+            throw new InvalidArgumentException(
+                'It was not possible to parse your key, reason: ' . openssl_error_string()
+            );
+        }
+
+        $details = openssl_pkey_get_details($key);
+
+        if (!isset($details['key']) || $details['type'] !== OPENSSL_KEYTYPE_RSA) {
+            throw new InvalidArgumentException('This key is not compatible with RSA signatures');
+        }
+    }
+
+    /**
+     * Returns the algorithm name
+     *
+     * @return string
+     */
+    abstract public function getAlgorithm();
+}

vendor/lcobucci/jwt/src/Signer/Rsa/Sha256.php

+<?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\Signer\Rsa;
+
+use Lcobucci\JWT\Signer\Rsa;
+
+/**
+ * Signer for RSA SHA-256
+ *
+ * @author Luís Otávio Cobucci Oblonczyk <lcobucci@gmail.com>
+ * @since 2.1.0
+ */
+class Sha256 extends Rsa
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getAlgorithmId()
+    {
+        return 'RS256';
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getAlgorithm()
+    {
+        return OPENSSL_ALGO_SHA256;
+    }
+}

vendor/lcobucci/jwt/src/Signer/Rsa/Sha384.php

+<?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\Signer\Rsa;
+
+use Lcobucci\JWT\Signer\Rsa;
+
+/**
+ * Signer for RSA SHA-384
+ *
+ * @author Luís Otávio Cobucci Oblonczyk <lcobucci@gmail.com>
+ * @since 2.1.0
+ */
+class Sha384 extends Rsa
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getAlgorithmId()
+    {
+        return 'RS384';
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getAlgorithm()
+    {
+        return OPENSSL_ALGO_SHA384;
+    }
+}

vendor/lcobucci/jwt/src/Signer/Rsa/Sha512.php

+<?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\Signer\Rsa;
+
+use Lcobucci\JWT\Signer\Rsa;
+
+/**
+ * Signer for RSA SHA-512
+ *
+ * @author Luís Otávio Cobucci Oblonczyk <lcobucci@gmail.com>
+ * @since 2.1.0
+ */
+class Sha512 extends Rsa
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getAlgorithmId()
+    {
+        return 'RS512';
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getAlgorithm()
+    {
+        return OPENSSL_ALGO_SHA512;
+    }
+}

vendor/lcobucci/jwt/src/Token.php

+<?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 BadMethodCallException;
+use DateTime;
+use DateTimeInterface;
+use Generator;
+use Lcobucci\JWT\Claim\Validatable;
+use OutOfBoundsException;
+
+/**
+ * Basic structure of the JWT
+ *
+ * @author Luís Otávio Cobucci Oblonczyk <lcobucci@gmail.com>
+ * @since 0.1.0
+ */
+class Token
+{
+    /**
+     * The token headers
+     *
+     * @var array
+     */
+    private $headers;
+
+    /**
+     * The token claim set
+     *
+     * @var array
+     */
+    private $claims;
+
+    /**
+     * The token signature
+     *
+     * @var Signature
+     */
+    private $signature;
+
+    /**
+     * The encoded data
+     *
+     * @var array
+     */
+    private $payload;
+
+    /**
+     * Initializes the object
+     *
+     * @param array $headers
+     * @param array $claims
+     * @param array $payload
+     * @param Signature $signature
+     */
+    public function __construct(
+        array $headers = ['alg' => 'none'],
+        array $claims = [],
+        Signature $signature = null,
+        array $payload = ['', '']
+    ) {
+        $this->headers = $headers;
+        $this->claims = $claims;
+        $this->signature = $signature;
+        $this->payload = $payload;
+    }
+
+    /**
+     * Returns the token headers
+     *
+     * @return array
+     */
+    public function getHeaders()
+    {
+        return $this->headers;
+    }
+
+    /**
+     * Returns if the header is configured
+     *
+     * @param string $name
+     *
+     * @return boolean
+     */
+    public function hasHeader($name)
+    {
+        return array_key_exists($name, $this->headers);
+    }
+
+    /**
+     * Returns the value of a token header
+     *
+     * @param string $name
+     * @param mixed $default
+     *
+     * @return mixed
+     *
+     * @throws OutOfBoundsException
+     */
+    public function getHeader($name, $default = null)
+    {
+        if ($this->hasHeader($name)) {
+            return $this->getHeaderValue($name);
+        }
+
+        if ($default === null) {
+            throw new OutOfBoundsException('Requested header is not configured');
+        }
+
+        return $default;
+    }
+
+    /**
+     * Returns the value stored in header
+     *
+     * @param string $name
+     *
+     * @return mixed
+     */
+    private function getHeaderValue($name)
+    {
+        $header = $this->headers[$name];
+
+        if ($header instanceof Claim) {
+            return $header->getValue();
+        }
+
+        return $header;
+    }
+
+    /**
+     * Returns the token claim set
+     *
+     * @return array
+     */
+    public function getClaims()
+    {
+        return $this->claims;
+    }
+
+    /**
+     * Returns if the claim is configured
+     *
+     * @param string $name
+     *
+     * @return boolean
+     */
+    public function hasClaim($name)
+    {
+        return array_key_exists($name, $this->claims);
+    }
+
+    /**
+     * Returns the value of a token claim
+     *
+     * @param string $name
+     * @param mixed $default
+     *
+     * @return mixed
+     *
+     * @throws OutOfBoundsException
+     */
+    public function getClaim($name, $default = null)
+    {
+        if ($this->hasClaim($name)) {
+            return $this->claims[$name]->getValue();
+        }
+
+        if ($default === null) {
+            throw new OutOfBoundsException('Requested claim is not configured');
+        }
+
+        return $default;
+    }
+
+    /**
+     * Verify if the key matches with the one that created the signature
+     *
+     * @param Signer $signer
+     * @param string $key
+     *
+     * @return boolean
+     *
+     * @throws BadMethodCallException When token is not signed
+     */
+    public function verify(Signer $signer, $key)
+    {
+        if ($this->signature === null) {
+            throw new BadMethodCallException('This token is not signed');
+        }
+
+        if ($this->headers['alg'] !== $signer->getAlgorithmId()) {
+            return false;
+        }
+
+        return $this->signature->verify($signer, $this->getPayload(), $key);
+    }
+
+    /**
+     * Validates if the token is valid
+     *
+     * @param ValidationData $data
+     *
+     * @return boolean
+     */
+    public function validate(ValidationData $data)
+    {
+        foreach ($this->getValidatableClaims() as $claim) {
+            if (!$claim->validate($data)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * Determine if the token is expired.
+     *
+     * @param DateTimeInterface $now Defaults to the current time.
+     *
+     * @return bool
+     */
+    public function isExpired(DateTimeInterface $now = null)
+    {
+        $exp = $this->getClaim('exp', false);
+
+        if ($exp === false) {
+            return false;
+        }
+
+        $now = $now ?: new DateTime();
+
+        $expiresAt = new DateTime();
+        $expiresAt->setTimestamp($exp);
+
+        return $now > $expiresAt;
+    }
+
+    /**
+     * Yields the validatable claims
+     *
+     * @return Generator
+     */
+    private function getValidatableClaims()
+    {
+        foreach ($this->claims as $claim) {
+            if ($claim instanceof Validatable) {
+                yield $claim;
+            }
+        }
+    }
+
+    /**
+     * Returns the token payload
+     *
+     * @return string
+     */
+    public function getPayload()
+    {
+        return $this->payload[0] . '.' . $this->payload[1];
+    }
+
+    /**
+     * Returns an encoded representation of the token
+     *
+     * @return string
+     */
+    public function __toString()
+    {
+        $data = implode('.', $this->payload);
+
+        if ($this->signature === null) {
+            $data .= '.';
+        }
+
+        return $data;
+    }
+}

vendor/lcobucci/jwt/src/ValidationData.php

+<?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;
+
+/**
+ * Class that wraps validation values
+ *
+ * @author Luís Otávio Cobucci Oblonczyk <lcobucci@gmail.com>
+ * @since 2.0.0
+ */
+class ValidationData
+{
+    /**
+     * The list of things to be validated
+     *
+     * @var array
+     */
+    private $items;
+
+    /**
+     * Initializes the object
+     *
+     * @param int $currentTime
+     */
+    public function __construct($currentTime = null)
+    {
+        $currentTime = $currentTime ?: time();
+
+        $this->items = [
+            'jti' => null,
+            'iss' => null,
+            'aud' => null,
+            'sub' => null,
+            'iat' => $currentTime,
+            'nbf' => $currentTime,
+            'exp' => $currentTime
+        ];
+    }
+
+    /**
+     * Configures the id
+     *
+     * @param string $id
+     */
+    public function setId($id)
+    {
+        $this->items['jti'] = (string) $id;
+    }
+
+    /**
+     * Configures the issuer
+     *
+     * @param string $issuer
+     */
+    public function setIssuer($issuer)
+    {
+        $this->items['iss'] = (string) $issuer;
+    }
+
+    /**
+     * Configures the audience
+     *
+     * @param string $audience
+     */
+    public function setAudience($audience)
+    {
+        $this->items['aud'] = (string) $audience;
+    }
+
+    /**
+     * Configures the subject
+     *
+     * @param string $subject
+     */
+    public function setSubject($subject)
+    {
+        $this->items['sub'] = (string) $subject;
+    }
+
+    /**
+     * Configures the time that "iat", "nbf" and "exp" should be based on
+     *
+     * @param int $currentTime
+     */
+    public function setCurrentTime($currentTime)
+    {
+        $this->items['iat'] = (int) $currentTime;
+        $this->items['nbf'] = (int) $currentTime;
+        $this->items['exp'] = (int) $currentTime;
+    }
+
+    /**
+     * Returns the requested item
+     *
+     * @param string $name
+     *
+     * @return mixed
+     */
+    public function get($name)
+    {
+        return isset($this->items[$name]) ? $this->items[$name] : null;
+    }
+
+    /**
+     * Returns if the item is present
+     *
+     * @param string $name
+     *
+     * @return boolean
+     */
+    public function has($name)
+    {
+        return !empty($this->items[$name]);
+    }
+}

vendor/lcobucci/jwt/test/functional/HmacTokenTest.php

+<?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\FunctionalTests;
+
+use Lcobucci\JWT\Builder;
+use Lcobucci\JWT\Parser;
+use Lcobucci\JWT\Token;
+use Lcobucci\JWT\Signature;
+use Lcobucci\JWT\Signer\Hmac\Sha256;
+use Lcobucci\JWT\Signer\Hmac\Sha512;
+
+/**
+ * @author Luís Otávio Cobucci Oblonczyk <lcobucci@gmail.com>
+ * @since 2.1.0
+ */
+class HmacTokenTest extends \PHPUnit_Framework_TestCase
+{
+    /**
+     * @var Sha256
+     */
+    private $signer;
+
+    /**
+     * @before
+     */
+    public function createSigner()
+    {
+        $this->signer = new Sha256();
+    }
+
+    /**
+     * @test
+     *
+     * @covers Lcobucci\JWT\Builder
+     * @covers Lcobucci\JWT\Token
+     * @covers Lcobucci\JWT\Signature
+     * @covers Lcobucci\JWT\Claim\Factory
+     * @covers Lcobucci\JWT\Claim\Basic
+     * @covers Lcobucci\JWT\Parsing\Encoder
+     * @covers Lcobucci\JWT\Signer\Key
+     * @covers Lcobucci\JWT\Signer\BaseSigner
+     * @covers Lcobucci\JWT\Signer\Hmac
+     * @covers Lcobucci\JWT\Signer\Hmac\Sha256
+     */
+    public function builderCanGenerateAToken()
+    {
+        $user = (object) ['name' => 'testing', 'email' => 'testing@abc.com'];
+
+        $token = (new Builder())->setId(1)
+                              ->setAudience('http://client.abc.com')
+                              ->setIssuer('http://api.abc.com')
+                              ->set('user', $user)
+                              ->setHeader('jki', '1234')
+                              ->sign($this->signer, 'testing')
+                              ->getToken();
+
+        $this->assertAttributeInstanceOf(Signature::class, 'signature', $token);
+        $this->assertEquals('1234', $token->getHeader('jki'));
+        $this->assertEquals('http://client.abc.com', $token->getClaim('aud'));
+        $this->assertEquals('http://api.abc.com', $token->getClaim('iss'));
+        $this->assertEquals($user, $token->getClaim('user'));
+
+        return $token;
+    }
+
+    /**
+     * @test
+     *
+     * @depends builderCanGenerateAToken
+     *
+     * @covers Lcobucci\JWT\Builder
+     * @covers Lcobucci\JWT\Parser
+     * @covers Lcobucci\JWT\Token
+     * @covers Lcobucci\JWT\Signature
+     * @covers Lcobucci\JWT\Claim\Factory
+     * @covers Lcobucci\JWT\Claim\Basic
+     * @covers Lcobucci\JWT\Parsing\Encoder
+     * @covers Lcobucci\JWT\Parsing\Decoder
+     */
+    public function parserCanReadAToken(Token $generated)
+    {
+        $read = (new Parser())->parse((string) $generated);
+
+        $this->assertEquals($generated, $read);
+        $this->assertEquals('testing', $read->getClaim('user')->name);
+    }
+
+    /**
+     * @test
+     *
+     * @depends builderCanGenerateAToken
+     *
+     * @covers Lcobucci\JWT\Builder
+     * @covers Lcobucci\JWT\Parser
+     * @covers Lcobucci\JWT\Token
+     * @covers Lcobucci\JWT\Signature
+     * @covers Lcobucci\JWT\Parsing\Encoder
+     * @covers Lcobucci\JWT\Claim\Factory
+     * @covers Lcobucci\JWT\Claim\Basic
+     * @covers Lcobucci\JWT\Signer\Key
+     * @covers Lcobucci\JWT\Signer\BaseSigner
+     * @covers Lcobucci\JWT\Signer\Hmac
+     * @covers Lcobucci\JWT\Signer\Hmac\Sha256
+     */
+    public function verifyShouldReturnFalseWhenKeyIsNotRight(Token $token)
+    {
+        $this->assertFalse($token->verify($this->signer, 'testing1'));
+    }
+
+    /**
+     * @test
+     *
+     * @depends builderCanGenerateAToken
+     *
+     * @covers Lcobucci\JWT\Builder
+     * @covers Lcobucci\JWT\Parser
+     * @covers Lcobucci\JWT\Token
+     * @covers Lcobucci\JWT\Signature
+     * @covers Lcobucci\JWT\Parsing\Encoder
+     * @covers Lcobucci\JWT\Claim\Factory
+     * @covers Lcobucci\JWT\Claim\Basic
+     * @covers Lcobucci\JWT\Signer\Key
+     * @covers Lcobucci\JWT\Signer\BaseSigner
+     * @covers Lcobucci\JWT\Signer\Hmac
+     * @covers Lcobucci\JWT\Signer\Hmac\Sha256
+     * @covers Lcobucci\JWT\Signer\Hmac\Sha512
+     */
+    public function verifyShouldReturnFalseWhenAlgorithmIsDifferent(Token $token)
+    {
+        $this->assertFalse($token->verify(new Sha512(), 'testing'));
+    }
+
+    /**
+     * @test
+     *
+     * @depends builderCanGenerateAToken
+     *
+     * @covers Lcobucci\JWT\Builder
+     * @covers Lcobucci\JWT\Parser
+     * @covers Lcobucci\JWT\Token
+     * @covers Lcobucci\JWT\Signature
+     * @covers Lcobucci\JWT\Parsing\Encoder
+     * @covers Lcobucci\JWT\Claim\Factory
+     * @covers Lcobucci\JWT\Claim\Basic
+     * @covers Lcobucci\JWT\Signer\Key
+     * @covers Lcobucci\JWT\Signer\BaseSigner
+     * @covers Lcobucci\JWT\Signer\Hmac
+     * @covers Lcobucci\JWT\Signer\Hmac\Sha256
+     */
+    public function verifyShouldReturnTrueWhenKeyIsRight(Token $token)
+    {
+        $this->assertTrue($token->verify($this->signer, 'testing'));
+    }
+
+    /**
+     * @test
+     *
+     * @covers Lcobucci\JWT\Builder
+     * @covers Lcobucci\JWT\Parser
+     * @covers Lcobucci\JWT\Token
+     * @covers Lcobucci\JWT\Signature
+     * @covers Lcobucci\JWT\Signer\Key
+     * @covers Lcobucci\JWT\Signer\BaseSigner
+     * @covers Lcobucci\JWT\Signer\Hmac
+     * @covers Lcobucci\JWT\Signer\Hmac\Sha256
+     * @covers Lcobucci\JWT\Claim\Factory
+     * @covers Lcobucci\JWT\Claim\Basic
+     * @covers Lcobucci\JWT\Parsing\Encoder
+     * @covers Lcobucci\JWT\Parsing\Decoder
+     */
+    public function everythingShouldWorkWhenUsingATokenGeneratedByOtherLibs()
+    {
+        $data = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXUyJ9.eyJoZWxsbyI6IndvcmxkIn0.Rh'
+                . '7AEgqCB7zae1PkgIlvOpeyw9Ab8NGTbeOH7heHO0o';
+
+        $token = (new Parser())->parse((string) $data);
+
+        $this->assertEquals('world', $token->getClaim('hello'));
+        $this->assertTrue($token->verify($this->signer, 'testing'));
+    }
+}

vendor/lcobucci/jwt/test/functional/Keys.php

+<?php
+namespace Lcobucci\JWT;
+
+use Lcobucci\JWT\Signer\Keychain;
+
+/**
+ * @author Luís Otávio Cobucci Oblonczyk <lcobucci@gmail.com>
+ */
+trait Keys
+{
+    /**
+     * @var array
+     */
+    protected static $rsaKeys;
+
+    /**
+     * @var array
+     */
+    protected static $ecdsaKeys;
+
+    /**
+     * @beforeClass
+     */
+    public static function createRsaKeys()
+    {
+        $keychain = new Keychain();
+        $dir = 'file://' . __DIR__;
+
+        static::$rsaKeys = [
+            'private' => $keychain->getPrivateKey($dir . '/rsa/private.key'),
+            'public' => $keychain->getPublicKey($dir . '/rsa/public.key'),
+            'encrypted-private' => $keychain->getPrivateKey($dir . '/rsa/encrypted-private.key', 'testing'),
+            'encrypted-public' => $keychain->getPublicKey($dir . '/rsa/encrypted-public.key')
+        ];
+    }
+
+    /**
+     * @beforeClass
+     */
+    public static function createEcdsaKeys()
+    {
+        $keychain = new Keychain();
+        $dir = 'file://' . __DIR__;
+
+        static::$ecdsaKeys = [
+            'private' => $keychain->getPrivateKey($dir . '/ecdsa/private.key'),
+            'private-params' => $keychain->getPrivateKey($dir . '/ecdsa/private2.key'),
+            'public1' => $keychain->getPublicKey($dir . '/ecdsa/public1.key'),
+            'public2' => $keychain->getPublicKey($dir . '/ecdsa/public2.key'),
+            'public-params' => $keychain->getPublicKey($dir . '/ecdsa/public3.key'),
+        ];
+    }
+}

vendor/lcobucci/jwt/test/functional/RsaTokenTest.php

+<?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\FunctionalTests;
+
+use Lcobucci\JWT\Builder;
+use Lcobucci\JWT\Keys;
+use Lcobucci\JWT\Parser;
+use Lcobucci\JWT\Signer\Key;
+use Lcobucci\JWT\Token;
+use Lcobucci\JWT\Signature;
+use Lcobucci\JWT\Signer\Rsa\Sha256;
+use Lcobucci\JWT\Signer\Rsa\Sha512;
+
+/**
+ * @author Luís Otávio Cobucci Oblonczyk <lcobucci@gmail.com>
+ * @since 2.1.0
+ */
+class RsaTokenTest extends \PHPUnit_Framework_TestCase
+{
+    use Keys;
+
+    /**
+     * @var Sha256
+     */
+    private $signer;
+
+    /**
+     * @before
+     */
+    public function createSigner()
+    {
+        $this->signer = new Sha256();
+    }
+
+    /**
+     * @test
+     *
+     * @expectedException \InvalidArgumentException
+     *
+     * @covers Lcobucci\JWT\Builder
+     * @covers Lcobucci\JWT\Token
+     * @covers Lcobucci\JWT\Signature
+     * @covers Lcobucci\JWT\Claim\Factory
+     * @covers Lcobucci\JWT\Claim\Basic
+     * @covers Lcobucci\JWT\Parsing\Encoder
+     * @covers Lcobucci\JWT\Signer\Key
+     * @covers Lcobucci\JWT\Signer\BaseSigner
+     * @covers Lcobucci\JWT\Signer\Rsa
+     * @covers Lcobucci\JWT\Signer\Rsa\Sha256
+     */
+    public function builderShouldRaiseExceptionWhenKeyIsInvalid()
+    {
+        $user = (object) ['name' => 'testing', 'email' => 'testing@abc.com'];
+
+        (new Builder())->setId(1)
+                       ->setAudience('http://client.abc.com')
+                       ->setIssuer('http://api.abc.com')
+                       ->set('user', $user)
+                       ->sign($this->signer, new Key('testing'));
+    }
+
+    /**
+     * @test
+     *
+     * @expectedException \InvalidArgumentException
+     *
+     * @covers Lcobucci\JWT\Builder
+     * @covers Lcobucci\JWT\Token
+     * @covers Lcobucci\JWT\Signature
+     * @covers Lcobucci\JWT\Claim\Factory
+     * @covers Lcobucci\JWT\Claim\Basic
+     * @covers Lcobucci\JWT\Parsing\Encoder
+     * @covers Lcobucci\JWT\Signer\Key
+     * @covers Lcobucci\JWT\Signer\BaseSigner
+     * @covers Lcobucci\JWT\Signer\Rsa
+     * @covers Lcobucci\JWT\Signer\Rsa\Sha256
+     */
+    public function builderShouldRaiseExceptionWhenKeyIsNotRsaCompatible()
+    {
+        $user = (object) ['name' => 'testing', 'email' => 'testing@abc.com'];
+
+        (new Builder())->setId(1)
+                       ->setAudience('http://client.abc.com')
+                       ->setIssuer('http://api.abc.com')
+                       ->set('user', $user)
+                       ->sign($this->signer, static::$ecdsaKeys['private']);
+    }
+
+    /**
+     * @test
+     *
+     * @covers Lcobucci\JWT\Builder
+     * @covers Lcobucci\JWT\Token
+     * @covers Lcobucci\JWT\Signature
+     * @covers Lcobucci\JWT\Claim\Factory
+     * @covers Lcobucci\JWT\Claim\Basic
+     * @covers Lcobucci\JWT\Parsing\Encoder
+     * @covers Lcobucci\JWT\Signer\Key
+     * @covers Lcobucci\JWT\Signer\BaseSigner
+     * @covers Lcobucci\JWT\Signer\Rsa
+     * @covers Lcobucci\JWT\Signer\Rsa\Sha256
+     */
+    public function builderCanGenerateAToken()
+    {
+        $user = (object) ['name' => 'testing', 'email' => 'testing@abc.com'];
+
+        $token = (new Builder())->setId(1)
+                              ->setAudience('http://client.abc.com')
+                              ->setIssuer('http://api.abc.com')
+                              ->set('user', $user)
+                              ->setHeader('jki', '1234')
+                              ->sign($this->signer, static::$rsaKeys['private'])
+                              ->getToken();
+
+        $this->assertAttributeInstanceOf(Signature::class, 'signature', $token);
+        $this->assertEquals('1234', $token->getHeader('jki'));
+        $this->assertEquals('http://client.abc.com', $token->getClaim('aud'));
+        $this->assertEquals('http://api.abc.com', $token->getClaim('iss'));
+        $this->assertEquals($user, $token->getClaim('user'));
+
+        return $token;
+    }
+
+    /**
+     * @test
+     *
+     * @depends builderCanGenerateAToken
+     *
+     * @covers Lcobucci\JWT\Builder
+     * @covers Lcobucci\JWT\Parser
+     * @covers Lcobucci\JWT\Token
+     * @covers Lcobucci\JWT\Signature
+     * @covers Lcobucci\JWT\Claim\Factory
+     * @covers Lcobucci\JWT\Claim\Basic
+     * @covers Lcobucci\JWT\Parsing\Encoder
+     * @covers Lcobucci\JWT\Parsing\Decoder
+     */
+    public function parserCanReadAToken(Token $generated)
+    {
+        $read = (new Parser())->parse((string) $generated);
+
+        $this->assertEquals($generated, $read);
+        $this->assertEquals('testing', $read->getClaim('user')->name);
+    }
+
+    /**
+     * @test
+     *
+     * @depends builderCanGenerateAToken
+     *
+     * @covers Lcobucci\JWT\Builder
+     * @covers Lcobucci\JWT\Parser
+     * @covers Lcobucci\JWT\Token
+     * @covers Lcobucci\JWT\Signature
+     * @covers Lcobucci\JWT\Parsing\Encoder
+     * @covers Lcobucci\JWT\Claim\Factory
+     * @covers Lcobucci\JWT\Claim\Basic
+     * @covers Lcobucci\JWT\Signer\Key
+     * @covers Lcobucci\JWT\Signer\BaseSigner
+     * @covers Lcobucci\JWT\Signer\Rsa
+     * @covers Lcobucci\JWT\Signer\Rsa\Sha256
+     */
+    public function verifyShouldReturnFalseWhenKeyIsNotRight(Token $token)
+    {
+        $this->assertFalse($token->verify($this->signer, self::$rsaKeys['encrypted-public']));
+    }
+
+    /**
+     * @test
+     *
+     * @depends builderCanGenerateAToken
+     *
+     * @covers Lcobucci\JWT\Builder
+     * @covers Lcobucci\JWT\Parser
+     * @covers Lcobucci\JWT\Token
+     * @covers Lcobucci\JWT\Signature
+     * @covers Lcobucci\JWT\Parsing\Encoder
+     * @covers Lcobucci\JWT\Claim\Factory
+     * @covers Lcobucci\JWT\Claim\Basic
+     * @covers Lcobucci\JWT\Signer\Key
+     * @covers Lcobucci\JWT\Signer\BaseSigner
+     * @covers Lcobucci\JWT\Signer\Rsa
+     * @covers Lcobucci\JWT\Signer\Rsa\Sha256
+     * @covers Lcobucci\JWT\Signer\Rsa\Sha512
+     */
+    public function verifyShouldReturnFalseWhenAlgorithmIsDifferent(Token $token)
+    {
+        $this->assertFalse($token->verify(new Sha512(), self::$rsaKeys['public']));
+    }
+
+    /**
+     * @test
+     *
+     * @expectedException \InvalidArgumentException
+     *
+     * @depends builderCanGenerateAToken
+     *
+     * @covers Lcobucci\JWT\Builder
+     * @covers Lcobucci\JWT\Parser
+     * @covers Lcobucci\JWT\Token
+     * @covers Lcobucci\JWT\Signature
+     * @covers Lcobucci\JWT\Parsing\Encoder
+     * @covers Lcobucci\JWT\Claim\Factory
+     * @covers Lcobucci\JWT\Claim\Basic
+     * @covers Lcobucci\JWT\Signer\Key
+     * @covers Lcobucci\JWT\Signer\BaseSigner
+     * @covers Lcobucci\JWT\Signer\Rsa
+     * @covers Lcobucci\JWT\Signer\Rsa\Sha256
+     */
+    public function verifyShouldRaiseExceptionWhenKeyIsNotRsaCompatible(Token $token)
+    {
+        $this->assertFalse($token->verify($this->signer, self::$ecdsaKeys['public1']));
+    }
+
+    /**
+     * @test
+     *
+     * @depends builderCanGenerateAToken
+     *
+     * @covers Lcobucci\JWT\Builder
+     * @covers Lcobucci\JWT\Parser
+     * @covers Lcobucci\JWT\Token
+     * @covers Lcobucci\JWT\Signature
+     * @covers Lcobucci\JWT\Parsing\Encoder
+     * @covers Lcobucci\JWT\Claim\Factory
+     * @covers Lcobucci\JWT\Claim\Basic
+     * @covers Lcobucci\JWT\Signer\Key
+     * @covers Lcobucci\JWT\Signer\BaseSigner
+     * @covers Lcobucci\JWT\Signer\Rsa
+     * @covers Lcobucci\JWT\Signer\Rsa\Sha256
+     */
+    public function verifyShouldReturnTrueWhenKeyIsRight(Token $token)
+    {
+        $this->assertTrue($token->verify($this->signer, self::$rsaKeys['public']));
+    }
+
+    /**
+     * @test
+     *
+     * @covers Lcobucci\JWT\Builder
+     * @covers Lcobucci\JWT\Parser
+     * @covers Lcobucci\JWT\Token
+     * @covers Lcobucci\JWT\Signature
+     * @covers Lcobucci\JWT\Signer\Key
+     * @covers Lcobucci\JWT\Signer\BaseSigner
+     * @covers Lcobucci\JWT\Signer\Rsa
+     * @covers Lcobucci\JWT\Signer\Rsa\Sha256
+     * @covers Lcobucci\JWT\Claim\Factory
+     * @covers Lcobucci\JWT\Claim\Basic
+     * @covers Lcobucci\JWT\Parsing\Encoder
+     * @covers Lcobucci\JWT\Parsing\Decoder
+     */
+    public function everythingShouldWorkWhenUsingATokenGeneratedByOtherLibs()
+    {
+        $data = 'eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXUyJ9.eyJoZWxsbyI6IndvcmxkIn0.s'
+                . 'GYbB1KrmnESNfJ4D9hOe1Zad_BMyxdb8G4p4LNP7StYlOyBWck6q7XPpPj_6gB'
+                . 'Bo1ohD3MA2o0HY42lNIrAStaVhfsFKGdIou8TarwMGZBPcif_3ThUV1pGS3fZc'
+                . 'lFwF2SP7rqCngQis_xcUVCyqa8E1Wa_v28grnl1QZrnmQFO8B5JGGLqcrfUHJO'
+                . 'nJCupP-Lqh4TmIhftIimSCgLNmJg80wyrpUEfZYReE7hPuEmY0ClTqAGIMQoNS'
+                . '98ljwDxwhfbSuL2tAdbV4DekbTpWzspe3dOJ7RSzmPKVZ6NoezaIazKqyqkmHZfcMaHI1lQeGia6LTbHU1bp0gINi74Vw';
+
+        $token = (new Parser())->parse((string) $data);
+
+        $this->assertEquals('world', $token->getClaim('hello'));
+        $this->assertTrue($token->verify($this->signer, self::$rsaKeys['public']));
+    }
+}

vendor/lcobucci/jwt/test/functional/UnsignedTokenTest.php

+<?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\FunctionalTests;
+
+use Lcobucci\JWT\Builder;
+use Lcobucci\JWT\Parser;
+use Lcobucci\JWT\Token;
+use Lcobucci\JWT\ValidationData;
+
+/**
+ * @author Luís Otávio Cobucci Oblonczyk <lcobucci@gmail.com>
+ * @since 2.1.0
+ */
+class UnsignedTokenTest extends \PHPUnit_Framework_TestCase
+{
+    const CURRENT_TIME = 100000;
+
+    /**
+     * @test
+     *
+     * @covers Lcobucci\JWT\Builder
+     * @covers Lcobucci\JWT\Token
+     * @covers Lcobucci\JWT\Claim\Factory
+     * @covers Lcobucci\JWT\Claim\Basic
+     * @covers Lcobucci\JWT\Parsing\Encoder
+     */
+    public function builderCanGenerateAToken()
+    {
+        $user = (object) ['name' => 'testing', 'email' => 'testing@abc.com'];
+
+        $token = (new Builder())->setId(1)
+                              ->setAudience('http://client.abc.com')
+                              ->setIssuer('http://api.abc.com')
+                              ->setExpiration(self::CURRENT_TIME + 3000)
+                              ->set('user', $user)
+                              ->getToken();
+
+        $this->assertAttributeEquals(null, 'signature', $token);
+        $this->assertEquals('http://client.abc.com', $token->getClaim('aud'));
+        $this->assertEquals('http://api.abc.com', $token->getClaim('iss'));
+        $this->assertEquals(self::CURRENT_TIME + 3000, $token->getClaim('exp'));
+        $this->assertEquals($user, $token->getClaim('user'));
+
+        return $token;
+    }
+
+    /**
+     * @test
+     *
+     * @depends builderCanGenerateAToken
+     *
+     * @covers Lcobucci\JWT\Builder
+     * @covers Lcobucci\JWT\Parser
+     * @covers Lcobucci\JWT\Token
+     * @covers Lcobucci\JWT\Claim\Factory
+     * @covers Lcobucci\JWT\Claim\Basic
+     * @covers Lcobucci\JWT\Parsing\Encoder
+     * @covers Lcobucci\JWT\Parsing\Decoder
+     */
+    public function parserCanReadAToken(Token $generated)
+    {
+        $read = (new Parser())->parse((string) $generated);
+
+        $this->assertEquals($generated, $read);
+        $this->assertEquals('testing', $read->getClaim('user')->name);
+    }
+
+    /**
+     * @test
+     *
+     * @depends builderCanGenerateAToken
+     *
+     * @covers Lcobucci\JWT\Builder
+     * @covers Lcobucci\JWT\Parser
+     * @covers Lcobucci\JWT\Token
+     * @covers Lcobucci\JWT\ValidationData
+     * @covers Lcobucci\JWT\Claim\Factory
+     * @covers Lcobucci\JWT\Claim\Basic
+     * @covers Lcobucci\JWT\Claim\EqualsTo
+     * @covers Lcobucci\JWT\Claim\GreaterOrEqualsTo
+     * @covers Lcobucci\JWT\Parsing\Encoder
+     * @covers Lcobucci\JWT\Parsing\Decoder
+     */
+    public function tokenValidationShouldReturnWhenEverythingIsFine(Token $generated)
+    {
+        $data = new ValidationData(self::CURRENT_TIME - 10);
+        $data->setAudience('http://client.abc.com');
+        $data->setIssuer('http://api.abc.com');
+
+        $this->assertTrue($generated->validate($data));
+    }
+
+    /**
+     * @test
+     *
+     * @dataProvider invalidValidationData
+     *
+     * @depends builderCanGenerateAToken
+     *
+     * @covers Lcobucci\JWT\Builder
+     * @covers Lcobucci\JWT\Parser
+     * @covers Lcobucci\JWT\Token
+     * @covers Lcobucci\JWT\ValidationData
+     * @covers Lcobucci\JWT\Claim\Factory
+     * @covers Lcobucci\JWT\Claim\Basic
+     * @covers Lcobucci\JWT\Claim\EqualsTo
+     * @covers Lcobucci\JWT\Claim\GreaterOrEqualsTo
+     * @covers Lcobucci\JWT\Parsing\Encoder
+     * @covers Lcobucci\JWT\Parsing\Decoder
+     */
+    public function tokenValidationShouldReturnFalseWhenExpectedDataDontMatch(ValidationData $data, Token $generated)
+    {
+        $this->assertFalse($generated->validate($data));
+    }
+
+    public function invalidValidationData()
+    {
+        $expired = new ValidationData(self::CURRENT_TIME + 3020);
+        $expired->setAudience('http://client.abc.com');
+        $expired->setIssuer('http://api.abc.com');
+
+        $invalidAudience = new ValidationData(self::CURRENT_TIME - 10);
+        $invalidAudience->setAudience('http://cclient.abc.com');
+        $invalidAudience->setIssuer('http://api.abc.com');
+
+        $invalidIssuer = new ValidationData(self::CURRENT_TIME - 10);
+        $invalidIssuer->setAudience('http://client.abc.com');
+        $invalidIssuer->setIssuer('http://aapi.abc.com');
+
+        return [[$expired], [$invalidAudience], [$invalidIssuer]];
+    }
+}

vendor/lcobucci/jwt/test/functional/ecdsa/private.key

+-----BEGIN EC PRIVATE KEY-----
+MHcCAQEEIBGpMoZJ64MMSzuo5JbmXpf9V4qSWdLIl/8RmJLcfn/qoAoGCCqGSM49
+AwEHoUQDQgAE7it/EKmcv9bfpcV1fBreLMRXxWpnd0wxa2iFruiI2tsEdGFTLTsy
+U+GeRqC7zN0aTnTQajarUylKJ3UWr/r1kg==
+-----END EC PRIVATE KEY-----
\ No newline at end of file

vendor/lcobucci/jwt/test/functional/ecdsa/private2.key

+-----BEGIN EC PARAMETERS-----
+BggqhkjOPQMBBw==
+-----END EC PARAMETERS-----
+-----BEGIN EC PRIVATE KEY-----
+MHcCAQEEIM6G7WZ6SqoPwrHwGXhOJkYD+ErT8dfRvrNifgBQvSb7oAoGCCqGSM49
+AwEHoUQDQgAE09Hkp/u0tIGdzlQ99R/sXCOr9DTZAfLex4D4Po0C1L3qUqHrzZ0m
+B3bAhe+pwEDQ/jqVqdzxhA9i4PqT7F4Aew==
+-----END EC PRIVATE KEY-----

vendor/lcobucci/jwt/test/functional/ecdsa/public1.key

+-----BEGIN PUBLIC KEY-----
+MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE7it/EKmcv9bfpcV1fBreLMRXxWpn
+d0wxa2iFruiI2tsEdGFTLTsyU+GeRqC7zN0aTnTQajarUylKJ3UWr/r1kg==
+-----END PUBLIC KEY-----
\ No newline at end of file

vendor/lcobucci/jwt/test/functional/ecdsa/public2.key

+-----BEGIN PUBLIC KEY-----
+MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEdgxRxlhzhHGj+v6S2ikp+33LoGp5
+QWbEWv8BORsr2Ayg6C7deDDRM/s/f0R++4zZqXro1gDTVF5VDv7nE+EfEw==
+-----END PUBLIC KEY-----
\ No newline at end of file

vendor/lcobucci/jwt/test/functional/ecdsa/public3.key

+-----BEGIN PUBLIC KEY-----
+MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE09Hkp/u0tIGdzlQ99R/sXCOr9DTZ
+AfLex4D4Po0C1L3qUqHrzZ0mB3bAhe+pwEDQ/jqVqdzxhA9i4PqT7F4Aew==
+-----END PUBLIC KEY-----

vendor/lcobucci/jwt/test/functional/rsa/encrypted-private.key

+-----BEGIN RSA PRIVATE KEY-----
+Proc-Type: 4,ENCRYPTED
+DEK-Info: AES-128-CBC,0D71668CE71033CB9150ED82FC87F4A1
+
+uLzPNDdlHnZ77tAGMHyPYERDMBcdV4SsQJYcSjiHhR2o0dLGTdgOpQrXTHPX4GJF
+LlEWLhAAV9wx2mM/2kHDWB4uZwThtT9/v+RFoW1WbVO/d3lhI9fg4/73/DWAH/7/
+afMRc7ZOVoAmVCESotPx4khCHoE97RdY/JtkLTzc3+peqmL53AbYXrg9rTN1B+ZV
+U3w4ciQS8Uki87zDYIBjYtaOCyMUTvug25CvdssvUMBoc/Jc0xps6/vAyXrnzlGT
+pZD0Tst8idswfDi613BhAaxJspeY0AErWA59qJ3eGzbiQq5RDWcbJe/Tz5r/6+NN
+DkvNQ7DaEZ6LpeWX0MUq6/QWfrM8yE95XhjyC1d3LYn32lXHUygbgTFWIgLDoOE6
+nBhu34SWtbLAnqYGewaJFxhlYVS9rb/uvYQg70r5X9Sx6alCQPiPyIv39IItezn2
+HF2GRfE91MPZUeDhdqdvvOlSZVM5KnYc1fhamGAwM48gdDDXe8Czu/JEGoANNvC3
+l/Z1p5RtGF4hrel9WpeX9zQq3pvtfVcVIiWuRUwCOSQytXlieRK37sMuYeggvmjV
+VvaCods3mS/panWg9T/D/deIXjhzNJLvyiJg8+3sY5H4yNe0XpbaAc/ySwt9Rcxy
+FzFQ+5pghLSZgR1uV3AhdcnzXBU2GkYhdGKt2tUsH0UeVQ2BXxTlBFsCOh2dWqcj
+y3suIG65bukDAAWidQ4q3S6ZIMpXBhhCj7nwB5jQ7wSlU3U9So0ndr7zxdUILiMm
+chHi3q5apVZnMGcwv2B33rt4nD7HgGEmRKkCelrSrBATY1ut+T4rCDzKDqDs3jpv
+hYIWrlNPTkJyQz3eWly6Db+FJEfdYGadYJusc7/nOxCh/QmUu8Sh3NhKT6TH0bS7
+1AAqd8H+2hJ9I32Dhd2qwAF7PkNe2LGi+P8tbAtepKGim5w65wnsPePMnrfxumsG
+PeDnMrqeCKy+fME7a/MS5kmEBpmD4BMhVC6/OhFVz8gBty1f8yIEZggHNQN2QK7m
+NIrG+PwqW2w8HoxOlAi2Ix4LTPifrdfsH02U7aM1pgo1rZzD4AOzqvzCaK43H2VB
+BHLeTBGoLEUxXA9C+iGbeQlKXkMC00QKkjK5+nvkvnvePFfsrTQIpuyGufD/MoPb
+6fpwsyHZDxhxMN1PJk1b1lPq2Ui4hXpVNOYd4Q6OQz7bwxTMRX9XQromUlKMMgAT
+edX8v2NdM7Ssy1IwHuGVbDEpZdjoeaWZ1iNRV17i/EaJAqwYDQLfsuHBlzZL1ov1
+xkKVJdL8Y3q80oRAzTQDVdzL/rI44LLAfv609YByCnw29feYJY2W6gV0O7ZSw413
+XUkc5CaEbR1LuG8NtnOOPJV4Tb/hNsIDtvVm7Hl5npBKBe4iVgQ2LNuC2eT69d/z
+uvzgjISlumPiO5ivuYe0QtLPuJSc+/Bl8bPL8gcNQEtqkzj7IftHPPZNs+bJC2uY
+bPjq5KoDNAMF6VHuKHwu48MBYpnXDIg3ZenmJwGRULRBhK6324hDS6NJ7ULTBU2M
+TZCHmg89ySLBfCAspVeo63o/R7bs9a7BP9x2h5uwCBogSvkEwhhPKnboVN45bp9c
+-----END RSA PRIVATE KEY-----
\ No newline at end of file

vendor/lcobucci/jwt/test/functional/rsa/encrypted-public.key

+-----BEGIN PUBLIC KEY-----
+MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAwLpbUP8a9yflt5LKUUS3
+NPuRM7yEouPWg0VKeY5AURu4i8bqQ20K5jwfRJ+w05FvlywG4EuxpnpTFTVS2/do
+q3xufzTf/C3KIDOAHEifkdx4140btKxxm4mD9Eu2CQ32adZyScha50KUFlfnAAic
+Hb8wYxjFyWo3PAbGYmCQCn2z97Ab0Ar6NR1e+V9f8EL9Orr2f04puKJfQTZdWVDF
+UJR4w7QZ/CPY0LEsiFLW3QQCNraka1mtrLJwPqreBtDEkj8IoISNkrguu/97RQZz
+miJgBQkVjr6OfqG5WIFr0MzbRZc1/aK9g8ft88nhhQm0E3GqkCxBKTwgA03HtK07
+qQIDAQAB
+-----END PUBLIC KEY-----
\ No newline at end of file

vendor/lcobucci/jwt/test/functional/rsa/private.key

+-----BEGIN PRIVATE KEY-----
+MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQDTvwE87MtgREYL
+TL4aHhQo3ZzogmxxvMUsKnPzyxRs1YrXOSOpwN0npsXarBKKVIUMNLfFODp/vnQn
+2Zp06N8XG59WAOKwvC4MfxLDQkA+JXggzHlkbVoTN+dUkdYIFqSKuAPGwiWToRK2
+SxEhij3rE2FON8jQZvDxZkiP9a4vxJO3OTPQwKredXFiObsXD/c3RtLFhKctjCyH
+OIrP0bQEsee/m7JNtG4ry6BPusN6wb+vJo5ieBYPa3c19akNq6q/nYWhplhkkJSu
+aOrL5xXEFzI5TvcvnXR568GVcxK8YLfFkdxpsXGt5rAbeh0h/U5kILEAqv8P9PGT
+ZpicKbrnAgMBAAECggEAd3yTQEQHR91/ASVfKPHMQns77eCbPVtekFusbugsMHYY
+EPdHbqVMpvFvOMRc+f5Tzd15ziq6qBdbCJm8lThLm4iU0z1QrpaiDZ8vgUvDYM5Y
+CXoZDli+uZWUTp60/n94fmb0ipZIChScsI2PrzOJWTvobvD/uso8MJydWc8zafQm
+uqYzygOfjFZvU4lSfgzpefhpquy0JUy5TiKRmGUnwLb3TtcsVavjsn4QmNwLYgOF
+2OE+R12ex3pAKTiRE6FcnE1xFIo1GKhBa2Otgw3MDO6Gg+kn8Q4alKz6C6RRlgaH
+R7sYzEfJhsk/GGFTYOzXKQz2lSaStKt9wKCor04RcQKBgQDzPOu5jCTfayUo7xY2
+jHtiogHyKLLObt9l3qbwgXnaD6rnxYNvCrA0OMvT+iZXsFZKJkYzJr8ZOxOpPROk
+10WdOaefiwUyL5dypueSwlIDwVm+hI4Bs82MajHtzOozh+73wA+aw5rPs84Uix9w
+VbbwaVR6qP/BV09yJYS5kQ7fmwKBgQDe2xjywX2d2MC+qzRr+LfU+1+gq0jjhBCX
+WHqRN6IECB0xTnXUf9WL/VCoI1/55BhdbbEja+4btYgcXSPmlXBIRKQ4VtFfVmYB
+kPXeD8oZ7LyuNdCsbKNe+x1IHXDe6Wfs3L9ulCfXxeIE84wy3fd66mQahyXV9iD9
+CkuifMqUpQKBgQCiydHlY1LGJ/o9tA2Ewm5Na6mrvOs2V2Ox1NqbObwoYbX62eiF
+53xX5u8bVl5U75JAm+79it/4bd5RtKux9dUETbLOhwcaOFm+hM+VG/IxyzRZ2nMD
+1qcpY2U5BpxzknUvYF3RMTop6edxPk7zKpp9ubCtSu+oINvtxAhY/SkcIwKBgGP1
+upcImyO2GZ5shLL5eNubdSVILwV+M0LveOqyHYXZbd6z5r5OKKcGFKuWUnJwEU22
+6gGNY9wh7M9sJ7JBzX9c6pwqtPcidda2AtJ8GpbOTUOG9/afNBhiYpv6OKqD3w2r
+ZmJfKg/qvpqh83zNezgy8nvDqwDxyZI2j/5uIx/RAoGBAMWRmxtv6H2cKhibI/aI
+MTJM4QRjyPNxQqvAQsv+oHUbid06VK3JE+9iQyithjcfNOwnCaoO7I7qAj9QEfJS
+MZQc/W/4DHJebo2kd11yoXPVTXXOuEwLSKCejBXABBY0MPNuPUmiXeU0O3Tyi37J
+TUKzrgcd7NvlA41Y4xKcOqEA
+-----END PRIVATE KEY-----
\ No newline at end of file

vendor/lcobucci/jwt/test/functional/rsa/public.key

+-----BEGIN PUBLIC KEY-----
+MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA078BPOzLYERGC0y+Gh4U
+KN2c6IJscbzFLCpz88sUbNWK1zkjqcDdJ6bF2qwSilSFDDS3xTg6f750J9madOjf
+FxufVgDisLwuDH8Sw0JAPiV4IMx5ZG1aEzfnVJHWCBakirgDxsIlk6EStksRIYo9
+6xNhTjfI0Gbw8WZIj/WuL8STtzkz0MCq3nVxYjm7Fw/3N0bSxYSnLYwshziKz9G0
+BLHnv5uyTbRuK8ugT7rDesG/ryaOYngWD2t3NfWpDauqv52FoaZYZJCUrmjqy+cV
+xBcyOU73L510eevBlXMSvGC3xZHcabFxreawG3odIf1OZCCxAKr/D/Txk2aYnCm6
+5wIDAQAB
+-----END PUBLIC KEY-----
\ No newline at end of file

vendor/lcobucci/jwt/test/unit/Claim/BasicTest.php

+<?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\Claim;
+
+/**
+ * @author Luís Otávio Cobucci Oblonczyk <lcobucci@gmail.com>
+ * @since 2.0.0
+ */
+class BasicTest extends \PHPUnit_Framework_TestCase
+{
+    /**
+     * @test
+     *
+     * @covers Lcobucci\JWT\Claim\Basic::__construct
+     */
+    public function constructorShouldConfigureTheAttributes()
+    {
+        $claim = new Basic('test', 1);
+
+        $this->assertAttributeEquals('test', 'name', $claim);
+        $this->assertAttributeEquals(1, 'value', $claim);
+    }
+
+    /**
+     * @test
+     *
+     * @uses Lcobucci\JWT\Claim\Basic::__construct
+     *
+     * @covers Lcobucci\JWT\Claim\Basic::getName
+     */
+    public function getNameShouldReturnTheClaimName()
+    {
+        $claim = new Basic('test', 1);
+
+        $this->assertEquals('test', $claim->getName());
+    }
+
+    /**
+     * @test
+     *
+     * @uses Lcobucci\JWT\Claim\Basic::__construct
+     *
+     * @covers Lcobucci\JWT\Claim\Basic::getValue
+     */
+    public function getValueShouldReturnTheClaimValue()
+    {
+        $claim = new Basic('test', 1);
+
+        $this->assertEquals(1, $claim->getValue());
+    }
+
+    /**
+     * @test
+     *
+     * @uses Lcobucci\JWT\Claim\Basic::__construct
+     *
+     * @covers Lcobucci\JWT\Claim\Basic::jsonSerialize
+     */
+    public function jsonSerializeShouldReturnTheClaimValue()
+    {
+        $claim = new Basic('test', 1);
+
+        $this->assertEquals(1, $claim->jsonSerialize());
+    }
+
+    /**
+     * @test
+     *
+     * @uses Lcobucci\JWT\Claim\Basic::__construct
+     *
+     * @covers Lcobucci\JWT\Claim\Basic::__toString
+     */
+    public function toStringShouldReturnTheClaimValue()
+    {
+        $claim = new Basic('test', 1);
+
+        $this->assertEquals('1', (string) $claim);
+    }
+}

vendor/lcobucci/jwt/test/unit/Claim/EqualsToTest.php

+<?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\Claim;
+
+use Lcobucci\JWT\ValidationData;
+
+/**
+ * @author Luís Otávio Cobucci Oblonczyk <lcobucci@gmail.com>
+ * @since 2.0.0
+ */
+class EqualsToTest extends \PHPUnit_Framework_TestCase
+{
+    /**
+     * @test
+     *
+     * @uses Lcobucci\JWT\Claim\Basic::__construct
+     * @uses Lcobucci\JWT\Claim\Basic::getName
+     * @uses Lcobucci\JWT\ValidationData::__construct
+     * @uses Lcobucci\JWT\ValidationData::has
+     *
+     * @covers Lcobucci\JWT\Claim\EqualsTo::validate
+     */
+    public function validateShouldReturnTrueWhenValidationDontHaveTheClaim()
+    {
+        $claim = new EqualsTo('iss', 'test');
+
+        $this->assertTrue($claim->validate(new ValidationData()));
+    }
+
+    /**
+     * @test
+     *
+     * @uses Lcobucci\JWT\Claim\Basic::__construct
+     * @uses Lcobucci\JWT\Claim\Basic::getName
+     * @uses Lcobucci\JWT\Claim\Basic::getValue
+     * @uses Lcobucci\JWT\ValidationData::__construct
+     * @uses Lcobucci\JWT\ValidationData::setIssuer
+     * @uses Lcobucci\JWT\ValidationData::has
+     * @uses Lcobucci\JWT\ValidationData::get
+     *
+     * @covers Lcobucci\JWT\Claim\EqualsTo::validate
+     */
+    public function validateShouldReturnTrueWhenValueIsEqualsToValidationData()
+    {
+        $claim = new EqualsTo('iss', 'test');
+
+        $data = new ValidationData();
+        $data->setIssuer('test');
+
+        $this->assertTrue($claim->validate($data));
+    }
+
+    /**
+     * @test
+     *
+     * @uses Lcobucci\JWT\Claim\Basic::__construct
+     * @uses Lcobucci\JWT\Claim\Basic::getName
+     * @uses Lcobucci\JWT\Claim\Basic::getValue
+     * @uses Lcobucci\JWT\ValidationData::__construct
+     * @uses Lcobucci\JWT\ValidationData::setIssuer
+     * @uses Lcobucci\JWT\ValidationData::has
+     * @uses Lcobucci\JWT\ValidationData::get
+     *
+     * @covers Lcobucci\JWT\Claim\EqualsTo::validate
+     */
+    public function validateShouldReturnFalseWhenValueIsNotEqualsToValidationData()
+    {
+        $claim = new EqualsTo('iss', 'test');
+
+        $data = new ValidationData();
+        $data->setIssuer('test1');
+
+        $this->assertFalse($claim->validate($data));
+    }
+}

vendor/lcobucci/jwt/test/unit/Claim/FactoryTest.php

+<?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\Claim;
+
+/**
+ * @author Luís Otávio Cobucci Oblonczyk <lcobucci@gmail.com>
+ * @since 2.0.0
+ */
+class FactoryTest extends \PHPUnit_Framework_TestCase
+{
+    /**
+     * @test
+     *
+     * @covers Lcobucci\JWT\Claim\Factory::__construct
+     */
+    public function constructMustConfigureTheCallbacks()
+    {
+        $callback = function () {
+        };
+        $factory = new Factory(['test' => $callback]);
+
+        $expected = [
+            'iat' => [$factory, 'createLesserOrEqualsTo'],
+            'nbf' => [$factory, 'createLesserOrEqualsTo'],
+            'exp' => [$factory, 'createGreaterOrEqualsTo'],
+            'iss' => [$factory, 'createEqualsTo'],
+            'aud' => [$factory, 'createEqualsTo'],
+            'sub' => [$factory, 'createEqualsTo'],
+            'jti' => [$factory, 'createEqualsTo'],
+            'test' => $callback
+        ];
+
+        $this->assertAttributeEquals($expected, 'callbacks', $factory);
+    }
+
+    /**
+     * @test
+     *
+     * @uses Lcobucci\JWT\Claim\Factory::__construct
+     * @uses Lcobucci\JWT\Claim\Basic::__construct
+     *
+     * @covers Lcobucci\JWT\Claim\Factory::create
+     * @covers Lcobucci\JWT\Claim\Factory::createLesserOrEqualsTo
+     */
+    public function createShouldReturnALesserOrEqualsToClaimForIssuedAt()
+    {
+        $claim = new Factory();
+
+        $this->assertInstanceOf(LesserOrEqualsTo::class, $claim->create('iat', 1));
+    }
+
+    /**
+     * @test
+     *
+     * @uses Lcobucci\JWT\Claim\Factory::__construct
+     * @uses Lcobucci\JWT\Claim\Basic::__construct
+     *
+     * @covers Lcobucci\JWT\Claim\Factory::create
+     * @covers Lcobucci\JWT\Claim\Factory::createLesserOrEqualsTo
+     */
+    public function createShouldReturnALesserOrEqualsToClaimForNotBefore()
+    {
+        $claim = new Factory();
+
+        $this->assertInstanceOf(LesserOrEqualsTo::class, $claim->create('nbf', 1));
+    }
+
+    /**
+     * @test
+     *
+     * @uses Lcobucci\JWT\Claim\Factory::__construct
+     * @uses Lcobucci\JWT\Claim\Basic::__construct
+     *
+     * @covers Lcobucci\JWT\Claim\Factory::create
+     * @covers Lcobucci\JWT\Claim\Factory::createGreaterOrEqualsTo
+     */
+    public function createShouldReturnAGreaterOrEqualsToClaimForExpiration()
+    {
+        $claim = new Factory();
+
+        $this->assertInstanceOf(GreaterOrEqualsTo::class, $claim->create('exp', 1));
+    }
+
+    /**
+     * @test
+     *
+     * @uses Lcobucci\JWT\Claim\Factory::__construct
+     * @uses Lcobucci\JWT\Claim\Basic::__construct
+     *
+     * @covers Lcobucci\JWT\Claim\Factory::create
+     * @covers Lcobucci\JWT\Claim\Factory::createEqualsTo
+     */
+    public function createShouldReturnAnEqualsToClaimForId()
+    {
+        $claim = new Factory();
+
+        $this->assertInstanceOf(EqualsTo::class, $claim->create('jti', 1));
+    }
+
+    /**
+     * @test
+     *
+     * @uses Lcobucci\JWT\Claim\Factory::__construct
+     * @uses Lcobucci\JWT\Claim\Basic::__construct
+     *
+     * @covers Lcobucci\JWT\Claim\Factory::create
+     * @covers Lcobucci\JWT\Claim\Factory::createEqualsTo
+     */
+    public function createShouldReturnAnEqualsToClaimForIssuer()
+    {
+        $claim = new Factory();
+
+        $this->assertInstanceOf(EqualsTo::class, $claim->create('iss', 1));
+    }
+
+    /**
+     * @test
+     *
+     * @uses Lcobucci\JWT\Claim\Factory::__construct
+     * @uses Lcobucci\JWT\Claim\Basic::__construct
+     *
+     * @covers Lcobucci\JWT\Claim\Factory::create
+     * @covers Lcobucci\JWT\Claim\Factory::createEqualsTo
+     */
+    public function createShouldReturnAnEqualsToClaimForAudience()
+    {
+        $claim = new Factory();
+
+        $this->assertInstanceOf(EqualsTo::class, $claim->create('aud', 1));
+    }
+
+    /**
+     * @test
+     *
+     * @uses Lcobucci\JWT\Claim\Factory::__construct
+     * @uses Lcobucci\JWT\Claim\Basic::__construct
+     *
+     * @covers Lcobucci\JWT\Claim\Factory::create
+     * @covers Lcobucci\JWT\Claim\Factory::createEqualsTo
+     */
+    public function createShouldReturnAnEqualsToClaimForSubject()
+    {
+        $claim = new Factory();
+
+        $this->assertInstanceOf(EqualsTo::class, $claim->create('sub', 1));
+    }
+
+    /**
+     * @test
+     *
+     * @uses Lcobucci\JWT\Claim\Factory::__construct
+     * @uses Lcobucci\JWT\Claim\Basic::__construct
+     *
+     * @covers Lcobucci\JWT\Claim\Factory::create
+     * @covers Lcobucci\JWT\Claim\Factory::createBasic
+     */
+    public function createShouldReturnABasiclaimForOtherClaims()
+    {
+        $claim = new Factory();
+
+        $this->assertInstanceOf(Basic::class, $claim->create('test', 1));
+    }
+}

vendor/lcobucci/jwt/test/unit/Claim/GreaterOrEqualsToTest.php

+<?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\Claim;
+
+use Lcobucci\JWT\ValidationData;
+
+/**
+ * @author Luís Otávio Cobucci Oblonczyk <lcobucci@gmail.com>
+ * @since 2.0.0
+ */
+class GreaterOrEqualsToTest extends \PHPUnit_Framework_TestCase
+{
+    /**
+     * @test
+     *
+     * @uses Lcobucci\JWT\Claim\Basic::__construct
+     * @uses Lcobucci\JWT\Claim\Basic::getName
+     * @uses Lcobucci\JWT\ValidationData::__construct
+     * @uses Lcobucci\JWT\ValidationData::has
+     *
+     * @covers Lcobucci\JWT\Claim\GreaterOrEqualsTo::validate
+     */
+    public function validateShouldReturnTrueWhenValidationDontHaveTheClaim()
+    {
+        $claim = new GreaterOrEqualsTo('iss', 10);
+
+        $this->assertTrue($claim->validate(new ValidationData()));
+    }
+
+    /**
+     * @test
+     *
+     * @uses Lcobucci\JWT\Claim\Basic::__construct
+     * @uses Lcobucci\JWT\Claim\Basic::getName
+     * @uses Lcobucci\JWT\Claim\Basic::getValue
+     * @uses Lcobucci\JWT\ValidationData::__construct
+     * @uses Lcobucci\JWT\ValidationData::setIssuer
+     * @uses Lcobucci\JWT\ValidationData::has
+     * @uses Lcobucci\JWT\ValidationData::get
+     *
+     * @covers Lcobucci\JWT\Claim\GreaterOrEqualsTo::validate
+     */
+    public function validateShouldReturnTrueWhenValueIsGreaterThanValidationData()
+    {
+        $claim = new GreaterOrEqualsTo('iss', 11);
+
+        $data = new ValidationData();
+        $data->setIssuer(10);
+
+        $this->assertTrue($claim->validate($data));
+    }
+
+    /**
+     * @test
+     *
+     * @uses Lcobucci\JWT\Claim\Basic::__construct
+     * @uses Lcobucci\JWT\Claim\Basic::getName
+     * @uses Lcobucci\JWT\Claim\Basic::getValue
+     * @uses Lcobucci\JWT\ValidationData::__construct
+     * @uses Lcobucci\JWT\ValidationData::setIssuer
+     * @uses Lcobucci\JWT\ValidationData::has
+     * @uses Lcobucci\JWT\ValidationData::get
+     *
+     * @covers Lcobucci\JWT\Claim\GreaterOrEqualsTo::validate
+     */
+    public function validateShouldReturnTrueWhenValueIsEqualsToValidationData()
+    {
+        $claim = new GreaterOrEqualsTo('iss', 10);
+
+        $data = new ValidationData();
+        $data->setIssuer(10);
+
+        $this->assertTrue($claim->validate($data));
+    }
+
+    /**
+     * @test
+     *
+     * @uses Lcobucci\JWT\Claim\Basic::__construct
+     * @uses Lcobucci\JWT\Claim\Basic::getName
+     * @uses Lcobucci\JWT\Claim\Basic::getValue
+     * @uses Lcobucci\JWT\ValidationData::__construct
+     * @uses Lcobucci\JWT\ValidationData::setIssuer
+     * @uses Lcobucci\JWT\ValidationData::has
+     * @uses Lcobucci\JWT\ValidationData::get
+     *
+     * @covers Lcobucci\JWT\Claim\GreaterOrEqualsTo::validate
+     */
+    public function validateShouldReturnFalseWhenValueIsLesserThanValidationData()
+    {
+        $claim = new GreaterOrEqualsTo('iss', 10);
+
+        $data = new ValidationData();
+        $data->setIssuer(11);
+
+        $this->assertFalse($claim->validate($data));
+    }
+}

vendor/lcobucci/jwt/test/unit/Claim/LesserOrEqualsToTest.php

+<?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\Claim;
+
+use Lcobucci\JWT\ValidationData;
+
+/**
+ * @author Luís Otávio Cobucci Oblonczyk <lcobucci@gmail.com>
+ * @since 2.0.0
+ */
+class LesserOrEqualsToTest extends \PHPUnit_Framework_TestCase
+{
+    /**
+     * @test
+     *
+     * @uses Lcobucci\JWT\Claim\Basic::__construct
+     * @uses Lcobucci\JWT\Claim\Basic::getName
+     * @uses Lcobucci\JWT\ValidationData::__construct
+     * @uses Lcobucci\JWT\ValidationData::has
+     *
+     * @covers Lcobucci\JWT\Claim\LesserOrEqualsTo::validate
+     */
+    public function validateShouldReturnTrueWhenValidationDontHaveTheClaim()
+    {
+        $claim = new LesserOrEqualsTo('iss', 10);
+
+        $this->assertTrue($claim->validate(new ValidationData()));
+    }
+
+    /**
+     * @test
+     *
+     * @uses Lcobucci\JWT\Claim\Basic::__construct
+     * @uses Lcobucci\JWT\Claim\Basic::getName
+     * @uses Lcobucci\JWT\Claim\Basic::getValue
+     * @uses Lcobucci\JWT\ValidationData::__construct
+     * @uses Lcobucci\JWT\ValidationData::setIssuer
+     * @uses Lcobucci\JWT\ValidationData::has
+     * @uses Lcobucci\JWT\ValidationData::get
+     *
+     * @covers Lcobucci\JWT\Claim\LesserOrEqualsTo::validate
+     */
+    public function validateShouldReturnTrueWhenValueIsLesserThanValidationData()
+    {
+        $claim = new LesserOrEqualsTo('iss', 10);
+
+        $data = new ValidationData();
+        $data->setIssuer(11);
+
+        $this->assertTrue($claim->validate($data));
+    }
+
+    /**
+     * @test
+     *
+     * @uses Lcobucci\JWT\Claim\Basic::__construct
+     * @uses Lcobucci\JWT\Claim\Basic::getName
+     * @uses Lcobucci\JWT\Claim\Basic::getValue
+     * @uses Lcobucci\JWT\ValidationData::__construct
+     * @uses Lcobucci\JWT\ValidationData::setIssuer
+     * @uses Lcobucci\JWT\ValidationData::has
+     * @uses Lcobucci\JWT\ValidationData::get
+     *
+     * @covers Lcobucci\JWT\Claim\LesserOrEqualsTo::validate
+     */
+    public function validateShouldReturnTrueWhenValueIsEqualsToValidationData()
+    {
+        $claim = new LesserOrEqualsTo('iss', 10);
+
+        $data = new ValidationData();
+        $data->setIssuer(10);
+
+        $this->assertTrue($claim->validate($data));
+    }
+
+    /**
+     * @test
+     *
+     * @uses Lcobucci\JWT\Claim\Basic::__construct
+     * @uses Lcobucci\JWT\Claim\Basic::getName
+     * @uses Lcobucci\JWT\Claim\Basic::getValue
+     * @uses Lcobucci\JWT\ValidationData::__construct
+     * @uses Lcobucci\JWT\ValidationData::setIssuer
+     * @uses Lcobucci\JWT\ValidationData::has
+     * @uses Lcobucci\JWT\ValidationData::get
+     *
+     * @covers Lcobucci\JWT\Claim\LesserOrEqualsTo::validate
+     */
+    public function validateShouldReturnFalseWhenValueIsGreaterThanValidationData()
+    {
+        $claim = new LesserOrEqualsTo('iss', 11);
+
+        $data = new ValidationData();
+        $data->setIssuer(10);
+
+        $this->assertFalse($claim->validate($data));
+    }
+}

vendor/lcobucci/jwt/test/unit/ParserTest.php

+<?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 Lcobucci\JWT\Claim\Factory as ClaimFactory;
+use Lcobucci\JWT\Parsing\Decoder;
+use RuntimeException;
+
+/**
+ * @author Luís Otávio Cobucci Oblonczyk <lcobucci@gmail.com>
+ * @since 0.1.0
+ */
+class ParserTest extends \PHPUnit_Framework_TestCase
+{
+    /**
+     * @var Decoder|\PHPUnit_Framework_MockObject_MockObject
+     */
+    protected $decoder;
+
+    /**
+     * @var ClaimFactory|\PHPUnit_Framework_MockObject_MockObject
+     */
+    protected $claimFactory;
+
+    /**
+     * @var Claim|\PHPUnit_Framework_MockObject_MockObject
+     */
+    protected $defaultClaim;
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function setUp()
+    {
+        $this->decoder = $this->getMock(Decoder::class);
+        $this->claimFactory = $this->getMock(ClaimFactory::class, [], [], '', false);
+        $this->defaultClaim = $this->getMock(Claim::class);
+
+        $this->claimFactory->expects($this->any())
+                           ->method('create')
+                           ->willReturn($this->defaultClaim);
+    }
+
+    /**
+     * @return Parser
+     */
+    private function createParser()
+    {
+        return new Parser($this->decoder, $this->claimFactory);
+    }
+
+    /**
+     * @test
+     *
+     * @covers Lcobucci\JWT\Parser::__construct
+     */
+    public function constructMustConfigureTheAttributes()
+    {
+        $parser = $this->createParser();
+
+        $this->assertAttributeSame($this->decoder, 'decoder', $parser);
+        $this->assertAttributeSame($this->claimFactory, 'claimFactory', $parser);
+    }
+
+    /**
+     * @test
+     *
+     * @uses Lcobucci\JWT\Parser::__construct
+     *
+     * @covers Lcobucci\JWT\Parser::parse
+     * @covers Lcobucci\JWT\Parser::splitJwt
+     *
+     * @expectedException InvalidArgumentException
+     */
+    public function parseMustRaiseExceptionWhenJWSIsNotAString()
+    {
+        $parser = $this->createParser();
+        $parser->parse(['asdasd']);
+    }
+
+    /**
+     * @test
+     *
+     * @uses Lcobucci\JWT\Parser::__construct
+     *
+     * @covers Lcobucci\JWT\Parser::parse
+     * @covers Lcobucci\JWT\Parser::splitJwt
+     *
+     * @expectedException InvalidArgumentException
+     */
+    public function parseMustRaiseExceptionWhenJWSDontHaveThreeParts()
+    {
+        $parser = $this->createParser();
+        $parser->parse('');
+    }
+
+    /**
+     * @test
+     *
+     * @uses Lcobucci\JWT\Parser::__construct
+     *
+     * @covers Lcobucci\JWT\Parser::parse
+     * @covers Lcobucci\JWT\Parser::splitJwt
+     * @covers Lcobucci\JWT\Parser::parseHeader
+     *
+     * @expectedException RuntimeException
+     */
+    public function parseMustRaiseExceptionWhenHeaderCannotBeDecoded()
+    {
+        $this->decoder->expects($this->any())
+                      ->method('jsonDecode')
+                      ->willThrowException(new RuntimeException());
+
+        $parser = $this->createParser();
+        $parser->parse('asdfad.asdfasdf.');
+    }
+
+    /**
+     * @test
+     *
+     * @uses Lcobucci\JWT\Parser::__construct
+     *
+     * @covers Lcobucci\JWT\Parser::parse
+     * @covers Lcobucci\JWT\Parser::splitJwt
+     * @covers Lcobucci\JWT\Parser::parseHeader
+     *
+     * @expectedException InvalidArgumentException
+     */
+    public function parseMustRaiseExceptionWhenHeaderIsFromAnEncryptedToken()
+    {
+        $this->decoder->expects($this->any())
+                      ->method('jsonDecode')
+                      ->willReturn(['enc' => 'AAA']);
+
+        $parser = $this->createParser();
+        $parser->parse('a.a.');
+    }
+
+    /**
+     * @test
+     *
+     * @uses Lcobucci\JWT\Parser::__construct
+     * @uses Lcobucci\JWT\Token::__construct
+     *
+     * @covers Lcobucci\JWT\Parser::parse
+     * @covers Lcobucci\JWT\Parser::splitJwt
+     * @covers Lcobucci\JWT\Parser::parseHeader
+     * @covers Lcobucci\JWT\Parser::parseClaims
+     * @covers Lcobucci\JWT\Parser::parseSignature
+     *
+     */
+    public function parseMustReturnANonSignedTokenWhenSignatureIsNotInformed()
+    {
+        $this->decoder->expects($this->at(1))
+                      ->method('jsonDecode')
+                      ->willReturn(['typ' => 'JWT', 'alg' => 'none']);
+
+        $this->decoder->expects($this->at(3))
+                      ->method('jsonDecode')
+                      ->willReturn(['aud' => 'test']);
+
+        $parser = $this->createParser();
+        $token = $parser->parse('a.a.');
+
+        $this->assertAttributeEquals(['typ' => 'JWT', 'alg' => 'none'], 'headers', $token);
+        $this->assertAttributeEquals(['aud' => $this->defaultClaim], 'claims', $token);
+        $this->assertAttributeEquals(null, 'signature', $token);
+    }
+
+    /**
+     * @test
+     *
+     * @uses Lcobucci\JWT\Parser::__construct
+     * @uses Lcobucci\JWT\Token::__construct
+     *
+     * @covers Lcobucci\JWT\Parser::parse
+     * @covers Lcobucci\JWT\Parser::splitJwt
+     * @covers Lcobucci\JWT\Parser::parseHeader
+     * @covers Lcobucci\JWT\Parser::parseClaims
+     * @covers Lcobucci\JWT\Parser::parseSignature
+     */
+    public function parseShouldReplicateClaimValueOnHeaderWhenNeeded()
+    {
+        $this->decoder->expects($this->at(1))
+                      ->method('jsonDecode')
+                      ->willReturn(['typ' => 'JWT', 'alg' => 'none', 'aud' => 'test']);
+
+        $this->decoder->expects($this->at(3))
+                      ->method('jsonDecode')
+                      ->willReturn(['aud' => 'test']);
+
+        $parser = $this->createParser();
+        $token = $parser->parse('a.a.');
+
+        $this->assertAttributeEquals(
+            ['typ' => 'JWT', 'alg' => 'none', 'aud' => $this->defaultClaim],
+            'headers',
+            $token
+        );
+
+        $this->assertAttributeEquals(['aud' => $this->defaultClaim], 'claims', $token);
+        $this->assertAttributeEquals(null, 'signature', $token);
+    }
+
+    /**
+     * @test
+     *
+     * @uses Lcobucci\JWT\Parser::__construct
+     * @uses Lcobucci\JWT\Token::__construct
+     * @uses Lcobucci\JWT\Signature::__construct
+     *
+     * @covers Lcobucci\JWT\Parser::parse
+     * @covers Lcobucci\JWT\Parser::splitJwt
+     * @covers Lcobucci\JWT\Parser::parseHeader
+     * @covers Lcobucci\JWT\Parser::parseClaims
+     * @covers Lcobucci\JWT\Parser::parseSignature
+     */
+    public function parseMustReturnASignedTokenWhenSignatureIsInformed()
+    {
+        $this->decoder->expects($this->at(1))
+                      ->method('jsonDecode')
+                      ->willReturn(['typ' => 'JWT', 'alg' => 'HS256']);
+
+        $this->decoder->expects($this->at(3))
+                      ->method('jsonDecode')
+                      ->willReturn(['aud' => 'test']);
+
+        $this->decoder->expects($this->at(4))
+                      ->method('base64UrlDecode')
+                      ->willReturn('aaa');
+
+        $parser = $this->createParser();
+        $token = $parser->parse('a.a.a');
+
+        $this->assertAttributeEquals(['typ' => 'JWT', 'alg' => 'HS256'], 'headers', $token);
+        $this->assertAttributeEquals(['aud' => $this->defaultClaim], 'claims', $token);
+        $this->assertAttributeEquals(new Signature('aaa'), 'signature', $token);
+    }
+}

vendor/lcobucci/jwt/test/unit/Parsing/DecoderTest.php

+<?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\Parsing;
+
+/**
+ * @author Luís Otávio Cobucci Oblonczyk <lcobucci@gmail.com>
+ * @since 0.1.0
+ */
+class DecoderTest extends \PHPUnit_Framework_TestCase
+{
+    /**
+     * @test
+     *
+     * @covers Lcobucci\JWT\Parsing\Decoder::jsonDecode
+     */
+    public function jsonDecodeMustReturnTheDecodedData()
+    {
+        $decoder = new Decoder();
+
+        $this->assertEquals(
+            (object) ['test' => 'test'],
+            $decoder->jsonDecode('{"test":"test"}')
+        );
+    }
+
+    /**
+     * @test
+     *
+     * @covers Lcobucci\JWT\Parsing\Decoder::jsonDecode
+     *
+     * @expectedException \RuntimeException
+     */
+    public function jsonDecodeMustRaiseExceptionWhenAnErrorHasOccured()
+    {
+        $decoder = new Decoder();
+        $decoder->jsonDecode('{"test":\'test\'}');
+    }
+
+    /**
+     * @test
+     *
+     * @covers Lcobucci\JWT\Parsing\Decoder::base64UrlDecode
+     */
+    public function base64UrlDecodeMustReturnTheRightData()
+    {
+        $data = base64_decode('0MB2wKB+L3yvIdzeggmJ+5WOSLaRLTUPXbpzqUe0yuo=');
+
+        $decoder = new Decoder();
+        $this->assertEquals($data, $decoder->base64UrlDecode('0MB2wKB-L3yvIdzeggmJ-5WOSLaRLTUPXbpzqUe0yuo'));
+    }
+}

vendor/lcobucci/jwt/test/unit/Parsing/EncoderTest.php

+<?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\Parsing;
+
+/**
+ * @author Luís Otávio Cobucci Oblonczyk <lcobucci@gmail.com>
+ * @since 0.1.0
+ */
+class EncoderTest extends \PHPUnit_Framework_TestCase
+{
+    /**
+     * @test
+     *
+     * @covers Lcobucci\JWT\Parsing\Encoder::jsonEncode
+     */
+    public function jsonEncodeMustReturnAJSONString()
+    {
+        $encoder = new Encoder();
+
+        $this->assertEquals('{"test":"test"}', $encoder->jsonEncode(['test' => 'test']));
+    }
+
+    /**
+     * @test
+     *
+     * @covers Lcobucci\JWT\Parsing\Encoder::jsonEncode
+     *
+     * @expectedException \RuntimeException
+     */
+    public function jsonEncodeMustRaiseExceptionWhenAnErrorHasOccured()
+    {
+        $encoder = new Encoder();
+        $encoder->jsonEncode("\xB1\x31");
+    }
+
+    /**
+     * @test
+     *
+     * @covers Lcobucci\JWT\Parsing\Encoder::base64UrlEncode
+     */
+    public function base64UrlEncodeMustReturnAnUrlSafeBase64()
+    {
+        $data = base64_decode('0MB2wKB+L3yvIdzeggmJ+5WOSLaRLTUPXbpzqUe0yuo=');
+
+        $encoder = new Encoder();
+        $this->assertEquals('0MB2wKB-L3yvIdzeggmJ-5WOSLaRLTUPXbpzqUe0yuo', $encoder->base64UrlEncode($data));
+    }
+}

vendor/lcobucci/jwt/test/unit/SignatureTest.php

+<?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;
+
+/**
+ * @author Luís Otávio Cobucci Oblonczyk <lcobucci@gmail.com>
+ * @since 0.1.0
+ */
+class SignatureTest extends \PHPUnit_Framework_TestCase
+{
+    /**
+     * @var Signer|\PHPUnit_Framework_MockObject_MockObject
+     */
+    protected $signer;
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function setUp()
+    {
+        $this->signer = $this->getMock(Signer::class);
+    }
+
+    /**
+     * @test
+     *
+     * @covers Lcobucci\JWT\Signature::__construct
+     */
+    public function constructorMustConfigureAttributes()
+    {
+        $signature = new Signature('test');
+
+        $this->assertAttributeEquals('test', 'hash', $signature);
+    }
+
+    /**
+     * @test
+     *
+     * @uses Lcobucci\JWT\Signature::__construct
+     *
+     * @covers Lcobucci\JWT\Signature::__toString
+     */
+    public function toStringMustReturnTheHash()
+    {
+        $signature = new Signature('test');
+
+        $this->assertEquals('test', (string) $signature);
+    }
+
+    /**
+     * @test
+     *
+     * @uses Lcobucci\JWT\Signature::__construct
+     * @uses Lcobucci\JWT\Signature::__toString
+     *
+     * @covers Lcobucci\JWT\Signature::verify
+     */
+    public function verifyMustReturnWhatSignerSays()
+    {
+        $this->signer->expects($this->any())
+                     ->method('verify')
+                     ->willReturn(true);
+
+        $signature = new Signature('test');
+
+        $this->assertTrue($signature->verify($this->signer, 'one', 'key'));
+    }
+}

vendor/lcobucci/jwt/test/unit/Signer/BaseSignerTest.php

+<?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\Signer;
+
+use Lcobucci\JWT\Signature;
+
+/**
+ * @author Luís Otávio Cobucci Oblonczyk <lcobucci@gmail.com>
+ * @since 0.1.0
+ */
+class BaseSignerTest extends \PHPUnit_Framework_TestCase
+{
+    /**
+     * @var BaseSigner|\PHPUnit_Framework_MockObject_MockObject
+     */
+    protected $signer;
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function setUp()
+    {
+        $this->signer = $this->getMockForAbstractClass(BaseSigner::class);
+
+        $this->signer->method('getAlgorithmId')
+                     ->willReturn('TEST123');
+    }
+
+    /**
+     * @test
+     *
+     * @covers Lcobucci\JWT\Signer\BaseSigner::modifyHeader
+     */
+    public function modifyHeaderShouldChangeAlgorithm()
+    {
+        $headers = ['typ' => 'JWT'];
+
+        $this->signer->modifyHeader($headers);
+
+        $this->assertEquals($headers['typ'], 'JWT');
+        $this->assertEquals($headers['alg'], 'TEST123');
+    }
+
+    /**
+     * @test
+     *
+     * @uses Lcobucci\JWT\Signature::__construct
+     * @uses Lcobucci\JWT\Signer\Key
+     *
+     * @covers Lcobucci\JWT\Signer\BaseSigner::sign
+     * @covers Lcobucci\JWT\Signer\BaseSigner::getKey
+     */
+    public function signMustReturnANewSignature()
+    {
+        $key = new Key('123');
+
+        $this->signer->expects($this->once())
+                     ->method('createHash')
+                     ->with('test', $key)
+                     ->willReturn('test');
+
+        $this->assertEquals(new Signature('test'), $this->signer->sign('test', $key));
+    }
+
+    /**
+     * @test
+     *
+     * @uses Lcobucci\JWT\Signature::__construct
+     * @uses Lcobucci\JWT\Signer\Key
+     *
+     * @covers Lcobucci\JWT\Signer\BaseSigner::sign
+     * @covers Lcobucci\JWT\Signer\BaseSigner::getKey
+     */
+    public function signShouldConvertKeyWhenItsNotAnObject()
+    {
+        $this->signer->expects($this->once())
+                     ->method('createHash')
+                     ->with('test', new Key('123'))
+                     ->willReturn('test');
+
+        $this->assertEquals(new Signature('test'), $this->signer->sign('test', '123'));
+    }
+
+    /**
+     * @test
+     *
+     * @uses Lcobucci\JWT\Signature::__construct
+     * @uses Lcobucci\JWT\Signer\Key
+     *
+     * @covers Lcobucci\JWT\Signer\BaseSigner::verify
+     * @covers Lcobucci\JWT\Signer\BaseSigner::getKey
+     */
+    public function verifyShouldDelegateTheCallToAbstractMethod()
+    {
+        $key = new Key('123');
+
+        $this->signer->expects($this->once())
+                     ->method('doVerify')
+                     ->with('test', 'test', $key)
+                     ->willReturn(true);
+
+        $this->assertTrue($this->signer->verify('test', 'test', $key));
+    }
+
+    /**
+     * @test
+     *
+     * @uses Lcobucci\JWT\Signature::__construct
+     * @uses Lcobucci\JWT\Signer\Key
+     *
+     * @covers Lcobucci\JWT\Signer\BaseSigner::verify
+     * @covers Lcobucci\JWT\Signer\BaseSigner::getKey
+     */
+    public function verifyShouldConvertKeyWhenItsNotAnObject()
+    {
+        $this->signer->expects($this->once())
+                     ->method('doVerify')
+                     ->with('test', 'test', new Key('123'))
+                     ->willReturn(true);
+
+        $this->assertTrue($this->signer->verify('test', 'test', '123'));
+    }
+}

vendor/lcobucci/jwt/test/unit/Signer/Ecdsa/KeyParserTest.php

+<?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\Signer\Ecdsa;
+
+use Mdanter\Ecc\Crypto\Key\PrivateKeyInterface;
+use Mdanter\Ecc\Crypto\Key\PublicKeyInterface;
+use Mdanter\Ecc\Math\MathAdapterInterface;
+use Mdanter\Ecc\Serializer\PrivateKey\PrivateKeySerializerInterface;
+use Mdanter\Ecc\Serializer\PublicKey\PublicKeySerializerInterface;
+use Lcobucci\JWT\Signer\Key;
+
+/**
+ * @author Luís Otávio Cobucci Oblonczyk <lcobucci@gmail.com>
+ * @since 3.0.4
+ */
+class KeyParserTest extends \PHPUnit_Framework_TestCase
+{
+    /**
+     * @var MathAdapterInterface|\PHPUnit_Framework_MockObject_MockObject
+     */
+    private $adapter;
+
+    /**
+     * @var PrivateKeySerializerInterface|\PHPUnit_Framework_MockObject_MockObject
+     */
+    private $privateKeySerializer;
+
+    /**
+     * @var PublicKeySerializerInterface|\PHPUnit_Framework_MockObject_MockObject
+     */
+    private $publicKeySerializer;
+
+    /**
+     * @before
+     */
+    public function createDependencies()
+    {
+        $this->adapter = $this->getMock(MathAdapterInterface::class);
+        $this->privateKeySerializer = $this->getMock(PrivateKeySerializerInterface::class);
+        $this->publicKeySerializer = $this->getMock(PublicKeySerializerInterface::class);
+    }
+
+    /**
+     * @test
+     *
+     * @covers Lcobucci\JWT\Signer\Ecdsa\KeyParser::__construct
+     */
+    public function constructShouldConfigureDependencies()
+    {
+        $parser = new KeyParser($this->adapter, $this->privateKeySerializer, $this->publicKeySerializer);
+
+        $this->assertAttributeSame($this->privateKeySerializer, 'privateKeySerializer', $parser);
+        $this->assertAttributeSame($this->publicKeySerializer, 'publicKeySerializer', $parser);
+    }
+
+    /**
+     * @test
+     *
+     * @uses Lcobucci\JWT\Signer\Ecdsa\KeyParser::__construct
+     * @uses Lcobucci\JWT\Signer\Key
+     *
+     * @covers Lcobucci\JWT\Signer\Ecdsa\KeyParser::getPrivateKey
+     * @covers Lcobucci\JWT\Signer\Ecdsa\KeyParser::getKeyContent
+     */
+    public function getPrivateKeyShouldAskSerializerToParseTheKey()
+    {
+        $privateKey = $this->getMock(PrivateKeyInterface::class);
+
+        $keyContent = 'MHcCAQEEIBGpMoZJ64MMSzuo5JbmXpf9V4qSWdLIl/8RmJLcfn/qoAoGC'
+                      . 'CqGSM49AwEHoUQDQgAE7it/EKmcv9bfpcV1fBreLMRXxWpnd0wxa2iF'
+                      . 'ruiI2tsEdGFTLTsyU+GeRqC7zN0aTnTQajarUylKJ3UWr/r1kg==';
+
+        $this->privateKeySerializer->expects($this->once())
+                                   ->method('parse')
+                                   ->with($keyContent)
+                                   ->willReturn($privateKey);
+
+        $parser = new KeyParser($this->adapter, $this->privateKeySerializer, $this->publicKeySerializer);
+        $this->assertSame($privateKey, $parser->getPrivateKey($this->getPrivateKey()));
+    }
+
+    /**
+     * @test
+     *
+     * @expectedException \InvalidArgumentException
+     *
+     * @uses Lcobucci\JWT\Signer\Ecdsa\KeyParser::__construct
+     * @uses Lcobucci\JWT\Signer\Key
+     *
+     * @covers Lcobucci\JWT\Signer\Ecdsa\KeyParser::getPrivateKey
+     * @covers Lcobucci\JWT\Signer\Ecdsa\KeyParser::getKeyContent
+     */
+    public function getPrivateKeyShouldRaiseExceptionWhenAWrongKeyWasGiven()
+    {
+        $this->privateKeySerializer->expects($this->never())
+                                   ->method('parse');
+
+        $parser = new KeyParser($this->adapter, $this->privateKeySerializer, $this->publicKeySerializer);
+        $parser->getPrivateKey($this->getPublicKey());
+    }
+
+    /**
+     * @test
+     *
+     * @uses Lcobucci\JWT\Signer\Ecdsa\KeyParser::__construct
+     * @uses Lcobucci\JWT\Signer\Key
+     *
+     * @covers Lcobucci\JWT\Signer\Ecdsa\KeyParser::getPublicKey
+     * @covers Lcobucci\JWT\Signer\Ecdsa\KeyParser::getKeyContent
+     */
+    public function getPublicKeyShouldAskSerializerToParseTheKey()
+    {
+        $publicKey = $this->getMock(PublicKeyInterface::class);
+
+        $keyContent = 'MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE7it/EKmcv9bfpcV1fBreLMRXxWpn'
+                      . 'd0wxa2iFruiI2tsEdGFTLTsyU+GeRqC7zN0aTnTQajarUylKJ3UWr/r1kg==';
+
+        $this->publicKeySerializer->expects($this->once())
+                                  ->method('parse')
+                                  ->with($keyContent)
+                                  ->willReturn($publicKey);
+
+        $parser = new KeyParser($this->adapter, $this->privateKeySerializer, $this->publicKeySerializer);
+        $this->assertSame($publicKey, $parser->getPublicKey($this->getPublicKey()));
+    }
+
+    /**
+     * @test
+     *
+     * @expectedException \InvalidArgumentException
+     *
+     * @uses Lcobucci\JWT\Signer\Ecdsa\KeyParser::__construct
+     * @uses Lcobucci\JWT\Signer\Key
+     *
+     * @covers Lcobucci\JWT\Signer\Ecdsa\KeyParser::getPublicKey
+     * @covers Lcobucci\JWT\Signer\Ecdsa\KeyParser::getKeyContent
+     */
+    public function getPublicKeyShouldRaiseExceptionWhenAWrongKeyWasGiven()
+    {
+        $this->publicKeySerializer->expects($this->never())
+                                  ->method('parse');
+
+        $parser = new KeyParser($this->adapter, $this->privateKeySerializer, $this->publicKeySerializer);
+        $parser->getPublicKey($this->getPrivateKey());
+    }
+
+    /**
+     * @return Key
+     */
+    private function getPrivateKey()
+    {
+        return new Key(
+            "-----BEGIN EC PRIVATE KEY-----\n"
+            . "MHcCAQEEIBGpMoZJ64MMSzuo5JbmXpf9V4qSWdLIl/8RmJLcfn/qoAoGCCqGSM49\n"
+            . "AwEHoUQDQgAE7it/EKmcv9bfpcV1fBreLMRXxWpnd0wxa2iFruiI2tsEdGFTLTsy\n"
+            . "U+GeRqC7zN0aTnTQajarUylKJ3UWr/r1kg==\n"
+            . "-----END EC PRIVATE KEY-----"
+        );
+    }
+
+    /**
+     * @return Key
+     */
+    private function getPublicKey()
+    {
+        return new Key(
+            "-----BEGIN PUBLIC KEY-----\n"
+            . "MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE7it/EKmcv9bfpcV1fBreLMRXxWpn\n"
+            . "d0wxa2iFruiI2tsEdGFTLTsyU+GeRqC7zN0aTnTQajarUylKJ3UWr/r1kg==\n"
+            . "-----END PUBLIC KEY-----"
+        );
+    }
+}

vendor/lcobucci/jwt/test/unit/Signer/Ecdsa/Sha256Test.php

+<?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\Signer\Ecdsa;
+
+/**
+ * @author Luís Otávio Cobucci Oblonczyk <lcobucci@gmail.com>
+ * @since 2.1.0
+ */
+class Sha256Test extends \PHPUnit_Framework_TestCase
+{
+    /**
+     * @test
+     *
+     * @uses Lcobucci\JWT\Signer\Ecdsa
+     * @uses Lcobucci\JWT\Signer\Ecdsa\KeyParser
+     *
+     * @covers Lcobucci\JWT\Signer\Ecdsa\Sha256::getAlgorithmId
+     */
+    public function getAlgorithmIdMustBeCorrect()
+    {
+        $signer = new Sha256();
+
+        $this->assertEquals('ES256', $signer->getAlgorithmId());
+    }
+
+    /**
+     * @test
+     *
+     * @uses Lcobucci\JWT\Signer\Ecdsa
+     * @uses Lcobucci\JWT\Signer\Ecdsa\KeyParser
+     *
+     * @covers Lcobucci\JWT\Signer\Ecdsa\Sha256::getAlgorithm
+     */
+    public function getAlgorithmMustBeCorrect()
+    {
+        $signer = new Sha256();
+
+        $this->assertEquals('sha256', $signer->getAlgorithm());
+    }
+
+    /**
+     * @test
+     *
+     * @uses Lcobucci\JWT\Signer\Ecdsa
+     * @uses Lcobucci\JWT\Signer\Ecdsa\KeyParser
+     *
+     * @covers Lcobucci\JWT\Signer\Ecdsa\Sha256::getSignatureLength
+     */
+    public function getSignatureLengthMustBeCorrect()
+    {
+        $signer = new Sha256();
+
+        $this->assertEquals(64, $signer->getSignatureLength());
+    }
+}