AbstractBlockCipherAlgorithm::validatePlainDataForEncryption() - Code Metrics - Inspection of "Fixed a few coding style issues found by Scrutiniz..." - TonyKaravasilev/CryptoManana - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 2242a1...272748 )

by Tony Karavasilev (Тони

created 2020-01-21 11:55 UTC

validatePlainDataForEncryption() A

↳ Parent: AbstractBlockCipherAlgorithm

Complexity

Conditions	2
Paths	2

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	2

Importance

Changes

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

<?php

/**
 * The symmetric block cipher encryption algorithm abstraction specification.
 */

namespace CryptoManana\Core\Abstractions\MessageEncryption;

use \CryptoManana\Core\Abstractions\MessageEncryption\AbstractSymmetricEncryptionAlgorithm as SymmetricCipherAlgorithm;
use \CryptoManana\Core\Interfaces\MessageEncryption\BlockOperationsInterface as CipherBlockOperations;
use \CryptoManana\Core\Interfaces\MessageEncryption\ObjectEncryptionInterface as ObjectEncryption;
use \CryptoManana\Core\Interfaces\MessageEncryption\FileEncryptionInterface as FileEncryption;
use \CryptoManana\Core\Traits\MessageEncryption\BlockOperationsTrait as CipherBlockInteractions;
use \CryptoManana\Core\Traits\MessageEncryption\ObjectEncryptionTrait as EncryptObjects;
use \CryptoManana\Core\Traits\MessageEncryption\FileEncryptionTrait as EncryptFiles;

/**
 * Class AbstractBlockCipherAlgorithm - The symmetric block cipher algorithm abstraction representation.
 *
 * @package CryptoManana\Core\Abstractions\MessageEncryption
 *
 * @mixin CipherBlockInteractions
 * @mixin EncryptObjects
 * @mixin EncryptFiles
 */
abstract class AbstractBlockCipherAlgorithm extends SymmetricCipherAlgorithm implements
    CipherBlockOperations,
    ObjectEncryption,
    FileEncryption
{
    /**
     * Block cipher capabilities and data operations.
     *
     * {@internal Reusable implementation of `BlockOperationsInterface`. }}
     */
    use CipherBlockInteractions;

    /**
     * Object encryption and decryption capabilities.
     *
     * {@internal Reusable implementation of `ObjectEncryptionInterface`. }}
     */
    use EncryptObjects;

    /**
     * File content encryption and decryption capabilities.
     *
     * {@internal Reusable implementation of `FileEncryptionInterface`. }}
     */
    use EncryptFiles;

    /**
     * The internal operational block size measured in raw bytes length for the algorithm
     */
    const BLOCK_SIZE = 0;

    /**
     * The internal initialization vector (IV) size measured in raw bytes length for the algorithm
     */
    const IV_SIZE = 0;

    /**
     * The initialization vector (IV) string property storage.
     *
     * @var string The initialization vector (IV) string value.
     */
    protected $iv = '';

    /**
     * The block encryption operation mode string property.
     *
     * @var string The block encryption operation mode string value.
     */
    protected $mode = self::CBC_MODE;

    /**
     * The final block padding operation property.
     *
     * @var int The final block padding operation string value.
     */
    protected $padding = self::PKCS7_PADDING;

    /**
     * Fetch the correctly formatted internal encryption algorithm method name.
     *
     * @return string The symmetric encryption algorithm standard.
     */
    protected function fetchAlgorithmMethodName()
    {
        return static::ALGORITHM_NAME . '-' . (static::KEY_SIZE * 8) . '-' . $this->mode;
    }

    /**
     * Internal method for the validation of plain data used at encryption operations.
     *
     * @param string $plainData The plain input string.
     *
     * @throws \Exception Validation errors.
     */
    protected function validatePlainDataForEncryption($plainData)
    {
        if (!is_string($plainData)) {
            throw new \InvalidArgumentException('The data for encryption must be a string or a binary string.');
        }
    }

    /**
     * Internal method for the validation of cipher data used at decryption operations.
     *
     * @param string $cipherData The encrypted input string.
     *
     * @throws \Exception Validation errors.
     */
    protected function validateCipherDataForDecryption($cipherData)
    {
        if (!is_string($cipherData)) {
            throw new \InvalidArgumentException('The data for decryption must be a string or a binary string.');
        } elseif ($cipherData === '') {
            throw new \InvalidArgumentException('The string is empty and there is nothing to decrypt from it.');
        }
    }

    /**
     * Block cipher algorithm constructor.
     */
    public function __construct()
    {
        /**
         * {@internal Serialization and initialization purposes for both the default key and IV. }}
         */
        if ($this->key === '') {
            $this->key = str_pad($this->key, static::KEY_SIZE, "\x0", STR_PAD_RIGHT);
        }

        if ($this->iv === '') {
            $this->iv = str_pad($this->iv, static::BLOCK_SIZE, "\x0", STR_PAD_RIGHT);
        }

        // @codeCoverageIgnoreStart
        if (!in_array($this->fetchAlgorithmMethodName(), openssl_get_cipher_methods(), true)) {
            throw new \RuntimeException(
                'The algorithm `' .
                $this->fetchAlgorithmMethodName() .
                '`is not supported under the current system configuration.'
            );
        }
        // @codeCoverageIgnoreEnd
    }

    /**
     * Encrypts the given plain data.
     *
     * @param string $plainData The plain input string.
     *
     * @return string The cipher/encrypted data.
     * @throws \Exception Validation errors.
     */
    public function encryptData($plainData)
    {
        $this->validatePlainDataForEncryption($plainData);

        if ($plainData === '') {
            $plainData = str_pad($plainData, static::BLOCK_SIZE, "\x0", STR_PAD_RIGHT);
        }

        $isZeroPadding = ($this->padding === self::ZERO_PADDING);
        $iv = ($this->mode === self::ECB_MODE) ? '' : $this->iv;

        /**
         * {@internal The encryption standard is 8-bit wise (don not use StringBuilder) and utilizes performance. }}
         */
        if ($isZeroPadding) {
            $plainData .= str_repeat("\x0", (static::BLOCK_SIZE - (strlen($plainData) % static::BLOCK_SIZE)));
        }

        $cipherData = openssl_encrypt($plainData, $this->fetchAlgorithmMethodName(), $this->key, $this->padding, $iv);

        /**
         * {@internal The zero padding in raw mode comes as Base64 string from OpenSSL by specification. }}
         */
        $cipherData = ($isZeroPadding) ? base64_decode($cipherData) : $cipherData;

        $cipherData = $this->changeOutputFormat($cipherData, true);

        return $cipherData;
    }

    /**
     * Decrypts the given cipher data.
     *
     * @param string $cipherData The encrypted input string.
     *
     * @return string The decrypted/plain data.
     * @throws \Exception Validation errors.
     */
    public function decryptData($cipherData)
    {
        $this->validateCipherDataForDecryption($cipherData);

        $iv = ($this->mode === self::ECB_MODE) ? '' : $this->iv;
        $isZeroPadding = ($this->padding === self::ZERO_PADDING);

        $cipherData = $this->changeOutputFormat($cipherData, false);

        /**
         * {@internal The zero padding in raw mode comes as Base64 string from OpenSSL by specification. }}
         */
        $cipherData = ($isZeroPadding) ? base64_encode($cipherData) : $cipherData;

        $plainData = openssl_decrypt($cipherData, $this->fetchAlgorithmMethodName(), $this->key, $this->padding, $iv);

        // Wrong format verification
        if ($plainData === false) {
            throw new \RuntimeException(
                "The passed string was not from the chosen outputting format `{$this->getCipherFormat()}`."
            );
        }

        return ($isZeroPadding) ? rtrim($plainData, "\x0") : $plainData;
    }

    /**
     * Get debug information for the class instance.
     *
     * @return array Debug information.
     */
    public function __debugInfo()
    {
        return [
            'standard' => static::ALGORITHM_NAME,
            'type' => 'symmetrical encryption or two-way block cipher',
            'block size in bits' => static::BLOCK_SIZE * 8,
            'key size in bits' => static::KEY_SIZE * 8,
            'iv size in bits' => static::IV_SIZE * 8,
            'block operation mode' => $this->mode,
            'padding standard' => $this->padding === self::PKCS7_PADDING ? 'PKCS7' : 'zero padding',
            'secret key' => $this->key,
            'initialization vector' => $this->iv,
            'internal algorithm full name' => $this->fetchAlgorithmMethodName(),
            'internal long data digestion algorithm' => 'HKDF-SHA-2-128',
        ];
    }
}


1		<?php
2
3		/**
4		* The symmetric block cipher encryption algorithm abstraction specification.
5		*/
6
7		namespace CryptoManana\Core\Abstractions\MessageEncryption;
8
9		use \CryptoManana\Core\Abstractions\MessageEncryption\AbstractSymmetricEncryptionAlgorithm as SymmetricCipherAlgorithm;
10		use \CryptoManana\Core\Interfaces\MessageEncryption\BlockOperationsInterface as CipherBlockOperations;
11		use \CryptoManana\Core\Interfaces\MessageEncryption\ObjectEncryptionInterface as ObjectEncryption;
12		use \CryptoManana\Core\Interfaces\MessageEncryption\FileEncryptionInterface as FileEncryption;
13		use \CryptoManana\Core\Traits\MessageEncryption\BlockOperationsTrait as CipherBlockInteractions;
14		use \CryptoManana\Core\Traits\MessageEncryption\ObjectEncryptionTrait as EncryptObjects;
15		use \CryptoManana\Core\Traits\MessageEncryption\FileEncryptionTrait as EncryptFiles;
16
17		/**
18		* Class AbstractBlockCipherAlgorithm - The symmetric block cipher algorithm abstraction representation.
19		*
20		* @package CryptoManana\Core\Abstractions\MessageEncryption
21		*
22		* @mixin CipherBlockInteractions
23		* @mixin EncryptObjects
24		* @mixin EncryptFiles
25		*/
26		abstract class AbstractBlockCipherAlgorithm extends SymmetricCipherAlgorithm implements
27		CipherBlockOperations,
28		ObjectEncryption,
29		FileEncryption
30		{
31		/**
32		* Block cipher capabilities and data operations.
33		*
34		* {@internal Reusable implementation of `BlockOperationsInterface`. }}
35		*/
36		use CipherBlockInteractions;
37
38		/**
39		* Object encryption and decryption capabilities.
40		*
41		* {@internal Reusable implementation of `ObjectEncryptionInterface`. }}
42		*/
43		use EncryptObjects;
44
45		/**
46		* File content encryption and decryption capabilities.
47		*
48		* {@internal Reusable implementation of `FileEncryptionInterface`. }}
49		*/
50		use EncryptFiles;
51
52		/**
53		* The internal operational block size measured in raw bytes length for the algorithm
54		*/
55		const BLOCK_SIZE = 0;
56
57		/**
58		* The internal initialization vector (IV) size measured in raw bytes length for the algorithm
59		*/
60		const IV_SIZE = 0;
61
62		/**
63		* The initialization vector (IV) string property storage.
64		*
65		* @var string The initialization vector (IV) string value.
66		*/
67		protected $iv = '';
68
69		/**
70		* The block encryption operation mode string property.
71		*
72		* @var string The block encryption operation mode string value.
73		*/
74		protected $mode = self::CBC_MODE;
75
76		/**
77		* The final block padding operation property.
78		*
79		* @var int The final block padding operation string value.
80		*/
81		protected $padding = self::PKCS7_PADDING;
82
83		/**
84		* Fetch the correctly formatted internal encryption algorithm method name.
85		*
86		* @return string The symmetric encryption algorithm standard.
87		*/
88	372	protected function fetchAlgorithmMethodName()
89		{
90	372	return static::ALGORITHM_NAME . '-' . (static::KEY_SIZE * 8) . '-' . $this->mode;
91		}
92
93		/**
94		* Internal method for the validation of plain data used at encryption operations.
95		*
96	372	* @param string $plainData The plain input string.
97		*
98		* @throws \Exception Validation errors.
99		*/
100		protected function validatePlainDataForEncryption($plainData)
101	372	{
102	372	if (!is_string($plainData)) {
103		throw new \InvalidArgumentException('The data for encryption must be a string or a binary string.');
104		}
105	372	}
106	372
107		/**
108		* Internal method for the validation of cipher data used at decryption operations.
109		*
110		* @param string $cipherData The encrypted input string.
111		*
112		* @throws \Exception Validation errors.
113		*/
114		protected function validateCipherDataForDecryption($cipherData)
115		{
116		if (!is_string($cipherData)) {
117		throw new \InvalidArgumentException('The data for decryption must be a string or a binary string.');
118	372	} elseif ($cipherData === '') {
119		throw new \InvalidArgumentException('The string is empty and there is nothing to decrypt from it.');
120		}
121		}
122
123		/**
124		* Block cipher algorithm constructor.
125		*/
126		public function __construct()
127		{
128	156	/**
129		* {@internal Serialization and initialization purposes for both the default key and IV. }}
130	156	*/
131	12	if ($this->key === '') {
132		$this->key = str_pad($this->key, static::KEY_SIZE, "\x0", STR_PAD_RIGHT);
133		}
134	144
135	24	if ($this->iv === '') {
136		$this->iv = str_pad($this->iv, static::BLOCK_SIZE, "\x0", STR_PAD_RIGHT);
137		}
138
139		// @codeCoverageIgnoreStart
140		if (!in_array($this->fetchAlgorithmMethodName(), openssl_get_cipher_methods(), true)) {
141	144	throw new \RuntimeException(
142	12	'The algorithm `' .
143		$this->fetchAlgorithmMethodName() .
144	12	'`is not supported under the current system configuration.'
145	12	);
146		}
147		// @codeCoverageIgnoreEnd
148		}
149	144
150		/**
151	144	* Encrypts the given plain data.
152		*
153	144	* @param string $plainData The plain input string.
154		*
155		* @return string The cipher/encrypted data.
156		* @throws \Exception Validation errors.
157		*/
158	144	public function encryptData($plainData)
159	12	{
160		$this->validatePlainDataForEncryption($plainData);
161
162	144	if ($plainData === '') {
163		$plainData = str_pad($plainData, static::BLOCK_SIZE, "\x0", STR_PAD_RIGHT);
164	144	}
165
166		$isZeroPadding = ($this->padding === self::ZERO_PADDING);
167		$iv = ($this->mode === self::ECB_MODE) ? '' : $this->iv;
168
169		/**
170		* {@internal The encryption standard is 8-bit wise (don not use StringBuilder) and utilizes performance. }}
171		*/
172		if ($isZeroPadding) {
173		$plainData .= str_repeat("\x0", (static::BLOCK_SIZE - (strlen($plainData) % static::BLOCK_SIZE)));
174		}
175	144
176		$cipherData = openssl_encrypt($plainData, $this->fetchAlgorithmMethodName(), $this->key, $this->padding, $iv);
177	144
178	12	/**
179	132	* {@internal The zero padding in raw mode comes as Base64 string from OpenSSL by specification. }}
180	12	*/
181		$cipherData = ($isZeroPadding) ? base64_decode($cipherData) : $cipherData;
182
183	120	$cipherData = $this->changeOutputFormat($cipherData, true);
184
185		return $cipherData;
186		}
187
188	120	/**
189	12	* Decrypts the given cipher data.
190		*
191		* @param string $cipherData The encrypted input string.
192	120	*
193		* @return string The decrypted/plain data.
194	120	* @throws \Exception Validation errors.
195		*/
196	120	public function decryptData($cipherData)
197		{
198		$this->validateCipherDataForDecryption($cipherData);
199	120
200	12	$iv = ($this->mode === self::ECB_MODE) ? '' : $this->iv;
201	12	$isZeroPadding = ($this->padding === self::ZERO_PADDING);
202
203		$cipherData = $this->changeOutputFormat($cipherData, false);
204
205	108	/**
206	12	* {@internal The zero padding in raw mode comes as Base64 string from OpenSSL by specification. }}
207		*/
208		$cipherData = ($isZeroPadding) ? base64_encode($cipherData) : $cipherData;
209	108
210		$plainData = openssl_decrypt($cipherData, $this->fetchAlgorithmMethodName(), $this->key, $this->padding, $iv);
211
212		// Wrong format verification
213		if ($plainData === false) {
214		throw new \RuntimeException(
215		"The passed string was not from the chosen outputting format `{$this->getCipherFormat()}`."
216		);
217	12	}
218
219		return ($isZeroPadding) ? rtrim($plainData, "\x0") : $plainData;
220	12	}
221	12
222	12	/**
223	12	* Get debug information for the class instance.
224	12	*
225	12	* @return array Debug information.
226	12	*/
227	12	public function __debugInfo()
228	12	{
229	12	return [
230	12	'standard' => static::ALGORITHM_NAME,
231		'type' => 'symmetrical encryption or two-way block cipher',
232		'block size in bits' => static::BLOCK_SIZE * 8,
233		'key size in bits' => static::KEY_SIZE * 8,
234		'iv size in bits' => static::IV_SIZE * 8,
235		'block operation mode' => $this->mode,
236		'padding standard' => $this->padding === self::PKCS7_PADDING ? 'PKCS7' : 'zero padding',
237		'secret key' => $this->key,
238		'initialization vector' => $this->iv,
239		'internal algorithm full name' => $this->fetchAlgorithmMethodName(),
240		'internal long data digestion algorithm' => 'HKDF-SHA-2-128',
241		];
242		}
243		}
244

TonyKaravasilev / CryptoManana

Push — master ( 2242a1...272748 )

validatePlainDataForEncryption() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like