2 # Copyright (c) 2014-2016 The Bitcoin Core developers
3 # Distributed under the MIT software license, see the accompanying
4 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
5 """Test logic for skipping signature validation on old blocks.
7 Test logic for skipping signature validation on blocks which we've assumed
8 valid (https://github.com/bitcoin/bitcoin/pull/9484)
10 We build a chain that includes and invalid signature for one of the
14 1: block 1 with coinbase transaction output.
15 2-101: bury that block with 100 blocks so the coinbase transaction
17 102: a block containing a transaction spending the coinbase
18 transaction output. The transaction has an invalid signature.
19 103-2202: bury the bad block with just over two weeks' worth of blocks
24 - node0 has no -assumevalid parameter. Try to sync to block 2202. It will
25 reject block 102 and only sync as far as block 101
26 - node1 has -assumevalid set to the hash of block 102. Try to sync to
27 block 2202. node1 will sync all the way to block 2202.
28 - node2 has -assumevalid set to the hash of block 102. Try to sync to
29 block 200. node2 will reject block 102 since it's assumed valid, but it
30 isn't buried by at least two weeks' work.
34 from test_framework
.blocktools
import (create_block
, create_coinbase
)
35 from test_framework
.key
import CECKey
36 from test_framework
.mininode
import (CBlockHeader
,
46 from test_framework
.script
import (CScript
, OP_TRUE
)
47 from test_framework
.test_framework
import BitcoinTestFramework
48 from test_framework
.util
import (p2p_port
, assert_equal
)
50 class BaseNode(NodeConnCB
):
51 def send_header_for_blocks(self
, new_blocks
):
52 headers_message
= msg_headers()
53 headers_message
.headers
= [CBlockHeader(b
) for b
in new_blocks
]
54 self
.send_message(headers_message
)
56 class AssumeValidTest(BitcoinTestFramework
):
59 self
.setup_clean_chain
= True
62 def setup_network(self
):
64 # Start node0. We don't start the other nodes yet since
65 # we need to pre-mine a block with an invalid transaction
66 # signature so we can pass in the block hash as assumevalid.
69 def send_blocks_until_disconnected(self
, node
):
70 """Keep sending blocks to the node until we're disconnected."""
71 for i
in range(len(self
.blocks
)):
73 node
.send_message(msg_block(self
.blocks
[i
]))
75 assert str(e
) == 'Not connected, no pushbuf'
78 def assert_blockchain_height(self
, node
, height
):
79 """Wait until the blockchain is no longer advancing and verify it's reached the expected height."""
80 last_height
= node
.getblock(node
.getbestblockhash())['height']
84 current_height
= node
.getblock(node
.getbestblockhash())['height']
85 if current_height
!= last_height
:
86 last_height
= current_height
88 assert False, "blockchain too short after timeout: %d" % current_height
91 elif current_height
> height
:
92 assert False, "blockchain too long: %d" % current_height
93 elif current_height
== height
:
101 connections
.append(NodeConn('127.0.0.1', p2p_port(0), self
.nodes
[0], node0
))
102 node0
.add_connection(connections
[0])
104 NetworkThread().start() # Start up network handling in another thread
105 node0
.wait_for_verack()
107 # Build the blockchain
108 self
.tip
= int(self
.nodes
[0].getbestblockhash(), 16)
109 self
.block_time
= self
.nodes
[0].getblock(self
.nodes
[0].getbestblockhash())['time'] + 1
113 # Get a pubkey for the coinbase TXO
114 coinbase_key
= CECKey()
115 coinbase_key
.set_secretbytes(b
"horsebattery")
116 coinbase_pubkey
= coinbase_key
.get_pubkey()
118 # Create the first block with a coinbase output to our key
120 block
= create_block(self
.tip
, create_coinbase(height
, coinbase_pubkey
), self
.block_time
)
121 self
.blocks
.append(block
)
124 # Save the coinbase for later
126 self
.tip
= block
.sha256
129 # Bury the block 100 deep so the coinbase output is spendable
131 block
= create_block(self
.tip
, create_coinbase(height
), self
.block_time
)
133 self
.blocks
.append(block
)
134 self
.tip
= block
.sha256
138 # Create a transaction spending the coinbase output with an invalid (null) signature
140 tx
.vin
.append(CTxIn(COutPoint(self
.block1
.vtx
[0].sha256
, 0), scriptSig
=b
""))
141 tx
.vout
.append(CTxOut(49 * 100000000, CScript([OP_TRUE
])))
144 block102
= create_block(self
.tip
, create_coinbase(height
), self
.block_time
)
146 block102
.vtx
.extend([tx
])
147 block102
.hashMerkleRoot
= block102
.calc_merkle_root()
150 self
.blocks
.append(block102
)
151 self
.tip
= block102
.sha256
155 # Bury the assumed valid block 2100 deep
156 for i
in range(2100):
157 block
= create_block(self
.tip
, create_coinbase(height
), self
.block_time
)
160 self
.blocks
.append(block
)
161 self
.tip
= block
.sha256
165 # Start node1 and node2 with assumevalid so they accept a block with a bad signature.
166 self
.start_node(1, extra_args
=["-assumevalid=" + hex(block102
.sha256
)])
167 node1
= BaseNode() # connects to node1
168 connections
.append(NodeConn('127.0.0.1', p2p_port(1), self
.nodes
[1], node1
))
169 node1
.add_connection(connections
[1])
170 node1
.wait_for_verack()
172 self
.start_node(2, extra_args
=["-assumevalid=" + hex(block102
.sha256
)])
173 node2
= BaseNode() # connects to node2
174 connections
.append(NodeConn('127.0.0.1', p2p_port(2), self
.nodes
[2], node2
))
175 node2
.add_connection(connections
[2])
176 node2
.wait_for_verack()
178 # send header lists to all three nodes
179 node0
.send_header_for_blocks(self
.blocks
[0:2000])
180 node0
.send_header_for_blocks(self
.blocks
[2000:])
181 node1
.send_header_for_blocks(self
.blocks
[0:2000])
182 node1
.send_header_for_blocks(self
.blocks
[2000:])
183 node2
.send_header_for_blocks(self
.blocks
[0:200])
185 # Send blocks to node0. Block 102 will be rejected.
186 self
.send_blocks_until_disconnected(node0
)
187 self
.assert_blockchain_height(self
.nodes
[0], 101)
189 # Send all blocks to node1. All blocks will be accepted.
190 for i
in range(2202):
191 node1
.send_message(msg_block(self
.blocks
[i
]))
192 # Syncing 2200 blocks can take a while on slow systems. Give it plenty of time to sync.
193 node1
.sync_with_ping(120)
194 assert_equal(self
.nodes
[1].getblock(self
.nodes
[1].getbestblockhash())['height'], 2202)
196 # Send blocks to node2. Block 102 will be rejected.
197 self
.send_blocks_until_disconnected(node2
)
198 self
.assert_blockchain_height(self
.nodes
[2], 101)
200 if __name__
== '__main__':
201 AssumeValidTest().main()