Checker::verifyLockTime() - Code Metrics - Inspection of "Adding signing/verification tests" - Bit-Wasp/bitcoin-php - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#333)

by thomas

created 2016-07-01 13:30 UTC

Checker::verifyLockTime() B

↳ Parent: Checker

Complexity

Conditions	5
Paths	2

Size

Total Lines	11
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	30

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	5
eloc	6
nc	2
nop	3
dl	0
loc	11
ccs	0
cts	7
cp	0
crap	30
rs	8.8571
c	1
b	0
f	0

<?php

namespace BitWasp\Bitcoin\Script\Interpreter;

use BitWasp\Bitcoin\Crypto\EcAdapter\Impl\PhpEcc\Key\PublicKey;

use BitWasp\Bitcoin\Crypto\EcAdapter\Adapter\EcAdapterInterface;
use BitWasp\Bitcoin\Exceptions\ScriptRuntimeException;
use BitWasp\Bitcoin\Exceptions\SignatureNotCanonical;
use BitWasp\Bitcoin\Key\PublicKeyFactory;
use BitWasp\Bitcoin\Locktime;
use BitWasp\Bitcoin\Script\ScriptInterface;
use BitWasp\Bitcoin\Signature\TransactionSignature;
use BitWasp\Bitcoin\Signature\TransactionSignatureFactory;
use BitWasp\Bitcoin\Transaction\SignatureHash\Hasher;
use BitWasp\Bitcoin\Transaction\SignatureHash\SigHashInterface;
use BitWasp\Bitcoin\Transaction\SignatureHash\V1Hasher;
use BitWasp\Bitcoin\Transaction\TransactionInputInterface;
use BitWasp\Bitcoin\Transaction\TransactionInterface;
use BitWasp\Buffertools\BufferInterface;

class Checker
{
    /**
     * @var EcAdapterInterface
     */
    private $adapter;

    /**
     * @var TransactionInterface
     */
    private $transaction;

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

    /**
     * @var int|string
     */
    private $amount;

    /**
     * Checker constructor.
     * @param EcAdapterInterface $ecAdapter
     * @param TransactionInterface $transaction
     * @param int $nInput
     * @param int|string $amount
     */
    public function __construct(EcAdapterInterface $ecAdapter, TransactionInterface $transaction, $nInput, $amount)
    {
        $this->adapter = $ecAdapter;
        $this->transaction = $transaction;
        $this->nInput = $nInput;
        $this->amount = $amount;
    }

    /**
     * @param BufferInterface $signature
     * @return bool
     */
    public function isValidSignatureEncoding(BufferInterface $signature)
    {
        try {
            TransactionSignature::isDERSignature($signature);
            return true;
        } catch (SignatureNotCanonical $e) {
            /* In any case, we will return false outside this block */
        }

        return false;
    }

    /**
     * @param BufferInterface $signature
     * @return bool
     * @throws ScriptRuntimeException
     * @throws \Exception
     */
    public function isLowDerSignature(BufferInterface $signature)
    {
        if (!$this->isValidSignatureEncoding($signature)) {
            throw new ScriptRuntimeException(Interpreter::VERIFY_DERSIG, 'Signature with incorrect encoding');
        }

        $binary = $signature->getBinary();
        $nLenR = ord($binary[3]);
        $nLenS = ord($binary[5 + $nLenR]);
        $s = $signature->slice(6 + $nLenR, $nLenS)->getGmp();

        return $this->adapter->validateSignatureElement($s, true);
    }

    /**
     * Determine whether the sighash byte appended to the signature encodes
     * a valid sighash type.
     *
     * @param BufferInterface $signature
     * @return bool
     */
    public function isDefinedHashtypeSignature(BufferInterface $signature)
    {
        if ($signature->getSize() === 0) {
            return false;
        }

        $binary = $signature->getBinary();
        $nHashType = ord(substr($binary, -1)) & (~(SigHashInterface::ANYONECANPAY));

        return !(($nHashType < SigHashInterface::ALL) || ($nHashType > SigHashInterface::SINGLE));
    }

    /**
     * @param BufferInterface $signature
     * @param int $flags
     * @return $this
     * @throws \BitWasp\Bitcoin\Exceptions\ScriptRuntimeException
     */
    public function checkSignatureEncoding(BufferInterface $signature, $flags)
    {
        if ($signature->getSize() === 0) {
            return $this;
        }

        if (($flags & (Interpreter::VERIFY_DERSIG | Interpreter::VERIFY_LOW_S | Interpreter::VERIFY_STRICTENC)) != 0 && !$this->isValidSignatureEncoding($signature)) {
            throw new ScriptRuntimeException(Interpreter::VERIFY_DERSIG, 'Signature with incorrect encoding');
        } else if (($flags & Interpreter::VERIFY_LOW_S) != 0 && !$this->isLowDerSignature($signature)) {
            throw new ScriptRuntimeException(Interpreter::VERIFY_LOW_S, 'Signature s element was not low');
        } else if (($flags & Interpreter::VERIFY_STRICTENC) != 0 && !$this->isDefinedHashtypeSignature($signature)) {
            throw new ScriptRuntimeException(Interpreter::VERIFY_STRICTENC, 'Signature with invalid hashtype');
        }

        return $this;
    }

    /**
     * @param BufferInterface $publicKey
     * @param int $flags
     * @return $this
     * @throws \Exception
     */
    public function checkPublicKeyEncoding(BufferInterface $publicKey, $flags)
    {
        if (($flags & Interpreter::VERIFY_STRICTENC) != 0 && !PublicKey::isCompressedOrUncompressed($publicKey)) {
            throw new ScriptRuntimeException(Interpreter::VERIFY_STRICTENC, 'Public key with incorrect encoding');
        }

        return $this;
    }

    /**
     * @param ScriptInterface $script
     * @param BufferInterface $sigBuf
     * @param BufferInterface $keyBuf
     * @param int $sigVersion
     * @param int $flags
     * @return bool
     * @throws ScriptRuntimeException
     */
    public function checkSig(ScriptInterface $script, BufferInterface $sigBuf, BufferInterface $keyBuf, $sigVersion, $flags)
    {
        $this
            ->checkSignatureEncoding($sigBuf, $flags)
            ->checkPublicKeyEncoding($keyBuf, $flags);

        try {
            $txSignature = TransactionSignatureFactory::fromHex($sigBuf->getHex());
            $publicKey = PublicKeyFactory::fromHex($keyBuf->getHex());

            if ($sigVersion === 1) {
                $hasher = new V1Hasher($this->transaction, $this->amount);
            } else {
                $hasher = new Hasher($this->transaction);
            }

            $hash = $hasher->calculate($script, $this->nInput, $txSignature->getHashType());
            return $this->adapter->verify($hash, $publicKey, $txSignature->getSignature());
        } catch (\Exception $e) {
            return false;
        }
    }

    /**
     * @param int $txLockTime
     * @param int $nThreshold
     * @param \BitWasp\Bitcoin\Script\Interpreter\Number $lockTime
     * @return bool
     */
    private function verifyLockTime($txLockTime, $nThreshold, \BitWasp\Bitcoin\Script\Interpreter\Number $lockTime)
    {
        $nTime = $lockTime->getInt();
        if (($txLockTime < $nThreshold && $nTime < $nThreshold) ||
            ($txLockTime >= $nThreshold && $nTime >= $nThreshold)
        ) {
            return false;
        }

        return $nTime >= $txLockTime;
    }

    /**
     * @param \BitWasp\Bitcoin\Script\Interpreter\Number $lockTime
     * @return bool
     */
    public function checkLockTime(\BitWasp\Bitcoin\Script\Interpreter\Number $lockTime)
    {
        if ($this->transaction->getInput($this->nInput)->isFinal()) {
            return false;
        }

        return $this->verifyLockTime($this->transaction->getLockTime(), Locktime::BLOCK_MAX, $lockTime);
    }


    /**
     * @param \BitWasp\Bitcoin\Script\Interpreter\Number $sequence
     * @return bool
     */
    public function checkSequence(\BitWasp\Bitcoin\Script\Interpreter\Number $sequence)
    {
        $txSequence = $this->transaction->getInput($this->nInput)->getSequence();
        if ($this->transaction->getVersion() < 2) {
            return false;
        }

        if ($txSequence & TransactionInputInterface::SEQUENCE_LOCKTIME_DISABLE_FLAG) {
            return false;
        }

        $mask = TransactionInputInterface::SEQUENCE_LOCKTIME_TYPE_FLAG | TransactionInputInterface::SEQUENCE_LOCKTIME_MASK;
        $txSequenceMasked = $txSequence & $mask;
        $nSequenceMasked = Number::int(gmp_strval(gmp_and($sequence->getInt(), gmp_init($mask)), 10))->getInt();

        if (!(
            ($txSequenceMasked <  TransactionInputInterface::SEQUENCE_LOCKTIME_TYPE_FLAG && $nSequenceMasked <  TransactionInputInterface::SEQUENCE_LOCKTIME_TYPE_FLAG) ||
            ($txSequenceMasked >= TransactionInputInterface::SEQUENCE_LOCKTIME_TYPE_FLAG && $nSequenceMasked >= TransactionInputInterface::SEQUENCE_LOCKTIME_TYPE_FLAG)
        )) {
            return false;
        }

        if ($nSequenceMasked > $txSequenceMasked) {
            return false;
        }

        return true;
    }
}


1		<?php
2
3		namespace BitWasp\Bitcoin\Script\Interpreter;
4
5		use BitWasp\Bitcoin\Crypto\EcAdapter\Impl\PhpEcc\Key\PublicKey;
6
7		use BitWasp\Bitcoin\Crypto\EcAdapter\Adapter\EcAdapterInterface;
8		use BitWasp\Bitcoin\Exceptions\ScriptRuntimeException;
9		use BitWasp\Bitcoin\Exceptions\SignatureNotCanonical;
10		use BitWasp\Bitcoin\Key\PublicKeyFactory;
11		use BitWasp\Bitcoin\Locktime;
12		use BitWasp\Bitcoin\Script\ScriptInterface;
13		use BitWasp\Bitcoin\Signature\TransactionSignature;
14		use BitWasp\Bitcoin\Signature\TransactionSignatureFactory;
15		use BitWasp\Bitcoin\Transaction\SignatureHash\Hasher;
16		use BitWasp\Bitcoin\Transaction\SignatureHash\SigHashInterface;
17		use BitWasp\Bitcoin\Transaction\SignatureHash\V1Hasher;
18		use BitWasp\Bitcoin\Transaction\TransactionInputInterface;
19		use BitWasp\Bitcoin\Transaction\TransactionInterface;
20		use BitWasp\Buffertools\BufferInterface;
21
22		class Checker
23		{
24		/**
25		* @var EcAdapterInterface
26		*/
27		private $adapter;
28
29		/**
30		* @var TransactionInterface
31		*/
32		private $transaction;
33
34		/**
35		* @var int
36		*/
37		private $nInput;
38
39		/**
40		* @var int\|string
41		*/
42		private $amount;
43
44		/**
45		* Checker constructor.
46		* @param EcAdapterInterface $ecAdapter
47		* @param TransactionInterface $transaction
48		* @param int $nInput
49		* @param int\|string $amount
50		*/
51	3693	public function __construct(EcAdapterInterface $ecAdapter, TransactionInterface $transaction, $nInput, $amount)
52		{
53	3693	$this->adapter = $ecAdapter;
54	3693	$this->transaction = $transaction;
55	3693	$this->nInput = $nInput;
56	3693	$this->amount = $amount;
57	3693	}
58
59		/**
60		* @param BufferInterface $signature
61		* @return bool
62		*/
63	132	public function isValidSignatureEncoding(BufferInterface $signature)
64		{
65		try {
66	132	TransactionSignature::isDERSignature($signature);
67	57	return true;
68	81	} catch (SignatureNotCanonical $e) {
69		/* In any case, we will return false outside this block */
70		}
71
72	81	return false;
73		}
74
75		/**
76		* @param BufferInterface $signature
77		* @return bool
78		* @throws ScriptRuntimeException
79		* @throws \Exception
80		*/
81	18	public function isLowDerSignature(BufferInterface $signature)
82		{
83	18	if (!$this->isValidSignatureEncoding($signature)) {
84	3	throw new ScriptRuntimeException(Interpreter::VERIFY_DERSIG, 'Signature with incorrect encoding');
85		}
86
87	15	$binary = $signature->getBinary();
88	15	$nLenR = ord($binary[3]);
89	15	$nLenS = ord($binary[5 + $nLenR]);
90	17	$s = $signature->slice(6 + $nLenR, $nLenS)->getGmp();
91
92	15	return $this->adapter->validateSignatureElement($s, true);
93		}
94
95		/**
96		* Determine whether the sighash byte appended to the signature encodes
97		* a valid sighash type.
98		*
99		* @param BufferInterface $signature
100		* @return bool
101		*/
102	48	public function isDefinedHashtypeSignature(BufferInterface $signature)
103		{
104	48	if ($signature->getSize() === 0) {
105	3	return false;
106		}
107
108	45	$binary = $signature->getBinary();
109	45	$nHashType = ord(substr($binary, -1)) & (~(SigHashInterface::ANYONECANPAY));
110
111	45	return !(($nHashType < SigHashInterface::ALL) \|\| ($nHashType > SigHashInterface::SINGLE));
112		}
113
114		/**
115		* @param BufferInterface $signature
116		* @param int $flags
117		* @return $this
118		* @throws \BitWasp\Bitcoin\Exceptions\ScriptRuntimeException
119		*/
120	393	public function checkSignatureEncoding(BufferInterface $signature, $flags)
121		{
122	393	if ($signature->getSize() === 0) {
123	43	return $this;
124		}
125
126	354	if (($flags & (Interpreter::VERIFY_DERSIG \| Interpreter::VERIFY_LOW_S \| Interpreter::VERIFY_STRICTENC)) != 0 && !$this->isValidSignatureEncoding($signature)) {
127	78	throw new ScriptRuntimeException(Interpreter::VERIFY_DERSIG, 'Signature with incorrect encoding');
128	282	} else if (($flags & Interpreter::VERIFY_LOW_S) != 0 && !$this->isLowDerSignature($signature)) {
129	6	throw new ScriptRuntimeException(Interpreter::VERIFY_LOW_S, 'Signature s element was not low');
130	276	} else if (($flags & Interpreter::VERIFY_STRICTENC) != 0 && !$this->isDefinedHashtypeSignature($signature)) {
131	9	throw new ScriptRuntimeException(Interpreter::VERIFY_STRICTENC, 'Signature with invalid hashtype');
132		}
133
134	267	return $this;
135		}
136
137		/**
138		* @param BufferInterface $publicKey
139		* @param int $flags
140		* @return $this
141		* @throws \Exception
142		*/
143	300	public function checkPublicKeyEncoding(BufferInterface $publicKey, $flags)
144		{
145	300	if (($flags & Interpreter::VERIFY_STRICTENC) != 0 && !PublicKey::isCompressedOrUncompressed($publicKey)) {
146	18	throw new ScriptRuntimeException(Interpreter::VERIFY_STRICTENC, 'Public key with incorrect encoding');
147		}
148
149	282	return $this;
150		}
151
152		/**
153		* @param ScriptInterface $script
154		* @param BufferInterface $sigBuf
155		* @param BufferInterface $keyBuf
156		* @param int $sigVersion
157		* @param int $flags
158		* @return bool
159		* @throws ScriptRuntimeException
160		*/
161	372	public function checkSig(ScriptInterface $script, BufferInterface $sigBuf, BufferInterface $keyBuf, $sigVersion, $flags)
162		{
163	248	$this
164	372	->checkSignatureEncoding($sigBuf, $flags)
165	294	->checkPublicKeyEncoding($keyBuf, $flags);
166
167		try {
168	279	$txSignature = TransactionSignatureFactory::fromHex($sigBuf->getHex());
169	214	$publicKey = PublicKeyFactory::fromHex($keyBuf->getHex());
170
171	205	if ($sigVersion === 1) {
172	51	$hasher = new V1Hasher($this->transaction, $this->amount);
173	34	} else {
174	154	$hasher = new Hasher($this->transaction);
175		}
176
177	205	$hash = $hasher->calculate($script, $this->nInput, $txSignature->getHashType());
178	205	return $this->adapter->verify($hash, $publicKey, $txSignature->getSignature());
179	78	} catch (\Exception $e) {
180	78	return false;
181		}
182		}
183
184		/**
185		* @param int $txLockTime
186		* @param int $nThreshold
187		* @param \BitWasp\Bitcoin\Script\Interpreter\Number $lockTime
188		* @return bool
189		*/
190		private function verifyLockTime($txLockTime, $nThreshold, \BitWasp\Bitcoin\Script\Interpreter\Number $lockTime)
191		{
192		$nTime = $lockTime->getInt();
193		if (($txLockTime < $nThreshold && $nTime < $nThreshold) \|\|
194		($txLockTime >= $nThreshold && $nTime >= $nThreshold)
195		) {
196		return false;
197		}
198
199		return $nTime >= $txLockTime;
200		}
201
202		/**
203		* @param \BitWasp\Bitcoin\Script\Interpreter\Number $lockTime
204		* @return bool
205		*/
206		public function checkLockTime(\BitWasp\Bitcoin\Script\Interpreter\Number $lockTime)
207		{
208		if ($this->transaction->getInput($this->nInput)->isFinal()) {
209		return false;
210		}
211
212		return $this->verifyLockTime($this->transaction->getLockTime(), Locktime::BLOCK_MAX, $lockTime);
213		}
214
215
216		/**
217		* @param \BitWasp\Bitcoin\Script\Interpreter\Number $sequence
218		* @return bool
219		*/
220	6	public function checkSequence(\BitWasp\Bitcoin\Script\Interpreter\Number $sequence)
221		{
222	6	$txSequence = $this->transaction->getInput($this->nInput)->getSequence();
223	6	if ($this->transaction->getVersion() < 2) {
224	6	return false;
225		}
226
227		if ($txSequence & TransactionInputInterface::SEQUENCE_LOCKTIME_DISABLE_FLAG) {
228		return false;
229		}
230
231		$mask = TransactionInputInterface::SEQUENCE_LOCKTIME_TYPE_FLAG \| TransactionInputInterface::SEQUENCE_LOCKTIME_MASK;
232		$txSequenceMasked = $txSequence & $mask;
233		$nSequenceMasked = Number::int(gmp_strval(gmp_and($sequence->getInt(), gmp_init($mask)), 10))->getInt();
234
235		if (!(
236		($txSequenceMasked < TransactionInputInterface::SEQUENCE_LOCKTIME_TYPE_FLAG && $nSequenceMasked < TransactionInputInterface::SEQUENCE_LOCKTIME_TYPE_FLAG) \|\|
237		($txSequenceMasked >= TransactionInputInterface::SEQUENCE_LOCKTIME_TYPE_FLAG && $nSequenceMasked >= TransactionInputInterface::SEQUENCE_LOCKTIME_TYPE_FLAG)
238		)) {
239		return false;
240		}
241
242		if ($nSequenceMasked > $txSequenceMasked) {
243		return false;
244		}
245
246		return true;
247		}
248		}
249

Bit-Wasp / bitcoin-php

Pull Request — master (#333)

Checker::verifyLockTime() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like