PHP对称加密类

<?php
/**
 * Created by PhpStorm.
 * User: zongbinghuang
 * Date: 2017/7/31
 * Time: 15:13
 */

namespace app\common;

use Exception;

class BizEncrypt
{
    const IV_SIZE = 16;
    const CIPHER = 'AES-256-CBC';

    private $key;#length:32

    public function __construct($key)
    {
        $key = (string)$key;

        if (static::supported($key, self::CIPHER)) {
            $this->key = $key;
        } else {
            throw new Exception('The only supported ciphers are AES-256-CBC with the correct key lengths.');
        }
    }

    public function encrypt($value)
    {
        $iv = self::random_bytes(self::IV_SIZE);

        $value = openssl_encrypt(serialize($value), self::CIPHER, $this->key, 0, $iv);

        if ($value === false) {
            throw new \Exception('Could not encrypt the data.');
        }

        $iv = base64_encode($iv);
        $mac = hash_hmac('sha256', $iv . $value, $this->key);
        $json = json_encode(compact('iv', 'value', 'mac'));

        if (!is_string($json)) {
            throw new Exception('Could not encrypt the data.');
        }

        return base64_encode($json);
    }

    public function decrypt($payload)
    {
        $payload = $this->getJsonPayload($payload);

        $iv = base64_decode($payload['iv']);

        $decrypted = openssl_decrypt($payload['value'], self::CIPHER, $this->key, 0, $iv);

        if ($decrypted === false) {
            throw new Exception('Could not decrypt the data.');
        }

        return unserialize($decrypted);
    }

    private static function supported($key, $cipher)
    {
        $length = mb_strlen($key, '8bit');

        return ($cipher === 'AES-256-CBC' && $length === 32);
    }

    private function getJsonPayload($payload)
    {
        $payload = json_decode(base64_decode($payload), true);

        if (!$payload || $this->invalidPayload($payload)) {
            throw new Exception('The payload is invalid.');
        }

        return $payload;
    }

    private function invalidPayload($data)
    {
        return !is_array($data) || !isset($data['iv']) || !isset($data['value']) || !isset($data['mac']);
    }

    private static function random_bytes($bytes)
    {
        try {
            $bytes = self::RandomCompareInteger($bytes);
        } catch (Exception $ex) {
            throw new Exception('random_bytes(): $bytes must be an integer');
        }

        if ($bytes < 1) {
            throw new Exception('Length must be greater than 0');
        }

        $secure = true;
        $buf = openssl_random_pseudo_bytes($bytes, $secure);
        if ($buf !== false && $secure && mb_strlen($buf, '8bit') === $bytes) {
            return $buf;
        }

        throw new Exception('Could not gather sufficient random data');
    }

    private static function RandomCompareInteger($number, $fail_open = false)
    {
        if (is_numeric($number)) {
            $number += 0;
        }

        if (is_float($number) && $number > ~PHP_INT_MAX && $number < PHP_INT_MAX) {
            $number = (int)$number;
        }

        if (is_int($number) || $fail_open) {
            return $number;
        }

        throw new Exception('Expected an integer.');
    }
}