Ds\Authenticate\HashHmac

Complexity

Total Complexity

17

Size/Duplication

Total Lines	158
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Test Coverage

Coverage

100%

Importance

Changes	4
Bugs	0	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	createHash()	0	11	1
A	getEncodedHash()	0	4	1
A	compareHash()	0	18	2
A	setPrivateKey()	0	6	1
A	getAlgorithm()	0	4	1
A	getPayload()	0	3	1
A	getPrivateKey()	0	4	1
B	verifyHash()	0	12	5
A	verifyAlgorithm()	0	10	3

<?php

namespace Ds\Authenticate;

/**
 * Hmac hashing functions.
 *
 * PHP version 5
 *
 * @package Ds\Authenticate
 * @author  Dan Smith <dan--smith@hotmail.co.uk>
 * @license MIT
 * @license https://opensource.org/licenses/MIT
 * @version v0.0.1
 * @link    https://github.com/djsmithme/Authenticate
 */
class HashHmac
{

    /**
     * Hashing Algorithm.
     *
     * @var string
     */
    private $algorithm;

    /**
     * Private Key.
     *
     * @var string
     */
    private $privateKey;

    private $payload;

    /**
     * Date Time Zone.
     *
     * @var \DateTimeZone
     */
    private $timezone;

    /**
     * BasicAuth constructor.
     *
     * @param string $privateKey
     * @param string $algo
     * @param string $timezone
     */
    public function __construct($privateKey, $algo = 'sha512', $timezone = 'UTC')
    {
        $this->privateKey = $privateKey;
        $this->algorithm = $algo;
        $this->timezone = new \DateTimeZone($timezone);
    }

    /**
     * Creates hash from payload.
     *
     * @param  array $payload
     * @return mixed
     */
    public function createHash($algorithm, array $payload = [], $privateKey)
    {

        $this->payload = json_encode($payload);

        return hash_hmac(
            $algorithm,
            $this->payload,
            $privateKey
        );
    }

    public function getEncodedHash(array $payload = []){
        $hash = $this->createHash($this->algorithm, $payload);

The call to createHash() misses a required argument $privateKey.

        return base64_encode($this->algorithm.'='.$hash);
    }


    /**
     * Compare received hash against payload.
     *
     * @param  $encodedHash
     * @param  array       $payload
     * @return bool
     * @throws \Exception
     */
    public function compareHash($encodedHash, array $payload = [])
    {
        $decodedHash = base64_decode($encodedHash);

        list($algo, $hash) = array_pad( explode('=', $decodedHash), 4, $this->algorithm);
        $payloadHash = $this->createHash($this->algorithm, $payload, $this->privateKey);


        try {
            $this->verifyAlgorithm($algo);
            $this->verifyHash($hash, $payloadHash);
        } catch (\Exception $e) {
            throw new \Exception($e->getMessage());
        }

        return true;

    }


    /**
     * @param $key
     * @return $this
     */
    public function setPrivateKey($key)
    {
        $new = clone $this;
        $new->privateKey = $key;
        return $new;
    }

    /**
     * Return current Algorithm
     *
     * @return string
     */
    public function getAlgorithm()
    {
        return $this->algorithm;
    }


    public function getPayload(){
        return $this->payload;
    }

    /**
     * Returns Current Private Key
     *
     * @return string
     */
    public function getPrivateKey()
    {
        return $this->privateKey;
    }

    /**
     * @param string $hash
     * @param string $payloadHash
     * @return bool
     * @throws \Exception
     */
    public function verifyHash($hash = '', $payloadHash = '')
    {
        if (!is_string($hash) || !is_string($payloadHash)) {
            throw new \Exception('hashes are not of the same type');
        }
        if (\md5($hash) === \md5($payloadHash)
            && strlen($hash) === strlen($payloadHash)
        ) {
            return true;
        }
        throw new \Exception('hashes do not match');
    }

    protected function verifyAlgorithm($algo)
    {
        foreach (hash_algos() as $validAlgo) {
            if ($algo === $validAlgo) {
                $this->algorithm = $validAlgo;
                return $this->algorithm;
            }
        }
        throw new \Exception('Algorithm is not valid');
    }
}