test/functional/p2p-leaktests.py

   1 #!/usr/bin/env python3
   2 # Copyright (c) 2017 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 message sending before handshake completion.
   6
   7 A node should never send anything other than VERSION/VERACK/REJECT until it's
   8 received a VERACK.
   9
  10 This test connects to a node and sends it a few messages, trying to intice it
  11 into sending us something it shouldn't.
  12
  13 Also test that nodes that send unsupported service bits to bitcoind are disconnected
  14 and don't receive a VERACK. Unsupported service bits are currently 1 << 5 and
  15 1 << 7 (until August 1st 2018)."""
  16
  17 from test_framework.mininode import *
  18 from test_framework.test_framework import BitcoinTestFramework
  19 from test_framework.util import *
  20
  21 banscore = 10
  22
  23 class CLazyNode(NodeConnCB):
  24     def __init__(self):
  25         super().__init__()
  26         self.unexpected_msg = False
  27         self.ever_connected = False
  28
  29     def bad_message(self, message):
  30         self.unexpected_msg = True
  31         self.log.info("should not have received message: %s" % message.command)
  32
  33     def on_open(self, conn):
  34         self.connected = True
  35         self.ever_connected = True
  36
  37     def on_version(self, conn, message): self.bad_message(message)
  38     def on_verack(self, conn, message): self.bad_message(message)
  39     def on_reject(self, conn, message): self.bad_message(message)
  40     def on_inv(self, conn, message): self.bad_message(message)
  41     def on_addr(self, conn, message): self.bad_message(message)
  42     def on_alert(self, conn, message): self.bad_message(message)
  43     def on_getdata(self, conn, message): self.bad_message(message)
  44     def on_getblocks(self, conn, message): self.bad_message(message)
  45     def on_tx(self, conn, message): self.bad_message(message)
  46     def on_block(self, conn, message): self.bad_message(message)
  47     def on_getaddr(self, conn, message): self.bad_message(message)
  48     def on_headers(self, conn, message): self.bad_message(message)
  49     def on_getheaders(self, conn, message): self.bad_message(message)
  50     def on_ping(self, conn, message): self.bad_message(message)
  51     def on_mempool(self, conn): self.bad_message(message)
  52     def on_pong(self, conn, message): self.bad_message(message)
  53     def on_feefilter(self, conn, message): self.bad_message(message)
  54     def on_sendheaders(self, conn, message): self.bad_message(message)
  55     def on_sendcmpct(self, conn, message): self.bad_message(message)
  56     def on_cmpctblock(self, conn, message): self.bad_message(message)
  57     def on_getblocktxn(self, conn, message): self.bad_message(message)
  58     def on_blocktxn(self, conn, message): self.bad_message(message)
  59
  60 # Node that never sends a version. We'll use this to send a bunch of messages
  61 # anyway, and eventually get disconnected.
  62 class CNodeNoVersionBan(CLazyNode):
  63     # send a bunch of veracks without sending a message. This should get us disconnected.
  64     # NOTE: implementation-specific check here. Remove if bitcoind ban behavior changes
  65     def on_open(self, conn):
  66         super().on_open(conn)
  67         for i in range(banscore):
  68             self.send_message(msg_verack())
  69
  70     def on_reject(self, conn, message): pass
  71
  72 # Node that never sends a version. This one just sits idle and hopes to receive
  73 # any message (it shouldn't!)
  74 class CNodeNoVersionIdle(CLazyNode):
  75     def __init__(self):
  76         super().__init__()
  77
  78 # Node that sends a version but not a verack.
  79 class CNodeNoVerackIdle(CLazyNode):
  80     def __init__(self):
  81         self.version_received = False
  82         super().__init__()
  83
  84     def on_reject(self, conn, message): pass
  85     def on_verack(self, conn, message): pass
  86     # When version is received, don't reply with a verack. Instead, see if the
  87     # node will give us a message that it shouldn't. This is not an exhaustive
  88     # list!
  89     def on_version(self, conn, message):
  90         self.version_received = True
  91         conn.send_message(msg_ping())
  92         conn.send_message(msg_getaddr())
  93
  94 class P2PLeakTest(BitcoinTestFramework):
  95     def set_test_params(self):
  96         self.num_nodes = 1
  97         self.extra_args = [['-banscore='+str(banscore)]]
  98
  99     def run_test(self):
 100         no_version_bannode = CNodeNoVersionBan()
 101         no_version_idlenode = CNodeNoVersionIdle()
 102         no_verack_idlenode = CNodeNoVerackIdle()
 103         unsupported_service_bit5_node = CLazyNode()
 104         unsupported_service_bit7_node = CLazyNode()
 105
 106         self.nodes[0].setmocktime(1501545600)  # August 1st 2017
 107         connections = []
 108         connections.append(NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], no_version_bannode, send_version=False))
 109         connections.append(NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], no_version_idlenode, send_version=False))
 110         connections.append(NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], no_verack_idlenode))
 111         connections.append(NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], unsupported_service_bit5_node, services=NODE_NETWORK|NODE_UNSUPPORTED_SERVICE_BIT_5))
 112         connections.append(NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], unsupported_service_bit7_node, services=NODE_NETWORK|NODE_UNSUPPORTED_SERVICE_BIT_7))
 113         no_version_bannode.add_connection(connections[0])
 114         no_version_idlenode.add_connection(connections[1])
 115         no_verack_idlenode.add_connection(connections[2])
 116         unsupported_service_bit5_node.add_connection(connections[3])
 117         unsupported_service_bit7_node.add_connection(connections[4])
 118
 119         NetworkThread().start()  # Start up network handling in another thread
 120
 121         wait_until(lambda: no_version_bannode.ever_connected, timeout=10, lock=mininode_lock)
 122         wait_until(lambda: no_version_idlenode.ever_connected, timeout=10, lock=mininode_lock)
 123         wait_until(lambda: no_verack_idlenode.version_received, timeout=10, lock=mininode_lock)
 124         wait_until(lambda: unsupported_service_bit5_node.ever_connected, timeout=10, lock=mininode_lock)
 125         wait_until(lambda: unsupported_service_bit7_node.ever_connected, timeout=10, lock=mininode_lock)
 126
 127         # Mine a block and make sure that it's not sent to the connected nodes
 128         self.nodes[0].generate(1)
 129
 130         #Give the node enough time to possibly leak out a message
 131         time.sleep(5)
 132
 133         #This node should have been banned
 134         assert not no_version_bannode.connected
 135
 136         # These nodes should have been disconnected
 137         assert not unsupported_service_bit5_node.connected
 138         assert not unsupported_service_bit7_node.connected
 139
 140         [conn.disconnect_node() for conn in connections]
 141
 142         # Make sure no unexpected messages came in
 143         assert(no_version_bannode.unexpected_msg == False)
 144         assert(no_version_idlenode.unexpected_msg == False)
 145         assert(no_verack_idlenode.unexpected_msg == False)
 146         assert not unsupported_service_bit5_node.unexpected_msg
 147         assert not unsupported_service_bit7_node.unexpected_msg
 148
 149         self.log.info("Service bits 5 and 7 are allowed after August 1st 2018")
 150         self.nodes[0].setmocktime(1533168000)  # August 2nd 2018
 151
 152         allowed_service_bit5_node = NodeConnCB()
 153         allowed_service_bit7_node = NodeConnCB()
 154
 155         connections.append(NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], allowed_service_bit5_node, services=NODE_NETWORK|NODE_UNSUPPORTED_SERVICE_BIT_5))
 156         connections.append(NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], allowed_service_bit7_node, services=NODE_NETWORK|NODE_UNSUPPORTED_SERVICE_BIT_7))
 157         allowed_service_bit5_node.add_connection(connections[5])
 158         allowed_service_bit7_node.add_connection(connections[6])
 159
 160         wait_until(lambda: allowed_service_bit5_node.message_count["verack"], timeout=10, lock=mininode_lock)
 161         wait_until(lambda: allowed_service_bit7_node.message_count["verack"], timeout=10, lock=mininode_lock)
 162
 163 if __name__ == '__main__':
 164     P2PLeakTest().main()