Quantum\Libraries\Encryption\Cryptor

Complexity

Total Complexity

27

Size/Duplication

Total Lines	257
Duplicated Lines	0 %

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	getInstance()	0	6	2
A	getIV()	0	3	1
A	getPrivateKey()	0	7	2
A	generateKeyPair()	0	14	2
A	getPublicKey()	0	7	2
A	getAsymmetricInstance()	0	7	2
A	__construct()	0	12	3
A	encrypt()	0	15	3
A	isAsymmetric()	0	3	1
A	iv()	0	4	1
A	decrypt()	0	24	6
A	getSymmetricInstance()	0	7	2

<?php

/**
 * Quantum PHP Framework
 *
 * An open source software development framework for PHP
 *
 * @package Quantum
 * @author Arman Ag. <arman.ag@softberg.org>
 * @copyright Copyright (c) 2018 Softberg LLC (https://softberg.org)
 * @link http://quantum.softberg.org/
 * @since 2.8.0
 */

namespace Quantum\Libraries\Encryption;

use Quantum\Exceptions\CryptorException;
use Quantum\Exceptions\AppException;

/**
 * Class Cryptor
 * @package Quantum\Libraries\Encryption
 */
class Cryptor
{

    /**
     * Asymmetric instance
     * @var Cryptor|null
     */
    private static $asymmetricInstance = null;

    /**
     * Symmetric instance
     * @var Cryptor|null
     */
    private static $symmetricInstance = null;

    /**
     * Asymmetric factor
     * @var boolean
     */
    private $asymmetric = false;

    /**
     * Application key
     * @var string
     */
    private $appKey;

    /**
     * Public and private keys
     * @var array
     */
    private $keys = [];

    /**
     * Digest algorithm
     * @var string
     */
    private $digestAlgorithm = 'SHA512';

    /**
     * Key type
     * @var integer
     */
    private $privateKeyType = OPENSSL_KEYTYPE_RSA;

    /**
     * Cipher method
     * @var string
     */
    private $cipherMethod = 'aes-256-cbc';

    /**
     * Key bites
     * @var integer
     */
    private $privateKeyBits = 1024;

    /**
     * The Initialization Vector
     * @var string
     */
    private $iv = null;

    /**
     * Cryptor constructor.
     * @param bool $asymmetric
     * @throws AppException
     * @throws CryptorException
     */
    private function __construct(bool $asymmetric = false)
    {
        if (!$asymmetric) {
            if (!env('APP_KEY')) {
                throw AppException::missingAppKey();
            }
            $this->appKey = env('APP_KEY');
        } else {
            $this->generateKeyPair();
        }

        $this->asymmetric = $asymmetric;

    }

    /**
     * Gets the cryptor instance
     * @param bool $asymmetric
     * @return Cryptor|null
     */
    public static function getInstance(bool $asymmetric = false): ?Cryptor
    {
        if ($asymmetric) {
            return self::getAsymmetricInstance();
        } else {
            return self::getSymmetricInstance();
        }
    }

    /**
     * Checks if the encryption mode is asymmetric
     * @return bool
     */
    public function isAsymmetric(): bool
    {
        return $this->asymmetric;
    }

    /**
     * Gets the Public Key
     * @return string
     * @throws CryptorException
     */
    public function getPublicKey(): string
    {
        if (!isset($this->keys['public'])) {
            throw CryptorException::noPublicKeyCreated();
        }

        return $this->keys['public'];
    }

    /**
     * Gets the Private Key
     * @return string
     * @throws CryptorException
     */
    public function getPrivateKey(): string
    {
        if (!isset($this->keys['private'])) {
            throw CryptorException::noPrivateKeyCreated();
        }

        return $this->keys['private'];
    }

    /**
     * Encrypts the plain text
     * @param string $plain
     * @param string|null $publicKey
     * @return string
     * @throws CryptorException
     */
    public function encrypt(string $plain, string $publicKey = null): string
    {
        if (!$this->isAsymmetric()) {
            $this->iv = $this->iv();

            $encrypted = openssl_encrypt($plain, $this->cipherMethod, $this->appKey, $options = 0, $this->iv);

            return base64_encode(base64_encode($encrypted) . '::' . base64_encode($this->iv));
        } else {
            if (!$publicKey) {
                throw CryptorException::publicKeyNotProvided();
            }

            openssl_public_encrypt($plain, $encrypted, $publicKey);
            return base64_encode($encrypted);
        }
    }

    /**
     * Decrypts the encrypted text
     * @param string $encrypted
     * @param string|null $privateKey
     * @return string
     * @throws CryptorException
     */
    public function decrypt(string $encrypted, string $privateKey = null): string
    {
        if (!$this->isAsymmetric()) {
            if (!valid_base64($encrypted)) {
                return $encrypted;
            }

            $data = explode('::', base64_decode($encrypted), 2);

            if (empty($data) || count($data) < 2) {
                throw CryptorException::invalidCipher();
            }

            $encrypted = base64_decode($data[0]);
            $iv = base64_decode($data[1]);

            return openssl_decrypt($encrypted, $this->cipherMethod, $this->appKey, $options = 0, $iv);
        } else {
            if (!$privateKey) {
                throw CryptorException::privateKeyNotProvided();
            }

            openssl_private_decrypt(base64_decode($encrypted), $decrypted, $privateKey);
            return $decrypted;
        }
    }

    /**
     * Gets the Initialization Vector used
     * @return string|null
     */
    public function getIV(): ?string
    {
        return $this->iv;
    }

    /**
     * Generates the Initialization Vector
     * @return string
     */
    private function iv(): string
    {
        $length = openssl_cipher_iv_length($this->cipherMethod);
        return openssl_random_pseudo_bytes($length);
    }

    /**
     * Generates Key Pair
     * @throws CryptorException
     */
    private function generateKeyPair()
    {
        $resource = openssl_pkey_new([
            "digest_alg" => $this->digestAlgorithm,
            "private_key_type" => $this->privateKeyType,
            "private_key_bits" => $this->privateKeyBits
        ]);

        if (!$resource) {
            throw CryptorException::configNotFound();
        }

        openssl_pkey_export($resource, $this->keys['private']);
        $this->keys['public'] = openssl_pkey_get_details($resource)['key'];
    }

    /**
     * Gets the symmetric cryptor insatnce
     * @return Cryptor|null
     */
    private static function getSymmetricInstance(): ?Cryptor
    {
        if (self::$symmetricInstance === null) {
            self::$symmetricInstance = new self(false);
        }

        return self::$symmetricInstance;
    }

    /**
     * Gets the asymmetric cryptor insatnce
     * @return Cryptor|null
     */
    private static function getAsymmetricInstance(): ?Cryptor
    {
        if (self::$asymmetricInstance === null) {
            self::$asymmetricInstance = new self(true);
        }

        return self::$asymmetricInstance;
    }

}