|
| 1 | +#!/usr/bin/env python3 |
| 2 | +# Copyright (c) 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 | + |
| 6 | +""" |
| 7 | +Test that an attacker can't degrade compact block relay by sending unsolicited |
| 8 | +mutated blocks to clear in-flight blocktxn requests from other honest peers. |
| 9 | +""" |
| 10 | + |
| 11 | +from test_framework.p2p import P2PInterface |
| 12 | +from test_framework.messages import ( |
| 13 | + BlockTransactions, |
| 14 | + msg_cmpctblock, |
| 15 | + msg_block, |
| 16 | + msg_blocktxn, |
| 17 | + HeaderAndShortIDs, |
| 18 | +) |
| 19 | +from test_framework.test_framework import BitcoinTestFramework |
| 20 | +from test_framework.blocktools import ( |
| 21 | + COINBASE_MATURITY, |
| 22 | + create_block, |
| 23 | + NORMAL_GBT_REQUEST_PARAMS, |
| 24 | +) |
| 25 | +from test_framework.util import assert_equal |
| 26 | +from test_framework.wallet import MiniWallet |
| 27 | +import copy |
| 28 | + |
| 29 | +class MutatedBlocksTest(BitcoinTestFramework): |
| 30 | + def set_test_params(self): |
| 31 | + self.setup_clean_chain = True |
| 32 | + self.num_nodes = 1 |
| 33 | + |
| 34 | + def run_test(self): |
| 35 | + self.wallet = MiniWallet(self.nodes[0]) |
| 36 | + self.generate(self.wallet, COINBASE_MATURITY) |
| 37 | + |
| 38 | + honest_relayer = self.nodes[0].add_outbound_p2p_connection(P2PInterface(), p2p_idx=0, connection_type="outbound-full-relay") |
| 39 | + attacker = self.nodes[0].add_p2p_connection(P2PInterface()) |
| 40 | + |
| 41 | + # Create new block with two transactions (coinbase + 1 self-transfer). |
| 42 | + # The self-transfer transaction is needed to trigger a compact block |
| 43 | + # `getblocktxn` roundtrip. |
| 44 | + tx = self.wallet.create_self_transfer()["tx"] |
| 45 | + block = create_block(tmpl=self.nodes[0].getblocktemplate(NORMAL_GBT_REQUEST_PARAMS), txlist=[tx]) |
| 46 | + block.solve() |
| 47 | + |
| 48 | + # Create mutated version of the block by changing the transaction |
| 49 | + # version on the self-transfer. Dash has no witness data, so mutating a |
| 50 | + # transaction (which changes its hash and hence the block's merkle root) |
| 51 | + # is what trips the mutation check. |
| 52 | + mutated_block = copy.deepcopy(block) |
| 53 | + mutated_block.vtx[1].nVersion = 4 |
| 54 | + |
| 55 | + # Announce the new block via a compact block through the honest relayer |
| 56 | + cmpctblock = HeaderAndShortIDs() |
| 57 | + cmpctblock.initialize_from_block(block) |
| 58 | + honest_relayer.send_message(msg_cmpctblock(cmpctblock.to_p2p())) |
| 59 | + |
| 60 | + # Wait for a `getblocktxn` that attempts to fetch the self-transfer |
| 61 | + def self_transfer_requested(): |
| 62 | + if not honest_relayer.last_message.get('getblocktxn'): |
| 63 | + return False |
| 64 | + |
| 65 | + get_block_txn = honest_relayer.last_message['getblocktxn'] |
| 66 | + return ( |
| 67 | + get_block_txn.block_txn_request.blockhash == block.sha256 |
| 68 | + and get_block_txn.block_txn_request.indexes == [1] |
| 69 | + ) |
| 70 | + honest_relayer.wait_until(self_transfer_requested, timeout=5) |
| 71 | + |
| 72 | + # Block at height 101 should be the only one in flight from peer 0 |
| 73 | + peer_info_prior_to_attack = self.nodes[0].getpeerinfo() |
| 74 | + assert_equal(peer_info_prior_to_attack[0]['id'], 0) |
| 75 | + assert_equal([101], peer_info_prior_to_attack[0]["inflight"]) |
| 76 | + |
| 77 | + # Attempt to clear the honest relayer's download request by sending the |
| 78 | + # mutated block (as the attacker). |
| 79 | + with self.nodes[0].assert_debug_log(expected_msgs=["Block mutated: bad-txnmrklroot, hashMerkleRoot mismatch"]): |
| 80 | + attacker.send_message(msg_block(mutated_block)) |
| 81 | + # Attacker should get disconnected for sending a mutated block |
| 82 | + attacker.wait_for_disconnect(timeout=5) |
| 83 | + |
| 84 | + # Block at height 101 should *still* be the only block in-flight from |
| 85 | + # peer 0 |
| 86 | + peer_info_after_attack = self.nodes[0].getpeerinfo() |
| 87 | + assert_equal(peer_info_after_attack[0]['id'], 0) |
| 88 | + assert_equal([101], peer_info_after_attack[0]["inflight"]) |
| 89 | + |
| 90 | + # The honest relayer should be able to complete relaying the block by |
| 91 | + # sending the blocktxn that was requested. |
| 92 | + block_txn = msg_blocktxn() |
| 93 | + block_txn.block_transactions = BlockTransactions(blockhash=block.sha256, transactions=[tx]) |
| 94 | + honest_relayer.send_and_ping(block_txn) |
| 95 | + assert_equal(int(self.nodes[0].getbestblockhash(), 16), block.sha256) |
| 96 | + |
| 97 | + |
| 98 | +if __name__ == '__main__': |
| 99 | + MutatedBlocksTest().main() |
0 commit comments