Jsq\Cache\EnvelopeEncryption\Decorator

Complexity

Total Complexity

17

Size/Duplication

Total Lines	125
Duplicated Lines	8.8 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	12	1
A	__destruct()	0	5	1
A	isDataDecryptable()	0	8	2
A	encrypt()	0	14	1
A	decrypt()	11	11	2
A	setPublicKey()	0	10	2
A	setPrivateKey()	0	9	2
A	validateOpenSslKey()	0	4	2
A	signString()	0	6	1
A	validateSignature()	0	4	1
A	encryptEnvelopeKey()	0	6	1
A	decryptEnvelopeKey()	0	6	1

<?php
namespace Jsq\Cache\EnvelopeEncryption;

use Doctrine\Common\Cache\Cache;
use InvalidArgumentException as IAE;
use Jsq\Cache\EncryptedValue;
use Jsq\Cache\EncryptingDecorator;

class Decorator extends EncryptingDecorator
{
    /** @var resource */
    private $publicKey;
    /** @var resource */
    private $privateKey;
    /** @var string */
    private $cipher;

    /**
     * @param Cache $decorated
     * @param mixed $cert
     * @param mixed $key
     * @param string|null $passphrase
     * @param string $cipher
     *
     * @throws IAE If OpenSSL keys cannot be extracted from $cert and $key.
     */
    public function __construct(
        Cache $decorated,
        $cert,
        $key,
        $passphrase = null,
        $cipher = 'aes-256-cbc'
    ) {
        parent::__construct($decorated);
        $this->setPublicKey($cert);
        $this->setPrivateKey($key, $passphrase);
        $this->cipher = $cipher;
    }

    public function __destruct()
    {
        openssl_free_key($this->publicKey);
        openssl_free_key($this->privateKey);
    }

    protected function isDataDecryptable($data, string $id): bool
    {
        return $data instanceof Value
            && $this->validateSignature(
                $id . $data->getCipherText(),
                $data->getSignature()
            );
    }

    protected function encrypt($data, string $id): EncryptedValue
    {
        $key = $this->generateIv($this->cipher);
        $iv = $this->generateIv($this->cipher);
        $cipherText = $this->encipher(serialize($data), $this->cipher, $key, $iv);

        return new Value(
            $cipherText,
            $this->cipher,
            $iv,
            $this->encryptEnvelopeKey($key),
            $this->signString($id . $cipherText)
        );
    }

    protected function decrypt($data)

This method seems to be duplicated in your project.

    {
        if (!$data instanceof Value) return false;

        return unserialize($this->decipher(
            $data->getCipherText(),
            $data->getMethod(),
            $this->decryptEnvelopeKey($data->getEnvelopeKey()),
            $data->getInitializationVector()
        ));
    }

    private function setPublicKey($cert)
    {
        $this->publicKey = @openssl_pkey_get_public($cert);
        if (!$this->validateOpenSslKey($this->publicKey)) {
            throw new IAE('Unable to create public key from provided'
                . ' certificate. Certificate must be a valid x509 certificate,'
                . ' a PEM encoded certificate, or a path to a file containing a'
                . ' PEM encoded certificate.');
        }
    }

    private function setPrivateKey($key, $passphrase)
    {
        $this->privateKey = @openssl_pkey_get_private($key, $passphrase);
        if (!$this->validateOpenSslKey($this->privateKey)) {
            throw new IAE('Unable to create private key from provided key. Key'
                . ' must be a PEM encoded private key or a path to a file'
                . ' containing a PEM encoded private key.');
        }
    }

    private function validateOpenSslKey($key)
    {
        return is_resource($key) && 'OpenSSL key' === get_resource_type($key);
    }

    private function signString($string)
    {
        openssl_sign($string, $signature, $this->privateKey);

        return $signature;
    }

    private function validateSignature($signed, $signature)
    {
        return openssl_verify($signed, $signature, $this->publicKey);
    }

    private function encryptEnvelopeKey($key)
    {
        openssl_public_encrypt($key, $sealedKey, $this->publicKey);

        return $sealedKey;
    }

    private function decryptEnvelopeKey($sealedKey)
    {
        openssl_private_decrypt($sealedKey, $key, $this->privateKey);

        return $key;
    }
}