Dcrypt\OpensslKey

Complexity

Total Complexity

11

Size/Duplication

Total Lines	147
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

100%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	29	3
A	authenticationKey()	0	4	1
A	encryptionKey()	0	4	1
A	deriveKey()	0	4	1
A	messageChecksum()	0	4	1
A	__get()	0	8	2
A	create()	0	8	2

<?php

declare(strict_types=1);

/**
 * OpensslKey.php.
 *
 * PHP version 7
 *
 * @category Dcrypt
 *
 * @author   Michael Meyer (mmeyer2k) <m.meyer2k@gmail.com>
 * @license  http://opensource.org/licenses/MIT The MIT License (MIT)
 *
 * @link     https://github.com/mmeyer2k/dcrypt
 */

namespace Dcrypt;

use Dcrypt\Exceptions\InvalidKeyException;
use Exception;

/**
 * Provides key derivation functions.
 *
 * @category Dcrypt
 *
 * @author   Michael Meyer (mmeyer2k) <m.meyer2k@gmail.com>
 * @license  http://opensource.org/licenses/MIT The MIT License (MIT)
 *
 * @link     https://github.com/mmeyer2k/dcrypt
 */
final class OpensslKey
{
    /**
     * High entropy key.
     *
     * @var string
     */
    private $_key;

    /**
     * Algo string.
     *
     * @var string
     */
    private $_algo;

    /**
     * High entropy salt.
     *
     * @var string
     */
    private $_iv;

    /**
     * Name of cipher
     *
     * @var string
     */
    private $_cipher;

    /**
     * OpensslKey constructor.
     *
     * @param string $key Key to use for encryption
     * @param string $algo Algo to use for HKDF
     * @param string $cipher Name of cipher
     * @param string $iv Initialization vector
     *
     * @throws InvalidKeyException
     */
    public function __construct(
        string $key,
        string $algo,
        string $cipher = '',
        string $iv = ''
    )
    {
        // Store the key as what was supplied
        $this->_key = \base64_decode($key, true);

        // If key was not proper base64, bail out
        if ($this->_key === false) {
            throw new InvalidKeyException(InvalidKeyException::BASE64ENC);
        }

        // If key was to short, bail out
        if (Str::strlen($this->_key) < 32) {
            throw new InvalidKeyException(InvalidKeyException::KEYLENGTH);
        }

        // Store algo in object
        $this->_algo = $algo;

        // Store init vector in object
        $this->_iv = $iv;

        // Store the cipher name
        $this->_cipher = $cipher;
    }

    /**
     * Generate the authentication key.
     *
     * @return string
     */
    public function authenticationKey(): string
    {
        return $this->deriveKey(__FUNCTION__ . '|' . $this->_cipher);
    }

    /**
     * Generate the encryption key.
     *
     * @return string
     */
    public function encryptionKey(): string
    {
        return $this->deriveKey(__FUNCTION__ . '|' . $this->_cipher);
    }

    /**
     * Derive a key with differing info string parameters.
     *
     * @param string $info Info parameter to provide to hash_hkdf
     *
     * @return string
     */
    public function deriveKey(string $info): string
    {
        return \hash_hkdf($this->_algo, $this->_key, 0, $info, $this->_iv);
    }

    /**
     * Calculates a given message HMAC.
     *
     * @param string $message
     * @return string
     */
    public function messageChecksum(string $message): string
    {
        return \hash_hmac($this->_algo, $message, $this->authenticationKey(), true);
    }

    /**
     * Allows secure read only access to private properties
     *
     * @param string $name
     * @return mixed
     * @throws Exception
     */
    public function __get(string $name)
    {
        if (in_array($name, ['iv', 'cipher'])) {
            return $this->{"_{$name}"};
        }

        throw new Exception("Invalid property access attempt");
    }

    /**
     * Generate a new key.
     *
     * @param int $bytes Size of key in bytes
     *
     * @return string
     * @throws InvalidKeyException
     * @throws Exception
     */
    public static function create(int $bytes = 32): string
    {
        if ($bytes < 32) {
            throw new InvalidKeyException(InvalidKeyException::KEYLENGTH);
        }

        return \base64_encode(\random_bytes($bytes));
    }
}