KeyPairTrait::setPublicKey() - Code Metrics - Inspection of "Added a vast of asymmetric encryption algorithm ob..." - TonyKaravasilev/CryptoManana - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( a44b29...b8fcd2 )

by Tony Karavasilev (Тони

created 2020-01-25 21:05 UTC

KeyPairTrait::setPublicKey() A

↳ Parent: KeyPairTrait

Complexity

Conditions	1
Paths	1

Size

Total Lines	9
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
eloc	4
c	1
b	0
f	0
dl	0
loc	9
ccs	0
cts	6
cp	0
rs	10
cc	1
nc	1
nop	1
crap	2

<?php

/**
 * Trait implementation of the public and private key pair capabilities for asymmetric encryption/signing algorithms.
 */

namespace CryptoManana\Core\Traits\MessageEncryption;

use \CryptoManana\Core\Interfaces\MessageEncryption\KeyPairInterface as KeyPairSpecification;

/**
 * Trait KeyPairTrait - Reusable implementation of `KeyPairInterface`.
 *
 * @see \CryptoManana\Core\Interfaces\MessageDigestion\KeyPairInterface The abstract specification.
 *
 * @package CryptoManana\Core\Traits\MessageEncryption
 *
 * @property string $privateKey The private key string property storage.
 * @property string $publicKey The public key string property storage.
 *
 * @mixin KeyPairSpecification
 */
trait KeyPairTrait
{
    /**
     * Internal method for the validation of the private key string representation format.
     *
     * @param string $privateKey The private key input string.
     *
     * @throws \Exception Validation errors.
     *
     * @internal The parameter is passed via reference from the main logical method for performance reasons.
     */
    protected function validatePrivateKeyFormat(&$privateKey)
    {
        if (!is_string($privateKey)) {

            throw new \InvalidArgumentException('The private key must be a string or a binary string.');
        }

        $isPrivateBase64String = (
            !empty($privateKey) && preg_match('%^[a-zA-Z0-9/+]*={0,2}$%', $privateKey) && strlen($privateKey) % 4 === 0
        );

        if (!$isPrivateBase64String) {
            throw new \InvalidArgumentException('The private key must be a valid Base64 formatted string.');
        }
    }

    /**
     * Internal method for the validation of the public key string representation format.
     *
     * @param string $publicKey The public key input string.
     *
     * @throws \Exception Validation errors.
     *
     * @internal The parameter is passed via reference from the main logical method for performance reasons.
     */
    protected function validatePublicKeyFormat(&$publicKey)
    {
        if (!is_string($publicKey)) {

            throw new \InvalidArgumentException('The public key must be a string or a binary string.');
        }

        $isPublicBase64String = (
            !empty($publicKey) && preg_match('%^[a-zA-Z0-9/+]*={0,2}$%', $publicKey) && strlen($publicKey) % 4 === 0
        );

        if (!$isPublicBase64String) {
            throw new \InvalidArgumentException('The public key must be a valid Base64 formatted string.');
        }
    }

    /**
     * Internal method for the validation of the private key resource.
     *
     * @param string $privateKey The private key input string.
     *
     * @return string The extracted public key string from the private key resource.
     * @throws \Exception Validation errors.
     *
     * @internal The parameter is passed via reference from the main logical method for performance reasons.
     *
     * @codeCoverageIgnore
     */
    protected function validatePrivateKeyResource(&$privateKey)
    {
        // Get the private key
        $privateKeyResource = openssl_pkey_get_private(base64_decode($privateKey));

        if ($privateKeyResource === false) {
            throw new \RuntimeException(
                'Failed to import the private key, probably because of ' .
                'a misconfigured OpenSSL library or an invalid key.'
            );
        }

        $privateKeyInformation = openssl_pkey_get_details($privateKeyResource);

        if ($privateKeyInformation === false) {
            throw new \RuntimeException(
                'Failed to export the key\'s information, probably because of a misconfigured ' .
                'OpenSSL library or an invalid private key.'
            );
        } elseif ($privateKeyInformation['bits'] !== static::KEY_SIZE) {

            throw new \DomainException('The private key is not of the correct size: `' . static::KEY_SIZE . '`.');
        }

        // Free the private key (resource cleanup)
        openssl_free_key($privateKeyResource);
        $privateKeyResource = null;


        return base64_encode((string)$privateKeyInformation['key']); // <- The extracted public key
    }

    /**
     * Internal method for the validation of the public key resource.
     *
     * @param string $publicKey The public key input string.
     *
     * @throws \Exception Validation errors.
     *
     * @internal The parameter is passed via reference from the main logical method for performance reasons.
     *
     * @codeCoverageIgnore
     */
    protected function validatePublicKeyResource(&$publicKey)
    {
        $publicKeyResource = openssl_pkey_get_public(base64_decode($publicKey));

        if ($publicKeyResource === false) {
            throw new \RuntimeException(
                'Failed to import the public key, probably because of ' .
                'a misconfigured OpenSSL library or an invalid key.'
            );
        }

        $publicKeyInformation = openssl_pkey_get_details($publicKeyResource);

        if ($publicKeyInformation === false) {
            throw new \RuntimeException(
                'Failed to export the key\'s information, probably because of a misconfigured ' .
                'OpenSSL library or an invalid public key.'
            );
        } elseif ($publicKeyInformation['bits'] !== static::KEY_SIZE) {

            throw new \DomainException('The public key is not of the correct size: `' . static::KEY_SIZE . '`.');
        }

        // Free the public key (resource cleanup)
        openssl_free_key($publicKeyResource);
        $publicKeyResource = null;

    }

    /**
     * Internal method for the validation of the private and public key pair string representations.
     *
     * @param string $privateKey The private key input string.
     * @param string $publicKey The public key input string.
     *
     * @throws \Exception Validation errors.
     */
    protected function validateKeyPair($privateKey, $publicKey)
    {
        $this->validatePrivateKeyFormat($privateKey);
        $this->validatePublicKeyFormat($publicKey);

        $extractedPublicKey = $this->validatePrivateKeyResource($privateKey);

        $this->validatePublicKeyResource($publicKey);

        // @codeCoverageIgnoreStart
        $thePairIsNotMatching = (
            strlen($extractedPublicKey) !== strlen($publicKey) ||
            substr($extractedPublicKey, -8) !== substr($extractedPublicKey, -8) ||
            hash('sha256', $extractedPublicKey) !== hash('sha256', $publicKey)
        );

        if ($thePairIsNotMatching) {
            throw new \RuntimeException('The private and public key pair are not matching and can not be used.');
        }
        // @codeCoverageIgnoreEnd
    }

    /**
     * Setter for the whole key pair as an array.
     *
     * @param string $privateKey The private key string.
     * @param string $publicKey The public key string.
     *
     * @return $this The encryption/signature algorithm object.
     * @throws \Exception Validation errors.
     */
    public function setKeyPair($privateKey, $publicKey)
    {
        $this->validateKeyPair($privateKey, $publicKey);

        // Set the key pair
        $this->privateKey = $privateKey;
        $this->publicKey = $publicKey;

        return $this;
    }

    /**
     * Getter for the whole key pair as an array.
     *
     * @param bool|int|null $asArray Flag for exporting as an array, instead of an object.
     *
     * @return \stdClass|array The private and public key pair as an object/array.
     */
    public function getKeyPair($asArray = false)
    {
        if ($asArray == true) {
            return [
                self::PRIVATE_KEY_INDEX_NAME => $this->privateKey,

                self::PUBLIC_KEY_INDEX_NAME => $this->publicKey

            ];
        } else {
            $object = new \stdClass();

            $object->{self::PRIVATE_KEY_INDEX_NAME} = $this->privateKey;
            $object->{self::PUBLIC_KEY_INDEX_NAME} = $this->publicKey;

            return $object;
        }
    }

    /**
     * Setter for the private key string property.
     *
     * @param string $privateKey The private key string.
     *
     * @return $this The encryption/signature algorithm object.
     * @throws \Exception Validation errors.
     */
    public function setPrivateKey($privateKey)
    {
        $this->validatePrivateKeyFormat($privateKey);
        $this->validatePrivateKeyResource($privateKey);

        // Set the key pair
        $this->privateKey = $privateKey;

        return $this;
    }

    /**
     * Getter for the private key string property.
     *
     * @return string The private key string.
     */
    public function getPrivateKey()
    {
        return ($this->privateKey !== '') ? $this->privateKey : null;
    }

    /**
     * Setter for the public key string property.
     *
     * @param string $publicKey The public key string.
     *
     * @return $this The encryption/signature algorithm object.
     * @throws \Exception Validation errors.
     */
    public function setPublicKey($publicKey)
    {
        $this->validatePublicKeyFormat($publicKey);
        $this->validatePublicKeyResource($publicKey);

        // Set the key pair
        $this->publicKey = $publicKey;

        return $this;
    }

    /**
     * Getter for the public key string property.
     *
     * @return string The public key string.
     */
    public function getPublicKey()
    {
        return ($this->publicKey !== '') ? $this->publicKey : null;
    }

    /**
     * Checks if the private key is present.
     *
     * @throws \Exception If there is no private key set.
     */
    public function checkIfThePrivateKeyIsSet()
    {
        if ($this->privateKey === '') {
            throw new \RuntimeException('There is no private key set, please generate or import your key pair.');
        }
    }

    /**
     * Checks if the public key is present.
     *
     * @throws \Exception If there is no public key set.
     */
    public function checkIfThePublicKeyIsSet()
    {
        if ($this->publicKey === '') {
            throw new \RuntimeException('There is no public key set, please generate or import your key pair.');
        }
    }
}


1			<?php
2
3			/**
4			* Trait implementation of the public and private key pair capabilities for asymmetric encryption/signing algorithms.
5			*/
6
7			namespace CryptoManana\Core\Traits\MessageEncryption;
8
9			use \CryptoManana\Core\Interfaces\MessageEncryption\KeyPairInterface as KeyPairSpecification;
10
11			/**
12			* Trait KeyPairTrait - Reusable implementation of `KeyPairInterface`.
13			*
14			* @see \CryptoManana\Core\Interfaces\MessageDigestion\KeyPairInterface The abstract specification.
15			*
16			* @package CryptoManana\Core\Traits\MessageEncryption
17			*
18			* @property string $privateKey The private key string property storage.
19			* @property string $publicKey The public key string property storage.
20			*
21			* @mixin KeyPairSpecification
22			*/
23			trait KeyPairTrait
24			{
25			/**
26			* Internal method for the validation of the private key string representation format.
27			*
28			* @param string $privateKey The private key input string.
29			*
30			* @throws \Exception Validation errors.
31			*
32			* @internal The parameter is passed via reference from the main logical method for performance reasons.
33			*/
34			protected function validatePrivateKeyFormat(&$privateKey)
35			{
36			if (!is_string($privateKey)) {
			1 ignored issue – show introduced 2020-01-25 21:22 UTC by Report Bug Copy Issue Report The condition `is_string($privateKey)` is always `true`. Loading history...
37			throw new \InvalidArgumentException('The private key must be a string or a binary string.');
38			}
39
40			$isPrivateBase64String = (
41			!empty($privateKey) && preg_match('%^[a-zA-Z0-9/+]*={0,2}$%', $privateKey) && strlen($privateKey) % 4 === 0
42			);
43
44			if (!$isPrivateBase64String) {
45			throw new \InvalidArgumentException('The private key must be a valid Base64 formatted string.');
46			}
47			}
48
49			/**
50			* Internal method for the validation of the public key string representation format.
51			*
52			* @param string $publicKey The public key input string.
53			*
54			* @throws \Exception Validation errors.
55			*
56			* @internal The parameter is passed via reference from the main logical method for performance reasons.
57			*/
58			protected function validatePublicKeyFormat(&$publicKey)
59			{
60			if (!is_string($publicKey)) {
			1 ignored issue – show introduced 2020-01-25 21:22 UTC by Report Bug Copy Issue Report The condition `is_string($publicKey)` is always `true`. Loading history...
61			throw new \InvalidArgumentException('The public key must be a string or a binary string.');
62			}
63
64			$isPublicBase64String = (
65			!empty($publicKey) && preg_match('%^[a-zA-Z0-9/+]*={0,2}$%', $publicKey) && strlen($publicKey) % 4 === 0
66			);
67
68			if (!$isPublicBase64String) {
69			throw new \InvalidArgumentException('The public key must be a valid Base64 formatted string.');
70			}
71			}
72
73			/**
74			* Internal method for the validation of the private key resource.
75			*
76			* @param string $privateKey The private key input string.
77			*
78			* @return string The extracted public key string from the private key resource.
79			* @throws \Exception Validation errors.
80			*
81			* @internal The parameter is passed via reference from the main logical method for performance reasons.
82			*
83			* @codeCoverageIgnore
84			*/
85			protected function validatePrivateKeyResource(&$privateKey)
86			{
87			// Get the private key
88			$privateKeyResource = openssl_pkey_get_private(base64_decode($privateKey));
89
90			if ($privateKeyResource === false) {
91			throw new \RuntimeException(
92			'Failed to import the private key, probably because of ' .
93			'a misconfigured OpenSSL library or an invalid key.'
94			);
95			}
96
97			$privateKeyInformation = openssl_pkey_get_details($privateKeyResource);
98
99			if ($privateKeyInformation === false) {
100			throw new \RuntimeException(
101			'Failed to export the key\'s information, probably because of a misconfigured ' .
102			'OpenSSL library or an invalid private key.'
103			);
104			} elseif ($privateKeyInformation['bits'] !== static::KEY_SIZE) {
			1 ignored issue – show Bug introduced 2020-01-25 21:22 UTC by Report Bug Copy Issue Report The constant `CryptoManana\Core\Traits...\KeyPairTrait::KEY_SIZE` was not found. Maybe you did not declare it correctly or list all dependencies? Loading history...
105			throw new \DomainException('The private key is not of the correct size: `' . static::KEY_SIZE . '`.');
106			}
107
108			// Free the private key (resource cleanup)
109			openssl_free_key($privateKeyResource);
110			$privateKeyResource = null;
			1 ignored issue – show Unused Code introduced 2020-01-25 21:22 UTC by Report Bug Copy Issue Report The assignment to `$privateKeyResource` is dead and can be removed. Loading history...
111
112			return base64_encode((string)$privateKeyInformation['key']); // <- The extracted public key
113			}
114
115			/**
116			* Internal method for the validation of the public key resource.
117			*
118			* @param string $publicKey The public key input string.
119			*
120			* @throws \Exception Validation errors.
121			*
122			* @internal The parameter is passed via reference from the main logical method for performance reasons.
123			*
124			* @codeCoverageIgnore
125			*/
126			protected function validatePublicKeyResource(&$publicKey)
127			{
128			$publicKeyResource = openssl_pkey_get_public(base64_decode($publicKey));
129
130			if ($publicKeyResource === false) {
131			throw new \RuntimeException(
132			'Failed to import the public key, probably because of ' .
133			'a misconfigured OpenSSL library or an invalid key.'
134			);
135			}
136
137			$publicKeyInformation = openssl_pkey_get_details($publicKeyResource);
138
139			if ($publicKeyInformation === false) {
140			throw new \RuntimeException(
141			'Failed to export the key\'s information, probably because of a misconfigured ' .
142			'OpenSSL library or an invalid public key.'
143			);
144			} elseif ($publicKeyInformation['bits'] !== static::KEY_SIZE) {
			1 ignored issue – show Bug introduced 2020-01-25 21:22 UTC by Report Bug Copy Issue Report The constant `CryptoManana\Core\Traits...\KeyPairTrait::KEY_SIZE` was not found. Maybe you did not declare it correctly or list all dependencies? Loading history...
145			throw new \DomainException('The public key is not of the correct size: `' . static::KEY_SIZE . '`.');
146			}
147
148			// Free the public key (resource cleanup)
149			openssl_free_key($publicKeyResource);
150			$publicKeyResource = null;
			1 ignored issue – show Unused Code introduced 2020-01-25 21:22 UTC by Report Bug Copy Issue Report The assignment to `$publicKeyResource` is dead and can be removed. Loading history...
151			}
152
153			/**
154			* Internal method for the validation of the private and public key pair string representations.
155			*
156			* @param string $privateKey The private key input string.
157			* @param string $publicKey The public key input string.
158			*
159			* @throws \Exception Validation errors.
160			*/
161			protected function validateKeyPair($privateKey, $publicKey)
162			{
163			$this->validatePrivateKeyFormat($privateKey);
164			$this->validatePublicKeyFormat($publicKey);
165
166			$extractedPublicKey = $this->validatePrivateKeyResource($privateKey);
167
168			$this->validatePublicKeyResource($publicKey);
169
170			// @codeCoverageIgnoreStart
171			$thePairIsNotMatching = (
172			strlen($extractedPublicKey) !== strlen($publicKey) \|\|
173			substr($extractedPublicKey, -8) !== substr($extractedPublicKey, -8) \|\|
174			hash('sha256', $extractedPublicKey) !== hash('sha256', $publicKey)
175			);
176
177			if ($thePairIsNotMatching) {
178			throw new \RuntimeException('The private and public key pair are not matching and can not be used.');
179			}
180			// @codeCoverageIgnoreEnd
181			}
182
183			/**
184			* Setter for the whole key pair as an array.
185			*
186			* @param string $privateKey The private key string.
187			* @param string $publicKey The public key string.
188			*
189			* @return $this The encryption/signature algorithm object.
190			* @throws \Exception Validation errors.
191			*/
192			public function setKeyPair($privateKey, $publicKey)
193			{
194			$this->validateKeyPair($privateKey, $publicKey);
195
196			// Set the key pair
197			$this->privateKey = $privateKey;
198			$this->publicKey = $publicKey;
199
200			return $this;
201			}
202
203			/**
204			* Getter for the whole key pair as an array.
205			*
206			* @param bool\|int\|null $asArray Flag for exporting as an array, instead of an object.
207			*
208			* @return \stdClass\|array The private and public key pair as an object/array.
209			*/
210			public function getKeyPair($asArray = false)
211			{
212			if ($asArray == true) {
213			return [
214			self::PRIVATE_KEY_INDEX_NAME => $this->privateKey,
			1 ignored issue – show Bug introduced 2020-01-25 21:22 UTC by Report Bug Copy Issue Report The constant `CryptoManana\Core\Traits...:PRIVATE_KEY_INDEX_NAME` was not found. Maybe you did not declare it correctly or list all dependencies? Loading history...
215			self::PUBLIC_KEY_INDEX_NAME => $this->publicKey
			1 ignored issue – show Bug introduced 2020-01-25 21:22 UTC by Report Bug Copy Issue Report The constant `CryptoManana\Core\Traits...::PUBLIC_KEY_INDEX_NAME` was not found. Maybe you did not declare it correctly or list all dependencies? Loading history...
216			];
217			} else {
218			$object = new \stdClass();
219
220			$object->{self::PRIVATE_KEY_INDEX_NAME} = $this->privateKey;
221			$object->{self::PUBLIC_KEY_INDEX_NAME} = $this->publicKey;
222
223			return $object;
224			}
225			}
226
227			/**
228			* Setter for the private key string property.
229			*
230			* @param string $privateKey The private key string.
231			*
232			* @return $this The encryption/signature algorithm object.
233			* @throws \Exception Validation errors.
234			*/
235			public function setPrivateKey($privateKey)
236			{
237			$this->validatePrivateKeyFormat($privateKey);
238			$this->validatePrivateKeyResource($privateKey);
239
240			// Set the key pair
241			$this->privateKey = $privateKey;
242
243			return $this;
244			}
245
246			/**
247			* Getter for the private key string property.
248			*
249			* @return string The private key string.
250			*/
251			public function getPrivateKey()
252			{
253			return ($this->privateKey !== '') ? $this->privateKey : null;
254			}
255
256			/**
257			* Setter for the public key string property.
258			*
259			* @param string $publicKey The public key string.
260			*
261			* @return $this The encryption/signature algorithm object.
262			* @throws \Exception Validation errors.
263			*/
264			public function setPublicKey($publicKey)
265			{
266			$this->validatePublicKeyFormat($publicKey);
267			$this->validatePublicKeyResource($publicKey);
268
269			// Set the key pair
270			$this->publicKey = $publicKey;
271
272			return $this;
273			}
274
275			/**
276			* Getter for the public key string property.
277			*
278			* @return string The public key string.
279			*/
280			public function getPublicKey()
281			{
282			return ($this->publicKey !== '') ? $this->publicKey : null;
283			}
284
285			/**
286			* Checks if the private key is present.
287			*
288			* @throws \Exception If there is no private key set.
289			*/
290			public function checkIfThePrivateKeyIsSet()
291			{
292			if ($this->privateKey === '') {
293			throw new \RuntimeException('There is no private key set, please generate or import your key pair.');
294			}
295			}
296
297			/**
298			* Checks if the public key is present.
299			*
300			* @throws \Exception If there is no public key set.
301			*/
302			public function checkIfThePublicKeyIsSet()
303			{
304			if ($this->publicKey === '') {
305			throw new \RuntimeException('There is no public key set, please generate or import your key pair.');
306			}
307			}
308			}
309

TonyKaravasilev / CryptoManana

Push — master ( a44b29...b8fcd2 )

KeyPairTrait::setPublicKey() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like