Limoncello\Crypt\SymmetricCrypt

Complexity

Total Complexity

26

Size/Duplication

Total Lines	271
Duplicated Lines	19.19 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

100%

Importance

Changes

0

20 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	decrypt()	18	18	2
A	encrypt()	18	18	2
A	getPassword()	0	4	1
A	getMethod()	0	4	1
A	setMethod()	0	8	2
A	setPassword()	0	8	2
A	resetInitializationVector()	0	8	2
A	getInitializationVector()	0	8	2
A	asRaw()	0	4	1
A	asBase64()	0	4	1
A	withZeroPadding()	0	4	1
A	withoutZeroPadding()	0	4	1
A	getOptions()	0	4	1
A	setOptions()	0	8	1
A	generateInitializationVector()	0	6	1
A	setOption()	8	8	1
A	clearOption()	8	8	1
A	openSslDecrypt()	0	4	1
A	openSslEncrypt()	0	4	1

<?php namespace Limoncello\Crypt;

/**
 * Copyright 2015-2016 info@neomerx.com (www.neomerx.com)
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

use Limoncello\Crypt\Contracts\DecryptInterface;
use Limoncello\Crypt\Contracts\EncryptInterface;

/**
 * @package Limoncello\Crypt
 */
class SymmetricCrypt extends BaseCrypt implements EncryptInterface, DecryptInterface
{
    /**
     * @var string
     */
    private $method;

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

    /**
     * Such as OPENSSL_RAW_DATA, OPENSSL_ZERO_PADDING.
     *
     * @var int
     */
    private $options;

    /**
     * @var string
     */
    private $initializationVector = null;

    /**
     * @param string $method
     * @param string $password
     */
    public function __construct($method, $password)
    {
        $this->setMethod($method)->setPassword($password)->asRaw();
    }

    /**
     * @inheritdoc
     */
    public function decrypt($data)

This method seems to be duplicated in your project.

    {
        assert(is_string($data) === true);

        $this->clearErrors();

        $decrypted = $this->openSslDecrypt(

The expression $this->openSslDecrypt($data, $this->getMethod(), $this->getPassword(), $this->getOptions(), $this->getInitializationVector()); of type string|false adds false to the return on line 77 which is incompatible with the return type declared by the interface Limoncello\Crypt\Contracts\DecryptInterface::decrypt of type string. It seems like you forgot to handle an error condition.

            $data,
            $this->getMethod(),
            $this->getPassword(),
            $this->getOptions(),
            $this->getInitializationVector()
        );

        $decrypted !== false ?: $this->throwException(new CryptException($this->getErrorMessage()));

        return $decrypted;
    }

    /**
     * @inheritdoc
     */
    public function encrypt($data)

This method seems to be duplicated in your project.

    {
        assert(is_string($data) === true);

        $this->clearErrors();

        $encrypted = $this->openSslEncrypt(

The expression $this->openSslEncrypt($data, $this->getMethod(), $this->getPassword(), $this->getOptions(), $this->getInitializationVector()); of type string|false adds false to the return on line 99 which is incompatible with the return type declared by the interface Limoncello\Crypt\Contracts\EncryptInterface::encrypt of type string. It seems like you forgot to handle an error condition.

            $data,
            $this->getMethod(),
            $this->getPassword(),
            $this->getOptions(),
            $this->getInitializationVector()
        );

        $encrypted !== false ?: $this->throwException(new CryptException($this->getErrorMessage()));

        return $encrypted;
    }

    /**
     * @return string
     */
    public function getPassword()
    {
        return $this->password;
    }

    /**
     * @return string
     */
    public function getMethod()
    {
        return $this->method;
    }

    /**
     * @param string $method
     *
     * @return $this
     */
    public function setMethod($method)
    {
        assert(is_string($method) === true && in_array($method, openssl_get_cipher_methods(true)) === true);

        $this->method = $method;

        return $this;
    }

    /**
     * @param string $password
     *
     * @return $this
     */
    public function setPassword($password)
    {
        assert(is_string($password) === true && empty($password) === false);

        $this->password = $password;

        return $this;
    }

    /**
     * @param null|string $value
     *
     * @return $this
     */
    public function resetInitializationVector($value = null)
    {
        assert(is_string($value) === true || $value === null);

        $this->initializationVector = $value;

        return $this;
    }

    /**
     * @return string
     */
    public function getInitializationVector()
    {
        if ($this->initializationVector === null) {
            $this->initializationVector = $this->generateInitializationVector();
        }

        return $this->initializationVector;
    }

    /**
     * @return $this
     */
    public function asRaw()
    {
        return $this->setOption(OPENSSL_RAW_DATA);
    }

    /**
     * @return $this
     */
    public function asBase64()
    {
        return $this->clearOption(OPENSSL_RAW_DATA);
    }

    /**
     * @return $this
     */
    public function withZeroPadding()
    {
        return $this->setOption(OPENSSL_ZERO_PADDING);
    }

    /**
     * @return $this
     */
    public function withoutZeroPadding()
    {
        return $this->clearOption(OPENSSL_ZERO_PADDING);
    }

    /**
     * @return int
     */
    protected function getOptions()
    {
        return $this->options;
    }

    /**
     * @param int $options
     *
     * @return $this
     */
    protected function setOptions($options)
    {
        assert(is_int($options) === true);

        $this->options = $options;

        return $this;
    }

    /**
     * @return string
     */
    protected function generateInitializationVector()
    {
        $vector = openssl_random_pseudo_bytes(openssl_cipher_iv_length($this->getMethod()));

        return $vector;
    }

    /**
     * @param int $option
     *
     * @return $this
     */
    protected function setOption($option)

This method seems to be duplicated in your project.

    {
        assert(is_int($option) === true);

        $this->setOptions($this->getOptions() | $option);

        return $this;
    }

    /**
     * @param int $option
     *
     * @return $this
     */
    protected function clearOption($option)

This method seems to be duplicated in your project.

    {
        assert(is_int($option) === true);

        $this->setOptions($this->getOptions() & ~$option);

        return $this;
    }

    /**
     * We need this wrapper for testing purposes so we can mock system call to Open SSL.
     *
     * @param string $data
     * @param string $method
     * @param string $password
     * @param int    $options
     * @param string $initializationVector
     *
     * @return string|false
     */
    protected function openSslDecrypt($data, $method, $password, $options, $initializationVector)
    {
        return openssl_decrypt($data, $method, $password, $options, $initializationVector);
    }

    /**
     * We need this wrapper for testing purposes so we can mock system call to Open SSL.
     *
     * @param string $data
     * @param string $method
     * @param string $password
     * @param int    $options
     * @param string $initializationVector
     *
     * @return string|false
     */
    protected function openSslEncrypt($data, $method, $password, $options, $initializationVector)
    {
        return openssl_encrypt($data, $method, $password, $options, $initializationVector);
    }
}