Phalcon\Crypt

Complexity

Total Complexity

107

Size/Duplication

Total Lines	878
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

27 Methods

Rating	Name	Duplication	Size	Complexity
A	assertHashAlgorithmAvailable()	0	9	2
A	setAuthTagLength()	0	5	1
A	getHashAlgo()	0	3	1
A	getAvailableHashAlgos()	0	7	2
A	decryptBase64()	0	13	2
A	getKey()	0	3	1
B	getAvailableCiphers()	0	26	8
C	decrypt()	0	113	16
A	getIvLength()	0	7	2
D	cryptUnpadText()	0	103	29
A	useSigning()	0	5	1
A	setAuthTag()	0	5	1
C	cryptPadText()	0	64	13
A	getAuthData()	0	3	1
A	setPadding()	0	5	1
A	setHashAlgo()	0	7	1
A	getAuthTagLength()	0	3	1
A	assertCipherIsAvailable()	0	9	2
A	initializeAvailableCiphers()	0	13	3
A	__construct()	0	8	1
A	setKey()	0	5	1
A	encryptBase64()	0	20	2
A	getAuthTag()	0	3	1
A	setAuthData()	0	5	1
A	getCipher()	0	3	1
A	setCipher()	0	8	1
C	encrypt()	0	84	11

<?php

/**
 * This file is part of the Phalcon Framework.
 *
 * (c) Phalcon Team <team@phalcon.io>
 *
 * For the full copyright and license information, please view the LICENSE.txt
 * file that was distributed with this source code.
 */

declare(strict_types=1);

namespace Phalcon;

use Phalcon\Crypt\CryptInterface;
use Phalcon\Crypt\Exception;

This use statement conflicts with another class in this namespace, Phalcon\Exception. Consider defining an alias.

use Phalcon\Crypt\MismatchException;
use Phalcon\Helper\Str;

use function base64_decode;
use function base64_encode;
use function chr;
use function function_exists;
use function hash;
use function hash_algos;
use function hash_hmac;
use function hash_hmac_algos;
use function in_array;
use function is_array;
use function openssl_cipher_iv_length;
use function openssl_decrypt;
use function openssl_encrypt;
use function openssl_get_cipher_methods;
use function openssl_random_pseudo_bytes;
use function ord;
use function rand;
use function range;
use function rtrim;
use function sprintf;
use function str_ireplace;
use function str_repeat;
use function strlen;
use function strrpos;
use function strtolower;
use function strtoupper;
use function substr;

use const OPENSSL_RAW_DATA;

/**
 * Provides encryption capabilities to Phalcon applications.
 *
 * ```php
 * use Phalcon\Crypt;
 *
 * $crypt = new Crypt();
 *
 * $crypt->setCipher('aes-256-ctr');
 *
 * $key  =
 * "T4\xb1\x8d\xa9\x98\x05\\\x8c\xbe\x1d\x07&[\x99\x18\xa4~Lc1\xbeW\xb3";
 * $text = "The message to be encrypted";
 *
 * $encrypted = $crypt->encrypt($text, $key);
 *
 * echo $crypt->decrypt($encrypted, $key);
 * ```
 *
 * @property string $authData
 * @property string $authTag
 * @property int    $authTagLength
 * @property array  $availableCiphers
 * @property string $cipher
 * @property string $hashAlgo
 * @property int    $ivLength
 * @property string $key
 * @property int    $padding
 * @property bool   $useSigning
 */
class Crypt implements CryptInterface
{
    public const PADDING_ANSI_X_923     = 1;
    public const PADDING_DEFAULT        = 0;
    public const PADDING_ISO_10126      = 3;
    public const PADDING_ISO_IEC_7816_4 = 4;
    public const PADDING_PKCS7          = 2;
    public const PADDING_SPACE          = 6;
    public const PADDING_ZERO           = 5;

    /**
     * @var string
     */
    protected $authData = "";

    /**
     * @var string
     */
    protected $authTag;

    /**
     * @var int
     */
    protected $authTagLength = 16;

    /**
     * Available cipher methods.
     *
     * @var array
     */
    protected $availableCiphers;

    /**
     * @var string
     */
    protected $cipher = "aes-256-cfb";

    /**
     * The name of hashing algorithm.
     *
     * @var string
     */
    protected $hashAlgo = "sha512";

    /**
     * The cipher iv length.
     *
     * @var int
     */
    protected $ivLength = 16;

    /**
     * @var string
     */
    protected $key = "";

    /**
     * @var int
     */
    protected $padding = 0;

    /**
     * Whether calculating message digest enabled or not.
     *
     * @var bool
     */
    protected $useSigning = true;

    /**
     * Crypt constructor.
     *
     * @param string $cipher
     * @param bool   $useSigning
     *
     * @throws Exception
     */
    public function __construct(
        string $cipher = "aes-256-cfb",
        bool $useSigning = false
    ) {
        $this->initializeAvailableCiphers();

        $this->setCipher($cipher);
        $this->useSigning($useSigning);
    }

    /**
     * Decrypts an encrypted text.
     *
     * ```php
     * $encrypted = $crypt->decrypt(
     *     $encrypted,
     *     "T4\xb1\x8d\xa9\x98\x05\\\x8c\xbe\x1d\x07&[\x99\x18\xa4~Lc1\xbeW\xb3"
     * );
     * ```
     *
     * @param string      $text
     * @param string|null $key
     *
     * @return string
     * @throws Exception
     */
    public function decrypt(string $text, string $key = null): string
    {
        if (empty($key)) {
            $decryptKey = $this->key;
        } else {
            $decryptKey = $key;
        }

        if (empty($decryptKey)) {
            throw new Exception("Decryption key cannot be empty");
        }

        $cipher   = $this->cipher;
        $mode     = strtolower(
            substr($cipher, strrpos($cipher, "-") - strlen($cipher))
        );
        $authData = $this->authData;
        $authTag  = $this->authTag;

        $this->assertCipherIsAvailable($cipher);

        $ivLength = $this->ivLength;

        if ($ivLength > 0) {
            $blockSize = $ivLength;
        } else {
            $blockSize = $this->getIvLength(
                str_ireplace("-" . $mode, "", $cipher)
            );
        }

        $iv = mb_substr($text, 0, $ivLength, "8bit");

        if ($this->useSigning) {
            $hashAlgo   = $this->getHashAlgo();
            $hashLength = strlen(hash($hashAlgo, "", true));
            $hash       = mb_substr($text, $ivLength, $hashLength, "8bit");
            $ciphertext = mb_substr($text, $ivLength + $hashLength, null, "8bit");

            if (
                ("-gcm" === $mode || "-ccm" === $mode) &&
                !empty($this->authData)
            ) {
                $decrypted = openssl_decrypt(
                    $ciphertext,
                    $cipher,
                    $decryptKey,
                    OPENSSL_RAW_DATA,
                    $iv,
                    $authTag,
                    $authData
                );
            } else {
                $decrypted = openssl_decrypt(
                    $ciphertext,
                    $cipher,
                    $decryptKey,
                    OPENSSL_RAW_DATA,
                    $iv
                );
            }

            if ($mode == "-cbc" || $mode == "-ecb") {
                $decrypted = $this->cryptUnpadText(
                    $decrypted,
                    $mode,
                    $blockSize,
                    $this->padding
                );
            }

            /**
             * Checks on the decrypted's message digest using the HMAC method.
             */
            if (hash_hmac($hashAlgo, $decrypted, $decryptKey, true) !== $hash) {
                throw new MismatchException("Hash does not match.");
            }

            return $decrypted;
        }

        $ciphertext = mb_substr($text, $ivLength, null, "8bit");

        if (("-gcm" === $mode || "-ccm" === $mode) && !empty($this->authData)) {
            $decrypted = openssl_decrypt(
                $ciphertext,
                $cipher,
                $decryptKey,
                OPENSSL_RAW_DATA,
                $iv,
                $authTag,
                $authData
            );
        } else {
            $decrypted = openssl_decrypt(
                $ciphertext,
                $cipher,
                $decryptKey,
                OPENSSL_RAW_DATA,
                $iv
            );
        }

        if ($mode == "-cbc" || $mode == "-ecb") {
            $decrypted = $this->cryptUnpadText(
                $decrypted,
                $mode,
                $blockSize,
                $this->padding
            );
        }

        return $decrypted;
    }

    /**
     * Decrypt a text that is coded as a base64 string.
     *
     * @param string $text
     * @param null   $key

Are you sure the doc-type for parameter $key is correct as it would always require null to be passed?

     * @param bool   $safe
     *
     * @return string
     * @throws Exception
     */
    public function decryptBase64(
        string $text,
        $key = null,
        bool $safe = false
    ): string {
        if ($safe) {
            $text = strtr($text, "-_", "+/") .
                substr("===", (strlen($text) + 3) % 4);
        }

        return $this->decrypt(
            base64_decode($text),
            $key
        );
    }

    /**
     * Encrypts a text.
     *
     * ```php
     * $encrypted = $crypt->encrypt(
     *     "Top secret",
     *     "T4\xb1\x8d\xa9\x98\x05\\\x8c\xbe\x1d\x07&[\x99\x18\xa4~Lc1\xbeW\xb3"
     * );
     * ```
     *
     * @param string      $text
     * @param string|null $key
     *
     * @return string
     * @throws Exception
     */
    public function encrypt(string $text, string $key = null): string
    {
        if (empty($key)) {
            $encryptKey = $this->key;
        } else {
            $encryptKey = $key;
        }

        if (empty($encryptKey)) {
            throw new Exception("Encryption key cannot be empty");
        }

        $cipher = $this->cipher;
        $mode   = strtolower(
            substr(
                $cipher,
                strrpos($cipher, "-") - strlen($cipher)
            )
        );

        $this->assertCipherIsAvailable($cipher);

        $ivLength = $this->ivLength;

        if ($ivLength > 0) {
            $blockSize = $ivLength;
        } else {
            $blockSize = $this->getIvLength(
                str_ireplace(
                    "-" . $mode,
                    "",
                    $cipher
                )
            );
        }

        $iv          = openssl_random_pseudo_bytes($ivLength);
        $paddingType = $this->padding;

        if ($paddingType != 0 && ($mode == "-cbc" || $mode == "-ecb")) {
            $padded = $this->cryptPadText($text, $mode, $blockSize, $paddingType);
        } else {
            $padded = $text;
        }

        /**
         * If the mode is "gcm" or "ccm" and auth data has been passed call it
         * with that data
         */
        if (("-gcm" === $mode || "-ccm" === $mode) && !empty($this->authData)) {
            $authData      = $this->authData;
            $authTag       = $this->authTag;
            $authTagLength = $this->authTagLength;

            $encrypted = openssl_encrypt(
                $padded,
                $cipher,
                $encryptKey,
                OPENSSL_RAW_DATA,
                $iv,
                $authTag,
                $authData,
                $authTagLength
            );

            $this->authTag = $authTag;
        } else {
            $encrypted = openssl_encrypt(
                $padded,
                $cipher,
                $encryptKey,
                OPENSSL_RAW_DATA,
                $iv
            );
        }

        if ($this->useSigning) {
            $hashAlgo = $this->getHashAlgo();
            $digest   = hash_hmac($hashAlgo, $padded, $encryptKey, true);

            return $iv . $digest . $encrypted;
        }

        return $iv . $encrypted;
    }

    /**
     * Encrypts a text returning the result as a base64 string.
     *
     * @param string     $text
     * @param mixed|null $key
     * @param bool       $safe
     *
     * @return string
     * @throws Exception
     */
    public function encryptBase64(
        string $text,
        $key = null,
        bool $safe = false
    ): string {
        if ($safe == true) {

It seems like you are loosely comparing two booleans. Considering using the strict comparison === instead.

            return rtrim(
                strtr(
                    base64_encode(
                        $this->encrypt($text, $key)
                    ),
                    "+/",
                    "-_"
                ),
                "="
            );
        }

        return base64_encode(
            $this->encrypt($text, $key)
        );
    }

    /**
     * Returns a list of available ciphers.
     *
     * @return array
     * @throws Exception
     */
    public function getAvailableCiphers(): array
    {
        $availableCiphers = $this->availableCiphers;

        if (is_array($availableCiphers)) {

The condition is_array($availableCiphers) is always true.

            $this->initializeAvailableCiphers();

            $availableCiphers = $this->availableCiphers;
        }

        $allowedCiphers = [];
        foreach ($availableCiphers as $cipher) {
            if (
                !(
                Str::endsWith(strtolower($cipher), "des") ||
                Str::endsWith(strtolower($cipher), "rc2") ||
                Str::endsWith(strtolower($cipher), "rc4") ||
                Str::endsWith(strtolower($cipher), "des") ||
                Str::endsWith(strtolower($cipher), "ecb")
                )
            ) {
                $allowedCiphers[] = $cipher;
            }
        }

        return $allowedCiphers;
    }

    /**
     * Return a list of registered hashing algorithms suitable for hash_hmac.
     */
    public function getAvailableHashAlgos(): array
    {
        if (function_exists("hash_hmac_algos")) {
            return hash_hmac_algos();
        }

        return hash_algos();
    }

    /**
     * @return string
     */
    public function getAuthData(): string
    {
        return $this->authData;
    }

    /**
     * @return string
     */
    public function getAuthTag(): string
    {
        return $this->authTag;
    }

    /**
     * @return int
     */
    public function getAuthTagLength(): int
    {
        return $this->authTagLength;
    }

    /**
     * Returns the current cipher
     */
    public function getCipher(): string
    {
        return $this->cipher;
    }

    /**
     * Get the name of hashing algorithm.
     */
    public function getHashAlgo(): string
    {
        return $this->hashAlgo;
    }

    /**
     * Returns the encryption key
     */
    public function getKey(): string
    {
        return $this->key;
    }

    /**
     * @param string $data
     *
     * @return CryptInterface
     */
    public function setAuthData(string $data): CryptInterface
    {
        $this->authData = $data;

        return $this;
    }

    /**
     * @param string $tag
     *
     * @return CryptInterface
     */
    public function setAuthTag(string $tag): CryptInterface
    {
        $this->authTag = $tag;

        return $this;
    }

    /**
     * @param int $length
     *
     * @return CryptInterface
     */
    public function setAuthTagLength(int $length): CryptInterface
    {
        $this->authTagLength = $length;

        return $this;
    }

    /**
     * Sets the cipher algorithm for data encryption and decryption.
     *
     * The `aes-256-gcm' is the preferable cipher, but it is not usable
     * until the openssl library is upgraded, which is available in PHP 7.1.
     *
     * The `aes-256-ctr' is arguably the best choice for cipher
     * algorithm for current openssl library version.
     *
     * @param string $cipher
     *
     * @return CryptInterface
     * @throws Exception
     */
    public function setCipher(string $cipher): CryptInterface
    {
        $this->assertCipherIsAvailable($cipher);

        $this->ivLength = $this->getIvLength($cipher);
        $this->cipher   = $cipher;

        return $this;
    }

    /**
     * Set the name of hashing algorithm.
     *
     * @param string $hashAlgo
     *
     * @return CryptInterface
     * @throws Exception
     */
    public function setHashAlgo(string $hashAlgo): CryptInterface
    {
        $this->assertHashAlgorithmAvailable($hashAlgo);

        $this->hashAlgo = $hashAlgo;

        return $this;
    }

    /**
     * Sets the encryption key.
     *
     * The `$key' should have been previously generated in a cryptographically
     * safe way.
     *
     * Bad key:
     * "le password"
     *
     * Better (but still unsafe):
     * "#1dj8$=dp?.ak//j1V$~%*0X"
     *
     * Good key:
     * "T4\xb1\x8d\xa9\x98\x05\\\x8c\xbe\x1d\x07&[\x99\x18\xa4~Lc1\xbeW\xb3"
     *
     * @param string $key
     *
     * @return CryptInterface
     */
    public function setKey(string $key): CryptInterface
    {
        $this->key = $key;

        return $this;
    }

    /**
     * Changes the padding scheme used.
     *
     * @param int $scheme
     *
     * @return CryptInterface
     */
    public function setPadding(int $scheme): CryptInterface
    {
        $this->padding = $scheme;

        return $this;
    }

    /**
     * Sets if the calculating message digest must used.
     *
     * @param bool $useSigning
     *
     * @return CryptInterface
     */
    public function useSigning(bool $useSigning): CryptInterface
    {
        $this->useSigning = $useSigning;

        return $this;
    }

    /**
     * Assert the cipher is available.
     *
     * @param string $cipher
     *
     * @throws Exception
     */
    protected function assertCipherIsAvailable(string $cipher): void
    {
        $availableCiphers = $this->getAvailableCiphers();

        if (!in_array(strtoupper($cipher), $availableCiphers)) {
            throw new Exception(
                sprintf(
                    "The cipher algorithm \"%s\" is not supported on this system.",
                    $cipher
                )
            );
        }
    }

    /**
     * Assert the hash algorithm is available.
     *
     * @param string $hashAlgo
     *
     * @throws Exception
     */
    protected function assertHashAlgorithmAvailable(string $hashAlgo): void
    {
        $availableAlgorithms = $this->getAvailableHashAlgos();

        if (!in_array($hashAlgo, $availableAlgorithms)) {
            throw new Exception(
                sprintf(
                    "The hash algorithm \"%s\" is not supported on this system.",
                    $hashAlgo
                )
            );
        }
    }

    /**
     * Pads texts before encryption.
     *
     * @see http://www.di-mgt.com.au/cryptopad.html
     *
     * @param string $text
     * @param string $mode
     * @param int    $blockSize
     * @param int    $paddingType
     *
     * @return string
     * @throws Exception
     */
    protected function cryptPadText(
        string $text,
        string $mode,
        int $blockSize,
        int $paddingType
    ): string {

        $paddingSize = 0;
        $padding     = null;

        if ($mode == "cbc" || $mode == "ecb") {
            $paddingSize = $blockSize - (strlen($text) % $blockSize);

            if ($paddingSize >= 256) {
                throw new Exception("Block size is bigger than 256");
            }

            switch ($paddingType) {
                case self::PADDING_ANSI_X_923:
                    $padding = str_repeat(chr(0), $paddingSize - 1) . chr($paddingSize);
                    break;

                case self::PADDING_PKCS7:
                    $padding = str_repeat(chr($paddingSize), $paddingSize);
                    break;

                case self::PADDING_ISO_10126:
                    $padding = "";

                    foreach (range(0, $paddingSize - 2) as $counter) {
                        $padding .= chr(rand());
                    }

                    $padding .= chr($paddingSize);

                    break;

                case self::PADDING_ISO_IEC_7816_4:
                    $padding = chr(0x80) . str_repeat(chr(0), $paddingSize - 1);
                    break;

                case self::PADDING_ZERO:
                    $padding = str_repeat(chr(0), $paddingSize);
                    break;

                case self::PADDING_SPACE:
                    $padding = str_repeat(" ", $paddingSize);
                    break;

                default:
                    $paddingSize = 0;
                    break;
            }
        }

        if (!$paddingSize) {
            return $text;
        }

        if ($paddingSize > $blockSize) {
            throw new Exception("Invalid padding size");
        }

        return $text . substr($padding, 0, $paddingSize);
    }

    /**
     * Removes a padding from a text.
     *
     * If the function detects that the text was not padded, it will return it
     * unmodified.
     *
     * @param string $text
     * @param string $mode
     * @param int    $blockSize
     * @param int    $paddingType
     *
     * @return false|string
     */
    protected function cryptUnpadText(
        string $text,
        string $mode,
        int $blockSize,
        int $paddingType
    ) {
        $paddingSize = 0;
        $length      = strlen($text);

        if (
            $length > 0 &&
            ($length % $blockSize == 0) &&
            ($mode == "cbc" || $mode == "ecb")
        ) {
            switch ($paddingType) {
                case self::PADDING_ANSI_X_923:
                    $last = substr($text, $length - 1, 1);
                    $ord  = (int) ord($last);

                    if ($ord <= $blockSize) {
                        $paddingSize = $ord;
                        $padding     = str_repeat(chr(0), $paddingSize - 1) . $last;

                        if (substr($text, $length - $paddingSize) != $padding) {
                            $paddingSize = 0;
                        }
                    }

                    break;

                case self::PADDING_PKCS7:
                    $last = substr($text, $length - 1, 1);
                    $ord  = (int) ord($last);

                    if ($ord <= $blockSize) {
                        $paddingSize = $ord;
                        $padding     = str_repeat(chr($paddingSize), $paddingSize);

                        if (substr($text, $length - $paddingSize) != $padding) {
                            $paddingSize = 0;
                        }
                    }

                    break;

                case self::PADDING_ISO_10126:
                    $last        = substr($text, $length - 1, 1);
                    $paddingSize = (int) ord($last);
                    break;

                case self::PADDING_ISO_IEC_7816_4:
                    $i = $length - 1;

                    while ($i > 0 && $text[$i] == 0x00 && $paddingSize < $blockSize) {
                        $paddingSize++;
                        $i--;
                    }

                    if ($text[$i] == 0x80) {
                        $paddingSize++;
                    } else {
                        $paddingSize = 0;
                    }

                    break;

                case self::PADDING_ZERO:
                    $i = $length - 1;

                    while ($i >= 0 && $text[$i] == 0x00 && $paddingSize <= $blockSize) {
                        $paddingSize++;
                        $i--;
                    }

                    break;

                case self::PADDING_SPACE:
                    $i = $length - 1;

                    while ($i >= 0 && $text[$i] == 0x20 && $paddingSize <= $blockSize) {
                        $paddingSize++;
                        $i--;
                    }

                    break;

                default:
                    break;
            }

            if ($paddingSize && $paddingSize <= $blockSize) {
                if ($paddingSize < $length) {
                    return substr($text, 0, $length - $paddingSize);
                }

                return "";
            } else {
                $paddingSize = 0;
            }
        }

        if (!$paddingSize) {
            return $text;
        }
    }

    /**
     * Initialize available cipher algorithms.
     *
     * @param string $cipher
     *
     * @return int
     * @throws Exception
     */
    protected function getIvLength(string $cipher): int
    {
        if (!function_exists("openssl_cipher_iv_length")) {
            throw new Exception("openssl extension is required");
        }

        return openssl_cipher_iv_length($cipher);
    }

    /**
     * Initialize available cipher algorithms.
     *
     * @throws Exception
     */
    protected function initializeAvailableCiphers(): void
    {
        if (!function_exists("openssl_get_cipher_methods")) {
            throw new Exception("openssl extension is required");
        }

        $availableCiphers = openssl_get_cipher_methods(true);

        foreach ($availableCiphers as $key => $cipher) {
            $availableCiphers[$key] = strtoupper($cipher);
        }

        $this->availableCiphers = $availableCiphers;
    }
}