BitWasp\Bitcoin\Transaction\Factory\InputSigner::extractChecksig()

Complexity

Conditions	33
Paths	317

Size

Total Lines	139
Code Lines	79

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	73
CRAP Score	33.0671

Importance

Changes

0

<?php
    public function extractChecksig(ScriptInterface $script, Checksig $checksig, Stack $stack, int $sigVersion, bool $expectFalse)
    {
        $size = count($stack);

        if ($checksig->getType() === ScriptType::P2PKH) {
            if ($size > 1) {
                $vchPubKey = $stack->pop();
                $vchSig = $stack->pop();

                $value = false;
                if (!$expectFalse) {
                    $value = $this->checkSignature($script, $vchSig, $vchPubKey);

                    if (!$value) {
                        throw new SignerException('Existing signatures are invalid!');
                    }
                }

                if (!$checksig->isVerify()) {
                    $stack->push($value ? new Buffer("\x01") : new Buffer());
                }

                if (!$expectFalse) {
                    $checksig
                        ->setSignature(0, $this->txSigSerializer->parse($vchSig))
                        ->setKey(0, $this->parseStepPublicKey($vchPubKey))
                    ;
                }
            }
        } else if ($checksig->getType() === ScriptType::P2PK) {
            if ($size > 0) {
                $vchSig = $stack->pop();

                $value = false;
                if (!$expectFalse) {
                    $value = $this->signatureChecker->checkSig($script, $vchSig, $checksig->getSolution(), $this->fqs->sigVersion(), $this->flags);

It seems like $checksig->getSolution() can also be of type BitWasp\Buffertools\BufferInterface[]; however, parameter $keyBuf of BitWasp\Bitcoin\Script\Interpreter\CheckerBase::checkSig() does only seem to accept BitWasp\Buffertools\BufferInterface, maybe add an additional type check?

                    if (!$value) {
                        throw new SignerException('Existing signatures are invalid!');
                    }
                }

                if (!$checksig->isVerify()) {
                    $stack->push($value ? new Buffer("\x01") : new Buffer());
                }

                if (!$expectFalse) {
                    $checksig->setSignature(0, $this->txSigSerializer->parse($vchSig));
                }
            }

            $checksig->setKey(0, $this->parseStepPublicKey($checksig->getSolution()));

It seems like $checksig->getSolution() can also be of type BitWasp\Buffertools\BufferInterface[]; however, parameter $vchPubKey of BitWasp\Bitcoin\Transaction\Factory\InputSigner::parseStepPublicKey() does only seem to accept BitWasp\Buffertools\BufferInterface, maybe add an additional type check?

        } else if (ScriptType::MULTISIG === $checksig->getType()) {
            /** @var Multisig $info */
            $info = $checksig->getInfo();
            $keyBuffers = $info->getKeyBuffers();
            foreach ($keyBuffers as $idx => $keyBuf) {
                $checksig->setKey($idx, $this->parseStepPublicKey($keyBuf));
            }

            $value = false;
            if ($this->padUnsignedMultisigs) {
                // Multisig padding is only used for partially signed transactions,
                // never fully signed. It is recognized by a scriptSig with $keyCount+1
                // values (including the dummy), with one for each candidate signature,
                // such that $this->signatures state is captured.
                // The feature serves to skip validation/sorting an incomplete multisig.

                if ($size === 1 + $info->getKeyCount()) {
                    $sigBufCount = 0;
                    $null = new Buffer();
                    $keyToSigMap = new \SplObjectStorage();

                    // Reproduce $keyToSigMap and $sigBufCount
                    for ($i = 0; $i < $info->getKeyCount(); $i++) {
                        if (!$stack[-1 - $i]->equals($null)) {
                            $keyToSigMap[$keyBuffers[$i]] = $stack[-1 - $i];
                            $sigBufCount++;
                        }
                    }

                    // We observed $this->requiredSigs sigs, therefore we can
                    // say the implementation is incompatible
                    if ($sigBufCount === $checksig->getRequiredSigs()) {
                        throw new SignerException("Padding is forbidden for a fully signed multisig script");
                    }

                    $toDelete = 1 + $info->getKeyCount();
                    $value = true;
                }
            }

            if (!isset($toDelete) || !isset($keyToSigMap)) {
                // Check signatures irrespective of scriptSig size, primes Checker cache, and need info
                $sigBufs = [];
                $max = min($checksig->getRequiredSigs(), $size - 1);
                for ($i = 0; $i < $max; $i++) {
                    $vchSig = $stack[-1 - $i];
                    $sigBufs[] = $vchSig;
                }

                $sigBufs = array_reverse($sigBufs);
                $sigBufCount = count($sigBufs);

                if (!$expectFalse) {
                    if ($sigBufCount > 0) {
                        $keyToSigMap = $this->sortMultiSigs($script, $sigBufs, $keyBuffers, $sigVersion);
                        // Here we learn if any signatures were invalid, it won't be in the map.
                        if ($sigBufCount !== count($keyToSigMap)) {
                            throw new SignerException('Existing signatures are invalid!');
                        }
                        $toDelete = 1 + count($keyToSigMap);
                    } else {
                        $toDelete = 0;
                        $keyToSigMap = new \SplObjectStorage();
                    }
                    $value = true;
                } else {
                    // todo: should check that all signatures are zero
                    $keyToSigMap = new \SplObjectStorage();
                    $toDelete = min($stack->count(), 1 + $info->getRequiredSigCount());
                    $value = false;
                }
            }

            while ($toDelete--) {
                $stack->pop();
            }

            foreach ($keyBuffers as $idx => $key) {
                if (isset($keyToSigMap[$key])) {
                    $checksig->setSignature($idx, $this->txSigSerializer->parse($keyToSigMap[$key]));
                }
            }

            if (!$checksig->isVerify()) {
                $stack->push($value ? new Buffer("\x01") : new Buffer());
            }
        } else {
            throw new UnsupportedScript('Unsupported output type passed to extractFromValues');
        }