Inside Bitcoin

251                # this should be added:
252                now_hex +  # time
253                '01' +     # service flags, COMPACTSIZE(NODE_NETWORK)
254                '01' +     # network type (IPv4)
255                '04' +     # address length (COMPACTSIZE(4))
256                '09' * 4 + # address
257                '208d'))   # port
258
259    def test_oversized_msg(self, msg, size):
260        msg_type = msg.msgtype.decode('ascii')
261        self.log.info("Test {} message of size {} is logged as misbehaving".format(msg_type, size))
262        with self.nodes[0].assert_debug_log(['Misbehaving', '{} message size = {}'.format(msg_type, size)]):
263            conn = self.nodes[0].add_p2p_connection(P2PInterface())
264            conn.send_without_ping(msg)
265            conn.wait_for_disconnect()
266        self.nodes[0].disconnect_p2ps()
267
268    def test_oversized_inv_msg(self):
269        size = MAX_INV_SIZE + 1
270        self.test_oversized_msg(msg_inv([CInv(MSG_TX, 1)] * size), size)
271
272    def test_oversized_getdata_msg(self):
273        size = MAX_INV_SIZE + 1
274        self.test_oversized_msg(msg_getdata([CInv(MSG_TX, 1)] * size), size)
275
276    def test_oversized_headers_msg(self):
277        size = MAX_HEADERS_RESULTS + 1
278        self.test_oversized_msg(msg_headers([CBlockHeader()] * size), size)
279
280    def test_invalid_pow_headers_msg(self):
281        self.log.info("Test headers message with invalid proof-of-work is logged as misbehaving and disconnects peer")
282        blockheader_tip_hash = self.nodes[0].getbestblockhash()
283        blockheader_tip = from_hex(CBlockHeader(), self.nodes[0].getblockheader(blockheader_tip_hash, False))
284
285        # send valid headers message first
286        assert_equal(self.nodes[0].getblockchaininfo()['headers'], 0)
287        blockheader = CBlockHeader()
288        blockheader.hashPrevBlock = int(blockheader_tip_hash, 16)
289        blockheader.nTime = int(time.time())
290        blockheader.nBits = blockheader_tip.nBits
291        while not blockheader.hash_hex.startswith('0'):
292            blockheader.nNonce += 1
293        peer = self.nodes[0].add_p2p_connection(P2PInterface())
294        peer.send_and_ping(msg_headers([blockheader]))
295        assert_equal(self.nodes[0].getblockchaininfo()['headers'], 1)
296        chaintips = self.nodes[0].getchaintips()
297        assert_equal(chaintips[0]['status'], 'headers-only')
298        assert_equal(chaintips[0]['hash'], blockheader.hash_hex)
299
300        # invalidate PoW
301        while not blockheader.hash_hex.startswith('f'):
302            blockheader.nNonce += 1
303        with self.nodes[0].assert_debug_log(['Misbehaving', 'header with invalid proof of work']):
304            peer.send_without_ping(msg_headers([blockheader]))
305            peer.wait_for_disconnect()
306
307    def test_noncontinuous_headers_msg(self):
308        self.log.info("Test headers message with non-continuous headers sequence is logged as misbehaving")
309        block_hashes = self.generate(self.nodes[0], 10)
310        block_headers = []
311        for block_hash in block_hashes:
312            block_headers.append(from_hex(CBlockHeader(), self.nodes[0].getblockheader(block_hash, False)))
313
314        # continuous headers sequence should be fine
315        MISBEHAVING_NONCONTINUOUS_HEADERS_MSGS = ['Misbehaving', 'non-continuous headers sequence']
316        peer = self.nodes[0].add_p2p_connection(P2PInterface())
317        with self.nodes[0].assert_debug_log([], unexpected_msgs=MISBEHAVING_NONCONTINUOUS_HEADERS_MSGS):
318            peer.send_and_ping(msg_headers(block_headers))
319
320        # delete arbitrary block header somewhere in the middle to break link
321        del block_headers[random.randrange(1, len(block_headers)-1)]
322        with self.nodes[0].assert_debug_log(expected_msgs=MISBEHAVING_NONCONTINUOUS_HEADERS_MSGS):
323            peer.send_without_ping(msg_headers(block_headers))
324            peer.wait_for_disconnect()
325        self.nodes[0].disconnect_p2ps()
326
327    def test_resource_exhaustion(self):
328        self.log.info("Test node stays up despite many large junk messages")
329        # Don't use v2 here - the non-optimised encryption would take too long to encrypt
330        # the large messages
331        conn = self.nodes[0].add_p2p_connection(P2PDataStore(), supports_v2_p2p=False)
332        conn2 = self.nodes[0].add_p2p_connection(P2PDataStore(), supports_v2_p2p=False)
333        msg_at_size = msg_unrecognized(str_data="b" * VALID_DATA_LIMIT)
334        assert_equal(len(msg_at_size.serialize()), MAX_PROTOCOL_MESSAGE_LENGTH)
335
336        self.log.info("(a) Send 80 messages, each of maximum valid data size (4MB)")
337        for _ in range(80):
338            conn.send_without_ping(msg_at_size)
339
340        # Check that, even though the node is being hammered by nonsense from one
341        # connection, it can still service other peers in a timely way.
342        self.log.info("(b) Check node still services peers in a timely way")
343        for _ in range(20):
344            conn2.sync_with_ping(timeout=2)
345
346        self.log.info("(c) Wait for node to drop junk messages, while remaining connected")
347        conn.sync_with_ping(timeout=400)
348
349        # Despite being served up a bunch of nonsense, the peers should still be connected.
350        assert conn.is_connected
351        assert conn2.is_connected
352        self.nodes[0].disconnect_p2ps()
353
354
355if __name__ == '__main__':
356    InvalidMessagesTest(__file__).main()
357