EcAdapter::doEcdh() - Code Metrics - Inspection of "WIP: Add EcDH" - Bit-Wasp/bitcoin-php - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#375)

by thomas

created 2016-11-05 12:42 UTC

EcAdapter::doEcdh() A

↳ Parent: EcAdapter

Complexity

Conditions	2
Paths	2

Size

Total Lines	9
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	6

Importance

Changes

Metric	Value
dl	0
loc	9
c	0
b	0
f	0
cc	2
eloc	5
nc	2
nop	2
ccs	0
cts	0
cp	0
crap	6
rs	9.6666

<?php

namespace BitWasp\Bitcoin\Crypto\EcAdapter\Impl\Secp256k1\Adapter;

use BitWasp\Bitcoin\Crypto\EcAdapter\Adapter\EcAdapterInterface;
use BitWasp\Bitcoin\Crypto\EcAdapter\Impl\Secp256k1\Key\PublicKey;
use BitWasp\Bitcoin\Crypto\EcAdapter\Impl\Secp256k1\Key\PrivateKey;
use BitWasp\Bitcoin\Crypto\EcAdapter\Impl\Secp256k1\Signature\CompactSignature;
use BitWasp\Bitcoin\Crypto\EcAdapter\Impl\Secp256k1\Signature\Signature;
use BitWasp\Bitcoin\Crypto\EcAdapter\Key\PublicKeyInterface;
use BitWasp\Bitcoin\Crypto\EcAdapter\Key\PrivateKeyInterface;
use BitWasp\Bitcoin\Crypto\EcAdapter\Signature\CompactSignatureInterface;
use BitWasp\Bitcoin\Crypto\EcAdapter\Signature\SignatureInterface;
use BitWasp\Bitcoin\Crypto\Random\RbgInterface;
use BitWasp\Bitcoin\Math\Math;
use BitWasp\Buffertools\Buffer;
use BitWasp\Buffertools\BufferInterface;
use Mdanter\Ecc\Primitives\GeneratorPoint;

class EcAdapter implements EcAdapterInterface
{
    /**
     * @var Math
     */
    private $math;

    /**
     * @var GeneratorPoint
     */
    private $generator;

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

    /**
     * @param Math $math
     * @param GeneratorPoint $generator
     * @param resource $secp256k1_context_t
     */
    public function __construct(Math $math, GeneratorPoint $generator, $secp256k1_context_t)
    {
        if (!is_resource($secp256k1_context_t) || !get_resource_type($secp256k1_context_t) === SECP256K1_TYPE_CONTEXT) {
            throw new \InvalidArgumentException('Secp256k1: Must pass a secp256k1_context_t resource');
        }
        $this->math = $math;
        $this->generator = $generator;
        $this->context = $secp256k1_context_t;
    }

    /**
     * @return Math
     */
    public function getMath()
    {
        return $this->math;
    }

    /**
     * @return GeneratorPoint
     */
    public function getGenerator()
    {
        return $this->generator;
    }

    /**
     * @param BufferInterface $privateKey
     * @return bool
     */
    public function validatePrivateKey(BufferInterface $privateKey)
    {
        return (bool) secp256k1_ec_seckey_verify($this->context, $privateKey->getBinary());
    }

    /**
     * @param \GMP $element
     * @param bool $half
     * @return bool
     */
    public function validateSignatureElement(\GMP $element, $half = false)
    {
        $math = $this->getMath();
        $against = $this->getGenerator()->getOrder();
        if ($half) {
            $against = $math->rightShift($against, 1);
        }

        return $math->cmp($element, $against) < 0 && $math->cmp($element, gmp_init(0)) !== 0;
    }

    /**
     * @param \GMP $int
     * @param bool|false $compressed
     * @return PrivateKey
     */
    public function getPrivateKey(\GMP $int, $compressed = false)
    {
        return new PrivateKey($this, $int, $compressed);
    }

    /**
     * @return resource
     */
    public function getContext()
    {
        return $this->context;
    }

    /**
     * @param BufferInterface $msg32
     * @param PrivateKey $privateKey
     * @return Signature
     */
    private function doSign(BufferInterface $msg32, PrivateKey $privateKey)
    {
        /** @var resource $sig_t */
        $sig_t = '';
        if (1 !== secp256k1_ecdsa_sign($this->context, $sig_t, $msg32->getBinary(), $privateKey->getBinary())) {
            throw new \RuntimeException('Secp256k1: failed to sign');
        }

        $derSig = '';
        secp256k1_ecdsa_signature_serialize_der($this->context, $derSig, $sig_t);

        $rL = ord($derSig[3]);
        $r = (new Buffer(substr($derSig, 4, $rL), $rL, $this->math))->getGmp();

        $sL = ord($derSig[4+$rL + 1]);
        $s = (new Buffer(substr($derSig, 4 + $rL + 2, $sL), $sL, $this->math))->getGmp();

        return new Signature($this, $r, $s, $sig_t);
    }

    /**
     * @param BufferInterface $msg32
     * @param PrivateKeyInterface $privateKey
     * @param RbgInterface|null $rbg
     * @return Signature
     */
    public function sign(BufferInterface $msg32, PrivateKeyInterface $privateKey, RbgInterface $rbg = null)
    {
        /** @var PrivateKey $privateKey */
        return $this->doSign($msg32, $privateKey);
    }

    /**
     * @param BufferInterface $msg32
     * @param PublicKey $publicKey
     * @param Signature $signature
     * @return bool
     */
    private function doVerify(BufferInterface $msg32, PublicKey $publicKey, Signature $signature)
    {
        return (bool) secp256k1_ecdsa_verify($this->context, $signature->getResource(), $msg32->getBinary(), $publicKey->getResource());
    }

    /**
     * @param BufferInterface $msg32
     * @param PublicKeyInterface $publicKey
     * @param SignatureInterface $signature
     * @return bool
     */
    public function verify(BufferInterface $msg32, PublicKeyInterface $publicKey, SignatureInterface $signature)
    {
        /** @var PublicKey $publicKey */
        /** @var Signature $signature */
        return $this->doVerify($msg32, $publicKey, $signature);

    }

    /**
     * @param BufferInterface $msg32
     * @param CompactSignature $compactSig
     * @return PublicKey
     */
    private function doRecover(BufferInterface $msg32, CompactSignature $compactSig)
    {
        $publicKey = '';
        /** @var resource $publicKey */
        $context = $this->context;
        $sig = $compactSig->getResource();
        if (1 !== secp256k1_ecdsa_recover($context, $publicKey, $sig, $msg32->getBinary())) {
            throw new \RuntimeException('Unable to recover Public Key');
        }

        return new PublicKey($this, $publicKey, $compactSig->isCompressed());
    }

    /**
     * @param BufferInterface $msg32
     * @param CompactSignatureInterface $compactSig
     * @return PublicKey
     */
    public function recover(BufferInterface $msg32, CompactSignatureInterface $compactSig)
    {
        /** @var CompactSignature $compactSig */
        return $this->doRecover($msg32, $compactSig);
    }

    /**
     * @param BufferInterface $msg32
     * @param PrivateKey $privateKey
     * @return CompactSignature
     */
    private function doSignCompact(BufferInterface $msg32, PrivateKey $privateKey)
    {
        $sig_t = '';
        /** @var resource $sig_t */
        if (1 !== secp256k1_ecdsa_sign_recoverable($this->context, $sig_t, $msg32->getBinary(), $privateKey->getBinary())) {
            throw new \RuntimeException('Secp256k1: failed to sign');
        }

        $recid = '';
        $ser = '';
        if (!secp256k1_ecdsa_recoverable_signature_serialize_compact($this->context, $sig_t, $ser, $recid)) {
            throw new \RuntimeException('Failed to obtain recid');
        }

        unset($ser);
        return new CompactSignature(
            $this,
            $sig_t,
            $recid,
            $privateKey->isCompressed()
        );
    }

    /**
     * @param BufferInterface $msg32
     * @param PrivateKeyInterface $privateKey
     * @param RbgInterface|null $rbg
     * @return CompactSignatureInterface
     */
    public function signCompact(BufferInterface $msg32, PrivateKeyInterface $privateKey, RbgInterface $rbg = null)
    {
        /** @var PrivateKey $privateKey */
        return $this->doSignCompact($msg32, $privateKey);
    }

    /**
     * @param PrivateKey $privateKey
     * @param PublicKey $publicKey
     * @return Buffer
     */
    private function doEcdh(PrivateKey $privateKey, PublicKey $publicKey)
    {
        $result = '';
        if (!secp256k1_ecdh($this->context, $result, $publicKey->getResource(), $privateKey->getSecretBinary())) {
            throw new \RuntimeException('Failed to perform ECDH');
        }

        return new Buffer($result);
    }

    /**
     * @param PrivateKeyInterface $privateKey
     * @param PublicKeyInterface $publicKey
     * @return Buffer
     */
    public function ecdh(PrivateKeyInterface $privateKey, PublicKeyInterface $publicKey)
    {
        /**
         * @var PrivateKey $privateKey
         * @var PublicKey $publicKey
         */
        return $this->doEcdh($privateKey, $publicKey);
    }
}


1		<?php
2
3		namespace BitWasp\Bitcoin\Crypto\EcAdapter\Impl\Secp256k1\Adapter;
4
5		use BitWasp\Bitcoin\Crypto\EcAdapter\Adapter\EcAdapterInterface;
6		use BitWasp\Bitcoin\Crypto\EcAdapter\Impl\Secp256k1\Key\PublicKey;
7		use BitWasp\Bitcoin\Crypto\EcAdapter\Impl\Secp256k1\Key\PrivateKey;
8		use BitWasp\Bitcoin\Crypto\EcAdapter\Impl\Secp256k1\Signature\CompactSignature;
9		use BitWasp\Bitcoin\Crypto\EcAdapter\Impl\Secp256k1\Signature\Signature;
10		use BitWasp\Bitcoin\Crypto\EcAdapter\Key\PublicKeyInterface;
11		use BitWasp\Bitcoin\Crypto\EcAdapter\Key\PrivateKeyInterface;
12		use BitWasp\Bitcoin\Crypto\EcAdapter\Signature\CompactSignatureInterface;
13		use BitWasp\Bitcoin\Crypto\EcAdapter\Signature\SignatureInterface;
14		use BitWasp\Bitcoin\Crypto\Random\RbgInterface;
15		use BitWasp\Bitcoin\Math\Math;
16		use BitWasp\Buffertools\Buffer;
17		use BitWasp\Buffertools\BufferInterface;
18		use Mdanter\Ecc\Primitives\GeneratorPoint;
19
20		class EcAdapter implements EcAdapterInterface
21		{
22		/**
23		* @var Math
24		*/
25		private $math;
26
27		/**
28		* @var GeneratorPoint
29		*/
30		private $generator;
31
32		/**
33		* @var resource
34		*/
35		private $context;
36
37		/**
38		* @param Math $math
39		* @param GeneratorPoint $generator
40		* @param resource $secp256k1_context_t
41		*/
42	20	public function __construct(Math $math, GeneratorPoint $generator, $secp256k1_context_t)
43		{
44	20	if (!is_resource($secp256k1_context_t) \|\| !get_resource_type($secp256k1_context_t) === SECP256K1_TYPE_CONTEXT) {
45		throw new \InvalidArgumentException('Secp256k1: Must pass a secp256k1_context_t resource');
46		}
47	20	$this->math = $math;
48	20	$this->generator = $generator;
49	20	$this->context = $secp256k1_context_t;
50	20	}
51
52		/**
53		* @return Math
54		*/
55	720	public function getMath()
56		{
57	720	return $this->math;
58		}
59
60		/**
61		* @return GeneratorPoint
62		*/
63	96	public function getGenerator()
64		{
65	96	return $this->generator;
66		}
67
68		/**
69		* @param BufferInterface $privateKey
70		* @return bool
71		*/
72	204	public function validatePrivateKey(BufferInterface $privateKey)
73		{
74	204	return (bool) secp256k1_ec_seckey_verify($this->context, $privateKey->getBinary());
75		}
76
77		/**
78		* @param \GMP $element
79		* @param bool $half
80		* @return bool
81		*/
82	16	public function validateSignatureElement(\GMP $element, $half = false)
83		{
84	16	$math = $this->getMath();
85	16	$against = $this->getGenerator()->getOrder();
86	16	if ($half) {
87	16	$against = $math->rightShift($against, 1);
88	8	}
89
90	16	return $math->cmp($element, $against) < 0 && $math->cmp($element, gmp_init(0)) !== 0;
91		}
92
93		/**
94		* @param \GMP $int
95		* @param bool\|false $compressed
96		* @return PrivateKey
97		*/
98	196	public function getPrivateKey(\GMP $int, $compressed = false)
99		{
100	196	return new PrivateKey($this, $int, $compressed);
101		}
102
103		/**
104		* @return resource
105		*/
106	512	public function getContext()
107		{
108	512	return $this->context;
109		}
110
111		/**
112		* @param BufferInterface $msg32
113		* @param PrivateKey $privateKey
114		* @return Signature
115		*/
116	68	private function doSign(BufferInterface $msg32, PrivateKey $privateKey)
117		{
118		/** @var resource $sig_t */
119	68	$sig_t = '';
120	68	if (1 !== secp256k1_ecdsa_sign($this->context, $sig_t, $msg32->getBinary(), $privateKey->getBinary())) {
121		throw new \RuntimeException('Secp256k1: failed to sign');
122		}
123
124	68	$derSig = '';
125	68	secp256k1_ecdsa_signature_serialize_der($this->context, $derSig, $sig_t);
126
127	68	$rL = ord($derSig[3]);
128	68	$r = (new Buffer(substr($derSig, 4, $rL), $rL, $this->math))->getGmp();
129
130	68	$sL = ord($derSig[4+$rL + 1]);
131	68	$s = (new Buffer(substr($derSig, 4 + $rL + 2, $sL), $sL, $this->math))->getGmp();
132
133	68	return new Signature($this, $r, $s, $sig_t);
134		}
135
136		/**
137		* @param BufferInterface $msg32
138		* @param PrivateKeyInterface $privateKey
139		* @param RbgInterface\|null $rbg
140		* @return Signature
141		*/
142	68	public function sign(BufferInterface $msg32, PrivateKeyInterface $privateKey, RbgInterface $rbg = null)
143		{
144		/** @var PrivateKey $privateKey */
145	68	return $this->doSign($msg32, $privateKey);
146		}
147
148		/**
149		* @param BufferInterface $msg32
150		* @param PublicKey $publicKey
151		* @param Signature $signature
152		* @return bool
153		*/
154	50	private function doVerify(BufferInterface $msg32, PublicKey $publicKey, Signature $signature)
155		{
156	50	return (bool) secp256k1_ecdsa_verify($this->context, $signature->getResource(), $msg32->getBinary(), $publicKey->getResource());
157		}
158
159		/**
160		* @param BufferInterface $msg32
161		* @param PublicKeyInterface $publicKey
162		* @param SignatureInterface $signature
163		* @return bool
164		*/
165	50	public function verify(BufferInterface $msg32, PublicKeyInterface $publicKey, SignatureInterface $signature)
166		{
167		/** @var PublicKey $publicKey */
168		/** @var Signature $signature */
169	50	return $this->doVerify($msg32, $publicKey, $signature);
		0 ignored issues – show Compatibility introduced 2015-11-21 03:53 UTC by Report Bug Copy Issue Report `$publicKey` of type `object<BitWasp\Bitcoin\C...Key\PublicKeyInterface>` is not a sub-type of `object<BitWasp\Bitcoin\C...ecp256k1\Key\PublicKey>`. It seems like you assume a concrete implementation of the interface `BitWasp\Bitcoin\Crypto\E...\Key\PublicKeyInterface` to be always present. This check looks for parameters that are defined as one type in their type hint or doc comment but seem to be used as a narrower type, i.e an implementation of an interface or a subclass. Consider changing the type of the parameter or doing an instanceof check before assuming your parameter is of the expected type. Loading history...
170		}
171
172		/**
173		* @param BufferInterface $msg32
174		* @param CompactSignature $compactSig
175		* @return PublicKey
176		*/
177	28	private function doRecover(BufferInterface $msg32, CompactSignature $compactSig)
178		{
179	28	$publicKey = '';
180		/** @var resource $publicKey */
181	28	$context = $this->context;
182	28	$sig = $compactSig->getResource();
183	28	if (1 !== secp256k1_ecdsa_recover($context, $publicKey, $sig, $msg32->getBinary())) {
184		throw new \RuntimeException('Unable to recover Public Key');
185		}
186
187	28	return new PublicKey($this, $publicKey, $compactSig->isCompressed());
188		}
189
190		/**
191		* @param BufferInterface $msg32
192		* @param CompactSignatureInterface $compactSig
193		* @return PublicKey
194		*/
195	28	public function recover(BufferInterface $msg32, CompactSignatureInterface $compactSig)
196		{
197		/** @var CompactSignature $compactSig */
198	28	return $this->doRecover($msg32, $compactSig);
199		}
200
201		/**
202		* @param BufferInterface $msg32
203		* @param PrivateKey $privateKey
204		* @return CompactSignature
205		*/
206	24	private function doSignCompact(BufferInterface $msg32, PrivateKey $privateKey)
207		{
208	24	$sig_t = '';
209		/** @var resource $sig_t */
210	24	if (1 !== secp256k1_ecdsa_sign_recoverable($this->context, $sig_t, $msg32->getBinary(), $privateKey->getBinary())) {
211		throw new \RuntimeException('Secp256k1: failed to sign');
212		}
213
214	24	$recid = '';
215	24	$ser = '';
216	24	if (!secp256k1_ecdsa_recoverable_signature_serialize_compact($this->context, $sig_t, $ser, $recid)) {
217		throw new \RuntimeException('Failed to obtain recid');
218		}
219
220	24	unset($ser);
221	24	return new CompactSignature(
222	12	$this,
223	12	$sig_t,
224	12	$recid,
225	24	$privateKey->isCompressed()
226	12	);
227		}
228
229		/**
230		* @param BufferInterface $msg32
231		* @param PrivateKeyInterface $privateKey
232		* @param RbgInterface\|null $rbg
233		* @return CompactSignatureInterface
234		*/
235	24	public function signCompact(BufferInterface $msg32, PrivateKeyInterface $privateKey, RbgInterface $rbg = null)
236		{
237		/** @var PrivateKey $privateKey */
238	24	return $this->doSignCompact($msg32, $privateKey);
239		}
240
241		/**
242		* @param PrivateKey $privateKey
243		* @param PublicKey $publicKey
244		* @return Buffer
245		*/
246		private function doEcdh(PrivateKey $privateKey, PublicKey $publicKey)
247		{
248		$result = '';
249		if (!secp256k1_ecdh($this->context, $result, $publicKey->getResource(), $privateKey->getSecretBinary())) {
250		throw new \RuntimeException('Failed to perform ECDH');
251		}
252
253		return new Buffer($result);
254		}
255
256		/**
257		* @param PrivateKeyInterface $privateKey
258		* @param PublicKeyInterface $publicKey
259		* @return Buffer
260		*/
261		public function ecdh(PrivateKeyInterface $privateKey, PublicKeyInterface $publicKey)
262		{
263		/**
264		* @var PrivateKey $privateKey
265		* @var PublicKey $publicKey
266		*/
267		return $this->doEcdh($privateKey, $publicKey);
268		}
269		}
270

Bit-Wasp / bitcoin-php

Pull Request — master (#375)

EcAdapter::doEcdh() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like