Genkgo\Mail\Dkim\Sha256Signer

Complexity

Total Complexity

11

Size/Duplication

Total Lines	97
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

100%

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	3
A	hashBody()	0	4	1
A	signHeaders()	0	12	2
A	name()	0	4	1
A	fromFile()	0	8	2
A	fromString()	0	10	2

<?php
declare(strict_types=1);

namespace Genkgo\Mail\Dkim;

use Genkgo\Mail\Exception\FailedToSignHeadersException;

/**
 * Class Sha256Signer
 * @package Genkgo\Mail\Dkim
 */
final class Sha256Signer implements SignInterface
{
    /**
     *
     */
    private CONST SIGN_ALGORITHM = OPENSSL_ALGO_SHA256;

    /**
     *
     */
    private CONST HASH_ALGORITHM = 'sha256';

    /**
     * @var resource
     */
    private $privateKey;

    /**
     * Sha256Signer constructor.
     * @param $key
     */
    public function __construct($key)
    {
        if (!is_resource($key) || get_resource_type($key) !== 'OpenSSL key') {
            throw new \InvalidArgumentException('Expected a private key resource');
        }

        $this->privateKey = $key;
    }

    /**
     * @param string $canonicalizedBody
     * @return string
     */
    public function hashBody(string $canonicalizedBody): string
    {
        return hash(self::HASH_ALGORITHM, $canonicalizedBody, true);
    }

    /**
     * @param string $canonicalizedHeaders
     * @return string
     * @throws \Exception
     */
    public function signHeaders(string $canonicalizedHeaders): string
    {
        if (openssl_sign($canonicalizedHeaders, $signature, $this->privateKey, self::SIGN_ALGORITHM)) {
            return $signature;
        }

        // @codeCoverageIgnoreStart
        throw new FailedToSignHeadersException(
            sprintf('Unable to sign DKIM Hash, openssl error: %s', openssl_error_string())
        );
        // @codeCoverageIgnoreEnd
    }

    /**
     * @return string
     */
    public function name(): string
    {
        return 'rsa-sha256';
    }

    /**
     * @param string $file
     * @param string|null $passphrase
     * @return Sha256Signer
     * @throws \Exception
     */
    public static function fromFile(string $file, string $passphrase = ''): self
    {
        if (!file_exists($file)) {
            throw new \InvalidArgumentException('File does not exist');
        }

        return self::fromString(file_get_contents($file), $passphrase);
    }

    /**
     * @param string $privateKeyString
     * @param string $passphrase
     * @return Sha256Signer
     * @throws \Exception
     */
    public static function fromString(string $privateKeyString, string $passphrase = ''): self
    {
        $key = openssl_pkey_get_private($privateKeyString, $passphrase);

        if ($key === false) {
            throw new \InvalidArgumentException('Cannot create resource from private key string');
        }

        return new self($key);
    }
}