Crypto\Cipher

Complexity

Total Complexity

15

Size/Duplication

Total Lines	128
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	encrypt()	0	3	1
A	decrypt()	0	9	2
A	getComputedHash()	0	8	2
A	getOptions()	0	7	2
A	__construct()	0	3	1
A	encryptPlainTextWithRandomIV()	0	3	1
A	generateRandomIV()	0	19	3
A	decryptCipherTextWithRandomIV()	0	5	1
A	encryptOrDecrypt()	0	20	2

<?php

namespace Crypto;

use Crypto\Exceptions\NotSecureIVGenerated;
use Crypto\Exceptions\UnableToDecrypt;
use Throwable;

class Cipher
{
  /**
   * Default setting for generating hash.
   *
   * @var array
   */
  private $_opts = [
    /*
         * Crypto method to encrypt your string with
         */
    'method' => 'AES-256-CBC',

    /*
         * Algorithm to apply while generating password via secrety key
         */
    'algorithm' => 'sha256',

    /*
         * Maximum key size
         */
    'maxKeySize' => 32,

    /*
         * Maximum IV size
         */
    'maxIVSize' => 16,

    /*
         * Number of iterations to generate hash for password
         */
    'numberOfIterations' => 1,
  ];

  public function __construct(array $options = [])
  {
    $this->_opts = $options + $this->_opts;

The property _opts does not exist on Crypto\Cipher. Did you maybe forget to declare it?

  }

  public function getOptions($key = '')
  {
    if ($key) {
      return $this->_opts[$key];

The property _opts does not exist on Crypto\Cipher. Did you maybe forget to declare it?

    }

    return $this->_opts;
  }

  public function generateRandomIV()
  {
    // We need to generate our IV by following characters
    $allowedIVString = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_';

    try {
      // Invalid method will throw a warning.
      $length = openssl_cipher_iv_length($this->getOptions('method'));

The method getOptions() does not exist on Crypto\Cipher.

    } catch (Throwable $t) {
      throw new NotSecureIVGenerated('Unable to generate random IV.');
    }

    // For any reason if required IV size needs greater value.
    if ($length > strlen($allowedIVString)) {
      $repeatedIVString = str_repeat($allowedIVString, ceil($length / strlen($allowedIVString)));

ceil($length / strlen($allowedIVString)) of type double is incompatible with the type integer expected by parameter $times of str_repeat().

      $allowedIVString .= $repeatedIVString;
    }

    return substr(str_shuffle($allowedIVString), 0, $length);
  }

  public function getComputedHash($key)
  {
    $hash = $key;
    for ($i = 0; $i < intval($this->getOptions('numberOfIterations')); ++$i) {
      $hash = hash($this->getOptions('algorithm'), $hash);
    }

    return $hash;
  }

  public function encrypt($plainText, $key, $initVector)
  {
    return $this->encryptOrDecrypt('encrypt', $plainText, $key, $initVector);

The method encryptOrDecrypt() does not exist on Crypto\Cipher. Did you maybe mean encrypt()?

  }

  public function decrypt($encryptedText, $key, $initVector)
  {
    $plainText = $this->encryptOrDecrypt('decrypt', $encryptedText, $key, $initVector);

    if (false === $plainText) {
      throw new UnableToDecrypt('Unable to decrypt your encrypted string.');
    }

    return $plainText;
  }

  public function encryptPlainTextWithRandomIV($plainText, $key)
  {
    return $this->encryptOrDecrypt('encrypt', $this->generateRandomIV() . $plainText, $key, $this->generateRandomIV());

The method generateRandomIV() does not exist on Crypto\Cipher.

  }

  public function decryptCipherTextWithRandomIV($cipherText, $key)
  {
    return substr(
      $this->encryptOrDecrypt('decrypt', $cipherText, $key, $this->generateRandomIV()),
      intval($this->getOptions('maxIVSize'))
    );
  }

  private function encryptOrDecrypt($mode, $string, $key, $initVector)
  {
    $password = substr($this->getComputedHash($key), 0, intval($this->getOptions('maxKeySize')));

The method getComputedHash() does not exist on Crypto\Cipher.

    if ('encrypt' === $mode) {
      return base64_encode(openssl_encrypt(
        $string,
        $this->getOptions('method'),
        $password,
        OPENSSL_RAW_DATA,
        $initVector
      ));
    }

    return openssl_decrypt(
      base64_decode($string),
      $this->getOptions('method'),
      $password,
      OPENSSL_RAW_DATA,
      $initVector
    );
  }
}