ECKeysTest::testLoadPrivateEC512Key() - Code Metrics - Inspection of "Bugs fixed" - Spomky-Labs/jose - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — develop ( 686594...b5844e )

by Florent

created 2016-03-19 22:24 UTC

ECKeysTest::testLoadPrivateEC512Key() A

↳ Parent: ECKeysTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	19
Code Lines	13

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	2	Features	0

Metric	Value
c	2
b	2
f	0
dl	0
loc	19
rs	9.4285
cc	1
eloc	13
nc	1
nop	0

<?php

/*
 * The MIT License (MIT)
 *
 * Copyright (c) 2014-2016 Spomky-Labs
 *
 * This software may be modified and distributed under the terms
 * of the MIT license.  See the LICENSE file for details.
 */

use Jose\KeyConverter\ECKey;
use Jose\KeyConverter\KeyConverter;
use Jose\Test\TestCase;

/**
 * @group ECKeys
 * @group Unit
 */
class ECKeysTest extends TestCase
{
    /**
     * @expectedException \InvalidArgumentException
     * @expectedExceptionMessage Unsupported key type
     */
    public function testKeyTypeNotSupported()
    {
        $file = 'file://'.__DIR__.DIRECTORY_SEPARATOR.'DSA'.DIRECTORY_SEPARATOR.'DSA.key';
        KeyConverter::loadFromKeyFile($file);
    }

    public function testLoadPublicEC256Key()
    {
        $pem = file_get_contents('file://'.__DIR__.DIRECTORY_SEPARATOR.'EC'.DIRECTORY_SEPARATOR.'public.es256.key');
        $details = KeyConverter::loadFromKey($pem);
        $this->assertEquals($details, [
            'kty' => 'EC',
            'crv' => 'P-256',
            'x'   => 'vuYsP-QnrqAbM7Iyhzjt08hFSuzapyojCB_gFsBt65U',
            'y'   => 'oq-E2K-X0kPeqGuKnhlXkxc5fnxomRSC6KLby7Ij8AE',

        ]);

        $ec_key = new ECKey($details);

        $this->assertEquals(str_replace("\r\n", PHP_EOL, $pem), $ec_key->toPEM());
    }

    public function testLoadPrivateEC256Key()
    {
        $private_pem = file_get_contents('file://'.__DIR__.DIRECTORY_SEPARATOR.'EC'.DIRECTORY_SEPARATOR.'private.es256.key');
        $public_pem = file_get_contents('file://'.__DIR__.DIRECTORY_SEPARATOR.'EC'.DIRECTORY_SEPARATOR.'public.es256.key');
        $details = KeyConverter::loadFromKey($private_pem);
        $this->assertEquals($details, [
            'kty' => 'EC',
            'crv' => 'P-256',
            'd'   => 'q_VkzNnxTG39jHB0qkwA_SeVXud7yCHT7kb7kZv-0xQ',
            'x'   => 'vuYsP-QnrqAbM7Iyhzjt08hFSuzapyojCB_gFsBt65U',
            'y'   => 'oq-E2K-X0kPeqGuKnhlXkxc5fnxomRSC6KLby7Ij8AE',
        ]);

        $ec_key = new ECKey($details);

        $this->assertEquals(str_replace("\r\n", PHP_EOL, $private_pem), $ec_key->toPEM());
        $this->assertEquals(str_replace("\r\n", PHP_EOL, $public_pem), ECKey::toPublic($ec_key)->toPEM());
    }

    public function testLoadEncryptedPrivateEC256Key()
    {
        $private_pem = file_get_contents('file://'.__DIR__.DIRECTORY_SEPARATOR.'EC'.DIRECTORY_SEPARATOR.'private.es256.encrypted.key');
        $public_pem = file_get_contents('file://'.__DIR__.DIRECTORY_SEPARATOR.'EC'.DIRECTORY_SEPARATOR.'public.es256.key');
        $details = KeyConverter::loadFromKey($private_pem, 'test');
        $this->assertEquals($details, [
            'kty' => 'EC',
            'crv' => 'P-256',
            'd'   => 'q_VkzNnxTG39jHB0qkwA_SeVXud7yCHT7kb7kZv-0xQ',
            'x'   => 'vuYsP-QnrqAbM7Iyhzjt08hFSuzapyojCB_gFsBt65U',
            'y'   => 'oq-E2K-X0kPeqGuKnhlXkxc5fnxomRSC6KLby7Ij8AE',
        ]);

        $ec_key = new ECKey($details);
        $this->assertEquals(str_replace("\r\n", PHP_EOL, $public_pem), ECKey::toPublic($ec_key)->toPEM());
    }

    /**
     * @expectedException \InvalidArgumentException
     * @expectedExceptionMessage Password required for encrypted keys.
     */
    public function testLoadEncryptedPrivateEC256KeyWithoutPassword()
    {
        KeyConverter::loadFromKeyFile('file://'.__DIR__.DIRECTORY_SEPARATOR.'EC'.DIRECTORY_SEPARATOR.'private.es256.encrypted.key');
    }

    public function testLoadPublicEC384Key()
    {
        $pem = file_get_contents('file://'.__DIR__.DIRECTORY_SEPARATOR.'EC'.DIRECTORY_SEPARATOR.'public.es384.key');
        $details = KeyConverter::loadFromKey($pem);
        $this->assertEquals($details, [
            'kty' => 'EC',
            'crv' => 'P-384',
            'x'   => '6f-XZsg2Tvn0EoEapQ-ylMYNtsm8CPf0cb8HI2EkfY9Bqpt3QMzwlM7mVsFRmaMZ',
            'y'   => 'b8nOnRwmpmEnvA2U8ydS-dbnPv7bwYl-q1qNeh8Wpjor3VO-RTt4ce0Pn25oGGWU',

        ]);

        $ec_key = new ECKey($details);

        $this->assertEquals(str_replace("\r\n", PHP_EOL, $pem), $ec_key->toPEM());
    }

    public function testLoadPrivateEC384Key()
    {
        $private_pem = file_get_contents('file://'.__DIR__.DIRECTORY_SEPARATOR.'EC'.DIRECTORY_SEPARATOR.'private.es384.key');
        $public_pem = file_get_contents('file://'.__DIR__.DIRECTORY_SEPARATOR.'EC'.DIRECTORY_SEPARATOR.'public.es384.key');
        $details = KeyConverter::loadFromKey($private_pem);
        $this->assertEquals($details, [
            'kty' => 'EC',
            'crv' => 'P-384',
            'd'   => 'pcSSXrbeZEOaBIs7IwqcU9M_OOM81XhZuOHoGgmS_2PdECwcdQcXzv7W8-lYL0cr',
            'x'   => '6f-XZsg2Tvn0EoEapQ-ylMYNtsm8CPf0cb8HI2EkfY9Bqpt3QMzwlM7mVsFRmaMZ',
            'y'   => 'b8nOnRwmpmEnvA2U8ydS-dbnPv7bwYl-q1qNeh8Wpjor3VO-RTt4ce0Pn25oGGWU',
        ]);

        $ec_key = new ECKey($details);

        $this->assertEquals(str_replace("\r\n", PHP_EOL, $private_pem), $ec_key->toPEM());
        $this->assertEquals(str_replace("\r\n", PHP_EOL, $public_pem), ECKey::toPublic($ec_key)->toPEM());
    }

    public function testLoadEncryptedPrivateEC384Key()
    {
        $private_pem = file_get_contents('file://'.__DIR__.DIRECTORY_SEPARATOR.'EC'.DIRECTORY_SEPARATOR.'private.es384.encrypted.key');
        $public_pem = file_get_contents('file://'.__DIR__.DIRECTORY_SEPARATOR.'EC'.DIRECTORY_SEPARATOR.'public.es384.key');
        $details = KeyConverter::loadFromKey($private_pem, 'test');
        $this->assertEquals($details, [
            'kty' => 'EC',
            'crv' => 'P-384',
            'd'   => 'pcSSXrbeZEOaBIs7IwqcU9M_OOM81XhZuOHoGgmS_2PdECwcdQcXzv7W8-lYL0cr',
            'x'   => '6f-XZsg2Tvn0EoEapQ-ylMYNtsm8CPf0cb8HI2EkfY9Bqpt3QMzwlM7mVsFRmaMZ',
            'y'   => 'b8nOnRwmpmEnvA2U8ydS-dbnPv7bwYl-q1qNeh8Wpjor3VO-RTt4ce0Pn25oGGWU',
        ]);
        $ec_key = new ECKey($details);

        $this->assertEquals(str_replace("\r\n", PHP_EOL, $public_pem), ECKey::toPublic($ec_key)->toPEM());
    }

    public function testLoadPublicEC512Key()
    {
        $pem = file_get_contents('file://'.__DIR__.DIRECTORY_SEPARATOR.'EC'.DIRECTORY_SEPARATOR.'public.es512.key');
        $details = KeyConverter::loadFromKey($pem);
        $this->assertEquals($details, [
            'kty' => 'EC',
            'crv' => 'P-521',
            'x'   => 'AVpvo7TGpQk5P7ZLo0qkBpaT-fFDv6HQrWElBKMxcrJd_mRNapweATsVv83YON4lTIIRXzgGkmWeqbDr6RQO-1cS',
            'y'   => 'AIs-MoRmLaiPyG2xmPwQCHX2CGX_uCZiT3iOxTAJEZuUbeSA828K4WfAA4ODdGiB87YVShhPOkiQswV3LpbpPGhC',

        ]);

        $ec_key = new ECKey($details);

        $this->assertEquals(str_replace("\r\n", PHP_EOL, $pem), $ec_key->toPEM());
    }

    public function testLoadPrivateEC512Key()
    {
        $private_pem = file_get_contents('file://'.__DIR__.DIRECTORY_SEPARATOR.'EC'.DIRECTORY_SEPARATOR.'private.es512.key');
        $public_pem = file_get_contents('file://'.__DIR__.DIRECTORY_SEPARATOR.'EC'.DIRECTORY_SEPARATOR.'public.es512.key');
        $details = KeyConverter::loadFromKey($private_pem);
        $this->assertEquals($details, [
            'kty' => 'EC',
            'crv' => 'P-521',
            'd'   => 'Fp6KFKRiHIdR_7PP2VKxz6OkS_phyoQqwzv2I89-8zP7QScrx5r8GFLcN5mCCNJt3rN3SIgI4XoIQbNePlAj6vE',
            'x'   => 'AVpvo7TGpQk5P7ZLo0qkBpaT-fFDv6HQrWElBKMxcrJd_mRNapweATsVv83YON4lTIIRXzgGkmWeqbDr6RQO-1cS',
            'y'   => 'AIs-MoRmLaiPyG2xmPwQCHX2CGX_uCZiT3iOxTAJEZuUbeSA828K4WfAA4ODdGiB87YVShhPOkiQswV3LpbpPGhC',

        ]);

        $ec_key = new ECKey($details);

        $this->assertEquals(str_replace("\r\n", PHP_EOL, $private_pem), $ec_key->toPEM());
        $this->assertEquals(str_replace("\r\n", PHP_EOL, $public_pem), ECKey::toPublic($ec_key)->toPEM());
    }

    public function testLoadEncryptedPrivateEC512Key()
    {
        $private_pem = file_get_contents('file://'.__DIR__.DIRECTORY_SEPARATOR.'EC'.DIRECTORY_SEPARATOR.'private.es512.encrypted.key');
        $public_pem = file_get_contents('file://'.__DIR__.DIRECTORY_SEPARATOR.'EC'.DIRECTORY_SEPARATOR.'public.es512.key');
        $details = KeyConverter::loadFromKey($private_pem, 'test');
        $this->assertEquals($details, [
            'kty' => 'EC',
            'crv' => 'P-521',
            'd'   => 'Fp6KFKRiHIdR_7PP2VKxz6OkS_phyoQqwzv2I89-8zP7QScrx5r8GFLcN5mCCNJt3rN3SIgI4XoIQbNePlAj6vE',
            'x'   => 'AVpvo7TGpQk5P7ZLo0qkBpaT-fFDv6HQrWElBKMxcrJd_mRNapweATsVv83YON4lTIIRXzgGkmWeqbDr6RQO-1cS',
            'y'   => 'AIs-MoRmLaiPyG2xmPwQCHX2CGX_uCZiT3iOxTAJEZuUbeSA828K4WfAA4ODdGiB87YVShhPOkiQswV3LpbpPGhC',

        ]);

        $ec_key = new ECKey($details);

        $this->assertEquals(str_replace("\r\n", PHP_EOL, $public_pem), ECKey::toPublic($ec_key)->toPEM());
    }

    public function testConvertPrivateKeyToPublic()
    {
        $private_ec_key = new ECKey([
            'kty' => 'EC',
            'kid' => 'Foo',
            'crv' => 'P-256',
            'use' => 'sig',
            'd'   => 'q_VkzNnxTG39jHB0qkwA_SeVXud7yCHT7kb7kZv-0xQ',
            'x'   => 'vuYsP-QnrqAbM7Iyhzjt08hFSuzapyojCB_gFsBt65U',
            'y'   => 'oq-E2K-X0kPeqGuKnhlXkxc5fnxomRSC6KLby7Ij8AE',
            'foo' => 'bar',
        ]);

        $public_ec_key = ECKey::toPublic($private_ec_key);

        $this->assertEquals([
            'kty' => 'EC',
            'kid' => 'Foo',
            'crv' => 'P-256',
            'use' => 'sig',
            'x'   => 'vuYsP-QnrqAbM7Iyhzjt08hFSuzapyojCB_gFsBt65U',
            'y'   => 'oq-E2K-X0kPeqGuKnhlXkxc5fnxomRSC6KLby7Ij8AE',
            'foo' => 'bar',
        ], $public_ec_key->toArray());
    }
}


1			<?php
2
3			/*
4			* The MIT License (MIT)
5			*
6			* Copyright (c) 2014-2016 Spomky-Labs
7			*
8			* This software may be modified and distributed under the terms
9			* of the MIT license. See the LICENSE file for details.
10			*/
11
12			use Jose\KeyConverter\ECKey;
13			use Jose\KeyConverter\KeyConverter;
14			use Jose\Test\TestCase;
15
16			/**
17			* @group ECKeys
18			* @group Unit
19			*/
20			class ECKeysTest extends TestCase
21			{
22			/**
23			* @expectedException \InvalidArgumentException
24			* @expectedExceptionMessage Unsupported key type
25			*/
26			public function testKeyTypeNotSupported()
27			{
28			$file = 'file://'.__DIR__.DIRECTORY_SEPARATOR.'DSA'.DIRECTORY_SEPARATOR.'DSA.key';
29			KeyConverter::loadFromKeyFile($file);
30			}
31
32			public function testLoadPublicEC256Key()
33			{
34			$pem = file_get_contents('file://'.__DIR__.DIRECTORY_SEPARATOR.'EC'.DIRECTORY_SEPARATOR.'public.es256.key');
35			$details = KeyConverter::loadFromKey($pem);
36			$this->assertEquals($details, [
37			'kty' => 'EC',
38			'crv' => 'P-256',
39			'x' => 'vuYsP-QnrqAbM7Iyhzjt08hFSuzapyojCB_gFsBt65U',
40			'y' => 'oq-E2K-X0kPeqGuKnhlXkxc5fnxomRSC6KLby7Ij8AE',
41
42			]);
43
44			$ec_key = new ECKey($details);
45
46			$this->assertEquals(str_replace("\r\n", PHP_EOL, $pem), $ec_key->toPEM());
47			}
48
49			public function testLoadPrivateEC256Key()
50			{
51			$private_pem = file_get_contents('file://'.__DIR__.DIRECTORY_SEPARATOR.'EC'.DIRECTORY_SEPARATOR.'private.es256.key');
52			$public_pem = file_get_contents('file://'.__DIR__.DIRECTORY_SEPARATOR.'EC'.DIRECTORY_SEPARATOR.'public.es256.key');
53			$details = KeyConverter::loadFromKey($private_pem);
54			$this->assertEquals($details, [
55			'kty' => 'EC',
56			'crv' => 'P-256',
57			'd' => 'q_VkzNnxTG39jHB0qkwA_SeVXud7yCHT7kb7kZv-0xQ',
58			'x' => 'vuYsP-QnrqAbM7Iyhzjt08hFSuzapyojCB_gFsBt65U',
59			'y' => 'oq-E2K-X0kPeqGuKnhlXkxc5fnxomRSC6KLby7Ij8AE',
60			]);
61
62			$ec_key = new ECKey($details);
63
64			$this->assertEquals(str_replace("\r\n", PHP_EOL, $private_pem), $ec_key->toPEM());
65			$this->assertEquals(str_replace("\r\n", PHP_EOL, $public_pem), ECKey::toPublic($ec_key)->toPEM());
66			}
67
68			public function testLoadEncryptedPrivateEC256Key()
69			{
70			$private_pem = file_get_contents('file://'.__DIR__.DIRECTORY_SEPARATOR.'EC'.DIRECTORY_SEPARATOR.'private.es256.encrypted.key');
71			$public_pem = file_get_contents('file://'.__DIR__.DIRECTORY_SEPARATOR.'EC'.DIRECTORY_SEPARATOR.'public.es256.key');
72			$details = KeyConverter::loadFromKey($private_pem, 'test');
73			$this->assertEquals($details, [
74			'kty' => 'EC',
75			'crv' => 'P-256',
76			'd' => 'q_VkzNnxTG39jHB0qkwA_SeVXud7yCHT7kb7kZv-0xQ',
77			'x' => 'vuYsP-QnrqAbM7Iyhzjt08hFSuzapyojCB_gFsBt65U',
78			'y' => 'oq-E2K-X0kPeqGuKnhlXkxc5fnxomRSC6KLby7Ij8AE',
79			]);
80
81			$ec_key = new ECKey($details);
82			$this->assertEquals(str_replace("\r\n", PHP_EOL, $public_pem), ECKey::toPublic($ec_key)->toPEM());
83			}
84
85			/**
86			* @expectedException \InvalidArgumentException
87			* @expectedExceptionMessage Password required for encrypted keys.
88			*/
89			public function testLoadEncryptedPrivateEC256KeyWithoutPassword()
90			{
91			KeyConverter::loadFromKeyFile('file://'.__DIR__.DIRECTORY_SEPARATOR.'EC'.DIRECTORY_SEPARATOR.'private.es256.encrypted.key');
92			}
93
94			public function testLoadPublicEC384Key()
95			{
96			$pem = file_get_contents('file://'.__DIR__.DIRECTORY_SEPARATOR.'EC'.DIRECTORY_SEPARATOR.'public.es384.key');
97			$details = KeyConverter::loadFromKey($pem);
98			$this->assertEquals($details, [
99			'kty' => 'EC',
100			'crv' => 'P-384',
101			'x' => '6f-XZsg2Tvn0EoEapQ-ylMYNtsm8CPf0cb8HI2EkfY9Bqpt3QMzwlM7mVsFRmaMZ',
102			'y' => 'b8nOnRwmpmEnvA2U8ydS-dbnPv7bwYl-q1qNeh8Wpjor3VO-RTt4ce0Pn25oGGWU',
103
104			]);
105
106			$ec_key = new ECKey($details);
107
108			$this->assertEquals(str_replace("\r\n", PHP_EOL, $pem), $ec_key->toPEM());
109			}
110
111			public function testLoadPrivateEC384Key()
112			{
113			$private_pem = file_get_contents('file://'.__DIR__.DIRECTORY_SEPARATOR.'EC'.DIRECTORY_SEPARATOR.'private.es384.key');
114			$public_pem = file_get_contents('file://'.__DIR__.DIRECTORY_SEPARATOR.'EC'.DIRECTORY_SEPARATOR.'public.es384.key');
115			$details = KeyConverter::loadFromKey($private_pem);
116			$this->assertEquals($details, [
117			'kty' => 'EC',
118			'crv' => 'P-384',
119			'd' => 'pcSSXrbeZEOaBIs7IwqcU9M_OOM81XhZuOHoGgmS_2PdECwcdQcXzv7W8-lYL0cr',
120			'x' => '6f-XZsg2Tvn0EoEapQ-ylMYNtsm8CPf0cb8HI2EkfY9Bqpt3QMzwlM7mVsFRmaMZ',
121			'y' => 'b8nOnRwmpmEnvA2U8ydS-dbnPv7bwYl-q1qNeh8Wpjor3VO-RTt4ce0Pn25oGGWU',
122			]);
123
124			$ec_key = new ECKey($details);
125
126			$this->assertEquals(str_replace("\r\n", PHP_EOL, $private_pem), $ec_key->toPEM());
127			$this->assertEquals(str_replace("\r\n", PHP_EOL, $public_pem), ECKey::toPublic($ec_key)->toPEM());
128			}
129
130			public function testLoadEncryptedPrivateEC384Key()
131			{
132			$private_pem = file_get_contents('file://'.__DIR__.DIRECTORY_SEPARATOR.'EC'.DIRECTORY_SEPARATOR.'private.es384.encrypted.key');
133			$public_pem = file_get_contents('file://'.__DIR__.DIRECTORY_SEPARATOR.'EC'.DIRECTORY_SEPARATOR.'public.es384.key');
134			$details = KeyConverter::loadFromKey($private_pem, 'test');
135			$this->assertEquals($details, [
136			'kty' => 'EC',
137			'crv' => 'P-384',
138			'd' => 'pcSSXrbeZEOaBIs7IwqcU9M_OOM81XhZuOHoGgmS_2PdECwcdQcXzv7W8-lYL0cr',
139			'x' => '6f-XZsg2Tvn0EoEapQ-ylMYNtsm8CPf0cb8HI2EkfY9Bqpt3QMzwlM7mVsFRmaMZ',
140			'y' => 'b8nOnRwmpmEnvA2U8ydS-dbnPv7bwYl-q1qNeh8Wpjor3VO-RTt4ce0Pn25oGGWU',
141			]);
142			$ec_key = new ECKey($details);
143
144			$this->assertEquals(str_replace("\r\n", PHP_EOL, $public_pem), ECKey::toPublic($ec_key)->toPEM());
145			}
146
147			public function testLoadPublicEC512Key()
148			{
149			$pem = file_get_contents('file://'.__DIR__.DIRECTORY_SEPARATOR.'EC'.DIRECTORY_SEPARATOR.'public.es512.key');
150			$details = KeyConverter::loadFromKey($pem);
151			$this->assertEquals($details, [
152			'kty' => 'EC',
153			'crv' => 'P-521',
154			'x' => 'AVpvo7TGpQk5P7ZLo0qkBpaT-fFDv6HQrWElBKMxcrJd_mRNapweATsVv83YON4lTIIRXzgGkmWeqbDr6RQO-1cS',
155			'y' => 'AIs-MoRmLaiPyG2xmPwQCHX2CGX_uCZiT3iOxTAJEZuUbeSA828K4WfAA4ODdGiB87YVShhPOkiQswV3LpbpPGhC',
156
157			]);
158
159			$ec_key = new ECKey($details);
160
161			$this->assertEquals(str_replace("\r\n", PHP_EOL, $pem), $ec_key->toPEM());
162			}
163
164			public function testLoadPrivateEC512Key()
165			{
166			$private_pem = file_get_contents('file://'.__DIR__.DIRECTORY_SEPARATOR.'EC'.DIRECTORY_SEPARATOR.'private.es512.key');
167			$public_pem = file_get_contents('file://'.__DIR__.DIRECTORY_SEPARATOR.'EC'.DIRECTORY_SEPARATOR.'public.es512.key');
168			$details = KeyConverter::loadFromKey($private_pem);
169			$this->assertEquals($details, [
170			'kty' => 'EC',
171			'crv' => 'P-521',
172			'd' => 'Fp6KFKRiHIdR_7PP2VKxz6OkS_phyoQqwzv2I89-8zP7QScrx5r8GFLcN5mCCNJt3rN3SIgI4XoIQbNePlAj6vE',
173			'x' => 'AVpvo7TGpQk5P7ZLo0qkBpaT-fFDv6HQrWElBKMxcrJd_mRNapweATsVv83YON4lTIIRXzgGkmWeqbDr6RQO-1cS',
174			'y' => 'AIs-MoRmLaiPyG2xmPwQCHX2CGX_uCZiT3iOxTAJEZuUbeSA828K4WfAA4ODdGiB87YVShhPOkiQswV3LpbpPGhC',
175
176			]);
177
178			$ec_key = new ECKey($details);
179
180			$this->assertEquals(str_replace("\r\n", PHP_EOL, $private_pem), $ec_key->toPEM());
181			$this->assertEquals(str_replace("\r\n", PHP_EOL, $public_pem), ECKey::toPublic($ec_key)->toPEM());
182			}
183
184			public function testLoadEncryptedPrivateEC512Key()
185			{
186			$private_pem = file_get_contents('file://'.__DIR__.DIRECTORY_SEPARATOR.'EC'.DIRECTORY_SEPARATOR.'private.es512.encrypted.key');
187			$public_pem = file_get_contents('file://'.__DIR__.DIRECTORY_SEPARATOR.'EC'.DIRECTORY_SEPARATOR.'public.es512.key');
188			$details = KeyConverter::loadFromKey($private_pem, 'test');
189			$this->assertEquals($details, [
190			'kty' => 'EC',
191			'crv' => 'P-521',
192			'd' => 'Fp6KFKRiHIdR_7PP2VKxz6OkS_phyoQqwzv2I89-8zP7QScrx5r8GFLcN5mCCNJt3rN3SIgI4XoIQbNePlAj6vE',
193			'x' => 'AVpvo7TGpQk5P7ZLo0qkBpaT-fFDv6HQrWElBKMxcrJd_mRNapweATsVv83YON4lTIIRXzgGkmWeqbDr6RQO-1cS',
194			'y' => 'AIs-MoRmLaiPyG2xmPwQCHX2CGX_uCZiT3iOxTAJEZuUbeSA828K4WfAA4ODdGiB87YVShhPOkiQswV3LpbpPGhC',
195
196			]);
197
198			$ec_key = new ECKey($details);
199
200			$this->assertEquals(str_replace("\r\n", PHP_EOL, $public_pem), ECKey::toPublic($ec_key)->toPEM());
201			}
202
203			public function testConvertPrivateKeyToPublic()
204			{
205			$private_ec_key = new ECKey([
206			'kty' => 'EC',
207			'kid' => 'Foo',
208			'crv' => 'P-256',
209			'use' => 'sig',
210			'd' => 'q_VkzNnxTG39jHB0qkwA_SeVXud7yCHT7kb7kZv-0xQ',
211			'x' => 'vuYsP-QnrqAbM7Iyhzjt08hFSuzapyojCB_gFsBt65U',
212			'y' => 'oq-E2K-X0kPeqGuKnhlXkxc5fnxomRSC6KLby7Ij8AE',
213			'foo' => 'bar',
214			]);
215
216			$public_ec_key = ECKey::toPublic($private_ec_key);
217
218			$this->assertEquals([
219			'kty' => 'EC',
220			'kid' => 'Foo',
221			'crv' => 'P-256',
222			'use' => 'sig',
223			'x' => 'vuYsP-QnrqAbM7Iyhzjt08hFSuzapyojCB_gFsBt65U',
224			'y' => 'oq-E2K-X0kPeqGuKnhlXkxc5fnxomRSC6KLby7Ij8AE',
225			'foo' => 'bar',
226			], $public_ec_key->toArray());
227			}
228			}
229

Spomky-Labs / jose

Push — develop ( 686594...b5844e )

ECKeysTest::testLoadPrivateEC512Key() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like