Jose\Algorithm\Signature\ECDSA

Complexity

Total Complexity

11

Size/Duplication

Total Lines	142
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	sign()	0	7	1
A	getOpenSSLSignature()	0	18	2
A	verify()	0	14	2
A	verifyOpenSSLSignature()	0	12	1
	getHashAlgorithm()	0	1	?
	getSignaturePartLength()	0	1	?
A	convertHexToBin()	0	4	1
A	convertBinToHex()	0	6	1
A	convertDecToHex()	0	6	1
A	convertHexToGmp()	0	4	1
A	checkKey()	0	7	1

<?php

/*
 * The MIT License (MIT)
 *
 * Copyright (c) 2014-2016 Spomky-Labs
 *
 * This software may be modified and distributed under the terms
 * of the MIT license.  See the LICENSE file for details.
 */

namespace Jose\Algorithm\Signature;

use Assert\Assertion;
use FG\ASN1\Object;
use FG\ASN1\Universal\Integer;
use FG\ASN1\Universal\Sequence;
use Jose\Algorithm\SignatureAlgorithmInterface;
use Jose\KeyConverter\ECKey;
use Jose\Object\JWKInterface;

/**
 * Class ECDSA.
 */
abstract class ECDSA implements SignatureAlgorithmInterface
{
    /**
     * {@inheritdoc}
     */
    public function sign(JWKInterface $key, string $data): string
    {
        $this->checkKey($key);
        Assertion::true($key->has('d'), 'The EC key is not private');

        return $this->getOpenSSLSignature($key, $data);
    }

    /**
     * @param \Jose\Object\JWKInterface $key
     * @param string                    $data
     *
     * @return string
     */
    private function getOpenSSLSignature(JWKInterface $key, string $data): string
    {
        $pem = (new ECKey($key))->toPEM();
        $result = openssl_sign($data, $signature, $pem, $this->getHashAlgorithm());

        Assertion::true($result, 'Signature failed');

        $asn = Object::fromBinary($signature);
        Assertion::isInstanceOf($asn, Sequence::class, 'Invalid signature');

        $res = '';
        foreach ($asn->getChildren() as $child) {

The method getChildren does only exist in FG\ASN1\Construct, but not in FG\ASN1\AbstractString and FG\ASN1\ExplicitlyTaggedObject and FG\ASN1\Universal\Boolean and FG\ASN1\Universal\GeneralizedTime and FG\ASN1\Universal\Integer and FG\ASN1\Universal\NullObject and FG\ASN1\Universal\ObjectIdentifier and FG\ASN1\Universal\OctetString and FG\ASN1\Universal\UTCTime and FG\ASN1\UnknownObject.

            Assertion::isInstanceOf($child, Integer::class, 'Invalid signature');
            $res .= str_pad($this->convertDecToHex($child->getContent()), $this->getSignaturePartLength(), '0', STR_PAD_LEFT);
        }

        return $this->convertHexToBin($res);
    }

    /**
     * {@inheritdoc}
     */
    public function verify(JWKInterface $key, string $data, string $signature): bool
    {
        $this->checkKey($key);

        $signature = $this->convertBinToHex($signature);
        $part_length = $this->getSignaturePartLength();
        if (mb_strlen($signature, '8bit') !== 2 * $part_length) {
            return false;
        }
        $R = mb_substr($signature, 0, $part_length, '8bit');
        $S = mb_substr($signature, $part_length, null, '8bit');

        return $this->verifyOpenSSLSignature($key, $data, $R, $S);
    }

    /**
     * @param \Jose\Object\JWKInterface $key
     * @param string                    $data
     * @param string                    $R
     * @param string                    $S
     *
     * @return bool
     */
    private function verifyOpenSSLSignature(JWKInterface $key, string $data, string $R, string $S): bool
    {
        $pem = ECKey::toPublic(new ECKey($key))->toPEM();

        $oid_sequence = new Sequence();
        $oid_sequence->addChildren([
            new Integer(gmp_strval($this->convertHexToGmp($R), 10)),
            new Integer(gmp_strval($this->convertHexToGmp($S), 10)),
        ]);

        return 1 === openssl_verify($data, $oid_sequence->getBinary(), $pem, $this->getHashAlgorithm());
    }

    /**
     * @return string
     */
    abstract protected function getHashAlgorithm(): string;

    /**
     * @return int
     */
    abstract protected function getSignaturePartLength(): int;

    /**
     * @param string $value
     *
     * @return string
     */
    private function convertHexToBin(string $value): string
    {
        return pack('H*', $value);
    }

    /**
     * @param string $value
     *
     * @return string
     */
    private function convertBinToHex(string $value): string
    {
        $value = unpack('H*', $value);

        return $value[1];
    }

    /**
     * @param string $value
     *
     * @return string
     */
    private function convertDecToHex(string $value): string
    {
        $value = gmp_strval($value, 10);

        return gmp_strval($value, 16);
    }

    /**
     * @param string $value
     *
     * @return \GMP
     */
    private function convertHexToGmp(string $value): \GMP
    {
        return gmp_init($value, 16);
    }

    /**
     * @param JWKInterface $key
     */
    private function checkKey(JWKInterface $key)
    {
        Assertion::eq($key->get('kty'), 'EC', 'Wrong key type.');
        Assertion::true($key->has('x'), 'The key parameter "x" is missing.');
        Assertion::true($key->has('y'), 'The key parameter "y" is missing.');
        Assertion::true($key->has('crv'), 'The key parameter "crv" is missing.');
    }
}