test/functional/assumevalid.py

   1 #!/usr/bin/env python3
   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.
   6
   7 Test logic for skipping signature validation on blocks which we've assumed
   8 valid (https://github.com/bitcoin/bitcoin/pull/9484)
   9
  10 We build a chain that includes and invalid signature for one of the
  11 transactions:
  12
  13     0:        genesis block
  14     1:        block 1 with coinbase transaction output.
  15     2-101:    bury that block with 100 blocks so the coinbase transaction
  16               output can be spent
  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
  20               (2100 blocks)
  21
  22 Start three nodes:
  23
  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.
  31 """
  32 import time
  33
  34 from test_framework.blocktools import (create_block, create_coinbase)
  35 from test_framework.key import CECKey
  36 from test_framework.mininode import (CBlockHeader,
  37                                      COutPoint,
  38                                      CTransaction,
  39                                      CTxIn,
  40                                      CTxOut,
  41                                      NetworkThread,
  42                                      P2PInterface,
  43                                      msg_block,
  44                                      msg_headers)
  45 from test_framework.script import (CScript, OP_TRUE)
  46 from test_framework.test_framework import BitcoinTestFramework
  47 from test_framework.util import assert_equal
  48
  49 class BaseNode(P2PInterface):
  50     def send_header_for_blocks(self, new_blocks):
  51         headers_message = msg_headers()
  52         headers_message.headers = [CBlockHeader(b) for b in new_blocks]
  53         self.send_message(headers_message)
  54
  55 class AssumeValidTest(BitcoinTestFramework):
  56     def set_test_params(self):
  57         self.setup_clean_chain = True
  58         self.num_nodes = 3
  59
  60     def setup_network(self):
  61         self.add_nodes(3)
  62         # Start node0. We don't start the other nodes yet since
  63         # we need to pre-mine a block with an invalid transaction
  64         # signature so we can pass in the block hash as assumevalid.
  65         self.start_node(0)
  66
  67     def send_blocks_until_disconnected(self, p2p_conn):
  68         """Keep sending blocks to the node until we're disconnected."""
  69         for i in range(len(self.blocks)):
  70             if p2p_conn.state != "connected":
  71                 break
  72             try:
  73                 p2p_conn.send_message(msg_block(self.blocks[i]))
  74             except IOError as e:
  75                 assert str(e) == 'Not connected, no pushbuf'
  76                 break
  77
  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']
  81         timeout = 10
  82         while True:
  83             time.sleep(0.25)
  84             current_height = node.getblock(node.getbestblockhash())['height']
  85             if current_height != last_height:
  86                 last_height = current_height
  87                 if timeout < 0:
  88                     assert False, "blockchain too short after timeout: %d" % current_height
  89                 timeout - 0.25
  90                 continue
  91             elif current_height > height:
  92                 assert False, "blockchain too long: %d" % current_height
  93             elif current_height == height:
  94                 break
  95
  96     def run_test(self):
  97
  98         # Connect to node0
  99         p2p0 = self.nodes[0].add_p2p_connection(BaseNode())
 100
 101         NetworkThread().start()  # Start up network handling in another thread
 102         self.nodes[0].p2p.wait_for_verack()
 103
 104         # Build the blockchain
 105         self.tip = int(self.nodes[0].getbestblockhash(), 16)
 106         self.block_time = self.nodes[0].getblock(self.nodes[0].getbestblockhash())['time'] + 1
 107
 108         self.blocks = []
 109
 110         # Get a pubkey for the coinbase TXO
 111         coinbase_key = CECKey()
 112         coinbase_key.set_secretbytes(b"horsebattery")
 113         coinbase_pubkey = coinbase_key.get_pubkey()
 114
 115         # Create the first block with a coinbase output to our key
 116         height = 1
 117         block = create_block(self.tip, create_coinbase(height, coinbase_pubkey), self.block_time)
 118         self.blocks.append(block)
 119         self.block_time += 1
 120         block.solve()
 121         # Save the coinbase for later
 122         self.block1 = block
 123         self.tip = block.sha256
 124         height += 1
 125
 126         # Bury the block 100 deep so the coinbase output is spendable
 127         for i in range(100):
 128             block = create_block(self.tip, create_coinbase(height), self.block_time)
 129             block.solve()
 130             self.blocks.append(block)
 131             self.tip = block.sha256
 132             self.block_time += 1
 133             height += 1
 134
 135         # Create a transaction spending the coinbase output with an invalid (null) signature
 136         tx = CTransaction()
 137         tx.vin.append(CTxIn(COutPoint(self.block1.vtx[0].sha256, 0), scriptSig=b""))
 138         tx.vout.append(CTxOut(49 * 100000000, CScript([OP_TRUE])))
 139         tx.calc_sha256()
 140
 141         block102 = create_block(self.tip, create_coinbase(height), self.block_time)
 142         self.block_time += 1
 143         block102.vtx.extend([tx])
 144         block102.hashMerkleRoot = block102.calc_merkle_root()
 145         block102.rehash()
 146         block102.solve()
 147         self.blocks.append(block102)
 148         self.tip = block102.sha256
 149         self.block_time += 1
 150         height += 1
 151
 152         # Bury the assumed valid block 2100 deep
 153         for i in range(2100):
 154             block = create_block(self.tip, create_coinbase(height), self.block_time)
 155             block.nVersion = 4
 156             block.solve()
 157             self.blocks.append(block)
 158             self.tip = block.sha256
 159             self.block_time += 1
 160             height += 1
 161
 162         # Start node1 and node2 with assumevalid so they accept a block with a bad signature.
 163         self.start_node(1, extra_args=["-assumevalid=" + hex(block102.sha256)])
 164         p2p1 = self.nodes[1].add_p2p_connection(BaseNode())
 165         p2p1.wait_for_verack()
 166
 167         self.start_node(2, extra_args=["-assumevalid=" + hex(block102.sha256)])
 168         p2p2 = self.nodes[2].add_p2p_connection(BaseNode())
 169         p2p2.wait_for_verack()
 170
 171         # send header lists to all three nodes
 172         p2p0.send_header_for_blocks(self.blocks[0:2000])
 173         p2p0.send_header_for_blocks(self.blocks[2000:])
 174         p2p1.send_header_for_blocks(self.blocks[0:2000])
 175         p2p1.send_header_for_blocks(self.blocks[2000:])
 176         p2p2.send_header_for_blocks(self.blocks[0:200])
 177
 178         # Send blocks to node0. Block 102 will be rejected.
 179         self.send_blocks_until_disconnected(p2p0)
 180         self.assert_blockchain_height(self.nodes[0], 101)
 181
 182         # Send all blocks to node1. All blocks will be accepted.
 183         for i in range(2202):
 184             p2p1.send_message(msg_block(self.blocks[i]))
 185         # Syncing 2200 blocks can take a while on slow systems. Give it plenty of time to sync.
 186         p2p1.sync_with_ping(120)
 187         assert_equal(self.nodes[1].getblock(self.nodes[1].getbestblockhash())['height'], 2202)
 188
 189         # Send blocks to node2. Block 102 will be rejected.
 190         self.send_blocks_until_disconnected(p2p2)
 191         self.assert_blockchain_height(self.nodes[2], 101)
 192
 193 if __name__ == '__main__':
 194     AssumeValidTest().main()