Gandung\JWT\Adapter\ECDSAAdapter

Complexity

Total Complexity

10

Size/Duplication

Total Lines	178
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	9

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	1
A	create()	0	6	1
B	sign()	0	26	1
A	verify()	0	12	1
A	createSigningHash()	0	9	1
A	getMathAdapter()	0	4	1
A	parseExpectedSignature()	0	12	1
A	addSignaturePadding()	0	4	1
A	determineGeneratorPoint()	0	13	2

<?php

namespace Gandung\JWT\Adapter;

use Mdanter\Ecc\EccFactory;
use Mdanter\Ecc\Crypto\Key\PrivateKeyInterface;
use Mdanter\Ecc\Crypto\Key\PublicKeyInterface;
use Mdanter\Ecc\Math\GmpMathInterface;
use Mdanter\Ecc\Crypto\Signature\Signer;
use Mdanter\Ecc\Curves\NistCurve;
use Mdanter\Ecc\Random\RandomGeneratorFactory;
use Mdanter\Ecc\Random\RandomNumberGeneratorInterface;
use Mdanter\Ecc\Crypto\Signature\Signature;
use Mdanter\Ecc\Crypto\Signature\SignatureInterface;
use Mdanter\Ecc\Crypto\Signature\SignHasher;
use Mdanter\Ecc\Primitives\GeneratorPoint;

/**
 * @author Paulus Gandung Prakosa <rvn.plvhx@gmail.com>
 */
class ECDSAAdapter implements ECDSAAdapterInterface
{
    /**
     * @var GmpMathInterface
     */
    private $adapter;

    /**
     * @var Signer
     */
    private $signer;

    /**
     * @var NistCurves
     */
    private $curve;

    /**
     * @var RandomGeneratorInterface
     */
    private $random;

    /**
     * Signature hash length hashmap.
     */
    private const SIGNATURE_LENGTH = [
        'sha256' => 64,
        'sha384' => 96,
        'sha512' => 132
    ];

    /**
     * Generator point hashmap.
     */
    private const GENERATOR_POINTS = [
        'sha256' => 'generator256',
        'sha384' => 'generator384',
        'sha512' => 'generator521'
    ];

    public function __construct(
        GmpMathInterface $adapter
    ) {
        $this->adapter = $adapter;
        $this->signer = EccFactory::getSigner($this->adapter);
        $this->curve = EccFactory::getNistCurves($this->adapter);

It seems like \Mdanter\Ecc\EccFactory::getNistCurves($this->adapter) of type object<Mdanter\Ecc\Curves\NistCurve> is incompatible with the declared type object<Gandung\JWT\Adapter\NistCurves> of property $curve.

        $this->random = RandomGeneratorFactory::getRandomGenerator();

It seems like \Mdanter\Ecc\Random\RandomGeneratorFactory::getRandomGenerator() of type object<Mdanter\Ecc\Random\RandomNumberGeneratorInterface> is incompatible with the declared type object<Gandung\JWT\Adapter\RandomGeneratorInterface> of property $random.

    }

    /**
     * For chainability purpose.
     */
    public static function create()
    {
        return new static(
            EccFactory::getAdapter()
        );
    }

    /**
     * {@inheritdoc}
     */
    public function sign(
        PrivateKeyInterface $key,
        \GMP $hash,
        $algorithm
    ) {
        $signature = $this->signer->sign(
            $key,
            $hash,
            $this->random->generate($key->getPoint()->getOrder())
        );

        return \pack(
            'H*',
            \sprintf(
                "%s%s",
                $this->addSignaturePadding(
                    $signature->getR(),
                    self::SIGNATURE_LENGTH[$algorithm]
                ),
                $this->addSignaturePadding(
                    $signature->getS(),
                    self::SIGNATURE_LENGTH[$algorithm]
                )
            )
        );
    }

    /**
     * {@inheritdoc}
     */
    public function verify(
        $expected,
        PublicKeyInterface $key,
        \GMP $hash,
        $algorithm
    ) {
        return $this->signer->verify(
            $key,
            $this->parseExpectedSignature($expected, $algorithm),
            $hash
        );
    }

    /**
     * {@inheritdoc}
     */
    public function createSigningHash($payload, $algorithm)
    {
        $hasher = new SignHasher($algorithm, $this->adapter);

        return $hasher->makeHash(
            $payload,
            $this->determineGeneratorPoint($algorithm)
        );
    }

    /**
     * {@inheritdoc}
     */
    public function getMathAdapter()
    {
        return $this->adapter;

The return type of return $this->adapter; (Mdanter\Ecc\Math\GmpMathInterface) is incompatible with the return type declared by the interface Gandung\JWT\Adapter\ECDSAAdapterInterface::getMathAdapter of type Gandung\JWT\Adapter\GmpMathInterface.

    }

    /**
     * Parse previous generated signature.
     *
     * @param string $expected
     * @param string $algorithm
     * @return SignatureInterface
     */
    private function parseExpectedSignature($expected, $algorithm)
    {
        [$pointR, $pointS] = \str_split(

The variable $pointR does not exist. Did you forget to declare it?

The variable $pointS does not exist. Did you forget to declare it?

            \unpack('H*', $expected)[1],
            self::SIGNATURE_LENGTH[$algorithm]
        );

        return new Signature(
            \gmp_init($this->adapter->hexDec($pointR), 10),
            \gmp_init($this->adapter->hexDec($pointS), 10)
        );
    }

    /**
     * Append zero char into given ECDSA signature.
     *
     * @param \GMP $point
     * @param integer $length
     * @return string
     */
    private function addSignaturePadding(\GMP $point, $length)
    {
        return \str_pad($this->adapter->decHex((string)$point), $length, '0', \STR_PAD_LEFT);
    }

    /**
     * Determine ECDSA generator point based on given algorithm.
     *
     * @param string $algorithm
     * @return GeneratorPoint
     */
    private function determineGeneratorPoint($algorithm)
    {
        if (!array_key_exists($algorithm, self::GENERATOR_POINTS)) {
            throw new \InvalidArgumentException(
                "Invalid ECDSA hashing algorithm."
            );
        }

        return \call_user_func(
            [$this->curve, self::GENERATOR_POINTS[$algorithm]],
            $this->random
        );
    }
}