Inside Bitcoin

1#!/usr/bin/env python3
2# Copyright (c) 2020-present 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"""
6Test addr relay
7"""
8
9import random
10import time
11
12from test_framework.messages import (
13    CAddress,
14    CBlockHeader,
15    msg_addr,
16    msg_getaddr,
17    msg_headers,
18    msg_verack,
19    from_hex,
20)
21from test_framework.p2p import (
22    P2PInterface,
23    p2p_lock,
24    P2P_SERVICES,
25)
26from test_framework.test_framework import BitcoinTestFramework
27from test_framework.util import (
28    assert_equal,
29    assert_greater_than,
30    assert_greater_than_or_equal
31)
32
33ONE_MINUTE  = 60
34TEN_MINUTES = 10 * ONE_MINUTE
35ONE_HOUR    = 60 * ONE_MINUTE
36TWO_HOURS   =  2 * ONE_HOUR
37ONE_DAY     = 24 * ONE_HOUR
38
39ADDR_DESTINATIONS_THRESHOLD = 4
40
41class AddrReceiver(P2PInterface):
42    num_ipv4_received = 0
43    test_addr_contents = False
44    _tokens = 1
45    send_getaddr = True
46
47    def __init__(self, test_addr_contents=False, send_getaddr=True):
48        super().__init__()
49        self.test_addr_contents = test_addr_contents
50        self.send_getaddr = send_getaddr
51
52    def on_addr(self, message):
53        for addr in message.addrs:
54            self.num_ipv4_received += 1
55            if self.test_addr_contents:
56                # relay_tests checks the content of the addr messages match
57                # expectations based on the message creation in setup_addr_msg
58                assert_equal(addr.nServices, 9)
59                if not 8333 <= addr.port < 8343:
60                    raise AssertionError("Invalid addr.port of {} (8333-8342 expected)".format(addr.port))
61                assert addr.ip.startswith('123.123.')
62
63    def on_getaddr(self, message):
64        # When the node sends us a getaddr, it increments the addr relay tokens for the connection by 1000
65        self._tokens += 1000
66
67    @property
68    def tokens(self):
69        with p2p_lock:
70            return self._tokens
71
72    def increment_tokens(self, n):
73        # When we move mocktime forward, the node increments the addr relay tokens for its peers
74        with p2p_lock:
75            self._tokens += n
76
77    def addr_received(self):
78        return self.num_ipv4_received != 0
79
80    def on_version(self, message):
81        self.send_version()
82        self.send_without_ping(msg_verack())
83        if (self.send_getaddr):
84            self.send_without_ping(msg_getaddr())
85
86    def getaddr_received(self):
87        return self.message_count['getaddr'] > 0
88
89
90class AddrTest(BitcoinTestFramework):
91    counter = 0
92    mocktime = int(time.time())
93
94    def set_test_params(self):
95        self.num_nodes = 1
96        self.extra_args = [["[email protected]"]]
97
98    def run_test(self):
99        self.oversized_addr_test()
100        self.relay_tests()
101        self.inbound_blackhole_tests()
102
103        self.destination_rotates_once_in_24_hours_test()
104        self.destination_rotates_more_than_once_over_several_days_test()
105
106        # This test populates the addrman, which can impact the node's behavior
107        # in subsequent tests
108        self.getaddr_tests()
109        self.blocksonly_mode_tests()
110        self.rate_limit_tests()
111
112    def setup_addr_msg(self, num, sequential_ips=True):
113        addrs = []
114        for i in range(num):
115            addr = CAddress()
116            addr.time = self.mocktime + random.randrange(-100, 100)
117            addr.nServices = P2P_SERVICES
118            if sequential_ips:
119                assert self.counter < 256 ** 2  # Don't allow the returned ip addresses to wrap.
120                addr.ip = f"123.123.{self.counter // 256}.{self.counter % 256}"
121                self.counter += 1
122            else:
123                addr.ip = f"{random.randrange(128,169)}.{random.randrange(1,255)}.{random.randrange(1,255)}.{random.randrange(1,255)}"
124            addr.port = 8333 + i
125            addrs.append(addr)
126
127        msg = msg_addr()
128        msg.addrs = addrs
129        return msg
130
131    def send_addr_msg(self, source, msg, receivers):
132        source.send_and_ping(msg)
133        # invoke m_next_addr_send timer:
134        # `addr` messages are sent on an exponential distribution with mean interval of 30s.
135        # Setting the mocktime 600s forward gives a probability of (1 - e^-(600/30)) that
136        # the event will occur (i.e. this fails once in ~500 million repeats).
137        self.mocktime += 10 * 60
138        self.nodes[0].setmocktime(self.mocktime)
139        for peer in receivers:
140            peer.sync_with_ping()
141
142    def oversized_addr_test(self):
143        self.log.info('Send an addr message that is too large')
144        addr_source = self.nodes[0].add_p2p_connection(P2PInterface())
145
146        msg = self.setup_addr_msg(1010)
147        with self.nodes[0].assert_debug_log(['addr message size = 1010']):
148            addr_source.send_without_ping(msg)
149            addr_source.wait_for_disconnect()
150
151        self.nodes[0].disconnect_p2ps()
152
153    def relay_tests(self):
154        self.log.info('Test address relay')
155        self.log.info('Check that addr message content is relayed and added to addrman')
156        addr_source = self.nodes[0].add_p2p_connection(P2PInterface())
157        num_receivers = 7
158        receivers = []
159        for _ in range(num_receivers):
160            receivers.append(self.nodes[0].add_p2p_connection(AddrReceiver(test_addr_contents=True)))
161
162        # Keep this with length <= 10. Addresses from larger messages are not
163        # relayed.
164        num_ipv4_addrs = 10
165        msg = self.setup_addr_msg(num_ipv4_addrs)
166        with self.nodes[0].assert_debug_log(
167            [
168                'received: addr (301 bytes) peer=1',
169            ]
170        ):
171            self.send_addr_msg(addr_source, msg, receivers)
172
173        total_ipv4_received = sum(r.num_ipv4_received for r in receivers)
174
175        # Every IPv4 address must be relayed to two peers, other than the
176        # originating node (addr_source).
177        ipv4_branching_factor = 2
178        assert_equal(total_ipv4_received, num_ipv4_addrs * ipv4_branching_factor)
179
180        self.nodes[0].disconnect_p2ps()
181
182        self.log.info('Check relay of addresses received from outbound peers')
183        inbound_peer = self.nodes[0].add_p2p_connection(AddrReceiver(test_addr_contents=True, send_getaddr=False))
184        # Send an empty ADDR message to initialize address relay on this connection.
185        inbound_peer.send_and_ping(msg_addr())
186
187        full_outbound_peer = self.nodes[0].add_outbound_p2p_connection(AddrReceiver(), p2p_idx=0, connection_type="outbound-full-relay")
188        msg = self.setup_addr_msg(2)
189        self.send_addr_msg(full_outbound_peer, msg, [inbound_peer])
190        self.log.info('Check that the first addr message received from an outbound peer is not relayed')
191        # Currently, there is a flag that prevents the first addr message received
192        # from a new outbound peer to be relayed to others. Originally meant to prevent
193        # large GETADDR responses from being relayed, it now typically affects the self-announcement
194        # of the outbound peer which is often sent before the GETADDR response.
195        assert_equal(inbound_peer.num_ipv4_received, 0)
196
197        self.log.info('Check that subsequent addr messages sent from an outbound peer are relayed')
198        msg2 = self.setup_addr_msg(2)
199        self.send_addr_msg(full_outbound_peer, msg2, [inbound_peer])
200        assert_equal(inbound_peer.num_ipv4_received, 2)
201
202        self.log.info('Check address relay to outbound peers')
203        block_relay_peer = self.nodes[0].add_outbound_p2p_connection(AddrReceiver(), p2p_idx=1, connection_type="block-relay-only")
204        msg3 = self.setup_addr_msg(2)
205        self.send_addr_msg(inbound_peer, msg3, [full_outbound_peer, block_relay_peer])
206
207        self.log.info('Check that addresses are relayed to full outbound peers')
208        assert_equal(full_outbound_peer.num_ipv4_received, 2)
209        self.log.info('Check that addresses are not relayed to block-relay-only outbound peers')
210        assert_equal(block_relay_peer.num_ipv4_received, 0)
211
212        self.nodes[0].disconnect_p2ps()
213
214    def sum_addr_messages(self, msgs_dict):
215        return sum(bytes_received for (msg, bytes_received) in msgs_dict.items() if msg in ['addr', 'addrv2', 'getaddr'])
216
217    def inbound_blackhole_tests(self):
218        self.log.info('Check that we only relay addresses to inbound peers who have previously sent us addr related messages')
219
220        addr_source = self.nodes[0].add_p2p_connection(P2PInterface())
221        receiver_peer = self.nodes[0].add_p2p_connection(AddrReceiver())
222        blackhole_peer = self.nodes[0].add_p2p_connection(AddrReceiver(send_getaddr=False))
223        initial_addrs_received = receiver_peer.num_ipv4_received
224
225        peerinfo = self.nodes[0].getpeerinfo()
226        assert_equal(peerinfo[0]['addr_relay_enabled'], True)  # addr_source
227        assert_equal(peerinfo[1]['addr_relay_enabled'], True)  # receiver_peer
228        assert_equal(peerinfo[2]['addr_relay_enabled'], False)  # blackhole_peer
229
230        # addr_source sends 2 addresses to node0
231        msg = self.setup_addr_msg(2)
232        addr_source.send_and_ping(msg)
233        self.mocktime += 30 * 60
234        self.nodes[0].setmocktime(self.mocktime)
235        receiver_peer.sync_with_ping()
236        blackhole_peer.sync_with_ping()
237
238        peerinfo = self.nodes[0].getpeerinfo()
239
240        # Confirm node received addr-related messages from receiver peer
241        assert_greater_than(self.sum_addr_messages(peerinfo[1]['bytesrecv_per_msg']), 0)
242        # And that peer received addresses
243        assert_equal(receiver_peer.num_ipv4_received - initial_addrs_received, 2)
244
245        # Confirm node has not received addr-related messages from blackhole peer
246        assert_equal(self.sum_addr_messages(peerinfo[2]['bytesrecv_per_msg']), 0)
247        # And that peer did not receive addresses
248        assert_equal(blackhole_peer.num_ipv4_received, 0)
249
250        self.log.info("After blackhole peer sends addr message, it becomes eligible for addr gossip")