Quantum\Libraries\Encryption\Adapters\AsymmetricEncryptionAdapter

Complexity

Total Complexity

7

Size/Duplication

Total Lines	86
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	generateKeyPair()	0	18	2
A	encrypt()	0	8	2
A	__construct()	0	6	1
A	decrypt()	0	8	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.9.5
 */

namespace Quantum\Libraries\Encryption\Adapters;

use Quantum\Libraries\Encryption\Contracts\EncryptionInterface;
use Quantum\Libraries\Encryption\Exceptions\CryptorException;

/**
 * Class AsymmetricEncryptionAdapter
 * @package Quantum\Libraries\Encryption
 */
class AsymmetricEncryptionAdapter implements EncryptionInterface
{

    /**
     * Digest algorithm
     */
    const DIGEST_ALGO = 'SHA512';

    /**
     * Key bits
     */
    const KEY_BITS = 1024;

    /**
     * @var string
     */
    private $publicKey;

    /**
     * @var string
     */
    private $privateKey;

    /**
     * @throws CryptorException
     */
    public function __construct()
    {
        $keyPair = $this->generateKeyPair();

        $this->publicKey = $keyPair['public'];
        $this->privateKey = $keyPair['private'];
    }

    /**
     * @param string $plain
     * @return string
     * @throws CryptorException
     */
    public function encrypt(string $plain): string
    {
        if(!$this->publicKey) {
            throw CryptorException::publicKeyNotProvided();
        }

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

    /**
     * @param string $encrypted
     * @return string
     * @throws CryptorException
     */
    public function decrypt(string $encrypted): string
    {
        if (!$this->privateKey) {
            throw CryptorException::privateKeyNotProvided();
        }

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

    /**
     * @return array
     * @throws CryptorException
     */
    private function generateKeyPair(): array
    {
        $resource = openssl_pkey_new([
            "private_key_type" => OPENSSL_KEYTYPE_RSA,
            'private_key_bits' => self::KEY_BITS,
            'digest_alg' => self::DIGEST_ALGO,
        ]);

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

        openssl_pkey_export($resource, $privateKey);
        $publicKey = openssl_pkey_get_details($resource)['key'];

        return [
            'private' => $privateKey,
            'public' => $publicKey
        ];
    }
}