MiladRahimi\Jwt\Cryptography\Algorithms\Ecdsa\AbstractEcdsaSigner

Complexity

Total Complexity

15

Size/Duplication

Total Lines	96
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	getPrivateKey()	0	3	1
A	__construct()	0	3	1
A	keySize()	0	7	1
A	derToSignature()	0	13	1
B	decodeDer()	0	28	6
A	sign()	0	7	3
A	name()	0	3	1
A	algorithm()	0	7	1

<?php declare(strict_types=1);

namespace MiladRahimi\Jwt\Cryptography\Algorithms\Ecdsa;

use MiladRahimi\Jwt\Cryptography\Keys\EcdsaPrivateKey;
use MiladRahimi\Jwt\Cryptography\Signer;
use MiladRahimi\Jwt\Exceptions\SigningException;
use function ltrim;
use function ord;
use function str_pad;
use function strlen;
use function substr;

abstract class AbstractEcdsaSigner implements Signer
{
    protected const ASN1_BIT_STRING = 0x03;

    protected static string $name;

    protected EcdsaPrivateKey $privateKey;

    public function __construct(EcdsaPrivateKey $privateKey)
    {
        $this->privateKey = $privateKey;
    }

    /**
     * @inheritdoc
     */
    public function name(): string
    {
        return static::$name;
    }

    public function sign(string $message): string
    {
        if (openssl_sign($message, $signature, $this->privateKey->getResource(), $this->algorithm()) === true) {
            return $this->derToSignature($signature, $this->keySize());
        }

        throw new SigningException(openssl_error_string() ?: "OpenSSL cannot sign the token.");
    }

    protected function algorithm(): int
    {
        return [
            'ES256' => OPENSSL_ALGO_SHA256,
            'ES256K' => OPENSSL_ALGO_SHA256,
            'ES384' => OPENSSL_ALGO_SHA384,
        ][static::$name];
    }

    protected function keySize(): int
    {
        return [
            'ES256' => 256,
            'ES256K' => 256,
            'ES384' => 384,
        ][static::$name];
    }

    protected function derToSignature(string $der, int $keySize): string
    {
        $i = $this->decodeDer($der)[0];
        [$i, $r] = $this->decodeDer($der, $i);
        $s = $this->decodeDer($der, $i)[1];

        $r = ltrim($r, "\x00");
        $s = ltrim($s, "\x00");

        $r = str_pad($r, $keySize / 8, "\x00", STR_PAD_LEFT);
        $s = str_pad($s, $keySize / 8, "\x00", STR_PAD_LEFT);

        return $r . $s;
    }

    protected function decodeDer(string $der, int $offset = 0): array
    {
        $pos = $offset;
        $size = strlen($der);
        $constructed = (ord($der[$pos]) >> 5) & 0x01;
        $type = ord($der[$pos++]) & 0x1f;

        $len = ord($der[$pos++]);
        if ($len & 0x80) {
            $n = $len & 0x1f;
            $len = 0;
            while ($n-- && $pos < $size) {
                $len = ($len << 8) | ord($der[$pos++]);
            }
        }

        if ($type === self::ASN1_BIT_STRING) {
            $pos++;
            $data = substr($der, $pos, $len - 1);
            $pos += $len - 1;
        } elseif (!$constructed) {
            $data = substr($der, $pos, $len);
            $pos += $len;
        } else {
            $data = '';
        }

        return [$pos, $data];
    }

    public function getPrivateKey(): EcdsaPrivateKey
    {
        return $this->privateKey;
    }
}