Inside Bitcoin

251
252    def skip_test_if_missing_module(self):
253        self.skip_if_platform_not_linux()
254        self.skip_if_no_bitcoind_tracepoints()
255        self.skip_if_no_python_bcc()
256        self.skip_if_no_bpf_permissions()
257        self.skip_if_running_under_valgrind()
258
259    def run_test(self):
260        self.p2p_message_tracepoint_test()
261        self.inbound_conn_tracepoint_test()
262        self.outbound_conn_tracepoint_test()
263        self.evicted_inbound_conn_tracepoint_test()
264        self.misbehaving_conn_tracepoint_test()
265        self.closed_conn_tracepoint_test()
266
267    def p2p_message_tracepoint_test(self):
268        # Tests the net:inbound_message and net:outbound_message tracepoints
269        # See https://github.com/bitcoin/bitcoin/blob/master/doc/tracing.md#context-net
270
271        class P2PMessage(ctypes.Structure):
272            _fields_ = [
273                ("peer_id", ctypes.c_uint64),
274                ("peer_addr", ctypes.c_char * MAX_PEER_ADDR_LENGTH),
275                ("peer_conn_type", ctypes.c_char * MAX_PEER_CONN_TYPE_LENGTH),
276                ("msg_type", ctypes.c_char * MAX_MSG_TYPE_LENGTH),
277                ("msg_size", ctypes.c_uint64),
278                ("msg", ctypes.c_ubyte * MAX_MSG_DATA_LENGTH),
279            ]
280
281            def __repr__(self):
282                return f"P2PMessage(peer={self.peer_id}, addr={self.peer_addr.decode('utf-8')}, conn_type={self.peer_conn_type.decode('utf-8')}, msg_type={self.msg_type.decode('utf-8')}, msg_size={self.msg_size})"
283
284        self.log.info(
285            "hook into the net:inbound_message and net:outbound_message tracepoints")
286        ctx = USDT(pid=self.nodes[0].process.pid)
287        ctx.enable_probe(probe="net:inbound_message",
288                         fn_name="trace_inbound_message")
289        ctx.enable_probe(probe="net:outbound_message",
290                         fn_name="trace_outbound_message")
291        bpf = BPF(text=net_tracepoints_program, usdt_contexts=[ctx], debug=0, cflags=bpf_cflags())
292
293        EXPECTED_INOUTBOUND_VERSION_MSG = 1
294        checked_inbound_version_msg = 0
295        checked_outbound_version_msg = 0
296        events = []
297
298        def check_p2p_message(event, is_inbound):
299            nonlocal checked_inbound_version_msg, checked_outbound_version_msg
300            if event.msg_type.decode("utf-8") == "version":
301                self.log.info(
302                    f"check_p2p_message(): {'inbound' if is_inbound else 'outbound'} {event}")
303                peer = self.nodes[0].getpeerinfo()[0]
304                msg = msg_version()
305                msg.deserialize(BytesIO(bytes(event.msg[:event.msg_size])))
306                assert_equal(peer["id"], event.peer_id, peer["id"])
307                assert_equal(peer["addr"], event.peer_addr.decode("utf-8"))
308                assert_equal(peer["connection_type"],
309                             event.peer_conn_type.decode("utf-8"))
310                if is_inbound:
311                    checked_inbound_version_msg += 1
312                else:
313                    checked_outbound_version_msg += 1
314
315        def handle_inbound(_, data, __):
316            event = ctypes.cast(data, ctypes.POINTER(P2PMessage)).contents
317            events.append((event, True))
318
319        def handle_outbound(_, data, __):
320            event = ctypes.cast(data, ctypes.POINTER(P2PMessage)).contents
321            events.append((event, False))
322
323        bpf["inbound_messages"].open_perf_buffer(handle_inbound)
324        bpf["outbound_messages"].open_perf_buffer(handle_outbound)
325
326        self.log.info("connect a P2P test node to our bitcoind node")
327        test_node = P2PInterface()
328        self.nodes[0].add_p2p_connection(test_node)
329        bpf.perf_buffer_poll(timeout=200)
330
331        self.log.info(
332            "check receipt and content of in- and outbound version messages")
333        for event, is_inbound in events:
334            check_p2p_message(event, is_inbound)
335        assert_equal(EXPECTED_INOUTBOUND_VERSION_MSG,
336                     checked_inbound_version_msg)
337        assert_equal(EXPECTED_INOUTBOUND_VERSION_MSG,
338                     checked_outbound_version_msg)
339
340
341        bpf.cleanup()
342        test_node.peer_disconnect()
343
344    def inbound_conn_tracepoint_test(self):
345        self.log.info("hook into the net:inbound_connection tracepoint")
346        ctx = USDT(pid=self.nodes[0].process.pid)
347        ctx.enable_probe(probe="net:inbound_connection",
348                         fn_name="trace_inbound_connection")
349        bpf = BPF(text=net_tracepoints_program, usdt_contexts=[ctx], debug=0, cflags=bpf_cflags())
350
351        inbound_connections = []
352        EXPECTED_INBOUND_CONNECTIONS = 2
353
354        def handle_inbound_connection(_, data, __):
355            nonlocal inbound_connections
356            event = ctypes.cast(data, ctypes.POINTER(NewConnection)).contents
357            self.log.info(f"handle_inbound_connection(): {event}")
358            inbound_connections.append(event)
359
360        bpf["inbound_connections"].open_perf_buffer(handle_inbound_connection)
361
362        self.log.info("connect two P2P test nodes to our bitcoind node")
363        testnodes = list()
364        for _ in range(EXPECTED_INBOUND_CONNECTIONS):
365            testnode = P2PInterface()
366            self.nodes[0].add_p2p_connection(testnode)
367            testnodes.append(testnode)
368        bpf.perf_buffer_poll(timeout=200)
369
370        assert_equal(EXPECTED_INBOUND_CONNECTIONS, len(inbound_connections))
371        for inbound_connection in inbound_connections:
372            assert_greater_than(inbound_connection.conn.id, 0)
373            assert_greater_than(inbound_connection.existing, 0)
374            assert_equal(b'inbound', inbound_connection.conn.conn_type)
375            assert_equal(NETWORK_TYPE_UNROUTABLE, inbound_connection.conn.network)
376
377        bpf.cleanup()
378        for node in testnodes:
379            node.peer_disconnect()
380
381    def outbound_conn_tracepoint_test(self):
382        self.log.info("hook into the net:outbound_connection tracepoint")
383        ctx = USDT(pid=self.nodes[0].process.pid)
384        ctx.enable_probe(probe="net:outbound_connection",
385                         fn_name="trace_outbound_connection")
386        bpf = BPF(text=net_tracepoints_program, usdt_contexts=[ctx], debug=0, cflags=bpf_cflags())
387
388        # that the handle_* function succeeds.
389        EXPECTED_OUTBOUND_CONNECTIONS = 2
390        EXPECTED_CONNECTION_TYPE = "feeler"
391        outbound_connections = []
392
393        def handle_outbound_connection(_, data, __):
394            event = ctypes.cast(data, ctypes.POINTER(NewConnection)).contents
395            self.log.info(f"handle_outbound_connection(): {event}")
396            outbound_connections.append(event)
397
398        bpf["outbound_connections"].open_perf_buffer(
399            handle_outbound_connection)
400
401        self.log.info(
402            f"connect {EXPECTED_OUTBOUND_CONNECTIONS} P2P test nodes to our bitcoind node")
403        testnodes = list()
404        for p2p_idx in range(EXPECTED_OUTBOUND_CONNECTIONS):
405            testnode = P2PInterface()
406            self.nodes[0].add_outbound_p2p_connection(
407                testnode, p2p_idx=p2p_idx, connection_type=EXPECTED_CONNECTION_TYPE)
408            testnodes.append(testnode)
409        bpf.perf_buffer_poll(timeout=200)
410
411        assert_equal(EXPECTED_OUTBOUND_CONNECTIONS, len(outbound_connections))
412        for outbound_connection in outbound_connections:
413            assert_greater_than(outbound_connection.conn.id, 0)
414            assert_greater_than(outbound_connection.existing, 0)
415            assert_equal(EXPECTED_CONNECTION_TYPE, outbound_connection.conn.conn_type.decode('utf-8'))
416            assert_equal(NETWORK_TYPE_UNROUTABLE, outbound_connection.conn.network)
417
418        bpf.cleanup()
419        for node in testnodes:
420            node.peer_disconnect()
421
422    def evicted_inbound_conn_tracepoint_test(self):
423        self.log.info("hook into the net:evicted_inbound_connection tracepoint")
424        ctx = USDT(pid=self.nodes[0].process.pid)
425        ctx.enable_probe(probe="net:evicted_inbound_connection",
426                         fn_name="trace_evicted_inbound_connection")
427        bpf = BPF(text=net_tracepoints_program, usdt_contexts=[ctx], debug=0, cflags=bpf_cflags())
428
429        EXPECTED_EVICTED_CONNECTIONS = 2
430        evicted_connections = []
431
432        def handle_evicted_inbound_connection(_, data, __):
433            event = ctypes.cast(data, ctypes.POINTER(ClosedConnection)).contents
434            self.log.info(f"handle_evicted_inbound_connection(): {event}")
435            evicted_connections.append(event)
436
437        bpf["evicted_inbound_connections"].open_perf_buffer(handle_evicted_inbound_connection)
438
439        self.log.info(
440            f"connect {MAX_INBOUND_CONNECTIONS + EXPECTED_EVICTED_CONNECTIONS} P2P test nodes to our bitcoind node and expect {EXPECTED_EVICTED_CONNECTIONS} evictions")
441        testnodes = list()
442        for p2p_idx in range(MAX_INBOUND_CONNECTIONS + EXPECTED_EVICTED_CONNECTIONS):
443            testnode = P2PInterface()
444            self.nodes[0].add_p2p_connection(testnode)
445            testnodes.append(testnode)
446        bpf.perf_buffer_poll(timeout=200)
447
448        assert_equal(EXPECTED_EVICTED_CONNECTIONS, len(evicted_connections))
449        for evicted_connection in evicted_connections:
450            assert_greater_than(evicted_connection.conn.id, 0)
451            assert_greater_than(evicted_connection.time_established, 0)
452            assert_equal("inbound", evicted_connection.conn.conn_type.decode('utf-8'))
453            assert_equal(NETWORK_TYPE_UNROUTABLE, evicted_connection.conn.network)
454
455        bpf.cleanup()
456        for node in testnodes:
457            node.peer_disconnect()
458
459    def misbehaving_conn_tracepoint_test(self):
460        self.log.info("hook into the net:misbehaving_connection tracepoint")
461        ctx = USDT(pid=self.nodes[0].process.pid)
462        ctx.enable_probe(probe="net:misbehaving_connection",
463                         fn_name="trace_misbehaving_connection")
464        bpf = BPF(text=net_tracepoints_program, usdt_contexts=[ctx], debug=0, cflags=bpf_cflags())
465
466        EXPECTED_MISBEHAVING_CONNECTIONS = 2
467        misbehaving_connections = []
468
469        def handle_misbehaving_connection(_, data, __):
470            event = ctypes.cast(data, ctypes.POINTER(MisbehavingConnection)).contents
471            self.log.info(f"handle_misbehaving_connection(): {event}")
472            misbehaving_connections.append(event)
473
474        bpf["misbehaving_connections"].open_perf_buffer(handle_misbehaving_connection)
475
476        self.log.info("connect a misbehaving P2P test nodes to our bitcoind node")
477        msg = msg_headers([CBlockHeader()] * (MAX_HEADERS_RESULTS + 1))
478        for _ in range(EXPECTED_MISBEHAVING_CONNECTIONS):
479            testnode = P2PInterface()
480            self.nodes[0].add_p2p_connection(testnode)
481            testnode.send_without_ping(msg)
482            bpf.perf_buffer_poll(timeout=500)
483            testnode.peer_disconnect()
484
485        assert_equal(EXPECTED_MISBEHAVING_CONNECTIONS, len(misbehaving_connections))
486        for misbehaving_connection in misbehaving_connections:
487            assert_greater_than(misbehaving_connection.id, 0)
488            assert_greater_than(len(misbehaving_connection.message), 0)
489            assert_equal(misbehaving_connection.message, b"headers message size = 2001")
490
491        bpf.cleanup()
492
493    def closed_conn_tracepoint_test(self):
494        self.log.info("hook into the net:closed_connection tracepoint")
495        ctx = USDT(pid=self.nodes[0].process.pid)
496        ctx.enable_probe(probe="net:closed_connection",
497                         fn_name="trace_closed_connection")
498        bpf = BPF(text=net_tracepoints_program, usdt_contexts=[ctx], debug=0, cflags=bpf_cflags())
499
500        EXPECTED_CLOSED_CONNECTIONS = 2