Jsq\CacheEncryption\Envelope\ItemDecorator

Complexity

Total Complexity

17

Size/Duplication

Total Lines	117
Duplicated Lines	9.4 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

100%

Importance

Changes	3
Bugs	0	Features	1

12 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	11	1
A	__destruct()	0	5	1
A	isDecryptable()	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
A	encrypt()	0	14	1
A	decrypt()	11	11	2
A	setPublicKey()	0	12	2

<?php
namespace Jsq\CacheEncryption\Envelope;

use Jsq\CacheEncryption\ItemDecorator as BaseItemDecorator;
use Jsq\CacheEncryption\InvalidArgumentException;
use Psr\Cache\CacheItemInterface;

class ItemDecorator extends BaseItemDecorator
{
    /** @var resource */
    private $publicKey;
    /** @var resource */
    private $privateKey;

    public function __construct(
        CacheItemInterface $decorated,
        $certificate,
        $key,
        $passPhrase,
        $cipher
    ) {
        parent::__construct($cipher, $decorated);
        $this->setPublicKey($certificate);
        $this->setPrivateKey($key, $passPhrase);
    }

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

    protected function isDecryptable()
    {
        $data = $this->getDecorated()->get();

        return $data instanceof EncryptedValue
            && $this->validateSignature(
                $this->getKey() . $data->getCipherText(),
                $data->getSignature()
            );
    }

    protected function encrypt($data)
    {
        $key = $this->generateIv();
        $iv = $this->generateIv();
        $cipherText = $this->encryptString(serialize($data), $key, $iv);

        return new EncryptedValue(
            $cipherText,
            $this->getCipherMethod(),
            $iv,
            $this->encryptEnvelopeKey($key),
            $this->signString($this->getKey() . $cipherText)
        );
    }

    protected function decrypt($data)

This method seems to be duplicated in your project.

    {
        if (!$data instanceof EncryptedValue) return null;

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

    private function setPublicKey($cert)
    {
        $publicKey = @openssl_pkey_get_public($cert);
        if (!$this->validateOpenSslKey($publicKey)) {
            throw new InvalidArgumentException('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.');
        }

        $this->publicKey = $publicKey;
    }

    private function setPrivateKey($key, $passPhrase)
    {
        $this->privateKey = @openssl_pkey_get_private($key, $passPhrase);
        if (!$this->validateOpenSslKey($this->privateKey)) {
            throw new InvalidArgumentException('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;
    }
}