1717 lines
43 KiB
Go
1717 lines
43 KiB
Go
// Copyright (c) 2013-2016 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 (
|
|
"errors"
|
|
"fmt"
|
|
"testing"
|
|
|
|
"github.com/btcsuite/btcd/btcec"
|
|
"github.com/btcsuite/btcd/chaincfg"
|
|
"github.com/btcsuite/btcd/chaincfg/chainhash"
|
|
"github.com/btcsuite/btcd/wire"
|
|
"github.com/btcsuite/btcutil"
|
|
)
|
|
|
|
type addressToKey struct {
|
|
key *btcec.PrivateKey
|
|
compressed bool
|
|
}
|
|
|
|
func mkGetKey(keys map[string]addressToKey) KeyDB {
|
|
if keys == nil {
|
|
return KeyClosure(func(addr btcutil.Address) (*btcec.PrivateKey,
|
|
bool, error) {
|
|
return nil, false, errors.New("nope")
|
|
})
|
|
}
|
|
return KeyClosure(func(addr btcutil.Address) (*btcec.PrivateKey,
|
|
bool, error) {
|
|
a2k, ok := keys[addr.EncodeAddress()]
|
|
if !ok {
|
|
return nil, false, errors.New("nope")
|
|
}
|
|
return a2k.key, a2k.compressed, nil
|
|
})
|
|
}
|
|
|
|
func mkGetScript(scripts map[string][]byte) ScriptDB {
|
|
if scripts == nil {
|
|
return ScriptClosure(func(addr btcutil.Address) ([]byte, error) {
|
|
return nil, errors.New("nope")
|
|
})
|
|
}
|
|
return ScriptClosure(func(addr btcutil.Address) ([]byte, error) {
|
|
script, ok := scripts[addr.EncodeAddress()]
|
|
if !ok {
|
|
return nil, errors.New("nope")
|
|
}
|
|
return script, nil
|
|
})
|
|
}
|
|
|
|
func checkScripts(msg string, tx *wire.MsgTx, idx int, inputAmt int64, sigScript, pkScript []byte) error {
|
|
tx.TxIn[idx].SignatureScript = sigScript
|
|
vm, err := NewEngine(pkScript, tx, idx,
|
|
ScriptBip16|ScriptVerifyDERSignatures, nil, nil, inputAmt)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to make script engine for %s: %v",
|
|
msg, err)
|
|
}
|
|
|
|
err = vm.Execute()
|
|
if err != nil {
|
|
return fmt.Errorf("invalid script signature for %s: %v", msg,
|
|
err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func signAndCheck(msg string, tx *wire.MsgTx, idx int, inputAmt int64, pkScript []byte,
|
|
hashType SigHashType, kdb KeyDB, sdb ScriptDB,
|
|
previousScript []byte) error {
|
|
|
|
sigScript, err := SignTxOutput(&chaincfg.TestNet3Params, tx, idx,
|
|
pkScript, hashType, kdb, sdb, nil)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to sign output %s: %v", msg, err)
|
|
}
|
|
|
|
return checkScripts(msg, tx, idx, inputAmt, sigScript, pkScript)
|
|
}
|
|
|
|
func TestSignTxOutput(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
// make key
|
|
// make script based on key.
|
|
// sign with magic pixie dust.
|
|
hashTypes := []SigHashType{
|
|
SigHashOld, // no longer used but should act like all
|
|
SigHashAll,
|
|
SigHashNone,
|
|
SigHashSingle,
|
|
SigHashAll | SigHashAnyOneCanPay,
|
|
SigHashNone | SigHashAnyOneCanPay,
|
|
SigHashSingle | SigHashAnyOneCanPay,
|
|
}
|
|
inputAmounts := []int64{5, 10, 15}
|
|
tx := &wire.MsgTx{
|
|
Version: 1,
|
|
TxIn: []*wire.TxIn{
|
|
{
|
|
PreviousOutPoint: wire.OutPoint{
|
|
Hash: chainhash.Hash{},
|
|
Index: 0,
|
|
},
|
|
Sequence: 4294967295,
|
|
},
|
|
{
|
|
PreviousOutPoint: wire.OutPoint{
|
|
Hash: chainhash.Hash{},
|
|
Index: 1,
|
|
},
|
|
Sequence: 4294967295,
|
|
},
|
|
{
|
|
PreviousOutPoint: wire.OutPoint{
|
|
Hash: chainhash.Hash{},
|
|
Index: 2,
|
|
},
|
|
Sequence: 4294967295,
|
|
},
|
|
},
|
|
TxOut: []*wire.TxOut{
|
|
{
|
|
Value: 1,
|
|
},
|
|
{
|
|
Value: 2,
|
|
},
|
|
{
|
|
Value: 3,
|
|
},
|
|
},
|
|
LockTime: 0,
|
|
}
|
|
|
|
// Pay to Pubkey Hash (uncompressed)
|
|
for _, hashType := range hashTypes {
|
|
for i := range tx.TxIn {
|
|
msg := fmt.Sprintf("%d:%d", hashType, i)
|
|
key, err := btcec.NewPrivateKey(btcec.S256())
|
|
if err != nil {
|
|
t.Errorf("failed to make privKey for %s: %v",
|
|
msg, err)
|
|
break
|
|
}
|
|
|
|
pk := (*btcec.PublicKey)(&key.PublicKey).
|
|
SerializeUncompressed()
|
|
address, err := btcutil.NewAddressPubKeyHash(
|
|
btcutil.Hash160(pk), &chaincfg.TestNet3Params)
|
|
if err != nil {
|
|
t.Errorf("failed to make address for %s: %v",
|
|
msg, err)
|
|
break
|
|
}
|
|
|
|
pkScript, err := PayToAddrScript(address)
|
|
if err != nil {
|
|
t.Errorf("failed to make pkscript "+
|
|
"for %s: %v", msg, err)
|
|
}
|
|
|
|
if err := signAndCheck(msg, tx, i, inputAmounts[i], pkScript, hashType,
|
|
mkGetKey(map[string]addressToKey{
|
|
address.EncodeAddress(): {key, false},
|
|
}), mkGetScript(nil), nil); err != nil {
|
|
t.Error(err)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
// Pay to Pubkey Hash (uncompressed) (merging with correct)
|
|
for _, hashType := range hashTypes {
|
|
for i := range tx.TxIn {
|
|
msg := fmt.Sprintf("%d:%d", hashType, i)
|
|
key, err := btcec.NewPrivateKey(btcec.S256())
|
|
if err != nil {
|
|
t.Errorf("failed to make privKey for %s: %v",
|
|
msg, err)
|
|
break
|
|
}
|
|
|
|
pk := (*btcec.PublicKey)(&key.PublicKey).
|
|
SerializeUncompressed()
|
|
address, err := btcutil.NewAddressPubKeyHash(
|
|
btcutil.Hash160(pk), &chaincfg.TestNet3Params)
|
|
if err != nil {
|
|
t.Errorf("failed to make address for %s: %v",
|
|
msg, err)
|
|
break
|
|
}
|
|
|
|
pkScript, err := PayToAddrScript(address)
|
|
if err != nil {
|
|
t.Errorf("failed to make pkscript "+
|
|
"for %s: %v", msg, err)
|
|
}
|
|
|
|
sigScript, err := SignTxOutput(&chaincfg.TestNet3Params,
|
|
tx, i, pkScript, hashType,
|
|
mkGetKey(map[string]addressToKey{
|
|
address.EncodeAddress(): {key, false},
|
|
}), mkGetScript(nil), nil)
|
|
if err != nil {
|
|
t.Errorf("failed to sign output %s: %v", msg,
|
|
err)
|
|
break
|
|
}
|
|
|
|
// by the above loop, this should be valid, now sign
|
|
// again and merge.
|
|
sigScript, err = SignTxOutput(&chaincfg.TestNet3Params,
|
|
tx, i, pkScript, hashType,
|
|
mkGetKey(map[string]addressToKey{
|
|
address.EncodeAddress(): {key, false},
|
|
}), mkGetScript(nil), sigScript)
|
|
if err != nil {
|
|
t.Errorf("failed to sign output %s a "+
|
|
"second time: %v", msg, err)
|
|
break
|
|
}
|
|
|
|
err = checkScripts(msg, tx, i, inputAmounts[i], sigScript, pkScript)
|
|
if err != nil {
|
|
t.Errorf("twice signed script invalid for "+
|
|
"%s: %v", msg, err)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
// Pay to Pubkey Hash (compressed)
|
|
for _, hashType := range hashTypes {
|
|
for i := range tx.TxIn {
|
|
msg := fmt.Sprintf("%d:%d", hashType, i)
|
|
|
|
key, err := btcec.NewPrivateKey(btcec.S256())
|
|
if err != nil {
|
|
t.Errorf("failed to make privKey for %s: %v",
|
|
msg, err)
|
|
break
|
|
}
|
|
|
|
pk := (*btcec.PublicKey)(&key.PublicKey).
|
|
SerializeCompressed()
|
|
address, err := btcutil.NewAddressPubKeyHash(
|
|
btcutil.Hash160(pk), &chaincfg.TestNet3Params)
|
|
if err != nil {
|
|
t.Errorf("failed to make address for %s: %v",
|
|
msg, err)
|
|
break
|
|
}
|
|
|
|
pkScript, err := PayToAddrScript(address)
|
|
if err != nil {
|
|
t.Errorf("failed to make pkscript "+
|
|
"for %s: %v", msg, err)
|
|
}
|
|
|
|
if err := signAndCheck(msg, tx, i, inputAmounts[i],
|
|
pkScript, hashType,
|
|
mkGetKey(map[string]addressToKey{
|
|
address.EncodeAddress(): {key, true},
|
|
}), mkGetScript(nil), nil); err != nil {
|
|
t.Error(err)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
// Pay to Pubkey Hash (compressed) with duplicate merge
|
|
for _, hashType := range hashTypes {
|
|
for i := range tx.TxIn {
|
|
msg := fmt.Sprintf("%d:%d", hashType, i)
|
|
|
|
key, err := btcec.NewPrivateKey(btcec.S256())
|
|
if err != nil {
|
|
t.Errorf("failed to make privKey for %s: %v",
|
|
msg, err)
|
|
break
|
|
}
|
|
|
|
pk := (*btcec.PublicKey)(&key.PublicKey).
|
|
SerializeCompressed()
|
|
address, err := btcutil.NewAddressPubKeyHash(
|
|
btcutil.Hash160(pk), &chaincfg.TestNet3Params)
|
|
if err != nil {
|
|
t.Errorf("failed to make address for %s: %v",
|
|
msg, err)
|
|
break
|
|
}
|
|
|
|
pkScript, err := PayToAddrScript(address)
|
|
if err != nil {
|
|
t.Errorf("failed to make pkscript "+
|
|
"for %s: %v", msg, err)
|
|
}
|
|
|
|
sigScript, err := SignTxOutput(&chaincfg.TestNet3Params,
|
|
tx, i, pkScript, hashType,
|
|
mkGetKey(map[string]addressToKey{
|
|
address.EncodeAddress(): {key, true},
|
|
}), mkGetScript(nil), nil)
|
|
if err != nil {
|
|
t.Errorf("failed to sign output %s: %v", msg,
|
|
err)
|
|
break
|
|
}
|
|
|
|
// by the above loop, this should be valid, now sign
|
|
// again and merge.
|
|
sigScript, err = SignTxOutput(&chaincfg.TestNet3Params,
|
|
tx, i, pkScript, hashType,
|
|
mkGetKey(map[string]addressToKey{
|
|
address.EncodeAddress(): {key, true},
|
|
}), mkGetScript(nil), sigScript)
|
|
if err != nil {
|
|
t.Errorf("failed to sign output %s a "+
|
|
"second time: %v", msg, err)
|
|
break
|
|
}
|
|
|
|
err = checkScripts(msg, tx, i, inputAmounts[i],
|
|
sigScript, pkScript)
|
|
if err != nil {
|
|
t.Errorf("twice signed script invalid for "+
|
|
"%s: %v", msg, err)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
// Pay to PubKey (uncompressed)
|
|
for _, hashType := range hashTypes {
|
|
for i := range tx.TxIn {
|
|
msg := fmt.Sprintf("%d:%d", hashType, i)
|
|
|
|
key, err := btcec.NewPrivateKey(btcec.S256())
|
|
if err != nil {
|
|
t.Errorf("failed to make privKey for %s: %v",
|
|
msg, err)
|
|
break
|
|
}
|
|
|
|
pk := (*btcec.PublicKey)(&key.PublicKey).
|
|
SerializeUncompressed()
|
|
address, err := btcutil.NewAddressPubKey(pk,
|
|
&chaincfg.TestNet3Params)
|
|
if err != nil {
|
|
t.Errorf("failed to make address for %s: %v",
|
|
msg, err)
|
|
break
|
|
}
|
|
|
|
pkScript, err := PayToAddrScript(address)
|
|
if err != nil {
|
|
t.Errorf("failed to make pkscript "+
|
|
"for %s: %v", msg, err)
|
|
}
|
|
|
|
if err := signAndCheck(msg, tx, i, inputAmounts[i],
|
|
pkScript, hashType,
|
|
mkGetKey(map[string]addressToKey{
|
|
address.EncodeAddress(): {key, false},
|
|
}), mkGetScript(nil), nil); err != nil {
|
|
t.Error(err)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
// Pay to PubKey (uncompressed)
|
|
for _, hashType := range hashTypes {
|
|
for i := range tx.TxIn {
|
|
msg := fmt.Sprintf("%d:%d", hashType, i)
|
|
|
|
key, err := btcec.NewPrivateKey(btcec.S256())
|
|
if err != nil {
|
|
t.Errorf("failed to make privKey for %s: %v",
|
|
msg, err)
|
|
break
|
|
}
|
|
|
|
pk := (*btcec.PublicKey)(&key.PublicKey).
|
|
SerializeUncompressed()
|
|
address, err := btcutil.NewAddressPubKey(pk,
|
|
&chaincfg.TestNet3Params)
|
|
if err != nil {
|
|
t.Errorf("failed to make address for %s: %v",
|
|
msg, err)
|
|
break
|
|
}
|
|
|
|
pkScript, err := PayToAddrScript(address)
|
|
if err != nil {
|
|
t.Errorf("failed to make pkscript "+
|
|
"for %s: %v", msg, err)
|
|
}
|
|
|
|
sigScript, err := SignTxOutput(&chaincfg.TestNet3Params,
|
|
tx, i, pkScript, hashType,
|
|
mkGetKey(map[string]addressToKey{
|
|
address.EncodeAddress(): {key, false},
|
|
}), mkGetScript(nil), nil)
|
|
if err != nil {
|
|
t.Errorf("failed to sign output %s: %v", msg,
|
|
err)
|
|
break
|
|
}
|
|
|
|
// by the above loop, this should be valid, now sign
|
|
// again and merge.
|
|
sigScript, err = SignTxOutput(&chaincfg.TestNet3Params,
|
|
tx, i, pkScript, hashType,
|
|
mkGetKey(map[string]addressToKey{
|
|
address.EncodeAddress(): {key, false},
|
|
}), mkGetScript(nil), sigScript)
|
|
if err != nil {
|
|
t.Errorf("failed to sign output %s a "+
|
|
"second time: %v", msg, err)
|
|
break
|
|
}
|
|
|
|
err = checkScripts(msg, tx, i, inputAmounts[i], sigScript, pkScript)
|
|
if err != nil {
|
|
t.Errorf("twice signed script invalid for "+
|
|
"%s: %v", msg, err)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
// Pay to PubKey (compressed)
|
|
for _, hashType := range hashTypes {
|
|
for i := range tx.TxIn {
|
|
msg := fmt.Sprintf("%d:%d", hashType, i)
|
|
|
|
key, err := btcec.NewPrivateKey(btcec.S256())
|
|
if err != nil {
|
|
t.Errorf("failed to make privKey for %s: %v",
|
|
msg, err)
|
|
break
|
|
}
|
|
|
|
pk := (*btcec.PublicKey)(&key.PublicKey).
|
|
SerializeCompressed()
|
|
address, err := btcutil.NewAddressPubKey(pk,
|
|
&chaincfg.TestNet3Params)
|
|
if err != nil {
|
|
t.Errorf("failed to make address for %s: %v",
|
|
msg, err)
|
|
break
|
|
}
|
|
|
|
pkScript, err := PayToAddrScript(address)
|
|
if err != nil {
|
|
t.Errorf("failed to make pkscript "+
|
|
"for %s: %v", msg, err)
|
|
}
|
|
|
|
if err := signAndCheck(msg, tx, i, inputAmounts[i],
|
|
pkScript, hashType,
|
|
mkGetKey(map[string]addressToKey{
|
|
address.EncodeAddress(): {key, true},
|
|
}), mkGetScript(nil), nil); err != nil {
|
|
t.Error(err)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
// Pay to PubKey (compressed) with duplicate merge
|
|
for _, hashType := range hashTypes {
|
|
for i := range tx.TxIn {
|
|
msg := fmt.Sprintf("%d:%d", hashType, i)
|
|
|
|
key, err := btcec.NewPrivateKey(btcec.S256())
|
|
if err != nil {
|
|
t.Errorf("failed to make privKey for %s: %v",
|
|
msg, err)
|
|
break
|
|
}
|
|
|
|
pk := (*btcec.PublicKey)(&key.PublicKey).
|
|
SerializeCompressed()
|
|
address, err := btcutil.NewAddressPubKey(pk,
|
|
&chaincfg.TestNet3Params)
|
|
if err != nil {
|
|
t.Errorf("failed to make address for %s: %v",
|
|
msg, err)
|
|
break
|
|
}
|
|
|
|
pkScript, err := PayToAddrScript(address)
|
|
if err != nil {
|
|
t.Errorf("failed to make pkscript "+
|
|
"for %s: %v", msg, err)
|
|
}
|
|
|
|
sigScript, err := SignTxOutput(&chaincfg.TestNet3Params,
|
|
tx, i, pkScript, hashType,
|
|
mkGetKey(map[string]addressToKey{
|
|
address.EncodeAddress(): {key, true},
|
|
}), mkGetScript(nil), nil)
|
|
if err != nil {
|
|
t.Errorf("failed to sign output %s: %v", msg,
|
|
err)
|
|
break
|
|
}
|
|
|
|
// by the above loop, this should be valid, now sign
|
|
// again and merge.
|
|
sigScript, err = SignTxOutput(&chaincfg.TestNet3Params,
|
|
tx, i, pkScript, hashType,
|
|
mkGetKey(map[string]addressToKey{
|
|
address.EncodeAddress(): {key, true},
|
|
}), mkGetScript(nil), sigScript)
|
|
if err != nil {
|
|
t.Errorf("failed to sign output %s a "+
|
|
"second time: %v", msg, err)
|
|
break
|
|
}
|
|
|
|
err = checkScripts(msg, tx, i, inputAmounts[i],
|
|
sigScript, pkScript)
|
|
if err != nil {
|
|
t.Errorf("twice signed script invalid for "+
|
|
"%s: %v", msg, err)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
// As before, but with p2sh now.
|
|
// Pay to Pubkey Hash (uncompressed)
|
|
for _, hashType := range hashTypes {
|
|
for i := range tx.TxIn {
|
|
msg := fmt.Sprintf("%d:%d", hashType, i)
|
|
key, err := btcec.NewPrivateKey(btcec.S256())
|
|
if err != nil {
|
|
t.Errorf("failed to make privKey for %s: %v",
|
|
msg, err)
|
|
break
|
|
}
|
|
|
|
pk := (*btcec.PublicKey)(&key.PublicKey).
|
|
SerializeUncompressed()
|
|
address, err := btcutil.NewAddressPubKeyHash(
|
|
btcutil.Hash160(pk), &chaincfg.TestNet3Params)
|
|
if err != nil {
|
|
t.Errorf("failed to make address for %s: %v",
|
|
msg, err)
|
|
break
|
|
}
|
|
|
|
pkScript, err := PayToAddrScript(address)
|
|
if err != nil {
|
|
t.Errorf("failed to make pkscript "+
|
|
"for %s: %v", msg, err)
|
|
break
|
|
}
|
|
|
|
scriptAddr, err := btcutil.NewAddressScriptHash(
|
|
pkScript, &chaincfg.TestNet3Params)
|
|
if err != nil {
|
|
t.Errorf("failed to make p2sh addr for %s: %v",
|
|
msg, err)
|
|
break
|
|
}
|
|
|
|
scriptPkScript, err := PayToAddrScript(
|
|
scriptAddr)
|
|
if err != nil {
|
|
t.Errorf("failed to make script pkscript for "+
|
|
"%s: %v", msg, err)
|
|
break
|
|
}
|
|
|
|
if err := signAndCheck(msg, tx, i, inputAmounts[i],
|
|
scriptPkScript, hashType,
|
|
mkGetKey(map[string]addressToKey{
|
|
address.EncodeAddress(): {key, false},
|
|
}), mkGetScript(map[string][]byte{
|
|
scriptAddr.EncodeAddress(): pkScript,
|
|
}), nil); err != nil {
|
|
t.Error(err)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
// Pay to Pubkey Hash (uncompressed) with duplicate merge
|
|
for _, hashType := range hashTypes {
|
|
for i := range tx.TxIn {
|
|
msg := fmt.Sprintf("%d:%d", hashType, i)
|
|
key, err := btcec.NewPrivateKey(btcec.S256())
|
|
if err != nil {
|
|
t.Errorf("failed to make privKey for %s: %v",
|
|
msg, err)
|
|
break
|
|
}
|
|
|
|
pk := (*btcec.PublicKey)(&key.PublicKey).
|
|
SerializeUncompressed()
|
|
address, err := btcutil.NewAddressPubKeyHash(
|
|
btcutil.Hash160(pk), &chaincfg.TestNet3Params)
|
|
if err != nil {
|
|
t.Errorf("failed to make address for %s: %v",
|
|
msg, err)
|
|
break
|
|
}
|
|
|
|
pkScript, err := PayToAddrScript(address)
|
|
if err != nil {
|
|
t.Errorf("failed to make pkscript "+
|
|
"for %s: %v", msg, err)
|
|
break
|
|
}
|
|
|
|
scriptAddr, err := btcutil.NewAddressScriptHash(
|
|
pkScript, &chaincfg.TestNet3Params)
|
|
if err != nil {
|
|
t.Errorf("failed to make p2sh addr for %s: %v",
|
|
msg, err)
|
|
break
|
|
}
|
|
|
|
scriptPkScript, err := PayToAddrScript(
|
|
scriptAddr)
|
|
if err != nil {
|
|
t.Errorf("failed to make script pkscript for "+
|
|
"%s: %v", msg, err)
|
|
break
|
|
}
|
|
|
|
sigScript, err := SignTxOutput(&chaincfg.TestNet3Params,
|
|
tx, i, scriptPkScript, hashType,
|
|
mkGetKey(map[string]addressToKey{
|
|
address.EncodeAddress(): {key, false},
|
|
}), mkGetScript(map[string][]byte{
|
|
scriptAddr.EncodeAddress(): pkScript,
|
|
}), nil)
|
|
if err != nil {
|
|
t.Errorf("failed to sign output %s: %v", msg,
|
|
err)
|
|
break
|
|
}
|
|
|
|
// by the above loop, this should be valid, now sign
|
|
// again and merge.
|
|
sigScript, err = SignTxOutput(&chaincfg.TestNet3Params,
|
|
tx, i, scriptPkScript, hashType,
|
|
mkGetKey(map[string]addressToKey{
|
|
address.EncodeAddress(): {key, false},
|
|
}), mkGetScript(map[string][]byte{
|
|
scriptAddr.EncodeAddress(): pkScript,
|
|
}), nil)
|
|
if err != nil {
|
|
t.Errorf("failed to sign output %s a "+
|
|
"second time: %v", msg, err)
|
|
break
|
|
}
|
|
|
|
err = checkScripts(msg, tx, i, inputAmounts[i],
|
|
sigScript, scriptPkScript)
|
|
if err != nil {
|
|
t.Errorf("twice signed script invalid for "+
|
|
"%s: %v", msg, err)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
// Pay to Pubkey Hash (compressed)
|
|
for _, hashType := range hashTypes {
|
|
for i := range tx.TxIn {
|
|
msg := fmt.Sprintf("%d:%d", hashType, i)
|
|
|
|
key, err := btcec.NewPrivateKey(btcec.S256())
|
|
if err != nil {
|
|
t.Errorf("failed to make privKey for %s: %v",
|
|
msg, err)
|
|
break
|
|
}
|
|
|
|
pk := (*btcec.PublicKey)(&key.PublicKey).
|
|
SerializeCompressed()
|
|
address, err := btcutil.NewAddressPubKeyHash(
|
|
btcutil.Hash160(pk), &chaincfg.TestNet3Params)
|
|
if err != nil {
|
|
t.Errorf("failed to make address for %s: %v",
|
|
msg, err)
|
|
break
|
|
}
|
|
|
|
pkScript, err := PayToAddrScript(address)
|
|
if err != nil {
|
|
t.Errorf("failed to make pkscript "+
|
|
"for %s: %v", msg, err)
|
|
}
|
|
|
|
scriptAddr, err := btcutil.NewAddressScriptHash(
|
|
pkScript, &chaincfg.TestNet3Params)
|
|
if err != nil {
|
|
t.Errorf("failed to make p2sh addr for %s: %v",
|
|
msg, err)
|
|
break
|
|
}
|
|
|
|
scriptPkScript, err := PayToAddrScript(
|
|
scriptAddr)
|
|
if err != nil {
|
|
t.Errorf("failed to make script pkscript for "+
|
|
"%s: %v", msg, err)
|
|
break
|
|
}
|
|
|
|
if err := signAndCheck(msg, tx, i, inputAmounts[i],
|
|
scriptPkScript, hashType,
|
|
mkGetKey(map[string]addressToKey{
|
|
address.EncodeAddress(): {key, true},
|
|
}), mkGetScript(map[string][]byte{
|
|
scriptAddr.EncodeAddress(): pkScript,
|
|
}), nil); err != nil {
|
|
t.Error(err)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
// Pay to Pubkey Hash (compressed) with duplicate merge
|
|
for _, hashType := range hashTypes {
|
|
for i := range tx.TxIn {
|
|
msg := fmt.Sprintf("%d:%d", hashType, i)
|
|
|
|
key, err := btcec.NewPrivateKey(btcec.S256())
|
|
if err != nil {
|
|
t.Errorf("failed to make privKey for %s: %v",
|
|
msg, err)
|
|
break
|
|
}
|
|
|
|
pk := (*btcec.PublicKey)(&key.PublicKey).
|
|
SerializeCompressed()
|
|
address, err := btcutil.NewAddressPubKeyHash(
|
|
btcutil.Hash160(pk), &chaincfg.TestNet3Params)
|
|
if err != nil {
|
|
t.Errorf("failed to make address for %s: %v",
|
|
msg, err)
|
|
break
|
|
}
|
|
|
|
pkScript, err := PayToAddrScript(address)
|
|
if err != nil {
|
|
t.Errorf("failed to make pkscript "+
|
|
"for %s: %v", msg, err)
|
|
}
|
|
|
|
scriptAddr, err := btcutil.NewAddressScriptHash(
|
|
pkScript, &chaincfg.TestNet3Params)
|
|
if err != nil {
|
|
t.Errorf("failed to make p2sh addr for %s: %v",
|
|
msg, err)
|
|
break
|
|
}
|
|
|
|
scriptPkScript, err := PayToAddrScript(
|
|
scriptAddr)
|
|
if err != nil {
|
|
t.Errorf("failed to make script pkscript for "+
|
|
"%s: %v", msg, err)
|
|
break
|
|
}
|
|
|
|
sigScript, err := SignTxOutput(&chaincfg.TestNet3Params,
|
|
tx, i, scriptPkScript, hashType,
|
|
mkGetKey(map[string]addressToKey{
|
|
address.EncodeAddress(): {key, true},
|
|
}), mkGetScript(map[string][]byte{
|
|
scriptAddr.EncodeAddress(): pkScript,
|
|
}), nil)
|
|
if err != nil {
|
|
t.Errorf("failed to sign output %s: %v", msg,
|
|
err)
|
|
break
|
|
}
|
|
|
|
// by the above loop, this should be valid, now sign
|
|
// again and merge.
|
|
sigScript, err = SignTxOutput(&chaincfg.TestNet3Params,
|
|
tx, i, scriptPkScript, hashType,
|
|
mkGetKey(map[string]addressToKey{
|
|
address.EncodeAddress(): {key, true},
|
|
}), mkGetScript(map[string][]byte{
|
|
scriptAddr.EncodeAddress(): pkScript,
|
|
}), nil)
|
|
if err != nil {
|
|
t.Errorf("failed to sign output %s a "+
|
|
"second time: %v", msg, err)
|
|
break
|
|
}
|
|
|
|
err = checkScripts(msg, tx, i, inputAmounts[i],
|
|
sigScript, scriptPkScript)
|
|
if err != nil {
|
|
t.Errorf("twice signed script invalid for "+
|
|
"%s: %v", msg, err)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
// Pay to PubKey (uncompressed)
|
|
for _, hashType := range hashTypes {
|
|
for i := range tx.TxIn {
|
|
msg := fmt.Sprintf("%d:%d", hashType, i)
|
|
|
|
key, err := btcec.NewPrivateKey(btcec.S256())
|
|
if err != nil {
|
|
t.Errorf("failed to make privKey for %s: %v",
|
|
msg, err)
|
|
break
|
|
}
|
|
|
|
pk := (*btcec.PublicKey)(&key.PublicKey).
|
|
SerializeUncompressed()
|
|
address, err := btcutil.NewAddressPubKey(pk,
|
|
&chaincfg.TestNet3Params)
|
|
if err != nil {
|
|
t.Errorf("failed to make address for %s: %v",
|
|
msg, err)
|
|
break
|
|
}
|
|
|
|
pkScript, err := PayToAddrScript(address)
|
|
if err != nil {
|
|
t.Errorf("failed to make pkscript "+
|
|
"for %s: %v", msg, err)
|
|
}
|
|
|
|
scriptAddr, err := btcutil.NewAddressScriptHash(
|
|
pkScript, &chaincfg.TestNet3Params)
|
|
if err != nil {
|
|
t.Errorf("failed to make p2sh addr for %s: %v",
|
|
msg, err)
|
|
break
|
|
}
|
|
|
|
scriptPkScript, err := PayToAddrScript(
|
|
scriptAddr)
|
|
if err != nil {
|
|
t.Errorf("failed to make script pkscript for "+
|
|
"%s: %v", msg, err)
|
|
break
|
|
}
|
|
|
|
if err := signAndCheck(msg, tx, i, inputAmounts[i],
|
|
scriptPkScript, hashType,
|
|
mkGetKey(map[string]addressToKey{
|
|
address.EncodeAddress(): {key, false},
|
|
}), mkGetScript(map[string][]byte{
|
|
scriptAddr.EncodeAddress(): pkScript,
|
|
}), nil); err != nil {
|
|
t.Error(err)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
// Pay to PubKey (uncompressed) with duplicate merge
|
|
for _, hashType := range hashTypes {
|
|
for i := range tx.TxIn {
|
|
msg := fmt.Sprintf("%d:%d", hashType, i)
|
|
|
|
key, err := btcec.NewPrivateKey(btcec.S256())
|
|
if err != nil {
|
|
t.Errorf("failed to make privKey for %s: %v",
|
|
msg, err)
|
|
break
|
|
}
|
|
|
|
pk := (*btcec.PublicKey)(&key.PublicKey).
|
|
SerializeUncompressed()
|
|
address, err := btcutil.NewAddressPubKey(pk,
|
|
&chaincfg.TestNet3Params)
|
|
if err != nil {
|
|
t.Errorf("failed to make address for %s: %v",
|
|
msg, err)
|
|
break
|
|
}
|
|
|
|
pkScript, err := PayToAddrScript(address)
|
|
if err != nil {
|
|
t.Errorf("failed to make pkscript "+
|
|
"for %s: %v", msg, err)
|
|
}
|
|
|
|
scriptAddr, err := btcutil.NewAddressScriptHash(
|
|
pkScript, &chaincfg.TestNet3Params)
|
|
if err != nil {
|
|
t.Errorf("failed to make p2sh addr for %s: %v",
|
|
msg, err)
|
|
break
|
|
}
|
|
|
|
scriptPkScript, err := PayToAddrScript(scriptAddr)
|
|
if err != nil {
|
|
t.Errorf("failed to make script pkscript for "+
|
|
"%s: %v", msg, err)
|
|
break
|
|
}
|
|
|
|
sigScript, err := SignTxOutput(&chaincfg.TestNet3Params,
|
|
tx, i, scriptPkScript, hashType,
|
|
mkGetKey(map[string]addressToKey{
|
|
address.EncodeAddress(): {key, false},
|
|
}), mkGetScript(map[string][]byte{
|
|
scriptAddr.EncodeAddress(): pkScript,
|
|
}), nil)
|
|
if err != nil {
|
|
t.Errorf("failed to sign output %s: %v", msg,
|
|
err)
|
|
break
|
|
}
|
|
|
|
// by the above loop, this should be valid, now sign
|
|
// again and merge.
|
|
sigScript, err = SignTxOutput(&chaincfg.TestNet3Params,
|
|
tx, i, scriptPkScript, hashType,
|
|
mkGetKey(map[string]addressToKey{
|
|
address.EncodeAddress(): {key, false},
|
|
}), mkGetScript(map[string][]byte{
|
|
scriptAddr.EncodeAddress(): pkScript,
|
|
}), nil)
|
|
if err != nil {
|
|
t.Errorf("failed to sign output %s a "+
|
|
"second time: %v", msg, err)
|
|
break
|
|
}
|
|
|
|
err = checkScripts(msg, tx, i, inputAmounts[i],
|
|
sigScript, scriptPkScript)
|
|
if err != nil {
|
|
t.Errorf("twice signed script invalid for "+
|
|
"%s: %v", msg, err)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
// Pay to PubKey (compressed)
|
|
for _, hashType := range hashTypes {
|
|
for i := range tx.TxIn {
|
|
msg := fmt.Sprintf("%d:%d", hashType, i)
|
|
|
|
key, err := btcec.NewPrivateKey(btcec.S256())
|
|
if err != nil {
|
|
t.Errorf("failed to make privKey for %s: %v",
|
|
msg, err)
|
|
break
|
|
}
|
|
|
|
pk := (*btcec.PublicKey)(&key.PublicKey).
|
|
SerializeCompressed()
|
|
address, err := btcutil.NewAddressPubKey(pk,
|
|
&chaincfg.TestNet3Params)
|
|
if err != nil {
|
|
t.Errorf("failed to make address for %s: %v",
|
|
msg, err)
|
|
break
|
|
}
|
|
|
|
pkScript, err := PayToAddrScript(address)
|
|
if err != nil {
|
|
t.Errorf("failed to make pkscript "+
|
|
"for %s: %v", msg, err)
|
|
}
|
|
|
|
scriptAddr, err := btcutil.NewAddressScriptHash(
|
|
pkScript, &chaincfg.TestNet3Params)
|
|
if err != nil {
|
|
t.Errorf("failed to make p2sh addr for %s: %v",
|
|
msg, err)
|
|
break
|
|
}
|
|
|
|
scriptPkScript, err := PayToAddrScript(scriptAddr)
|
|
if err != nil {
|
|
t.Errorf("failed to make script pkscript for "+
|
|
"%s: %v", msg, err)
|
|
break
|
|
}
|
|
|
|
if err := signAndCheck(msg, tx, i, inputAmounts[i],
|
|
scriptPkScript, hashType,
|
|
mkGetKey(map[string]addressToKey{
|
|
address.EncodeAddress(): {key, true},
|
|
}), mkGetScript(map[string][]byte{
|
|
scriptAddr.EncodeAddress(): pkScript,
|
|
}), nil); err != nil {
|
|
t.Error(err)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
// Pay to PubKey (compressed)
|
|
for _, hashType := range hashTypes {
|
|
for i := range tx.TxIn {
|
|
msg := fmt.Sprintf("%d:%d", hashType, i)
|
|
|
|
key, err := btcec.NewPrivateKey(btcec.S256())
|
|
if err != nil {
|
|
t.Errorf("failed to make privKey for %s: %v",
|
|
msg, err)
|
|
break
|
|
}
|
|
|
|
pk := (*btcec.PublicKey)(&key.PublicKey).
|
|
SerializeCompressed()
|
|
address, err := btcutil.NewAddressPubKey(pk,
|
|
&chaincfg.TestNet3Params)
|
|
if err != nil {
|
|
t.Errorf("failed to make address for %s: %v",
|
|
msg, err)
|
|
break
|
|
}
|
|
|
|
pkScript, err := PayToAddrScript(address)
|
|
if err != nil {
|
|
t.Errorf("failed to make pkscript "+
|
|
"for %s: %v", msg, err)
|
|
}
|
|
|
|
scriptAddr, err := btcutil.NewAddressScriptHash(
|
|
pkScript, &chaincfg.TestNet3Params)
|
|
if err != nil {
|
|
t.Errorf("failed to make p2sh addr for %s: %v",
|
|
msg, err)
|
|
break
|
|
}
|
|
|
|
scriptPkScript, err := PayToAddrScript(scriptAddr)
|
|
if err != nil {
|
|
t.Errorf("failed to make script pkscript for "+
|
|
"%s: %v", msg, err)
|
|
break
|
|
}
|
|
|
|
sigScript, err := SignTxOutput(&chaincfg.TestNet3Params,
|
|
tx, i, scriptPkScript, hashType,
|
|
mkGetKey(map[string]addressToKey{
|
|
address.EncodeAddress(): {key, true},
|
|
}), mkGetScript(map[string][]byte{
|
|
scriptAddr.EncodeAddress(): pkScript,
|
|
}), nil)
|
|
if err != nil {
|
|
t.Errorf("failed to sign output %s: %v", msg,
|
|
err)
|
|
break
|
|
}
|
|
|
|
// by the above loop, this should be valid, now sign
|
|
// again and merge.
|
|
sigScript, err = SignTxOutput(&chaincfg.TestNet3Params,
|
|
tx, i, scriptPkScript, hashType,
|
|
mkGetKey(map[string]addressToKey{
|
|
address.EncodeAddress(): {key, true},
|
|
}), mkGetScript(map[string][]byte{
|
|
scriptAddr.EncodeAddress(): pkScript,
|
|
}), nil)
|
|
if err != nil {
|
|
t.Errorf("failed to sign output %s a "+
|
|
"second time: %v", msg, err)
|
|
break
|
|
}
|
|
|
|
err = checkScripts(msg, tx, i, inputAmounts[i],
|
|
sigScript, scriptPkScript)
|
|
if err != nil {
|
|
t.Errorf("twice signed script invalid for "+
|
|
"%s: %v", msg, err)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
// Basic Multisig
|
|
for _, hashType := range hashTypes {
|
|
for i := range tx.TxIn {
|
|
msg := fmt.Sprintf("%d:%d", hashType, i)
|
|
|
|
key1, err := btcec.NewPrivateKey(btcec.S256())
|
|
if err != nil {
|
|
t.Errorf("failed to make privKey for %s: %v",
|
|
msg, err)
|
|
break
|
|
}
|
|
|
|
pk1 := (*btcec.PublicKey)(&key1.PublicKey).
|
|
SerializeCompressed()
|
|
address1, err := btcutil.NewAddressPubKey(pk1,
|
|
&chaincfg.TestNet3Params)
|
|
if err != nil {
|
|
t.Errorf("failed to make address for %s: %v",
|
|
msg, err)
|
|
break
|
|
}
|
|
|
|
key2, err := btcec.NewPrivateKey(btcec.S256())
|
|
if err != nil {
|
|
t.Errorf("failed to make privKey 2 for %s: %v",
|
|
msg, err)
|
|
break
|
|
}
|
|
|
|
pk2 := (*btcec.PublicKey)(&key2.PublicKey).
|
|
SerializeCompressed()
|
|
address2, err := btcutil.NewAddressPubKey(pk2,
|
|
&chaincfg.TestNet3Params)
|
|
if err != nil {
|
|
t.Errorf("failed to make address 2 for %s: %v",
|
|
msg, err)
|
|
break
|
|
}
|
|
|
|
pkScript, err := MultiSigScript(
|
|
[]*btcutil.AddressPubKey{address1, address2},
|
|
2)
|
|
if err != nil {
|
|
t.Errorf("failed to make pkscript "+
|
|
"for %s: %v", msg, err)
|
|
}
|
|
|
|
scriptAddr, err := btcutil.NewAddressScriptHash(
|
|
pkScript, &chaincfg.TestNet3Params)
|
|
if err != nil {
|
|
t.Errorf("failed to make p2sh addr for %s: %v",
|
|
msg, err)
|
|
break
|
|
}
|
|
|
|
scriptPkScript, err := PayToAddrScript(scriptAddr)
|
|
if err != nil {
|
|
t.Errorf("failed to make script pkscript for "+
|
|
"%s: %v", msg, err)
|
|
break
|
|
}
|
|
|
|
if err := signAndCheck(msg, tx, i, inputAmounts[i],
|
|
scriptPkScript, hashType,
|
|
mkGetKey(map[string]addressToKey{
|
|
address1.EncodeAddress(): {key1, true},
|
|
address2.EncodeAddress(): {key2, true},
|
|
}), mkGetScript(map[string][]byte{
|
|
scriptAddr.EncodeAddress(): pkScript,
|
|
}), nil); err != nil {
|
|
t.Error(err)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
// Two part multisig, sign with one key then the other.
|
|
for _, hashType := range hashTypes {
|
|
for i := range tx.TxIn {
|
|
msg := fmt.Sprintf("%d:%d", hashType, i)
|
|
|
|
key1, err := btcec.NewPrivateKey(btcec.S256())
|
|
if err != nil {
|
|
t.Errorf("failed to make privKey for %s: %v",
|
|
msg, err)
|
|
break
|
|
}
|
|
|
|
pk1 := (*btcec.PublicKey)(&key1.PublicKey).
|
|
SerializeCompressed()
|
|
address1, err := btcutil.NewAddressPubKey(pk1,
|
|
&chaincfg.TestNet3Params)
|
|
if err != nil {
|
|
t.Errorf("failed to make address for %s: %v",
|
|
msg, err)
|
|
break
|
|
}
|
|
|
|
key2, err := btcec.NewPrivateKey(btcec.S256())
|
|
if err != nil {
|
|
t.Errorf("failed to make privKey 2 for %s: %v",
|
|
msg, err)
|
|
break
|
|
}
|
|
|
|
pk2 := (*btcec.PublicKey)(&key2.PublicKey).
|
|
SerializeCompressed()
|
|
address2, err := btcutil.NewAddressPubKey(pk2,
|
|
&chaincfg.TestNet3Params)
|
|
if err != nil {
|
|
t.Errorf("failed to make address 2 for %s: %v",
|
|
msg, err)
|
|
break
|
|
}
|
|
|
|
pkScript, err := MultiSigScript(
|
|
[]*btcutil.AddressPubKey{address1, address2},
|
|
2)
|
|
if err != nil {
|
|
t.Errorf("failed to make pkscript "+
|
|
"for %s: %v", msg, err)
|
|
}
|
|
|
|
scriptAddr, err := btcutil.NewAddressScriptHash(
|
|
pkScript, &chaincfg.TestNet3Params)
|
|
if err != nil {
|
|
t.Errorf("failed to make p2sh addr for %s: %v",
|
|
msg, err)
|
|
break
|
|
}
|
|
|
|
scriptPkScript, err := PayToAddrScript(scriptAddr)
|
|
if err != nil {
|
|
t.Errorf("failed to make script pkscript for "+
|
|
"%s: %v", msg, err)
|
|
break
|
|
}
|
|
|
|
sigScript, err := SignTxOutput(&chaincfg.TestNet3Params,
|
|
tx, i, scriptPkScript, hashType,
|
|
mkGetKey(map[string]addressToKey{
|
|
address1.EncodeAddress(): {key1, true},
|
|
}), mkGetScript(map[string][]byte{
|
|
scriptAddr.EncodeAddress(): pkScript,
|
|
}), nil)
|
|
if err != nil {
|
|
t.Errorf("failed to sign output %s: %v", msg,
|
|
err)
|
|
break
|
|
}
|
|
|
|
// Only 1 out of 2 signed, this *should* fail.
|
|
if checkScripts(msg, tx, i, inputAmounts[i], sigScript,
|
|
scriptPkScript) == nil {
|
|
t.Errorf("part signed script valid for %s", msg)
|
|
break
|
|
}
|
|
|
|
// Sign with the other key and merge
|
|
sigScript, err = SignTxOutput(&chaincfg.TestNet3Params,
|
|
tx, i, scriptPkScript, hashType,
|
|
mkGetKey(map[string]addressToKey{
|
|
address2.EncodeAddress(): {key2, true},
|
|
}), mkGetScript(map[string][]byte{
|
|
scriptAddr.EncodeAddress(): pkScript,
|
|
}), sigScript)
|
|
if err != nil {
|
|
t.Errorf("failed to sign output %s: %v", msg, err)
|
|
break
|
|
}
|
|
|
|
err = checkScripts(msg, tx, i, inputAmounts[i], sigScript,
|
|
scriptPkScript)
|
|
if err != nil {
|
|
t.Errorf("fully signed script invalid for "+
|
|
"%s: %v", msg, err)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
// Two part multisig, sign with one key then both, check key dedup
|
|
// correctly.
|
|
for _, hashType := range hashTypes {
|
|
for i := range tx.TxIn {
|
|
msg := fmt.Sprintf("%d:%d", hashType, i)
|
|
|
|
key1, err := btcec.NewPrivateKey(btcec.S256())
|
|
if err != nil {
|
|
t.Errorf("failed to make privKey for %s: %v",
|
|
msg, err)
|
|
break
|
|
}
|
|
|
|
pk1 := (*btcec.PublicKey)(&key1.PublicKey).
|
|
SerializeCompressed()
|
|
address1, err := btcutil.NewAddressPubKey(pk1,
|
|
&chaincfg.TestNet3Params)
|
|
if err != nil {
|
|
t.Errorf("failed to make address for %s: %v",
|
|
msg, err)
|
|
break
|
|
}
|
|
|
|
key2, err := btcec.NewPrivateKey(btcec.S256())
|
|
if err != nil {
|
|
t.Errorf("failed to make privKey 2 for %s: %v",
|
|
msg, err)
|
|
break
|
|
}
|
|
|
|
pk2 := (*btcec.PublicKey)(&key2.PublicKey).
|
|
SerializeCompressed()
|
|
address2, err := btcutil.NewAddressPubKey(pk2,
|
|
&chaincfg.TestNet3Params)
|
|
if err != nil {
|
|
t.Errorf("failed to make address 2 for %s: %v",
|
|
msg, err)
|
|
break
|
|
}
|
|
|
|
pkScript, err := MultiSigScript(
|
|
[]*btcutil.AddressPubKey{address1, address2},
|
|
2)
|
|
if err != nil {
|
|
t.Errorf("failed to make pkscript "+
|
|
"for %s: %v", msg, err)
|
|
}
|
|
|
|
scriptAddr, err := btcutil.NewAddressScriptHash(
|
|
pkScript, &chaincfg.TestNet3Params)
|
|
if err != nil {
|
|
t.Errorf("failed to make p2sh addr for %s: %v",
|
|
msg, err)
|
|
break
|
|
}
|
|
|
|
scriptPkScript, err := PayToAddrScript(scriptAddr)
|
|
if err != nil {
|
|
t.Errorf("failed to make script pkscript for "+
|
|
"%s: %v", msg, err)
|
|
break
|
|
}
|
|
|
|
sigScript, err := SignTxOutput(&chaincfg.TestNet3Params,
|
|
tx, i, scriptPkScript, hashType,
|
|
mkGetKey(map[string]addressToKey{
|
|
address1.EncodeAddress(): {key1, true},
|
|
}), mkGetScript(map[string][]byte{
|
|
scriptAddr.EncodeAddress(): pkScript,
|
|
}), nil)
|
|
if err != nil {
|
|
t.Errorf("failed to sign output %s: %v", msg,
|
|
err)
|
|
break
|
|
}
|
|
|
|
// Only 1 out of 2 signed, this *should* fail.
|
|
if checkScripts(msg, tx, i, inputAmounts[i], sigScript,
|
|
scriptPkScript) == nil {
|
|
t.Errorf("part signed script valid for %s", msg)
|
|
break
|
|
}
|
|
|
|
// Sign with the other key and merge
|
|
sigScript, err = SignTxOutput(&chaincfg.TestNet3Params,
|
|
tx, i, scriptPkScript, hashType,
|
|
mkGetKey(map[string]addressToKey{
|
|
address1.EncodeAddress(): {key1, true},
|
|
address2.EncodeAddress(): {key2, true},
|
|
}), mkGetScript(map[string][]byte{
|
|
scriptAddr.EncodeAddress(): pkScript,
|
|
}), sigScript)
|
|
if err != nil {
|
|
t.Errorf("failed to sign output %s: %v", msg, err)
|
|
break
|
|
}
|
|
|
|
// Now we should pass.
|
|
err = checkScripts(msg, tx, i, inputAmounts[i],
|
|
sigScript, scriptPkScript)
|
|
if err != nil {
|
|
t.Errorf("fully signed script invalid for "+
|
|
"%s: %v", msg, err)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
type tstInput struct {
|
|
txout *wire.TxOut
|
|
sigscriptGenerates bool
|
|
inputValidates bool
|
|
indexOutOfRange bool
|
|
}
|
|
|
|
type tstSigScript struct {
|
|
name string
|
|
inputs []tstInput
|
|
hashType SigHashType
|
|
compress bool
|
|
scriptAtWrongIndex bool
|
|
}
|
|
|
|
var coinbaseOutPoint = &wire.OutPoint{
|
|
Index: (1 << 32) - 1,
|
|
}
|
|
|
|
// Pregenerated private key, with associated public key and pkScripts
|
|
// for the uncompressed and compressed hash160.
|
|
var (
|
|
privKeyD = []byte{0x6b, 0x0f, 0xd8, 0xda, 0x54, 0x22, 0xd0, 0xb7,
|
|
0xb4, 0xfc, 0x4e, 0x55, 0xd4, 0x88, 0x42, 0xb3, 0xa1, 0x65,
|
|
0xac, 0x70, 0x7f, 0x3d, 0xa4, 0x39, 0x5e, 0xcb, 0x3b, 0xb0,
|
|
0xd6, 0x0e, 0x06, 0x92}
|
|
pubkeyX = []byte{0xb2, 0x52, 0xf0, 0x49, 0x85, 0x78, 0x03, 0x03, 0xc8,
|
|
0x7d, 0xce, 0x51, 0x7f, 0xa8, 0x69, 0x0b, 0x91, 0x95, 0xf4,
|
|
0xf3, 0x5c, 0x26, 0x73, 0x05, 0x05, 0xa2, 0xee, 0xbc, 0x09,
|
|
0x38, 0x34, 0x3a}
|
|
pubkeyY = []byte{0xb7, 0xc6, 0x7d, 0xb2, 0xe1, 0xff, 0xc8, 0x43, 0x1f,
|
|
0x63, 0x32, 0x62, 0xaa, 0x60, 0xc6, 0x83, 0x30, 0xbd, 0x24,
|
|
0x7e, 0xef, 0xdb, 0x6f, 0x2e, 0x8d, 0x56, 0xf0, 0x3c, 0x9f,
|
|
0x6d, 0xb6, 0xf8}
|
|
uncompressedPkScript = []byte{0x76, 0xa9, 0x14, 0xd1, 0x7c, 0xb5,
|
|
0xeb, 0xa4, 0x02, 0xcb, 0x68, 0xe0, 0x69, 0x56, 0xbf, 0x32,
|
|
0x53, 0x90, 0x0e, 0x0a, 0x86, 0xc9, 0xfa, 0x88, 0xac}
|
|
compressedPkScript = []byte{0x76, 0xa9, 0x14, 0x27, 0x4d, 0x9f, 0x7f,
|
|
0x61, 0x7e, 0x7c, 0x7a, 0x1c, 0x1f, 0xb2, 0x75, 0x79, 0x10,
|
|
0x43, 0x65, 0x68, 0x27, 0x9d, 0x86, 0x88, 0xac}
|
|
shortPkScript = []byte{0x76, 0xa9, 0x14, 0xd1, 0x7c, 0xb5,
|
|
0xeb, 0xa4, 0x02, 0xcb, 0x68, 0xe0, 0x69, 0x56, 0xbf, 0x32,
|
|
0x53, 0x90, 0x0e, 0x0a, 0x88, 0xac}
|
|
uncompressedAddrStr = "1L6fd93zGmtzkK6CsZFVVoCwzZV3MUtJ4F"
|
|
compressedAddrStr = "14apLppt9zTq6cNw8SDfiJhk9PhkZrQtYZ"
|
|
)
|
|
|
|
// Pretend output amounts.
|
|
const coinbaseVal = 2500000000
|
|
const fee = 5000000
|
|
|
|
var sigScriptTests = []tstSigScript{
|
|
{
|
|
name: "one input uncompressed",
|
|
inputs: []tstInput{
|
|
{
|
|
txout: wire.NewTxOut(coinbaseVal, uncompressedPkScript),
|
|
sigscriptGenerates: true,
|
|
inputValidates: true,
|
|
indexOutOfRange: false,
|
|
},
|
|
},
|
|
hashType: SigHashAll,
|
|
compress: false,
|
|
scriptAtWrongIndex: false,
|
|
},
|
|
{
|
|
name: "two inputs uncompressed",
|
|
inputs: []tstInput{
|
|
{
|
|
txout: wire.NewTxOut(coinbaseVal, uncompressedPkScript),
|
|
sigscriptGenerates: true,
|
|
inputValidates: true,
|
|
indexOutOfRange: false,
|
|
},
|
|
{
|
|
txout: wire.NewTxOut(coinbaseVal+fee, uncompressedPkScript),
|
|
sigscriptGenerates: true,
|
|
inputValidates: true,
|
|
indexOutOfRange: false,
|
|
},
|
|
},
|
|
hashType: SigHashAll,
|
|
compress: false,
|
|
scriptAtWrongIndex: false,
|
|
},
|
|
{
|
|
name: "one input compressed",
|
|
inputs: []tstInput{
|
|
{
|
|
txout: wire.NewTxOut(coinbaseVal, compressedPkScript),
|
|
sigscriptGenerates: true,
|
|
inputValidates: true,
|
|
indexOutOfRange: false,
|
|
},
|
|
},
|
|
hashType: SigHashAll,
|
|
compress: true,
|
|
scriptAtWrongIndex: false,
|
|
},
|
|
{
|
|
name: "two inputs compressed",
|
|
inputs: []tstInput{
|
|
{
|
|
txout: wire.NewTxOut(coinbaseVal, compressedPkScript),
|
|
sigscriptGenerates: true,
|
|
inputValidates: true,
|
|
indexOutOfRange: false,
|
|
},
|
|
{
|
|
txout: wire.NewTxOut(coinbaseVal+fee, compressedPkScript),
|
|
sigscriptGenerates: true,
|
|
inputValidates: true,
|
|
indexOutOfRange: false,
|
|
},
|
|
},
|
|
hashType: SigHashAll,
|
|
compress: true,
|
|
scriptAtWrongIndex: false,
|
|
},
|
|
{
|
|
name: "hashType SigHashNone",
|
|
inputs: []tstInput{
|
|
{
|
|
txout: wire.NewTxOut(coinbaseVal, uncompressedPkScript),
|
|
sigscriptGenerates: true,
|
|
inputValidates: true,
|
|
indexOutOfRange: false,
|
|
},
|
|
},
|
|
hashType: SigHashNone,
|
|
compress: false,
|
|
scriptAtWrongIndex: false,
|
|
},
|
|
{
|
|
name: "hashType SigHashSingle",
|
|
inputs: []tstInput{
|
|
{
|
|
txout: wire.NewTxOut(coinbaseVal, uncompressedPkScript),
|
|
sigscriptGenerates: true,
|
|
inputValidates: true,
|
|
indexOutOfRange: false,
|
|
},
|
|
},
|
|
hashType: SigHashSingle,
|
|
compress: false,
|
|
scriptAtWrongIndex: false,
|
|
},
|
|
{
|
|
name: "hashType SigHashAnyoneCanPay",
|
|
inputs: []tstInput{
|
|
{
|
|
txout: wire.NewTxOut(coinbaseVal, uncompressedPkScript),
|
|
sigscriptGenerates: true,
|
|
inputValidates: true,
|
|
indexOutOfRange: false,
|
|
},
|
|
},
|
|
hashType: SigHashAnyOneCanPay,
|
|
compress: false,
|
|
scriptAtWrongIndex: false,
|
|
},
|
|
{
|
|
name: "hashType non-standard",
|
|
inputs: []tstInput{
|
|
{
|
|
txout: wire.NewTxOut(coinbaseVal, uncompressedPkScript),
|
|
sigscriptGenerates: true,
|
|
inputValidates: true,
|
|
indexOutOfRange: false,
|
|
},
|
|
},
|
|
hashType: 0x04,
|
|
compress: false,
|
|
scriptAtWrongIndex: false,
|
|
},
|
|
{
|
|
name: "invalid compression",
|
|
inputs: []tstInput{
|
|
{
|
|
txout: wire.NewTxOut(coinbaseVal, uncompressedPkScript),
|
|
sigscriptGenerates: true,
|
|
inputValidates: false,
|
|
indexOutOfRange: false,
|
|
},
|
|
},
|
|
hashType: SigHashAll,
|
|
compress: true,
|
|
scriptAtWrongIndex: false,
|
|
},
|
|
{
|
|
name: "short PkScript",
|
|
inputs: []tstInput{
|
|
{
|
|
txout: wire.NewTxOut(coinbaseVal, shortPkScript),
|
|
sigscriptGenerates: false,
|
|
indexOutOfRange: false,
|
|
},
|
|
},
|
|
hashType: SigHashAll,
|
|
compress: false,
|
|
scriptAtWrongIndex: false,
|
|
},
|
|
{
|
|
name: "valid script at wrong index",
|
|
inputs: []tstInput{
|
|
{
|
|
txout: wire.NewTxOut(coinbaseVal, uncompressedPkScript),
|
|
sigscriptGenerates: true,
|
|
inputValidates: true,
|
|
indexOutOfRange: false,
|
|
},
|
|
{
|
|
txout: wire.NewTxOut(coinbaseVal+fee, uncompressedPkScript),
|
|
sigscriptGenerates: true,
|
|
inputValidates: true,
|
|
indexOutOfRange: false,
|
|
},
|
|
},
|
|
hashType: SigHashAll,
|
|
compress: false,
|
|
scriptAtWrongIndex: true,
|
|
},
|
|
{
|
|
name: "index out of range",
|
|
inputs: []tstInput{
|
|
{
|
|
txout: wire.NewTxOut(coinbaseVal, uncompressedPkScript),
|
|
sigscriptGenerates: true,
|
|
inputValidates: true,
|
|
indexOutOfRange: false,
|
|
},
|
|
{
|
|
txout: wire.NewTxOut(coinbaseVal+fee, uncompressedPkScript),
|
|
sigscriptGenerates: true,
|
|
inputValidates: true,
|
|
indexOutOfRange: false,
|
|
},
|
|
},
|
|
hashType: SigHashAll,
|
|
compress: false,
|
|
scriptAtWrongIndex: true,
|
|
},
|
|
}
|
|
|
|
// Test the sigscript generation for valid and invalid inputs, all
|
|
// hashTypes, and with and without compression. This test creates
|
|
// sigscripts to spend fake coinbase inputs, as sigscripts cannot be
|
|
// created for the MsgTxs in txTests, since they come from the blockchain
|
|
// and we don't have the private keys.
|
|
func TestSignatureScript(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
privKey, _ := btcec.PrivKeyFromBytes(btcec.S256(), privKeyD)
|
|
|
|
nexttest:
|
|
for i := range sigScriptTests {
|
|
tx := wire.NewMsgTx(wire.TxVersion)
|
|
|
|
output := wire.NewTxOut(500, []byte{OP_RETURN})
|
|
tx.AddTxOut(output)
|
|
|
|
for range sigScriptTests[i].inputs {
|
|
txin := wire.NewTxIn(coinbaseOutPoint, nil, nil)
|
|
tx.AddTxIn(txin)
|
|
}
|
|
|
|
var script []byte
|
|
var err error
|
|
for j := range tx.TxIn {
|
|
var idx int
|
|
if sigScriptTests[i].inputs[j].indexOutOfRange {
|
|
t.Errorf("at test %v", sigScriptTests[i].name)
|
|
idx = len(sigScriptTests[i].inputs)
|
|
} else {
|
|
idx = j
|
|
}
|
|
script, err = SignatureScript(tx, idx,
|
|
sigScriptTests[i].inputs[j].txout.PkScript,
|
|
sigScriptTests[i].hashType, privKey,
|
|
sigScriptTests[i].compress)
|
|
|
|
if (err == nil) != sigScriptTests[i].inputs[j].sigscriptGenerates {
|
|
if err == nil {
|
|
t.Errorf("passed test '%v' incorrectly",
|
|
sigScriptTests[i].name)
|
|
} else {
|
|
t.Errorf("failed test '%v': %v",
|
|
sigScriptTests[i].name, err)
|
|
}
|
|
continue nexttest
|
|
}
|
|
if !sigScriptTests[i].inputs[j].sigscriptGenerates {
|
|
// done with this test
|
|
continue nexttest
|
|
}
|
|
|
|
tx.TxIn[j].SignatureScript = script
|
|
}
|
|
|
|
// If testing using a correct sigscript but for an incorrect
|
|
// index, use last input script for first input. Requires > 0
|
|
// inputs for test.
|
|
if sigScriptTests[i].scriptAtWrongIndex {
|
|
tx.TxIn[0].SignatureScript = script
|
|
sigScriptTests[i].inputs[0].inputValidates = false
|
|
}
|
|
|
|
// Validate tx input scripts
|
|
scriptFlags := ScriptBip16 | ScriptVerifyDERSignatures
|
|
for j := range tx.TxIn {
|
|
vm, err := NewEngine(sigScriptTests[i].
|
|
inputs[j].txout.PkScript, tx, j, scriptFlags, nil, nil, 0)
|
|
if err != nil {
|
|
t.Errorf("cannot create script vm for test %v: %v",
|
|
sigScriptTests[i].name, err)
|
|
continue nexttest
|
|
}
|
|
err = vm.Execute()
|
|
if (err == nil) != sigScriptTests[i].inputs[j].inputValidates {
|
|
if err == nil {
|
|
t.Errorf("passed test '%v' validation incorrectly: %v",
|
|
sigScriptTests[i].name, err)
|
|
} else {
|
|
t.Errorf("failed test '%v' validation: %v",
|
|
sigScriptTests[i].name, err)
|
|
}
|
|
continue nexttest
|
|
}
|
|
}
|
|
}
|
|
}
|