create-prisma-php-app 1.0.0

package/vendor/firebase/php-jwt/tests/JWTTest.php

@@ -0,0 +1,543 @@
+<?php
+
+namespace Firebase\JWT;
+
+use ArrayObject;
+use DomainException;
+use InvalidArgumentException;
+use PHPUnit\Framework\TestCase;
+use stdClass;
+use TypeError;
+use UnexpectedValueException;
+
+class JWTTest extends TestCase
+{
+    public function testUrlSafeCharacters()
+    {
+        $encoded = JWT::encode(['message' => 'f?'], 'a', 'HS256');
+        $expected = new stdClass();
+        $expected->message = 'f?';
+        $this->assertEquals($expected, JWT::decode($encoded, new Key('a', 'HS256')));
+    }
+
+    public function testMalformedUtf8StringsFail()
+    {
+        $this->expectException(DomainException::class);
+        JWT::encode(['message' => pack('c', 128)], 'a', 'HS256');
+    }
+
+    public function testMalformedJsonThrowsException()
+    {
+        $this->expectException(DomainException::class);
+        JWT::jsonDecode('this is not valid JSON string');
+    }
+
+    public function testExpiredToken()
+    {
+        $this->expectException(ExpiredException::class);
+        $payload = [
+            'message' => 'abc',
+            'exp' => time() - 20, // time in the past
+        ];
+        $encoded = JWT::encode($payload, 'my_key', 'HS256');
+        JWT::decode($encoded, new Key('my_key', 'HS256'));
+    }
+
+    public function testBeforeValidTokenWithNbf()
+    {
+        $this->expectException(BeforeValidException::class);
+        $payload = [
+            'message' => 'abc',
+            'nbf' => time() + 20, // time in the future
+        ];
+        $encoded = JWT::encode($payload, 'my_key', 'HS256');
+        JWT::decode($encoded, new Key('my_key', 'HS256'));
+    }
+
+    public function testBeforeValidTokenWithIat()
+    {
+        $this->expectException(BeforeValidException::class);
+        $payload = [
+            'message' => 'abc',
+            'iat' => time() + 20, // time in the future
+        ];
+        $encoded = JWT::encode($payload, 'my_key', 'HS256');
+        JWT::decode($encoded, new Key('my_key', 'HS256'));
+    }
+
+    public function testValidToken()
+    {
+        $payload = [
+            'message' => 'abc',
+            'exp' => time() + JWT::$leeway + 20, // time in the future
+        ];
+        $encoded = JWT::encode($payload, 'my_key', 'HS256');
+        $decoded = JWT::decode($encoded, new Key('my_key', 'HS256'));
+        $this->assertSame($decoded->message, 'abc');
+    }
+
+    /**
+     * @runInSeparateProcess
+     */
+    public function testValidTokenWithLeeway()
+    {
+        JWT::$leeway = 60;
+        $payload = [
+            'message' => 'abc',
+            'exp' => time() - 20, // time in the past
+        ];
+        $encoded = JWT::encode($payload, 'my_key', 'HS256');
+        $decoded = JWT::decode($encoded, new Key('my_key', 'HS256'));
+        $this->assertSame($decoded->message, 'abc');
+    }
+
+    /**
+     * @runInSeparateProcess
+     */
+    public function testExpiredTokenWithLeeway()
+    {
+        JWT::$leeway = 60;
+        $payload = [
+            'message' => 'abc',
+            'exp' => time() - 70, // time far in the past
+        ];
+        $this->expectException(ExpiredException::class);
+        $encoded = JWT::encode($payload, 'my_key', 'HS256');
+        $decoded = JWT::decode($encoded, new Key('my_key', 'HS256'));
+        $this->assertSame($decoded->message, 'abc');
+    }
+
+    public function testExpiredExceptionPayload()
+    {
+        $this->expectException(ExpiredException::class);
+        $payload = [
+            'message' => 'abc',
+            'exp' => time() - 100, // time in the past
+        ];
+        $encoded = JWT::encode($payload, 'my_key', 'HS256');
+        try {
+            JWT::decode($encoded, new Key('my_key', 'HS256'));
+        } catch (ExpiredException $e) {
+            $exceptionPayload = (array) $e->getPayload();
+            $this->assertEquals($exceptionPayload, $payload);
+            throw $e;
+        }
+    }
+
+    public function testBeforeValidExceptionPayload()
+    {
+        $this->expectException(BeforeValidException::class);
+        $payload = [
+            'message' => 'abc',
+            'iat' => time() + 100, // time in the future
+        ];
+        $encoded = JWT::encode($payload, 'my_key', 'HS256');
+        try {
+            JWT::decode($encoded, new Key('my_key', 'HS256'));
+        } catch (BeforeValidException $e) {
+            $exceptionPayload = (array) $e->getPayload();
+            $this->assertEquals($exceptionPayload, $payload);
+            throw $e;
+        }
+    }
+
+    public function testValidTokenWithNbf()
+    {
+        $payload = [
+            'message' => 'abc',
+            'iat' => time(),
+            'exp' => time() + 20, // time in the future
+            'nbf' => time() - 20
+        ];
+        $encoded = JWT::encode($payload, 'my_key', 'HS256');
+        $decoded = JWT::decode($encoded, new Key('my_key', 'HS256'));
+        $this->assertSame($decoded->message, 'abc');
+    }
+
+    /**
+     * @runInSeparateProcess
+     */
+    public function testValidTokenWithNbfLeeway()
+    {
+        JWT::$leeway = 60;
+        $payload = [
+            'message' => 'abc',
+            'nbf'     => time() + 20, // not before in near (leeway) future
+        ];
+        $encoded = JWT::encode($payload, 'my_key', 'HS256');
+        $decoded = JWT::decode($encoded, new Key('my_key', 'HS256'));
+        $this->assertSame($decoded->message, 'abc');
+    }
+
+    /**
+     * @runInSeparateProcess
+     */
+    public function testInvalidTokenWithNbfLeeway()
+    {
+        JWT::$leeway = 60;
+        $payload = [
+            'message' => 'abc',
+            'nbf'     => time() + 65,  // not before too far in future
+        ];
+        $encoded = JWT::encode($payload, 'my_key', 'HS256');
+        $this->expectException(BeforeValidException::class);
+        $this->expectExceptionMessage('Cannot handle token with nbf prior to');
+        JWT::decode($encoded, new Key('my_key', 'HS256'));
+    }
+
+    public function testValidTokenWithNbfIgnoresIat()
+    {
+        $payload = [
+            'message' => 'abc',
+            'nbf' => time() - 20, // time in the future
+            'iat' => time() + 20, // time in the past
+        ];
+        $encoded = JWT::encode($payload, 'my_key', 'HS256');
+        $decoded = JWT::decode($encoded, new Key('my_key', 'HS256'));
+        $this->assertEquals('abc', $decoded->message);
+    }
+
+    public function testValidTokenWithNbfMicrotime()
+    {
+        $payload = [
+            'message' => 'abc',
+            'nbf' => microtime(true), // use microtime
+        ];
+        $encoded = JWT::encode($payload, 'my_key', 'HS256');
+        $decoded = JWT::decode($encoded, new Key('my_key', 'HS256'));
+        $this->assertEquals('abc', $decoded->message);
+    }
+
+    public function testInvalidTokenWithNbfMicrotime()
+    {
+        $this->expectException(BeforeValidException::class);
+        $this->expectExceptionMessage('Cannot handle token with nbf prior to');
+        $payload = [
+            'message' => 'abc',
+            'nbf' => microtime(true) + 20, // use microtime in the future
+        ];
+        $encoded = JWT::encode($payload, 'my_key', 'HS256');
+        JWT::decode($encoded, new Key('my_key', 'HS256'));
+    }
+
+    /**
+     * @runInSeparateProcess
+     */
+    public function testValidTokenWithIatLeeway()
+    {
+        JWT::$leeway = 60;
+        $payload = [
+            'message' => 'abc',
+            'iat'     => time() + 20, // issued in near (leeway) future
+        ];
+        $encoded = JWT::encode($payload, 'my_key', 'HS256');
+        $decoded = JWT::decode($encoded, new Key('my_key', 'HS256'));
+        $this->assertSame($decoded->message, 'abc');
+    }
+
+    /**
+     * @runInSeparateProcess
+     */
+    public function testInvalidTokenWithIatLeeway()
+    {
+        JWT::$leeway = 60;
+        $payload = [
+            'message' => 'abc',
+            'iat'     => time() + 65, // issued too far in future
+        ];
+        $encoded = JWT::encode($payload, 'my_key', 'HS256');
+        $this->expectException(BeforeValidException::class);
+        $this->expectExceptionMessage('Cannot handle token with iat prior to');
+        JWT::decode($encoded, new Key('my_key', 'HS256'));
+    }
+
+    public function testValidTokenWithIatMicrotime()
+    {
+        $payload = [
+            'message' => 'abc',
+            'iat' => microtime(true), // use microtime
+        ];
+        $encoded = JWT::encode($payload, 'my_key', 'HS256');
+        $decoded = JWT::decode($encoded, new Key('my_key', 'HS256'));
+        $this->assertEquals('abc', $decoded->message);
+    }
+
+    public function testInvalidTokenWithIatMicrotime()
+    {
+        $this->expectException(BeforeValidException::class);
+        $this->expectExceptionMessage('Cannot handle token with iat prior to');
+        $payload = [
+            'message' => 'abc',
+            'iat' => microtime(true) + 20, // use microtime in the future
+        ];
+        $encoded = JWT::encode($payload, 'my_key', 'HS256');
+        JWT::decode($encoded, new Key('my_key', 'HS256'));
+    }
+
+    public function testInvalidToken()
+    {
+        $payload = [
+            'message' => 'abc',
+            'exp' => time() + 20, // time in the future
+        ];
+        $encoded = JWT::encode($payload, 'my_key', 'HS256');
+        $this->expectException(SignatureInvalidException::class);
+        JWT::decode($encoded, new Key('my_key2', 'HS256'));
+    }
+
+    public function testNullKeyFails()
+    {
+        $payload = [
+            'message' => 'abc',
+            'exp' => time() + JWT::$leeway + 20, // time in the future
+        ];
+        $encoded = JWT::encode($payload, 'my_key', 'HS256');
+        $this->expectException(TypeError::class);
+        JWT::decode($encoded, new Key(null, 'HS256'));
+    }
+
+    public function testEmptyKeyFails()
+    {
+        $payload = [
+            'message' => 'abc',
+            'exp' => time() + JWT::$leeway + 20, // time in the future
+        ];
+        $encoded = JWT::encode($payload, 'my_key', 'HS256');
+        $this->expectException(InvalidArgumentException::class);
+        JWT::decode($encoded, new Key('', 'HS256'));
+    }
+
+    public function testKIDChooser()
+    {
+        $keys = [
+            '0' => new Key('my_key0', 'HS256'),
+            '1' => new Key('my_key1', 'HS256'),
+            '2' => new Key('my_key2', 'HS256')
+        ];
+        $msg = JWT::encode(['message' => 'abc'], $keys['0']->getKeyMaterial(), 'HS256', '0');
+        $decoded = JWT::decode($msg, $keys);
+        $expected = new stdClass();
+        $expected->message = 'abc';
+        $this->assertEquals($decoded, $expected);
+    }
+
+    public function testArrayAccessKIDChooser()
+    {
+        $keys = new ArrayObject([
+            '0' => new Key('my_key0', 'HS256'),
+            '1' => new Key('my_key1', 'HS256'),
+            '2' => new Key('my_key2', 'HS256'),
+        ]);
+        $msg = JWT::encode(['message' => 'abc'], $keys['0']->getKeyMaterial(), 'HS256', '0');
+        $decoded = JWT::decode($msg, $keys);
+        $expected = new stdClass();
+        $expected->message = 'abc';
+        $this->assertEquals($decoded, $expected);
+    }
+
+    public function testNoneAlgorithm()
+    {
+        $msg = JWT::encode(['message' => 'abc'], 'my_key', 'HS256');
+        $this->expectException(UnexpectedValueException::class);
+        JWT::decode($msg, new Key('my_key', 'none'));
+    }
+
+    public function testIncorrectAlgorithm()
+    {
+        $msg = JWT::encode(['message' => 'abc'], 'my_key', 'HS256');
+        $this->expectException(UnexpectedValueException::class);
+        JWT::decode($msg, new Key('my_key', 'RS256'));
+    }
+
+    public function testEmptyAlgorithm()
+    {
+        $msg = JWT::encode(['message' => 'abc'], 'my_key', 'HS256');
+        $this->expectException(InvalidArgumentException::class);
+        JWT::decode($msg, new Key('my_key', ''));
+    }
+
+    public function testAdditionalHeaders()
+    {
+        $msg = JWT::encode(['message' => 'abc'], 'my_key', 'HS256', null, ['cty' => 'test-eit;v=1']);
+        $expected = new stdClass();
+        $expected->message = 'abc';
+        $this->assertEquals(JWT::decode($msg, new Key('my_key', 'HS256')), $expected);
+    }
+
+    public function testInvalidSegmentCount()
+    {
+        $this->expectException(UnexpectedValueException::class);
+        JWT::decode('brokenheader.brokenbody', new Key('my_key', 'HS256'));
+    }
+
+    public function testInvalidSignatureEncoding()
+    {
+        $msg = 'eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJpZCI6MSwibmFtZSI6ImZvbyJ9.Q4Kee9E8o0Xfo4ADXvYA8t7dN_X_bU9K5w6tXuiSjlUxx';
+        $this->expectException(UnexpectedValueException::class);
+        JWT::decode($msg, new Key('secret', 'HS256'));
+    }
+
+    public function testHSEncodeDecode()
+    {
+        $msg = JWT::encode(['message' => 'abc'], 'my_key', 'HS256');
+        $expected = new stdClass();
+        $expected->message = 'abc';
+        $this->assertEquals(JWT::decode($msg, new Key('my_key', 'HS256')), $expected);
+    }
+
+    public function testRSEncodeDecode()
+    {
+        $privKey = openssl_pkey_new(['digest_alg' => 'sha256',
+            'private_key_bits' => 1024,
+            'private_key_type' => OPENSSL_KEYTYPE_RSA]);
+        $msg = JWT::encode(['message' => 'abc'], $privKey, 'RS256');
+        $pubKey = openssl_pkey_get_details($privKey);
+        $pubKey = $pubKey['key'];
+        $decoded = JWT::decode($msg, new Key($pubKey, 'RS256'));
+        $expected = new stdClass();
+        $expected->message = 'abc';
+        $this->assertEquals($decoded, $expected);
+    }
+
+    public function testEdDsaEncodeDecode()
+    {
+        $keyPair = sodium_crypto_sign_keypair();
+        $privKey = base64_encode(sodium_crypto_sign_secretkey($keyPair));
+
+        $payload = ['foo' => 'bar'];
+        $msg = JWT::encode($payload, $privKey, 'EdDSA');
+
+        $pubKey = base64_encode(sodium_crypto_sign_publickey($keyPair));
+        $decoded = JWT::decode($msg, new Key($pubKey, 'EdDSA'));
+        $this->assertSame('bar', $decoded->foo);
+    }
+
+    public function testInvalidEdDsaEncodeDecode()
+    {
+        $keyPair = sodium_crypto_sign_keypair();
+        $privKey = base64_encode(sodium_crypto_sign_secretkey($keyPair));
+
+        $payload = ['foo' => 'bar'];
+        $msg = JWT::encode($payload, $privKey, 'EdDSA');
+
+        // Generate a different key.
+        $keyPair = sodium_crypto_sign_keypair();
+        $pubKey = base64_encode(sodium_crypto_sign_publickey($keyPair));
+        $this->expectException(SignatureInvalidException::class);
+        JWT::decode($msg, new Key($pubKey, 'EdDSA'));
+    }
+
+    public function testRSEncodeDecodeWithPassphrase()
+    {
+        $privateKey = openssl_pkey_get_private(
+            file_get_contents(__DIR__ . '/data/rsa-with-passphrase.pem'),
+            'passphrase'
+        );
+
+        $jwt = JWT::encode(['message' => 'abc'], $privateKey, 'RS256');
+        $keyDetails = openssl_pkey_get_details($privateKey);
+        $pubKey = $keyDetails['key'];
+        $decoded = JWT::decode($jwt, new Key($pubKey, 'RS256'));
+        $expected = new stdClass();
+        $expected->message = 'abc';
+        $this->assertEquals($decoded, $expected);
+    }
+
+    public function testDecodesEmptyArrayAsObject()
+    {
+        $key = 'yma6Hq4XQegCVND8ef23OYgxSrC3IKqk';
+        $payload = [];
+        $jwt = JWT::encode($payload, $key, 'HS256');
+        $decoded = JWT::decode($jwt, new Key($key, 'HS256'));
+        $this->assertEquals((object) $payload, $decoded);
+    }
+
+    public function testDecodesArraysInJWTAsArray()
+    {
+        $key = 'yma6Hq4XQegCVND8ef23OYgxSrC3IKqk';
+        $payload = ['foo' => [1, 2, 3]];
+        $jwt = JWT::encode($payload, $key, 'HS256');
+        $decoded = JWT::decode($jwt, new Key($key, 'HS256'));
+        $this->assertSame($payload['foo'], $decoded->foo);
+    }
+
+    /**
+     * @runInSeparateProcess
+     * @dataProvider provideEncodeDecode
+     */
+    public function testEncodeDecode($privateKeyFile, $publicKeyFile, $alg)
+    {
+        $privateKey = file_get_contents($privateKeyFile);
+        $payload = ['foo' => 'bar'];
+        $encoded = JWT::encode($payload, $privateKey, $alg);
+
+        // Verify decoding succeeds
+        $publicKey = file_get_contents($publicKeyFile);
+        $decoded = JWT::decode($encoded, new Key($publicKey, $alg));
+
+        $this->assertSame('bar', $decoded->foo);
+    }
+
+    public function provideEncodeDecode()
+    {
+        return [
+            [__DIR__ . '/data/ecdsa-private.pem', __DIR__ . '/data/ecdsa-public.pem', 'ES256'],
+            [__DIR__ . '/data/ecdsa384-private.pem', __DIR__ . '/data/ecdsa384-public.pem', 'ES384'],
+            [__DIR__ . '/data/rsa1-private.pem', __DIR__ . '/data/rsa1-public.pub', 'RS512'],
+            [__DIR__ . '/data/ed25519-1.sec', __DIR__ . '/data/ed25519-1.pub', 'EdDSA'],
+            [__DIR__ . '/data/secp256k1-private.pem', __DIR__ . '/data/secp256k1-public.pem', 'ES256K'],
+        ];
+    }
+
+    public function testEncodeDecodeWithResource()
+    {
+        $pem = file_get_contents(__DIR__ . '/data/rsa1-public.pub');
+        $resource = openssl_pkey_get_public($pem);
+        $privateKey = file_get_contents(__DIR__ . '/data/rsa1-private.pem');
+
+        $payload = ['foo' => 'bar'];
+        $encoded = JWT::encode($payload, $privateKey, 'RS512');
+
+        // Verify decoding succeeds
+        $decoded = JWT::decode($encoded, new Key($resource, 'RS512'));
+
+        $this->assertSame('bar', $decoded->foo);
+    }
+
+    public function testGetHeaders()
+    {
+        $payload = [
+            'message' => 'abc',
+            'exp' => time() + JWT::$leeway + 20, // time in the future
+        ];
+        $headers = new stdClass();
+
+        $encoded = JWT::encode($payload, 'my_key', 'HS256');
+        JWT::decode($encoded, new Key('my_key', 'HS256'), $headers);
+
+        $this->assertEquals($headers->typ, 'JWT');
+        $this->assertEquals($headers->alg, 'HS256');
+    }
+
+    public function testAdditionalHeaderOverrides()
+    {
+        $msg = JWT::encode(
+            ['message' => 'abc'],
+            'my_key',
+            'HS256',
+            'my_key_id',
+            [
+                'cty' => 'test-eit;v=1',
+                'typ' => 'JOSE', // override type header
+                'kid' => 'not_my_key_id', // should not override $key param
+                'alg' => 'BAD', // should not override $alg param
+            ]
+        );
+        $headers = new stdClass();
+        JWT::decode($msg, new Key('my_key', 'HS256'), $headers);
+        $this->assertEquals('test-eit;v=1', $headers->cty, 'additional field works');
+        $this->assertEquals('JOSE', $headers->typ, 'typ override works');
+        $this->assertEquals('my_key_id', $headers->kid, 'key param not overridden');
+        $this->assertEquals('HS256', $headers->alg, 'alg param not overridden');
+    }
+}

package/vendor/firebase/php-jwt/tests/data/ec-jwkset.json

@@ -0,0 +1,40 @@
+{
+    "keys": [
+        {
+            "kty": "EC",
+            "use": "sig",
+            "crv": "P-256",
+            "kid": "jwk1",
+            "x": "ALXnvdCvbBx35J2bozBkIFHPT747KiYioLK4JquMhZU",
+            "y": "fAt_rGPqS95Ytwdluh4TNWTmj9xkcAbKGBRpP5kuGBk",
+            "alg": "ES256"
+        },
+        {
+            "kty": "EC",
+            "use": "sig",
+            "crv": "P-256",
+            "kid": "jwk2",
+            "x": "mQa0q5FvxPRujxzFazQT1Mo2YJJzuKiXU3svOJ41jhw",
+            "y": "jAz7UwIl2oOFk06kj42ZFMOXmGMFUGjKASvyYtibCH0",
+            "alg": "ES256"
+        },
+        {
+            "kty": "EC",
+            "use": "sig",
+            "crv": "secp256k1",
+            "kid": "jwk3",
+            "x": "EFpwNuP322bU3WP1DtJgx67L0CUV1MxNixqPVMH2L9Q",
+            "y": "_fSTbijIJjpsqL16cIEvxxf3MaYMY8MbqEq066yV9ls",
+            "alg": "ES256K"
+        },
+        {
+            "kty": "EC",
+            "use": "sig",
+            "crv": "P-384",
+            "kid": "jwk4",
+            "x": "FhXXcyKmWkTkdVbWYYU3dtJqpJ0JmLGftEdNzUEFEKSU5MlnLr_FjcneszvXAqEB",
+            "y": "M4veJF_dO_zhFk44bh_ELXbp0_nn9QaViVtQpuTvpu29eefx6PfUMqX0K--IS4NQ",
+            "alg": "ES384"
+        }
+    ]
+}

package/vendor/firebase/php-jwt/tests/data/ecdsa-private.pem

@@ -0,0 +1,18 @@
+-----BEGIN EC PARAMETERS-----
+MIH3AgEBMCwGByqGSM49AQECIQD/////AAAAAQAAAAAAAAAAAAAAAP//////////
+/////zBbBCD/////AAAAAQAAAAAAAAAAAAAAAP///////////////AQgWsY12Ko6
+k+ez671VdpiGvGUdBrDMU7D2O848PifSYEsDFQDEnTYIhucEk2pmeOETnSa3gZ9+
+kARBBGsX0fLhLEJH+Lzm5WOkQPJ3A32BLeszoPShOUXYmMKWT+NC4v4af5uO5+tK
+fA+eFivOM1drMV7Oy7ZAaDe/UfUCIQD/////AAAAAP//////////vOb6racXnoTz
+ucrC/GMlUQIBAQ==
+-----END EC PARAMETERS-----
+-----BEGIN EC PRIVATE KEY-----
+MIIBaAIBAQQgyP9e7yS1tjpXa0l6o+80dbSxuMcqx3lUg0n2OT9AmiuggfowgfcC
+AQEwLAYHKoZIzj0BAQIhAP////8AAAABAAAAAAAAAAAAAAAA////////////////
+MFsEIP////8AAAABAAAAAAAAAAAAAAAA///////////////8BCBaxjXYqjqT57Pr
+vVV2mIa8ZR0GsMxTsPY7zjw+J9JgSwMVAMSdNgiG5wSTamZ44ROdJreBn36QBEEE
+axfR8uEsQkf4vOblY6RA8ncDfYEt6zOg9KE5RdiYwpZP40Li/hp/m47n60p8D54W
+K84zV2sxXs7LtkBoN79R9QIhAP////8AAAAA//////////+85vqtpxeehPO5ysL8
+YyVRAgEBoUQDQgAE2klp6aX6y5kAir3EWQt0QAeapTW+db/9fD65KAoDzVajtThx
+PVLEf1CufcfTxMQAQPM3wkZhu0NjlWFetcMdcQ==
+-----END EC PRIVATE KEY-----

package/vendor/firebase/php-jwt/tests/data/ecdsa-public.pem

@@ -0,0 +1,9 @@
+-----BEGIN PUBLIC KEY-----
+MIIBSzCCAQMGByqGSM49AgEwgfcCAQEwLAYHKoZIzj0BAQIhAP////8AAAABAAAA
+AAAAAAAAAAAA////////////////MFsEIP////8AAAABAAAAAAAAAAAAAAAA////
+///////////8BCBaxjXYqjqT57PrvVV2mIa8ZR0GsMxTsPY7zjw+J9JgSwMVAMSd
+NgiG5wSTamZ44ROdJreBn36QBEEEaxfR8uEsQkf4vOblY6RA8ncDfYEt6zOg9KE5
+RdiYwpZP40Li/hp/m47n60p8D54WK84zV2sxXs7LtkBoN79R9QIhAP////8AAAAA
+//////////+85vqtpxeehPO5ysL8YyVRAgEBA0IABNpJaeml+suZAIq9xFkLdEAH
+mqU1vnW//Xw+uSgKA81Wo7U4cT1SxH9Qrn3H08TEAEDzN8JGYbtDY5VhXrXDHXE=
+-----END PUBLIC KEY-----

package/vendor/firebase/php-jwt/tests/data/ecdsa256-private.pem

@@ -0,0 +1,4 @@
+-----BEGIN PRIVATE KEY-----
+MEECAQAwEwYHKoZIzj0CAQYIKoZIzj0DAQcEJzAlAgEBBCD0KvVxLJEzRBQmcEXf
+D2okKCNoUwZY8fc1/1Z4aJuJdg==
+-----END PRIVATE KEY-----

package/vendor/firebase/php-jwt/tests/data/ecdsa384-private.pem

@@ -0,0 +1,6 @@
+-----BEGIN EC PRIVATE KEY-----
+MIGkAgEBBDBQJuwafREZ1494Fm2MTVXuZbWXVAOwIAxGhyLdc3CChzi0FVXZq8e6
+65oR0Qq9Jv2gBwYFK4EEACKhZANiAAQWFddzIqZaROR1VtZhhTd20mqknQmYsZ+0
+R03NQQUQpJTkyWcuv8WNyd6zO9cCoQEzi94kX907/OEWTjhuH8QtdunT+ef1BpWJ
+W1Cm5O+m7b155/Ho99QypfQr74hLg1A=
+-----END EC PRIVATE KEY-----

package/vendor/firebase/php-jwt/tests/data/ecdsa384-public.pem

@@ -0,0 +1,5 @@
+-----BEGIN PUBLIC KEY-----
+MHYwEAYHKoZIzj0CAQYFK4EEACIDYgAEFhXXcyKmWkTkdVbWYYU3dtJqpJ0JmLGf
+tEdNzUEFEKSU5MlnLr/FjcneszvXAqEBM4veJF/dO/zhFk44bh/ELXbp0/nn9QaV
+iVtQpuTvpu29eefx6PfUMqX0K++IS4NQ
+-----END PUBLIC KEY-----

package/vendor/firebase/php-jwt/tests/data/ed25519-1.pub

@@ -0,0 +1 @@
+uOSJMhbKSG4V5xUHS7B9YHmVg/1yVd+G+Io6oBFhSfY=

package/vendor/firebase/php-jwt/tests/data/ed25519-1.sec

@@ -0,0 +1 @@
+i4eTKkWNIISKumdk3v90cPDrY/g8WRTJWy7DmGDsdzC45IkyFspIbhXnFQdLsH1geZWD/XJV34b4ijqgEWFJ9g==

package/vendor/firebase/php-jwt/tests/data/ed25519-jwkset.json

@@ -0,0 +1,11 @@
+{
+    "keys": [
+        {
+            "kid": "jwk1",
+            "alg": "EdDSA",
+            "kty": "OKP",
+            "crv": "Ed25519",
+            "x": "uOSJMhbKSG4V5xUHS7B9YHmVg_1yVd-G-Io6oBFhSfY"
+        }
+    ]
+}

package/vendor/firebase/php-jwt/tests/data/rsa-jwkset.json

@@ -0,0 +1,18 @@
+{
+    "keys": [
+        {
+            "kty": "RSA",
+            "e": "AQAB",
+            "kid": "jwk1",
+            "n": "0Ttga33B1yX4w77NbpKyNYDNSVCo8j-RlZaZ9tI-KfkV1d-tfsvI9ZPAheP11FoN52ceBaY5ltelHW-IKwCfyT0orLdsxLgowaXki9woF1Azvcg2JVxQLv9aVjjAvy3CZFIG_EeN7J3nsyCXGnu1yMEbnvkWxA88__Q6HQ2K9wqfApkQ0LNlsK0YHz_sfjHNvRKxnbAJk7D5fUhZunPZXOPHXFgA5SvLvMaNIXduMKJh4OMfuoLdJowXJAR9j31Mqz_is4FMhm_9Mq7vZZ-uF09htRvIR8tRY28oJuW1gKWyg7cQQpnjHgFyG3XLXWAeXclWqyh_LfjyHQjrYhyeFw",
+            "alg": "RS256"
+        },
+        {
+            "kty": "RSA",
+            "e": "AQAB",
+            "kid": "jwk2",
+            "n": "pXi2o6AnNhwL30MaK_nuDHi2fxZHVen7Xwk0bjLGlHYpq3mSvXm2HBA-zR41vQCbHkYGsDpsyDhIXLBDTbSa7ue7D1ZqYdv5YLIS33zdX9GtUHfFHc6zYgXAU9ziWeyTzVn7icAbjxqcgT2xKNuGK7Zf2ZJ053rr-dxjAE-SjX4SG0WWUhwPjxlr1etF7mEurhHweuSdZYl36g39o9BtTBVfS87io2MwdIRsnL3w8ulgXRVRWjv-vvcuhMS_y6zGbzOC55Yr23sb4h2PSll32bgyglEIsGgHqjOdyjuUzl0t6jh86DHzbu9h-u1iihX8EI8t7CBbizbPPyHQygp-rQ",
+            "alg": "RS256"
+        }
+    ]
+}