mirror of
https://github.com/btcsuite/btcd.git
synced 2024-11-19 18:00:11 +01:00
07edce81b0
This cleans up the code for handling the checksig and checkmultisig opcode strict signatures to explicitly call out any semantics that are likely not obvious and improve readability. It also introduce new distinct errors for each condition which can result in a signature being rejected due to not following the strict encoding requirements and updates reference test adaptor accordingly.
876 lines
24 KiB
Go
876 lines
24 KiB
Go
// Copyright (c) 2013-2017 The btcsuite developers
|
|
// Use of this source code is governed by an ISC
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package txscript
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/hex"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"io/ioutil"
|
|
"strconv"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/btcsuite/btcd/chaincfg/chainhash"
|
|
"github.com/btcsuite/btcd/wire"
|
|
"github.com/btcsuite/btcutil"
|
|
)
|
|
|
|
// scriptTestName returns a descriptive test name for the given reference script
|
|
// test data.
|
|
func scriptTestName(test []interface{}) (string, error) {
|
|
// Account for any optional leading witness data.
|
|
var witnessOffset int
|
|
if _, ok := test[0].([]interface{}); ok {
|
|
witnessOffset++
|
|
}
|
|
|
|
// In addition to the optional leading witness data, the test must
|
|
// consist of at least a signature script, public key script, flags,
|
|
// and expected error. Finally, it may optionally contain a comment.
|
|
if len(test) < witnessOffset+4 || len(test) > witnessOffset+5 {
|
|
return "", fmt.Errorf("invalid test length %d", len(test))
|
|
}
|
|
|
|
// Use the comment for the test name if one is specified, otherwise,
|
|
// construct the name based on the signature script, public key script,
|
|
// and flags.
|
|
var name string
|
|
if len(test) == witnessOffset+5 {
|
|
name = fmt.Sprintf("test (%s)", test[witnessOffset+4])
|
|
} else {
|
|
name = fmt.Sprintf("test ([%s, %s, %s])", test[witnessOffset],
|
|
test[witnessOffset+1], test[witnessOffset+2])
|
|
}
|
|
return name, nil
|
|
}
|
|
|
|
// parse hex string into a []byte.
|
|
func parseHex(tok string) ([]byte, error) {
|
|
if !strings.HasPrefix(tok, "0x") {
|
|
return nil, errors.New("not a hex number")
|
|
}
|
|
return hex.DecodeString(tok[2:])
|
|
}
|
|
|
|
// parseWitnessStack parses a json array of witness items encoded as hex into a
|
|
// slice of witness elements.
|
|
func parseWitnessStack(elements []interface{}) ([][]byte, error) {
|
|
witness := make([][]byte, len(elements))
|
|
for i, e := range elements {
|
|
witElement, err := hex.DecodeString(e.(string))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
witness[i] = witElement
|
|
}
|
|
|
|
return witness, nil
|
|
}
|
|
|
|
// shortFormOps holds a map of opcode names to values for use in short form
|
|
// parsing. It is declared here so it only needs to be created once.
|
|
var shortFormOps map[string]byte
|
|
|
|
// parseShortForm parses a string as as used in the Bitcoin Core reference tests
|
|
// into the script it came from.
|
|
//
|
|
// The format used for these tests is pretty simple if ad-hoc:
|
|
// - Opcodes other than the push opcodes and unknown are present as
|
|
// either OP_NAME or just NAME
|
|
// - Plain numbers are made into push operations
|
|
// - Numbers beginning with 0x are inserted into the []byte as-is (so
|
|
// 0x14 is OP_DATA_20)
|
|
// - Single quoted strings are pushed as data
|
|
// - Anything else is an error
|
|
func parseShortForm(script string) ([]byte, error) {
|
|
// Only create the short form opcode map once.
|
|
if shortFormOps == nil {
|
|
ops := make(map[string]byte)
|
|
for opcodeName, opcodeValue := range OpcodeByName {
|
|
if strings.Contains(opcodeName, "OP_UNKNOWN") {
|
|
continue
|
|
}
|
|
ops[opcodeName] = opcodeValue
|
|
|
|
// The opcodes named OP_# can't have the OP_ prefix
|
|
// stripped or they would conflict with the plain
|
|
// numbers. Also, since OP_FALSE and OP_TRUE are
|
|
// aliases for the OP_0, and OP_1, respectively, they
|
|
// have the same value, so detect those by name and
|
|
// allow them.
|
|
if (opcodeName == "OP_FALSE" || opcodeName == "OP_TRUE") ||
|
|
(opcodeValue != OP_0 && (opcodeValue < OP_1 ||
|
|
opcodeValue > OP_16)) {
|
|
|
|
ops[strings.TrimPrefix(opcodeName, "OP_")] = opcodeValue
|
|
}
|
|
}
|
|
shortFormOps = ops
|
|
}
|
|
|
|
// Split only does one separator so convert all \n and tab into space.
|
|
script = strings.Replace(script, "\n", " ", -1)
|
|
script = strings.Replace(script, "\t", " ", -1)
|
|
tokens := strings.Split(script, " ")
|
|
builder := NewScriptBuilder()
|
|
|
|
for _, tok := range tokens {
|
|
if len(tok) == 0 {
|
|
continue
|
|
}
|
|
// if parses as a plain number
|
|
if num, err := strconv.ParseInt(tok, 10, 64); err == nil {
|
|
builder.AddInt64(num)
|
|
continue
|
|
} else if bts, err := parseHex(tok); err == nil {
|
|
// Concatenate the bytes manually since the test code
|
|
// intentionally creates scripts that are too large and
|
|
// would cause the builder to error otherwise.
|
|
if builder.err == nil {
|
|
builder.script = append(builder.script, bts...)
|
|
}
|
|
} else if len(tok) >= 2 &&
|
|
tok[0] == '\'' && tok[len(tok)-1] == '\'' {
|
|
builder.AddFullData([]byte(tok[1 : len(tok)-1]))
|
|
} else if opcode, ok := shortFormOps[tok]; ok {
|
|
builder.AddOp(opcode)
|
|
} else {
|
|
return nil, fmt.Errorf("bad token %q", tok)
|
|
}
|
|
|
|
}
|
|
return builder.Script()
|
|
}
|
|
|
|
// parseScriptFlags parses the provided flags string from the format used in the
|
|
// reference tests into ScriptFlags suitable for use in the script engine.
|
|
func parseScriptFlags(flagStr string) (ScriptFlags, error) {
|
|
var flags ScriptFlags
|
|
|
|
sFlags := strings.Split(flagStr, ",")
|
|
for _, flag := range sFlags {
|
|
switch flag {
|
|
case "":
|
|
// Nothing.
|
|
case "CHECKLOCKTIMEVERIFY":
|
|
flags |= ScriptVerifyCheckLockTimeVerify
|
|
case "CHECKSEQUENCEVERIFY":
|
|
flags |= ScriptVerifyCheckSequenceVerify
|
|
case "CLEANSTACK":
|
|
flags |= ScriptVerifyCleanStack
|
|
case "DERSIG":
|
|
flags |= ScriptVerifyDERSignatures
|
|
case "DISCOURAGE_UPGRADABLE_NOPS":
|
|
flags |= ScriptDiscourageUpgradableNops
|
|
case "LOW_S":
|
|
flags |= ScriptVerifyLowS
|
|
case "MINIMALDATA":
|
|
flags |= ScriptVerifyMinimalData
|
|
case "NONE":
|
|
// Nothing.
|
|
case "NULLDUMMY":
|
|
flags |= ScriptStrictMultiSig
|
|
case "NULLFAIL":
|
|
flags |= ScriptVerifyNullFail
|
|
case "P2SH":
|
|
flags |= ScriptBip16
|
|
case "SIGPUSHONLY":
|
|
flags |= ScriptVerifySigPushOnly
|
|
case "STRICTENC":
|
|
flags |= ScriptVerifyStrictEncoding
|
|
case "WITNESS":
|
|
flags |= ScriptVerifyWitness
|
|
case "DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM":
|
|
flags |= ScriptVerifyDiscourageUpgradeableWitnessProgram
|
|
case "MINIMALIF":
|
|
flags |= ScriptVerifyMinimalIf
|
|
case "WITNESS_PUBKEYTYPE":
|
|
flags |= ScriptVerifyWitnessPubKeyType
|
|
default:
|
|
return flags, fmt.Errorf("invalid flag: %s", flag)
|
|
}
|
|
}
|
|
return flags, nil
|
|
}
|
|
|
|
// parseExpectedResult parses the provided expected result string into allowed
|
|
// script error codes. An error is returned if the expected result string is
|
|
// not supported.
|
|
func parseExpectedResult(expected string) ([]ErrorCode, error) {
|
|
switch expected {
|
|
case "OK":
|
|
return nil, nil
|
|
case "UNKNOWN_ERROR":
|
|
return []ErrorCode{ErrNumberTooBig, ErrMinimalData}, nil
|
|
case "PUBKEYTYPE":
|
|
return []ErrorCode{ErrPubKeyType}, nil
|
|
case "SIG_DER":
|
|
return []ErrorCode{ErrSigTooShort, ErrSigTooLong,
|
|
ErrSigInvalidSeqID, ErrSigInvalidDataLen, ErrSigMissingSTypeID,
|
|
ErrSigMissingSLen, ErrSigInvalidSLen,
|
|
ErrSigInvalidRIntID, ErrSigZeroRLen, ErrSigNegativeR,
|
|
ErrSigTooMuchRPadding, ErrSigInvalidSIntID,
|
|
ErrSigZeroSLen, ErrSigNegativeS, ErrSigTooMuchSPadding,
|
|
ErrInvalidSigHashType}, nil
|
|
case "EVAL_FALSE":
|
|
return []ErrorCode{ErrEvalFalse, ErrEmptyStack}, nil
|
|
case "EQUALVERIFY":
|
|
return []ErrorCode{ErrEqualVerify}, nil
|
|
case "NULLFAIL":
|
|
return []ErrorCode{ErrNullFail}, nil
|
|
case "SIG_HIGH_S":
|
|
return []ErrorCode{ErrSigHighS}, nil
|
|
case "SIG_HASHTYPE":
|
|
return []ErrorCode{ErrInvalidSigHashType}, nil
|
|
case "SIG_NULLDUMMY":
|
|
return []ErrorCode{ErrSigNullDummy}, nil
|
|
case "SIG_PUSHONLY":
|
|
return []ErrorCode{ErrNotPushOnly}, nil
|
|
case "CLEANSTACK":
|
|
return []ErrorCode{ErrCleanStack}, nil
|
|
case "BAD_OPCODE":
|
|
return []ErrorCode{ErrReservedOpcode, ErrMalformedPush}, nil
|
|
case "UNBALANCED_CONDITIONAL":
|
|
return []ErrorCode{ErrUnbalancedConditional,
|
|
ErrInvalidStackOperation}, nil
|
|
case "OP_RETURN":
|
|
return []ErrorCode{ErrEarlyReturn}, nil
|
|
case "VERIFY":
|
|
return []ErrorCode{ErrVerify}, nil
|
|
case "INVALID_STACK_OPERATION", "INVALID_ALTSTACK_OPERATION":
|
|
return []ErrorCode{ErrInvalidStackOperation}, nil
|
|
case "DISABLED_OPCODE":
|
|
return []ErrorCode{ErrDisabledOpcode}, nil
|
|
case "DISCOURAGE_UPGRADABLE_NOPS":
|
|
return []ErrorCode{ErrDiscourageUpgradableNOPs}, nil
|
|
case "PUSH_SIZE":
|
|
return []ErrorCode{ErrElementTooBig}, nil
|
|
case "OP_COUNT":
|
|
return []ErrorCode{ErrTooManyOperations}, nil
|
|
case "STACK_SIZE":
|
|
return []ErrorCode{ErrStackOverflow}, nil
|
|
case "SCRIPT_SIZE":
|
|
return []ErrorCode{ErrScriptTooBig}, nil
|
|
case "PUBKEY_COUNT":
|
|
return []ErrorCode{ErrInvalidPubKeyCount}, nil
|
|
case "SIG_COUNT":
|
|
return []ErrorCode{ErrInvalidSignatureCount}, nil
|
|
case "MINIMALDATA":
|
|
return []ErrorCode{ErrMinimalData}, nil
|
|
case "NEGATIVE_LOCKTIME":
|
|
return []ErrorCode{ErrNegativeLockTime}, nil
|
|
case "UNSATISFIED_LOCKTIME":
|
|
return []ErrorCode{ErrUnsatisfiedLockTime}, nil
|
|
case "MINIMALIF":
|
|
return []ErrorCode{ErrMinimalIf}, nil
|
|
case "DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM":
|
|
return []ErrorCode{ErrDiscourageUpgradableWitnessProgram}, nil
|
|
case "WITNESS_PROGRAM_WRONG_LENGTH":
|
|
return []ErrorCode{ErrWitnessProgramWrongLength}, nil
|
|
case "WITNESS_PROGRAM_WITNESS_EMPTY":
|
|
return []ErrorCode{ErrWitnessProgramEmpty}, nil
|
|
case "WITNESS_PROGRAM_MISMATCH":
|
|
return []ErrorCode{ErrWitnessProgramMismatch}, nil
|
|
case "WITNESS_MALLEATED":
|
|
return []ErrorCode{ErrWitnessMalleated}, nil
|
|
case "WITNESS_MALLEATED_P2SH":
|
|
return []ErrorCode{ErrWitnessMalleatedP2SH}, nil
|
|
case "WITNESS_UNEXPECTED":
|
|
return []ErrorCode{ErrWitnessUnexpected}, nil
|
|
case "WITNESS_PUBKEYTYPE":
|
|
return []ErrorCode{ErrWitnessPubKeyType}, nil
|
|
}
|
|
|
|
return nil, fmt.Errorf("unrecognized expected result in test data: %v",
|
|
expected)
|
|
}
|
|
|
|
// createSpendTx generates a basic spending transaction given the passed
|
|
// signature, witness and public key scripts.
|
|
func createSpendingTx(witness [][]byte, sigScript, pkScript []byte,
|
|
outputValue int64) *wire.MsgTx {
|
|
|
|
coinbaseTx := wire.NewMsgTx(wire.TxVersion)
|
|
|
|
outPoint := wire.NewOutPoint(&chainhash.Hash{}, ^uint32(0))
|
|
txIn := wire.NewTxIn(outPoint, []byte{OP_0, OP_0}, nil)
|
|
txOut := wire.NewTxOut(outputValue, pkScript)
|
|
coinbaseTx.AddTxIn(txIn)
|
|
coinbaseTx.AddTxOut(txOut)
|
|
|
|
spendingTx := wire.NewMsgTx(wire.TxVersion)
|
|
coinbaseTxSha := coinbaseTx.TxHash()
|
|
outPoint = wire.NewOutPoint(&coinbaseTxSha, 0)
|
|
txIn = wire.NewTxIn(outPoint, sigScript, witness)
|
|
txOut = wire.NewTxOut(outputValue, nil)
|
|
|
|
spendingTx.AddTxIn(txIn)
|
|
spendingTx.AddTxOut(txOut)
|
|
|
|
return spendingTx
|
|
}
|
|
|
|
// scriptWithInputVal wraps a target pkScript with the value of the output in
|
|
// which it is contained. The inputVal is necessary in order to properly
|
|
// validate inputs which spend nested, or native witness programs.
|
|
type scriptWithInputVal struct {
|
|
inputVal int64
|
|
pkScript []byte
|
|
}
|
|
|
|
// testScripts ensures all of the passed script tests execute with the expected
|
|
// results with or without using a signature cache, as specified by the
|
|
// parameter.
|
|
func testScripts(t *testing.T, tests [][]interface{}, useSigCache bool) {
|
|
// Create a signature cache to use only if requested.
|
|
var sigCache *SigCache
|
|
if useSigCache {
|
|
sigCache = NewSigCache(10)
|
|
}
|
|
|
|
for i, test := range tests {
|
|
// "Format is: [[wit..., amount]?, scriptSig, scriptPubKey,
|
|
// flags, expected_scripterror, ... comments]"
|
|
|
|
// Skip single line comments.
|
|
if len(test) == 1 {
|
|
continue
|
|
}
|
|
|
|
// Construct a name for the test based on the comment and test
|
|
// data.
|
|
name, err := scriptTestName(test)
|
|
if err != nil {
|
|
t.Errorf("TestScripts: invalid test #%d: %v", i, err)
|
|
continue
|
|
}
|
|
|
|
var (
|
|
witness wire.TxWitness
|
|
inputAmt btcutil.Amount
|
|
)
|
|
|
|
// When the first field of the test data is a slice it contains
|
|
// witness data and everything else is offset by 1 as a result.
|
|
witnessOffset := 0
|
|
if witnessData, ok := test[0].([]interface{}); ok {
|
|
witnessOffset++
|
|
|
|
// If this is a witness test, then the final element
|
|
// within the slice is the input amount, so we ignore
|
|
// all but the last element in order to parse the
|
|
// witness stack.
|
|
strWitnesses := witnessData[:len(witnessData)-1]
|
|
witness, err = parseWitnessStack(strWitnesses)
|
|
if err != nil {
|
|
t.Errorf("%s: can't parse witness; %v", name, err)
|
|
continue
|
|
}
|
|
|
|
inputAmt, err = btcutil.NewAmount(witnessData[len(witnessData)-1].(float64))
|
|
if err != nil {
|
|
t.Errorf("%s: can't parse input amt: %v",
|
|
name, err)
|
|
continue
|
|
}
|
|
|
|
}
|
|
|
|
// Extract and parse the signature script from the test fields.
|
|
scriptSigStr, ok := test[witnessOffset].(string)
|
|
if !ok {
|
|
t.Errorf("%s: signature script is not a string", name)
|
|
continue
|
|
}
|
|
scriptSig, err := parseShortForm(scriptSigStr)
|
|
if err != nil {
|
|
t.Errorf("%s: can't parse signature script: %v", name,
|
|
err)
|
|
continue
|
|
}
|
|
|
|
// Extract and parse the public key script from the test fields.
|
|
scriptPubKeyStr, ok := test[witnessOffset+1].(string)
|
|
if !ok {
|
|
t.Errorf("%s: public key script is not a string", name)
|
|
continue
|
|
}
|
|
scriptPubKey, err := parseShortForm(scriptPubKeyStr)
|
|
if err != nil {
|
|
t.Errorf("%s: can't parse public key script: %v", name,
|
|
err)
|
|
continue
|
|
}
|
|
|
|
// Extract and parse the script flags from the test fields.
|
|
flagsStr, ok := test[witnessOffset+2].(string)
|
|
if !ok {
|
|
t.Errorf("%s: flags field is not a string", name)
|
|
continue
|
|
}
|
|
flags, err := parseScriptFlags(flagsStr)
|
|
if err != nil {
|
|
t.Errorf("%s: %v", name, err)
|
|
continue
|
|
}
|
|
|
|
// Extract and parse the expected result from the test fields.
|
|
//
|
|
// Convert the expected result string into the allowed script
|
|
// error codes. This is necessary because txscript is more
|
|
// fine grained with its errors than the reference test data, so
|
|
// some of the reference test data errors map to more than one
|
|
// possibility.
|
|
resultStr, ok := test[witnessOffset+3].(string)
|
|
if !ok {
|
|
t.Errorf("%s: result field is not a string", name)
|
|
continue
|
|
}
|
|
allowedErrorCodes, err := parseExpectedResult(resultStr)
|
|
if err != nil {
|
|
t.Errorf("%s: %v", name, err)
|
|
continue
|
|
}
|
|
|
|
// Generate a transaction pair such that one spends from the
|
|
// other and the provided signature and public key scripts are
|
|
// used, then create a new engine to execute the scripts.
|
|
tx := createSpendingTx(witness, scriptSig, scriptPubKey,
|
|
int64(inputAmt))
|
|
vm, err := NewEngine(scriptPubKey, tx, 0, flags, sigCache, nil,
|
|
int64(inputAmt))
|
|
if err == nil {
|
|
err = vm.Execute()
|
|
}
|
|
|
|
// Ensure there were no errors when the expected result is OK.
|
|
if resultStr == "OK" {
|
|
if err != nil {
|
|
t.Errorf("%s failed to execute: %v", name, err)
|
|
}
|
|
continue
|
|
}
|
|
|
|
// At this point an error was expected so ensure the result of
|
|
// the execution matches it.
|
|
success := false
|
|
for _, code := range allowedErrorCodes {
|
|
if IsErrorCode(err, code) {
|
|
success = true
|
|
break
|
|
}
|
|
}
|
|
if !success {
|
|
if serr, ok := err.(Error); ok {
|
|
t.Errorf("%s: want error codes %v, got %v", name,
|
|
allowedErrorCodes, serr.ErrorCode)
|
|
continue
|
|
}
|
|
t.Errorf("%s: want error codes %v, got err: %v (%T)",
|
|
name, allowedErrorCodes, err, err)
|
|
continue
|
|
}
|
|
}
|
|
}
|
|
|
|
// TestScripts ensures all of the tests in script_tests.json execute with the
|
|
// expected results as defined in the test data.
|
|
func TestScripts(t *testing.T) {
|
|
file, err := ioutil.ReadFile("data/script_tests.json")
|
|
if err != nil {
|
|
t.Fatalf("TestScripts: %v\n", err)
|
|
}
|
|
|
|
var tests [][]interface{}
|
|
err = json.Unmarshal(file, &tests)
|
|
if err != nil {
|
|
t.Fatalf("TestScripts couldn't Unmarshal: %v", err)
|
|
}
|
|
|
|
// Run all script tests with and without the signature cache.
|
|
testScripts(t, tests, true)
|
|
testScripts(t, tests, false)
|
|
}
|
|
|
|
// testVecF64ToUint32 properly handles conversion of float64s read from the JSON
|
|
// test data to unsigned 32-bit integers. This is necessary because some of the
|
|
// test data uses -1 as a shortcut to mean max uint32 and direct conversion of a
|
|
// negative float to an unsigned int is implementation dependent and therefore
|
|
// doesn't result in the expected value on all platforms. This function woks
|
|
// around that limitation by converting to a 32-bit signed integer first and
|
|
// then to a 32-bit unsigned integer which results in the expected behavior on
|
|
// all platforms.
|
|
func testVecF64ToUint32(f float64) uint32 {
|
|
return uint32(int32(f))
|
|
}
|
|
|
|
// TestTxInvalidTests ensures all of the tests in tx_invalid.json fail as
|
|
// expected.
|
|
func TestTxInvalidTests(t *testing.T) {
|
|
file, err := ioutil.ReadFile("data/tx_invalid.json")
|
|
if err != nil {
|
|
t.Fatalf("TestTxInvalidTests: %v\n", err)
|
|
}
|
|
|
|
var tests [][]interface{}
|
|
err = json.Unmarshal(file, &tests)
|
|
if err != nil {
|
|
t.Fatalf("TestTxInvalidTests couldn't Unmarshal: %v\n", err)
|
|
}
|
|
|
|
// form is either:
|
|
// ["this is a comment "]
|
|
// or:
|
|
// [[[previous hash, previous index, previous scriptPubKey]...,]
|
|
// serializedTransaction, verifyFlags]
|
|
testloop:
|
|
for i, test := range tests {
|
|
inputs, ok := test[0].([]interface{})
|
|
if !ok {
|
|
continue
|
|
}
|
|
|
|
if len(test) != 3 {
|
|
t.Errorf("bad test (bad length) %d: %v", i, test)
|
|
continue
|
|
|
|
}
|
|
serializedhex, ok := test[1].(string)
|
|
if !ok {
|
|
t.Errorf("bad test (arg 2 not string) %d: %v", i, test)
|
|
continue
|
|
}
|
|
serializedTx, err := hex.DecodeString(serializedhex)
|
|
if err != nil {
|
|
t.Errorf("bad test (arg 2 not hex %v) %d: %v", err, i,
|
|
test)
|
|
continue
|
|
}
|
|
|
|
tx, err := btcutil.NewTxFromBytes(serializedTx)
|
|
if err != nil {
|
|
t.Errorf("bad test (arg 2 not msgtx %v) %d: %v", err,
|
|
i, test)
|
|
continue
|
|
}
|
|
|
|
verifyFlags, ok := test[2].(string)
|
|
if !ok {
|
|
t.Errorf("bad test (arg 3 not string) %d: %v", i, test)
|
|
continue
|
|
}
|
|
|
|
flags, err := parseScriptFlags(verifyFlags)
|
|
if err != nil {
|
|
t.Errorf("bad test %d: %v", i, err)
|
|
continue
|
|
}
|
|
|
|
prevOuts := make(map[wire.OutPoint]scriptWithInputVal)
|
|
for j, iinput := range inputs {
|
|
input, ok := iinput.([]interface{})
|
|
if !ok {
|
|
t.Errorf("bad test (%dth input not array)"+
|
|
"%d: %v", j, i, test)
|
|
continue testloop
|
|
}
|
|
|
|
if len(input) < 3 || len(input) > 4 {
|
|
t.Errorf("bad test (%dth input wrong length)"+
|
|
"%d: %v", j, i, test)
|
|
continue testloop
|
|
}
|
|
|
|
previoustx, ok := input[0].(string)
|
|
if !ok {
|
|
t.Errorf("bad test (%dth input hash not string)"+
|
|
"%d: %v", j, i, test)
|
|
continue testloop
|
|
}
|
|
|
|
prevhash, err := chainhash.NewHashFromStr(previoustx)
|
|
if err != nil {
|
|
t.Errorf("bad test (%dth input hash not hash %v)"+
|
|
"%d: %v", j, err, i, test)
|
|
continue testloop
|
|
}
|
|
|
|
idxf, ok := input[1].(float64)
|
|
if !ok {
|
|
t.Errorf("bad test (%dth input idx not number)"+
|
|
"%d: %v", j, i, test)
|
|
continue testloop
|
|
}
|
|
idx := testVecF64ToUint32(idxf)
|
|
|
|
oscript, ok := input[2].(string)
|
|
if !ok {
|
|
t.Errorf("bad test (%dth input script not "+
|
|
"string) %d: %v", j, i, test)
|
|
continue testloop
|
|
}
|
|
|
|
script, err := parseShortForm(oscript)
|
|
if err != nil {
|
|
t.Errorf("bad test (%dth input script doesn't "+
|
|
"parse %v) %d: %v", j, err, i, test)
|
|
continue testloop
|
|
}
|
|
|
|
var inputValue float64
|
|
if len(input) == 4 {
|
|
inputValue, ok = input[3].(float64)
|
|
if !ok {
|
|
t.Errorf("bad test (%dth input value not int) "+
|
|
"%d: %v", j, i, test)
|
|
continue
|
|
}
|
|
}
|
|
|
|
v := scriptWithInputVal{
|
|
inputVal: int64(inputValue),
|
|
pkScript: script,
|
|
}
|
|
prevOuts[*wire.NewOutPoint(prevhash, idx)] = v
|
|
}
|
|
|
|
for k, txin := range tx.MsgTx().TxIn {
|
|
prevOut, ok := prevOuts[txin.PreviousOutPoint]
|
|
if !ok {
|
|
t.Errorf("bad test (missing %dth input) %d:%v",
|
|
k, i, test)
|
|
continue testloop
|
|
}
|
|
// These are meant to fail, so as soon as the first
|
|
// input fails the transaction has failed. (some of the
|
|
// test txns have good inputs, too..
|
|
vm, err := NewEngine(prevOut.pkScript, tx.MsgTx(), k,
|
|
flags, nil, nil, prevOut.inputVal)
|
|
if err != nil {
|
|
continue testloop
|
|
}
|
|
|
|
err = vm.Execute()
|
|
if err != nil {
|
|
continue testloop
|
|
}
|
|
|
|
}
|
|
t.Errorf("test (%d:%v) succeeded when should fail",
|
|
i, test)
|
|
}
|
|
}
|
|
|
|
// TestTxValidTests ensures all of the tests in tx_valid.json pass as expected.
|
|
func TestTxValidTests(t *testing.T) {
|
|
file, err := ioutil.ReadFile("data/tx_valid.json")
|
|
if err != nil {
|
|
t.Fatalf("TestTxValidTests: %v\n", err)
|
|
}
|
|
|
|
var tests [][]interface{}
|
|
err = json.Unmarshal(file, &tests)
|
|
if err != nil {
|
|
t.Fatalf("TestTxValidTests couldn't Unmarshal: %v\n", err)
|
|
}
|
|
|
|
// form is either:
|
|
// ["this is a comment "]
|
|
// or:
|
|
// [[[previous hash, previous index, previous scriptPubKey, input value]...,]
|
|
// serializedTransaction, verifyFlags]
|
|
testloop:
|
|
for i, test := range tests {
|
|
inputs, ok := test[0].([]interface{})
|
|
if !ok {
|
|
continue
|
|
}
|
|
|
|
if len(test) != 3 {
|
|
t.Errorf("bad test (bad length) %d: %v", i, test)
|
|
continue
|
|
}
|
|
serializedhex, ok := test[1].(string)
|
|
if !ok {
|
|
t.Errorf("bad test (arg 2 not string) %d: %v", i, test)
|
|
continue
|
|
}
|
|
serializedTx, err := hex.DecodeString(serializedhex)
|
|
if err != nil {
|
|
t.Errorf("bad test (arg 2 not hex %v) %d: %v", err, i,
|
|
test)
|
|
continue
|
|
}
|
|
|
|
tx, err := btcutil.NewTxFromBytes(serializedTx)
|
|
if err != nil {
|
|
t.Errorf("bad test (arg 2 not msgtx %v) %d: %v", err,
|
|
i, test)
|
|
continue
|
|
}
|
|
|
|
verifyFlags, ok := test[2].(string)
|
|
if !ok {
|
|
t.Errorf("bad test (arg 3 not string) %d: %v", i, test)
|
|
continue
|
|
}
|
|
|
|
flags, err := parseScriptFlags(verifyFlags)
|
|
if err != nil {
|
|
t.Errorf("bad test %d: %v", i, err)
|
|
continue
|
|
}
|
|
|
|
prevOuts := make(map[wire.OutPoint]scriptWithInputVal)
|
|
for j, iinput := range inputs {
|
|
input, ok := iinput.([]interface{})
|
|
if !ok {
|
|
t.Errorf("bad test (%dth input not array)"+
|
|
"%d: %v", j, i, test)
|
|
continue
|
|
}
|
|
|
|
if len(input) < 3 || len(input) > 4 {
|
|
t.Errorf("bad test (%dth input wrong length)"+
|
|
"%d: %v", j, i, test)
|
|
continue
|
|
}
|
|
|
|
previoustx, ok := input[0].(string)
|
|
if !ok {
|
|
t.Errorf("bad test (%dth input hash not string)"+
|
|
"%d: %v", j, i, test)
|
|
continue
|
|
}
|
|
|
|
prevhash, err := chainhash.NewHashFromStr(previoustx)
|
|
if err != nil {
|
|
t.Errorf("bad test (%dth input hash not hash %v)"+
|
|
"%d: %v", j, err, i, test)
|
|
continue
|
|
}
|
|
|
|
idxf, ok := input[1].(float64)
|
|
if !ok {
|
|
t.Errorf("bad test (%dth input idx not number)"+
|
|
"%d: %v", j, i, test)
|
|
continue
|
|
}
|
|
idx := testVecF64ToUint32(idxf)
|
|
|
|
oscript, ok := input[2].(string)
|
|
if !ok {
|
|
t.Errorf("bad test (%dth input script not "+
|
|
"string) %d: %v", j, i, test)
|
|
continue
|
|
}
|
|
|
|
script, err := parseShortForm(oscript)
|
|
if err != nil {
|
|
t.Errorf("bad test (%dth input script doesn't "+
|
|
"parse %v) %d: %v", j, err, i, test)
|
|
continue
|
|
}
|
|
|
|
var inputValue float64
|
|
if len(input) == 4 {
|
|
inputValue, ok = input[3].(float64)
|
|
if !ok {
|
|
t.Errorf("bad test (%dth input value not int) "+
|
|
"%d: %v", j, i, test)
|
|
continue
|
|
}
|
|
}
|
|
|
|
v := scriptWithInputVal{
|
|
inputVal: int64(inputValue),
|
|
pkScript: script,
|
|
}
|
|
prevOuts[*wire.NewOutPoint(prevhash, idx)] = v
|
|
}
|
|
|
|
for k, txin := range tx.MsgTx().TxIn {
|
|
prevOut, ok := prevOuts[txin.PreviousOutPoint]
|
|
if !ok {
|
|
t.Errorf("bad test (missing %dth input) %d:%v",
|
|
k, i, test)
|
|
continue testloop
|
|
}
|
|
vm, err := NewEngine(prevOut.pkScript, tx.MsgTx(), k,
|
|
flags, nil, nil, prevOut.inputVal)
|
|
if err != nil {
|
|
t.Errorf("test (%d:%v:%d) failed to create "+
|
|
"script: %v", i, test, k, err)
|
|
continue
|
|
}
|
|
|
|
err = vm.Execute()
|
|
if err != nil {
|
|
t.Errorf("test (%d:%v:%d) failed to execute: "+
|
|
"%v", i, test, k, err)
|
|
continue
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// TestCalcSignatureHash runs the Bitcoin Core signature hash calculation tests
|
|
// in sighash.json.
|
|
// https://github.com/bitcoin/bitcoin/blob/master/src/test/data/sighash.json
|
|
func TestCalcSignatureHash(t *testing.T) {
|
|
file, err := ioutil.ReadFile("data/sighash.json")
|
|
if err != nil {
|
|
t.Fatalf("TestCalcSignatureHash: %v\n", err)
|
|
}
|
|
|
|
var tests [][]interface{}
|
|
err = json.Unmarshal(file, &tests)
|
|
if err != nil {
|
|
t.Fatalf("TestCalcSignatureHash couldn't Unmarshal: %v\n",
|
|
err)
|
|
}
|
|
|
|
for i, test := range tests {
|
|
if i == 0 {
|
|
// Skip first line -- contains comments only.
|
|
continue
|
|
}
|
|
if len(test) != 5 {
|
|
t.Fatalf("TestCalcSignatureHash: Test #%d has "+
|
|
"wrong length.", i)
|
|
}
|
|
var tx wire.MsgTx
|
|
rawTx, _ := hex.DecodeString(test[0].(string))
|
|
err := tx.Deserialize(bytes.NewReader(rawTx))
|
|
if err != nil {
|
|
t.Errorf("TestCalcSignatureHash failed test #%d: "+
|
|
"Failed to parse transaction: %v", i, err)
|
|
continue
|
|
}
|
|
|
|
subScript, _ := hex.DecodeString(test[1].(string))
|
|
parsedScript, err := parseScript(subScript)
|
|
if err != nil {
|
|
t.Errorf("TestCalcSignatureHash failed test #%d: "+
|
|
"Failed to parse sub-script: %v", i, err)
|
|
continue
|
|
}
|
|
|
|
hashType := SigHashType(testVecF64ToUint32(test[3].(float64)))
|
|
hash := calcSignatureHash(parsedScript, hashType, &tx,
|
|
int(test[2].(float64)))
|
|
|
|
expectedHash, _ := chainhash.NewHashFromStr(test[4].(string))
|
|
if !bytes.Equal(hash, expectedHash[:]) {
|
|
t.Errorf("TestCalcSignatureHash failed test #%d: "+
|
|
"Signature hash mismatch.", i)
|
|
}
|
|
}
|
|
}
|