HierarchicalKey::isHardened() - Code Metrics - Inspection of "Merge pull request #321 from afk11/hk-chaincode-bu..." - Bit-Wasp/bitcoin-php - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 246998...6d15a1 )

by thomas

created 2016-06-18 01:57 UTC

HierarchicalKey::isHardened() A

↳ Parent: HierarchicalKey

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes	1
Bugs	1	Features	0

Metric	Value
cc	1
eloc	2
c	1
b	1
f	0
nc	1
nop	0
dl	0
loc	4
ccs	2
cts	2
cp	1
crap	1
rs	10

<?php

namespace BitWasp\Bitcoin\Key\Deterministic;

use BitWasp\Bitcoin\Bitcoin;
use BitWasp\Bitcoin\Crypto\EcAdapter\Key\KeyInterface;
use BitWasp\Bitcoin\Crypto\EcAdapter\Key\PrivateKeyInterface;
use BitWasp\Bitcoin\Crypto\EcAdapter\Impl\PhpEcc\Key\PublicKey;
use BitWasp\Buffertools\Buffer;
use BitWasp\Bitcoin\Crypto\EcAdapter\Adapter\EcAdapterInterface;
use BitWasp\Bitcoin\Serializer\Key\HierarchicalKey\Base58ExtendedKeySerializer;
use BitWasp\Bitcoin\Serializer\Key\HierarchicalKey\ExtendedKeySerializer;
use BitWasp\Buffertools\BufferInterface;
use BitWasp\Buffertools\Buffertools;
use BitWasp\Buffertools\Parser;
use BitWasp\Bitcoin\Crypto\Hash;
use BitWasp\Bitcoin\Network\NetworkInterface;

class HierarchicalKey
{
    /**
     * @var EcAdapterInterface
     */
    private $ecAdapter;

    /**
     * @var int
     */
    private $depth;

    /**
     * @var int
     */
    private $parentFingerprint;

    /**
     * @var int
     */
    private $sequence;

    /**
     * @var BufferInterface
     */
    private $chainCode;

    /**
     * @var KeyInterface
     */
    private $key;

    /**
     * @param EcAdapterInterface $ecAdapter
     * @param int $depth
     * @param int $parentFingerprint
     * @param int $sequence
     * @param BufferInterface $chainCode
     * @param KeyInterface $key
     * @throws \Exception
     */
    public function __construct(EcAdapterInterface $ecAdapter, $depth, $parentFingerprint, $sequence, BufferInterface $chainCode, KeyInterface $key)
    {
        if ($chainCode->getSize() !== 32) {
            throw new \RuntimeException('Chaincode should be 32 bytes');
        }

        if (!$key->isCompressed()) {
            throw new \InvalidArgumentException('A HierarchicalKey must always be compressed');
        }

        $this->ecAdapter = $ecAdapter;
        $this->depth = $depth;
        $this->sequence = $sequence;
        $this->parentFingerprint = $parentFingerprint;
        $this->chainCode = $chainCode;
        $this->key = $key;

    }

    /**
     * Return the depth of this key. This is limited to 256 sequential derivations.
     *
     * @return int
     */
    public function getDepth()
    {
        return $this->depth;
    }

    /**
     * Get the sequence number for this address. Hardened keys are
     * created with sequence > 0x80000000. a sequence number lower
     * than this can be derived with the public key.
     *
     * @return int
     */
    public function getSequence()
    {
        return $this->sequence;
    }

    /**
     * Get the fingerprint of the parent key. For master keys, this is 00000000.
     *
     * @return string
     */
    public function getFingerprint()
    {
        if ($this->getDepth() === 0) {
            return 0;
        }

        return $this->parentFingerprint;
    }

    /**
     * Return the fingerprint to be used for child keys.
     * @return int
     */
    public function getChildFingerprint()
    {
        return $this->getPublicKey()->getPubKeyHash()->slice(0, 4)->getInt();
    }

    /**
     * Return the chain code - a deterministic 'salt' for HMAC-SHA512
     * in child derivations
     *
     * @return BufferInterface
     */
    public function getChainCode()
    {
        return $this->chainCode;
    }

    /**
     * @return PrivateKeyInterface
     */
    public function getPrivateKey()
    {
        if ($this->key->isPrivate()) {
            return $this->key;
        }

        throw new \RuntimeException('Unable to get private key, not known');
    }

    /**
     * Get the public key the private key or public key.
     *
     * @return PublicKey
     */
    public function getPublicKey()
    {
        if ($this->isPrivate()) {
            return $this->getPrivateKey()->getPublicKey();
        } else {
            return $this->key;
        }
    }

    /**
     * @return HierarchicalKey
     */
    public function toPublic()
    {
        if ($this->isPrivate()) {
            $this->key = $this->getPrivateKey()->getPublicKey();
        }

        return $this;
    }

    /**
     * Return whether this is a private key
     *
     * @return bool
     */
    public function isPrivate()
    {
        return $this->key->isPrivate();
    }

    /**
     * Return whether the key is hardened
     *
     * @return bool
     */
    public function isHardened()
    {
        return ($this->sequence >> 31) === 1;
    }

    /**
     * Create a buffer containing data to be hashed hashed to yield the child offset
     *
     * @param int $sequence
     * @return BufferInterface
     * @throws \Exception
     */
    public function getHmacSeed($sequence)
    {
        if (($sequence >> 31) === 1) {
            if ($this->isPrivate() === false) {
                throw new \Exception("Can't derive a hardened key without the private key");
            }

            $buffer = Buffertools::concat(new Buffer("\x00"), $this->getPrivateKey()->getBuffer());
        } else {
            $buffer = $this->getPublicKey()->getBuffer();
        }

        return (new Parser($buffer))
            ->writeBytes(4, Buffer::int($sequence, 4))
            ->getBuffer();
    }

    /**
     * Derive a child key
     *
     * @param int $sequence
     * @return HierarchicalKey
     * @throws \Exception
     */
    public function deriveChild($sequence)
    {
        $hash = Hash::hmac('sha512', $this->getHmacSeed($sequence), $this->getChainCode());
        $offset = $hash->slice(0, 32);
        $chain = $hash->slice(32);

        if (false === $this->ecAdapter->validatePrivateKey($offset)) {
            return $this->deriveChild($sequence + 1);
        }

        $key = $this->isPrivate() ? $this->getPrivateKey() : $this->getPublicKey();
        $key = $key->tweakAdd(gmp_init($offset->getInt(), 10));

        return new HierarchicalKey(
            $this->ecAdapter,
            $this->getDepth() + 1,
            $this->getChildFingerprint(),
            $sequence,
            $chain,
            $key
        );
    }

    /**
     * @param array|\stdClass|\Traversable $list
     * @return HierarchicalKey
     */
    public function deriveFromList($list)
    {
        if (!is_array($list) && !$list instanceof \Traversable && !$list instanceof \stdClass) {
            throw new \InvalidArgumentException('List must be an array or \Traversable');
        }

        $key = $this;
        foreach ($list as $sequence) {
$collection = json_decode($data, true);
if ( ! is_array($collection)) {
    throw new \RuntimeException('$collection must be an array.');
}

foreach ($collection as $item) { /** ... */ }
            $key = $key->deriveChild($sequence);
        }

        return $key;
    }

    /**
     * Decodes a BIP32 path into actual 32bit sequence numbers and derives the child key
     *
     * @param string $path
     * @return HierarchicalKey
     * @throws \Exception
     */
    public function derivePath($path)
    {
        $sequences = new HierarchicalKeySequence();
        return $this->deriveFromList($sequences->decodePath($path));
    }

    /**
     * Serializes the instance according to whether it wraps a private or public key.
     * @param NetworkInterface $network
     * @return string
     */
    public function toExtendedKey(NetworkInterface $network = null)
    {
        $network = $network ?: Bitcoin::getNetwork();

        $extendedSerializer = new Base58ExtendedKeySerializer(new ExtendedKeySerializer($this->ecAdapter, $network));
        $extended = $extendedSerializer->serialize($this);
        return $extended;
    }

    /**
     * Explicitly serialize as a private key. Throws an exception if
     * the key isn't private.
     *
     * @param NetworkInterface $network
     * @return string
     */
    public function toExtendedPrivateKey(NetworkInterface $network = null)
    {
        if (!$this->isPrivate()) {
            throw new \LogicException('Cannot create extended private key from public');
        }

        return $this->toExtendedKey($network);
    }

    /**
     * Explicitly serialize as a public key. This will always work.
     *
     * @param NetworkInterface $network
     * @return string
     */
    public function toExtendedPublicKey(NetworkInterface $network = null)
    {
        $clone = clone($this);
        return $clone->toPublic()->toExtendedKey($network);
    }
}


1		<?php
2
3		namespace BitWasp\Bitcoin\Key\Deterministic;
4
5		use BitWasp\Bitcoin\Bitcoin;
6		use BitWasp\Bitcoin\Crypto\EcAdapter\Key\KeyInterface;
7		use BitWasp\Bitcoin\Crypto\EcAdapter\Key\PrivateKeyInterface;
8		use BitWasp\Bitcoin\Crypto\EcAdapter\Impl\PhpEcc\Key\PublicKey;
9		use BitWasp\Buffertools\Buffer;
10		use BitWasp\Bitcoin\Crypto\EcAdapter\Adapter\EcAdapterInterface;
11		use BitWasp\Bitcoin\Serializer\Key\HierarchicalKey\Base58ExtendedKeySerializer;
12		use BitWasp\Bitcoin\Serializer\Key\HierarchicalKey\ExtendedKeySerializer;
13		use BitWasp\Buffertools\BufferInterface;
14		use BitWasp\Buffertools\Buffertools;
15		use BitWasp\Buffertools\Parser;
16		use BitWasp\Bitcoin\Crypto\Hash;
17		use BitWasp\Bitcoin\Network\NetworkInterface;
18
19		class HierarchicalKey
20		{
21		/**
22		* @var EcAdapterInterface
23		*/
24		private $ecAdapter;
25
26		/**
27		* @var int
28		*/
29		private $depth;
30
31		/**
32		* @var int
33		*/
34		private $parentFingerprint;
35
36		/**
37		* @var int
38		*/
39		private $sequence;
40
41		/**
42		* @var BufferInterface
43		*/
44		private $chainCode;
45
46		/**
47		* @var KeyInterface
48		*/
49		private $key;
50
51		/**
52		* @param EcAdapterInterface $ecAdapter
53		* @param int $depth
54		* @param int $parentFingerprint
55		* @param int $sequence
56		* @param BufferInterface $chainCode
57		* @param KeyInterface $key
58		* @throws \Exception
59		*/
60	75	public function __construct(EcAdapterInterface $ecAdapter, $depth, $parentFingerprint, $sequence, BufferInterface $chainCode, KeyInterface $key)
61		{
62	75	if ($chainCode->getSize() !== 32) {
63		throw new \RuntimeException('Chaincode should be 32 bytes');
64		}
65
66	75	if (!$key->isCompressed()) {
67	3	throw new \InvalidArgumentException('A HierarchicalKey must always be compressed');
68		}
69
70	72	$this->ecAdapter = $ecAdapter;
71	72	$this->depth = $depth;
72	72	$this->sequence = $sequence;
73	72	$this->parentFingerprint = $parentFingerprint;
74	72	$this->chainCode = $chainCode;
75	72	$this->key = $key;
76
77	72	}
78
79		/**
80		* Return the depth of this key. This is limited to 256 sequential derivations.
81		*
82		* @return int
83		*/
84	33	public function getDepth()
85		{
86	33	return $this->depth;
87		}
88
89		/**
90		* Get the sequence number for this address. Hardened keys are
91		* created with sequence > 0x80000000. a sequence number lower
92		* than this can be derived with the public key.
93		*
94		* @return int
95		*/
96	18	public function getSequence()
97		{
98	18	return $this->sequence;
99		}
100
101		/**
102		* Get the fingerprint of the parent key. For master keys, this is 00000000.
103		*
104		* @return string
105		*/
106	18	public function getFingerprint()
107		{
108	18	if ($this->getDepth() === 0) {
109	9	return 0;
110		}
111
112	18	return $this->parentFingerprint;
113		}
114
115		/**
116		* Return the fingerprint to be used for child keys.
117		* @return int
118		*/
119	21	public function getChildFingerprint()
120		{
121	21	return $this->getPublicKey()->getPubKeyHash()->slice(0, 4)->getInt();
122		}
123
124		/**
125		* Return the chain code - a deterministic 'salt' for HMAC-SHA512
126		* in child derivations
127		*
128		* @return BufferInterface
129		*/
130	24	public function getChainCode()
131		{
132	24	return $this->chainCode;
133		}
134
135		/**
136		* @return PrivateKeyInterface
137		*/
138	42	public function getPrivateKey()
139		{
140	42	if ($this->key->isPrivate()) {
141	39	return $this->key;
142		}
143
144	3	throw new \RuntimeException('Unable to get private key, not known');
145		}
146
147		/**
148		* Get the public key the private key or public key.
149		*
150		* @return PublicKey
151		*/
152	42	public function getPublicKey()
153		{
154	42	if ($this->isPrivate()) {
155	30	return $this->getPrivateKey()->getPublicKey();
156		} else {
157	18	return $this->key;
158	2	}
159		}
160
161		/**
162		* @return HierarchicalKey
163		*/
164	12	public function toPublic()
165		{
166	12	if ($this->isPrivate()) {
167	9	$this->key = $this->getPrivateKey()->getPublicKey();
168	6	}
169
170	12	return $this;
171		}
172
173		/**
174		* Return whether this is a private key
175		*
176		* @return bool
177		*/
178	48	public function isPrivate()
179		{
180	48	return $this->key->isPrivate();
181		}
182
183		/**
184		* Return whether the key is hardened
185		*
186		* @return bool
187		*/
188	3	public function isHardened()
189		{
190	3	return ($this->sequence >> 31) === 1;
191		}
192
193		/**
194		* Create a buffer containing data to be hashed hashed to yield the child offset
195		*
196		* @param int $sequence
197		* @return BufferInterface
198		* @throws \Exception
199		*/
200	21	public function getHmacSeed($sequence)
201		{
202	21	if (($sequence >> 31) === 1) {
203	15	if ($this->isPrivate() === false) {
204	3	throw new \Exception("Can't derive a hardened key without the private key");
205		}
206
207	12	$buffer = Buffertools::concat(new Buffer("\x00"), $this->getPrivateKey()->getBuffer());
208	8	} else {
209	18	$buffer = $this->getPublicKey()->getBuffer();
210		}
211
212	18	return (new Parser($buffer))
213	18	->writeBytes(4, Buffer::int($sequence, 4))
214	18	->getBuffer();
215		}
216
217		/**
218		* Derive a child key
219		*
220		* @param int $sequence
221		* @return HierarchicalKey
222		* @throws \Exception
223		*/
224	21	public function deriveChild($sequence)
225		{
226	21	$hash = Hash::hmac('sha512', $this->getHmacSeed($sequence), $this->getChainCode());
227	18	$offset = $hash->slice(0, 32);
228	18	$chain = $hash->slice(32);
229
230	18	if (false === $this->ecAdapter->validatePrivateKey($offset)) {
231	3	return $this->deriveChild($sequence + 1);
232		}
233
234	18	$key = $this->isPrivate() ? $this->getPrivateKey() : $this->getPublicKey();
235	18	$key = $key->tweakAdd(gmp_init($offset->getInt(), 10));
236
237	18	return new HierarchicalKey(
238	18	$this->ecAdapter,
239	18	$this->getDepth() + 1,
240	18	$this->getChildFingerprint(),
241	12	$sequence,
242	12	$chain,
243		$key
244	12	);
245		}
246
247		/**
248		* @param array\|\stdClass\|\Traversable $list
249		* @return HierarchicalKey
250		*/
251	9	public function deriveFromList($list)
252		{
253	9	if (!is_array($list) && !$list instanceof \Traversable && !$list instanceof \stdClass) {
254		throw new \InvalidArgumentException('List must be an array or \Traversable');
255		}
256
257	9	$key = $this;
258	9	foreach ($list as $sequence) {
		0 ignored issues – show Bug introduced 2015-11-30 20:43 UTC by Report Bug Copy Issue Report The expression `$list` of type `array\|object<Traversable>\|object<stdClass>` is not guaranteed to be traversable. How about adding an additional type check? There are different options of fixing this problem. If you want to be on the safe side, you can add an additional type-check: $collection = json_decode($data, true); if ( ! is_array($collection)) { throw new \RuntimeException('$collection must be an array.'); } foreach ($collection as $item) { /** ... / } If you are sure that the expression is traversable, you might want to add a doc comment cast* to improve IDE auto-completion and static analysis: /** @var array $collection / $collection = json_decode($data, true); foreach ($collection as $item) { /* .. / } Mark the issue as a false-positive*: Just hover the remove button, in the top-right corner of this issue for more options. Loading history...
259	9	$key = $key->deriveChild($sequence);
260	6	}
261
262	9	return $key;
263		}
264
265		/**
266		* Decodes a BIP32 path into actual 32bit sequence numbers and derives the child key
267		*
268		* @param string $path
269		* @return HierarchicalKey
270		* @throws \Exception
271		*/
272	9	public function derivePath($path)
273		{
274	9	$sequences = new HierarchicalKeySequence();
275	9	return $this->deriveFromList($sequences->decodePath($path));
276		}
277
278		/**
279		* Serializes the instance according to whether it wraps a private or public key.
280		* @param NetworkInterface $network
281		* @return string
282		*/
283	15	public function toExtendedKey(NetworkInterface $network = null)
284		{
285	15	$network = $network ?: Bitcoin::getNetwork();
286
287	15	$extendedSerializer = new Base58ExtendedKeySerializer(new ExtendedKeySerializer($this->ecAdapter, $network));
288	15	$extended = $extendedSerializer->serialize($this);
289	15	return $extended;
290		}
291
292		/**
293		* Explicitly serialize as a private key. Throws an exception if
294		* the key isn't private.
295		*
296		* @param NetworkInterface $network
297		* @return string
298		*/
299	15	public function toExtendedPrivateKey(NetworkInterface $network = null)
300		{
301	15	if (!$this->isPrivate()) {
302	3	throw new \LogicException('Cannot create extended private key from public');
303		}
304
305	12	return $this->toExtendedKey($network);
306		}
307
308		/**
309		* Explicitly serialize as a public key. This will always work.
310		*
311		* @param NetworkInterface $network
312		* @return string
313		*/
314	12	public function toExtendedPublicKey(NetworkInterface $network = null)
315		{
316	12	$clone = clone($this);
317	12	return $clone->toPublic()->toExtendedKey($network);
318		}
319		}
320

Bit-Wasp / bitcoin-php

Push — master ( 246998...6d15a1 )

HierarchicalKey::isHardened() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like