TokenGenerator::getEncryptionInitializationVector() - Code Metrics - Inspection of "Reduced the complexity of some methods and updated..." - TonyKaravasilev/CryptoManana - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Branch — master (b68521)

by Tony Karavasilev (Тони

created 2019-04-01 20:34 UTC

getEncryptionInitializationVector() A

↳ Parent: TokenGenerator

Complexity

Conditions	2
Paths	2

Size

Total Lines	5
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	3
CRAP Score	2

Importance

Changes

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

<?php

/**
 * Utility class for cryptography key and token generation.
 */

namespace CryptoManana\Utilities;

use \CryptoManana\Core\Abstractions\Containers\AbstractRandomnessInjectable as RandomnessContainer;
use \CryptoManana\Core\Interfaces\Randomness\EncryptionKeyGenerationInterface as EncryptionKeyGeneration;
use \CryptoManana\Core\Interfaces\Randomness\HashingKeyGenerationInterface as HashingKeyGeneration;
use \CryptoManana\Core\Interfaces\Randomness\TokenGenerationInterface as TokenStringGeneration;
use \CryptoManana\Core\StringBuilder as StringBuilder;

/**
 * Class TokenGenerator - Utility class for cryptography token generation.
 *
 * @package CryptoManana\Utilities
 *
 * @property \CryptoManana\Core\Abstractions\Randomness\AbstractGenerator $randomnessSource
 */
class TokenGenerator extends RandomnessContainer implements
    TokenStringGeneration,
    HashingKeyGeneration,
    EncryptionKeyGeneration
{
    /**
     * Internal method for validation of positive output length.
     *
     * @param int $length The output length value for validation.
     *
     * @throws \Exception Validation errors.
     */
    protected function applyLengthValidation($length)
    {
        $length = filter_var(
            $length,
            FILTER_VALIDATE_INT,
            [
                "options" => [
                    "min_range" => 1,
                    "max_range" => PHP_INT_MAX,
                ],
            ]
        );

        if ($length === false) {
            throw new \LengthException(
                'The length of the desired output data must me at least 1 character long.'
            );
        }
    }

    /**
     * Internal method for generation of characters used for secure password string building.
     *
     * @param int|mixed $case Generation case as integer.
     *
     * @return string Password character.
     * @throws \Exception Validation Errors.
     */
    protected function getPasswordCharacter($case)
    {
        switch ($case) {
            case 1:
                return $this->randomnessSource->getDigit(true);
            case 2:
                return $this->randomnessSource->getLetter(false);
            case 3:
                return StringBuilder::stringToUpper($this->randomnessSource->getLetter(false));

            default:
                return $this->randomnessSource->getString(1, ['!', '@', '#', '$', '%', '^']);
        }
    }

    /**
     * Generate a random token string in alphanumeric or hexadecimal format.
     *
     * Note: This method can generate HEX output if the `$useAlphaNumeric` parameter is set to `false`.
     *
     * @param int $length The desired output length (default => 40).
     * @param bool|int $useAlphaNumeric Flag for switching to alphanumerical (default => true).
     *
     * @return string Randomly generated alphanumeric/hexadecimal token string.
     * @throws \Exception Validation errors.
     */
    public function getTokenString($length = 40, $useAlphaNumeric = true)
    {
        $this->applyLengthValidation($length);

        if ($useAlphaNumeric) {
            $token = $this->randomnessSource->getAlphaNumeric($length, true);
        } else {
            $token = $this->randomnessSource->getHex($length, true);
        }

        return StringBuilder::stringReverse($token);
    }

    /**
     * Generate a random password string.
     *
     * Note: This method can use more special symbols on generation if the `$stronger` parameter is set to `true`.
     *
     * @param int $length The desired output length (default => 10).
     * @param bool|int $stronger Flag for using all printable ASCII characters (default => true).
     *
     * @return string Randomly generated password string.
     * @throws \Exception Validation errors.
     */
    public function getPasswordString($length = 10, $stronger = true)
    {
        $this->applyLengthValidation($length);

        if ($stronger) {
            $password = $this->randomnessSource->getAscii($length);
        } else {
            $password = '';

            for ($i = 1; $i <= $length; $i++) {
                $case = $this->randomnessSource->getInt(1, 4);

                $password .= $this->getPasswordCharacter($case);
            }
        }

        return $password;
    }

    /**
     * Generate a random HMAC key for hashing purposes.
     *
     * Note: The output string can be in raw bytes of the `$printable` parameter is set to `true`.
     *
     * @param int $length The desired output length (default => 128).
     * @param bool|int $printable Flag for using only printable characters instead of bytes (default => true).
     *
     * @return string Randomly generated HMAC key.
     * @throws \Exception Validation errors.
     */
    public function getHashingKey($length = 128, $printable = true)
    {
        $this->applyLengthValidation($length);

        return ($printable) ? $this->randomnessSource->getAscii($length) : $this->randomnessSource->getBytes($length);
    }

    /**
     * Generate a random salt string for hashing purposes.
     *
     * Note: The output string can be in raw bytes of the `$printable` parameter is set to `true`.
     *
     * @param int $length The desired output length (default => 128).
     * @param bool|int $printable Flag for using only printable characters instead of bytes (default => true).
     *
     * @return string Randomly generated hashing salt.
     * @throws \Exception Validation errors.
     */
    public function getHashingSalt($length = 128, $printable = true)
    {
        $this->applyLengthValidation($length);

        return ($printable) ? $this->randomnessSource->getAscii($length) : $this->randomnessSource->getBytes($length);
    }

    /**
     * Generate a random encryption key for symmetrical cyphers.
     *
     * Note: The output string can be in raw bytes of the `$printable` parameter is set to `true`.
     *
     * @param int $length The desired output length (default => 128).
     * @param bool|int $printable Flag for using only printable characters instead of bytes (default => true).
     *
     * @return string Randomly generated encryption key.
     * @throws \Exception Validation errors.
     */
    public function getEncryptionKey($length = 128, $printable = true)
    {
        $this->applyLengthValidation($length);

        return ($printable) ? $this->randomnessSource->getAscii($length) : $this->randomnessSource->getBytes($length);
    }

    /**
     * Generate a random initialization vector (IV) for encryption purposes.
     *
     * Note: The output string can be in raw bytes of the `$printable` parameter is set to `true`.
     *
     * @param int $length The desired output length (default => 128).
     * @param bool|int $printable Flag for using only printable characters instead of bytes (default => true).
     *
     * @return string Randomly generated encryption initialization vector.
     * @throws \Exception Validation errors.
     */
    public function getEncryptionInitializationVector($length = 128, $printable = true)
    {
        $this->applyLengthValidation($length);

        return ($printable) ? $this->randomnessSource->getAscii($length) : $this->randomnessSource->getBytes($length);
    }
}


1		<?php
2
3		/**
4		* Utility class for cryptography key and token generation.
5		*/
6
7		namespace CryptoManana\Utilities;
8
9		use \CryptoManana\Core\Abstractions\Containers\AbstractRandomnessInjectable as RandomnessContainer;
10		use \CryptoManana\Core\Interfaces\Randomness\EncryptionKeyGenerationInterface as EncryptionKeyGeneration;
11		use \CryptoManana\Core\Interfaces\Randomness\HashingKeyGenerationInterface as HashingKeyGeneration;
12		use \CryptoManana\Core\Interfaces\Randomness\TokenGenerationInterface as TokenStringGeneration;
13		use \CryptoManana\Core\StringBuilder as StringBuilder;
14
15		/**
16		* Class TokenGenerator - Utility class for cryptography token generation.
17		*
18		* @package CryptoManana\Utilities
19		*
20		* @property \CryptoManana\Core\Abstractions\Randomness\AbstractGenerator $randomnessSource
21		*/
22		class TokenGenerator extends RandomnessContainer implements
23		TokenStringGeneration,
24		HashingKeyGeneration,
25		EncryptionKeyGeneration
26		{
27		/**
28		* Internal method for validation of positive output length.
29		*
30		* @param int $length The output length value for validation.
31		*
32		* @throws \Exception Validation errors.
33		*/
34	9	protected function applyLengthValidation($length)
35		{
36	9	$length = filter_var(
37	9	$length,
38	9	FILTER_VALIDATE_INT,
39		[
40		"options" => [
41	9	"min_range" => 1,
42	9	"max_range" => PHP_INT_MAX,
43		],
44		]
45		);
46
47	9	if ($length === false) {
48	1	throw new \LengthException(
49	1	'The length of the desired output data must me at least 1 character long.'
50		);
51		}
52	8	}
53
54		/**
55		* Internal method for generation of characters used for secure password string building.
56		*
57		* @param int\|mixed $case Generation case as integer.
58		*
59		* @return string Password character.
60		* @throws \Exception Validation Errors.
61		*/
62	1	protected function getPasswordCharacter($case)
63		{
64		switch ($case) {
65	1	case 1:
66	1	return $this->randomnessSource->getDigit(true);
67	1	case 2:
68	1	return $this->randomnessSource->getLetter(false);
69	1	case 3:
70	1	return StringBuilder::stringToUpper($this->randomnessSource->getLetter(false));
71
72		default:
73	1	return $this->randomnessSource->getString(1, ['!', '@', '#', '$', '%', '^']);
74		}
75		}
76
77		/**
78		* Generate a random token string in alphanumeric or hexadecimal format.
79		*
80		* Note: This method can generate HEX output if the `$useAlphaNumeric` parameter is set to `false`.
81		*
82		* @param int $length The desired output length (default => 40).
83		* @param bool\|int $useAlphaNumeric Flag for switching to alphanumerical (default => true).
84		*
85		* @return string Randomly generated alphanumeric/hexadecimal token string.
86		* @throws \Exception Validation errors.
87		*/
88	4	public function getTokenString($length = 40, $useAlphaNumeric = true)
89		{
90	4	$this->applyLengthValidation($length);
91
92	3	if ($useAlphaNumeric) {
93	3	$token = $this->randomnessSource->getAlphaNumeric($length, true);
94		} else {
95	1	$token = $this->randomnessSource->getHex($length, true);
96		}
97
98	3	return StringBuilder::stringReverse($token);
99		}
100
101		/**
102		* Generate a random password string.
103		*
104		* Note: This method can use more special symbols on generation if the `$stronger` parameter is set to `true`.
105		*
106		* @param int $length The desired output length (default => 10).
107		* @param bool\|int $stronger Flag for using all printable ASCII characters (default => true).
108		*
109		* @return string Randomly generated password string.
110		* @throws \Exception Validation errors.
111		*/
112	1	public function getPasswordString($length = 10, $stronger = true)
113		{
114	1	$this->applyLengthValidation($length);
115
116	1	if ($stronger) {
117	1	$password = $this->randomnessSource->getAscii($length);
118		} else {
119	1	$password = '';
120
121	1	for ($i = 1; $i <= $length; $i++) {
122	1	$case = $this->randomnessSource->getInt(1, 4);
123
124	1	$password .= $this->getPasswordCharacter($case);
125		}
126		}
127
128	1	return $password;
129		}
130
131		/**
132		* Generate a random HMAC key for hashing purposes.
133		*
134		* Note: The output string can be in raw bytes of the `$printable` parameter is set to `true`.
135		*
136		* @param int $length The desired output length (default => 128).
137		* @param bool\|int $printable Flag for using only printable characters instead of bytes (default => true).
138		*
139		* @return string Randomly generated HMAC key.
140		* @throws \Exception Validation errors.
141		*/
142	1	public function getHashingKey($length = 128, $printable = true)
143		{
144	1	$this->applyLengthValidation($length);
145
146	1	return ($printable) ? $this->randomnessSource->getAscii($length) : $this->randomnessSource->getBytes($length);
147		}
148
149		/**
150		* Generate a random salt string for hashing purposes.
151		*
152		* Note: The output string can be in raw bytes of the `$printable` parameter is set to `true`.
153		*
154		* @param int $length The desired output length (default => 128).
155		* @param bool\|int $printable Flag for using only printable characters instead of bytes (default => true).
156		*
157		* @return string Randomly generated hashing salt.
158		* @throws \Exception Validation errors.
159		*/
160	1	public function getHashingSalt($length = 128, $printable = true)
161		{
162	1	$this->applyLengthValidation($length);
163
164	1	return ($printable) ? $this->randomnessSource->getAscii($length) : $this->randomnessSource->getBytes($length);
165		}
166
167		/**
168		* Generate a random encryption key for symmetrical cyphers.
169		*
170		* Note: The output string can be in raw bytes of the `$printable` parameter is set to `true`.
171		*
172		* @param int $length The desired output length (default => 128).
173		* @param bool\|int $printable Flag for using only printable characters instead of bytes (default => true).
174		*
175		* @return string Randomly generated encryption key.
176		* @throws \Exception Validation errors.
177		*/
178	1	public function getEncryptionKey($length = 128, $printable = true)
179		{
180	1	$this->applyLengthValidation($length);
181
182	1	return ($printable) ? $this->randomnessSource->getAscii($length) : $this->randomnessSource->getBytes($length);
183		}
184
185		/**
186		* Generate a random initialization vector (IV) for encryption purposes.
187		*
188		* Note: The output string can be in raw bytes of the `$printable` parameter is set to `true`.
189		*
190		* @param int $length The desired output length (default => 128).
191		* @param bool\|int $printable Flag for using only printable characters instead of bytes (default => true).
192		*
193		* @return string Randomly generated encryption initialization vector.
194		* @throws \Exception Validation errors.
195		*/
196	1	public function getEncryptionInitializationVector($length = 128, $printable = true)
197		{
198	1	$this->applyLengthValidation($length);
199
200	1	return ($printable) ? $this->randomnessSource->getAscii($length) : $this->randomnessSource->getBytes($length);
201		}
202		}
203

TonyKaravasilev / CryptoManana

Branch — master (b68521)

getEncryptionInitializationVector() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like