1  #!/usr/bin/env python3
  2  # Copyright (c) 2021-2022 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 addrman functionality"""
  6  
  7  import os
  8  import re
  9  
 10  from test_framework.messages import ser_uint256, hash256, MAGIC_BYTES
 11  from test_framework.netutil import ADDRMAN_NEW_BUCKET_COUNT, ADDRMAN_TRIED_BUCKET_COUNT, ADDRMAN_BUCKET_SIZE
 12  from test_framework.test_framework import BitcoinTestFramework
 13  from test_framework.test_node import ErrorMatch
 14  from test_framework.util import assert_equal
 15  
 16  def serialize_addrman(
 17      *,
 18      format=1,
 19      lowest_compatible=4,
 20      net_magic="regtest",
 21      bucket_key=1,
 22      len_new=None,
 23      len_tried=None,
 24      mock_checksum=None,
 25  ):
 26      new = []
 27      tried = []
 28      INCOMPATIBILITY_BASE = 32
 29      r = MAGIC_BYTES[net_magic]
 30      r += format.to_bytes(1, "little")
 31      r += (INCOMPATIBILITY_BASE + lowest_compatible).to_bytes(1, "little")
 32      r += ser_uint256(bucket_key)
 33      r += (len_new or len(new)).to_bytes(4, "little", signed=True)
 34      r += (len_tried or len(tried)).to_bytes(4, "little", signed=True)
 35      ADDRMAN_NEW_BUCKET_COUNT = 1 << 10
 36      r += (ADDRMAN_NEW_BUCKET_COUNT ^ (1 << 30)).to_bytes(4, "little", signed=True)
 37      for _ in range(ADDRMAN_NEW_BUCKET_COUNT):
 38          r += (0).to_bytes(4, "little", signed=True)
 39      checksum = hash256(r)
 40      r += mock_checksum or checksum
 41      return r
 42  
 43  
 44  def write_addrman(peers_dat, **kwargs):
 45      with open(peers_dat, "wb") as f:
 46          f.write(serialize_addrman(**kwargs))
 47  
 48  
 49  class AddrmanTest(BitcoinTestFramework):
 50      def set_test_params(self):
 51          self.num_nodes = 1
 52  
 53      def run_test(self):
 54          peers_dat = os.path.join(self.nodes[0].chain_path, "peers.dat")
 55          init_error = lambda reason: (
 56              f"Error: Invalid or corrupt peers.dat \\({reason}\\). If you believe this "
 57              f"is a bug, please report it to {self.config['environment']['CLIENT_BUGREPORT']}. "
 58              f'As a workaround, you can move the file \\("{re.escape(peers_dat)}"\\) out of the way \\(rename, '
 59              "move, or delete\\) to have a new one created on the next start."
 60          )
 61  
 62          self.log.info("Check that mocked addrman is valid")
 63          self.stop_node(0)
 64          write_addrman(peers_dat)
 65          with self.nodes[0].assert_debug_log(["Loaded 0 addresses from peers.dat"]):
 66              self.start_node(0, extra_args=["-checkaddrman=1"])
 67          assert_equal(self.nodes[0].getnodeaddresses(), [])
 68  
 69          self.log.info("Check that addrman with negative lowest_compatible cannot be read")
 70          self.stop_node(0)
 71          write_addrman(peers_dat, lowest_compatible=-32)
 72          self.nodes[0].assert_start_raises_init_error(
 73              expected_msg=init_error(
 74                  "Corrupted addrman database: The compat value \\(0\\) is lower "
 75                  "than the expected minimum value 32.: (.+)"
 76              ),
 77              match=ErrorMatch.FULL_REGEX,
 78          )
 79  
 80          self.log.info("Check that addrman from future is overwritten with new addrman")
 81          self.stop_node(0)
 82          write_addrman(peers_dat, lowest_compatible=111)
 83          assert_equal(os.path.exists(peers_dat + ".bak"), False)
 84          with self.nodes[0].assert_debug_log([
 85                  f'Creating new peers.dat because the file version was not compatible ("{peers_dat}"). Original backed up to peers.dat.bak',
 86          ]):
 87              self.start_node(0)
 88          assert_equal(self.nodes[0].getnodeaddresses(), [])
 89          assert_equal(os.path.exists(peers_dat + ".bak"), True)
 90  
 91          self.log.info("Check that corrupt addrman cannot be read (EOF)")
 92          self.stop_node(0)
 93          with open(peers_dat, "wb") as f:
 94              f.write(serialize_addrman()[:-1])
 95          self.nodes[0].assert_start_raises_init_error(
 96              expected_msg=init_error("AutoFile::read: end of file.*"),
 97              match=ErrorMatch.FULL_REGEX,
 98          )
 99  
100          self.log.info("Check that corrupt addrman cannot be read (magic)")
101          self.stop_node(0)
102          write_addrman(peers_dat, net_magic="signet")
103          self.nodes[0].assert_start_raises_init_error(
104              expected_msg=init_error("Invalid network magic number"),
105              match=ErrorMatch.FULL_REGEX,
106          )
107  
108          self.log.info("Check that corrupt addrman cannot be read (checksum)")
109          self.stop_node(0)
110          write_addrman(peers_dat, mock_checksum=b"ab" * 32)
111          self.nodes[0].assert_start_raises_init_error(
112              expected_msg=init_error("Checksum mismatch, data corrupted"),
113              match=ErrorMatch.FULL_REGEX,
114          )
115  
116          self.log.info("Check that corrupt addrman cannot be read (len_tried)")
117          self.stop_node(0)
118          max_len_tried = ADDRMAN_TRIED_BUCKET_COUNT * ADDRMAN_BUCKET_SIZE
119          write_addrman(peers_dat, len_tried=-1)
120          self.nodes[0].assert_start_raises_init_error(
121              expected_msg=init_error(f"Corrupt AddrMan serialization: nTried=-1, should be in \\[0, {max_len_tried}\\]:.*"),
122              match=ErrorMatch.FULL_REGEX,
123          )
124  
125          self.log.info("Check that corrupt addrman cannot be read (large len_tried)")
126          write_addrman(peers_dat, len_tried=max_len_tried + 1)
127          self.nodes[0].assert_start_raises_init_error(
128              expected_msg=init_error(f"Corrupt AddrMan serialization: nTried={max_len_tried + 1}, should be in \\[0, {max_len_tried}\\]:.*"),
129              match=ErrorMatch.FULL_REGEX,
130          )
131  
132          self.log.info("Check that corrupt addrman cannot be read (len_new)")
133          self.stop_node(0)
134          max_len_new = ADDRMAN_NEW_BUCKET_COUNT * ADDRMAN_BUCKET_SIZE
135          write_addrman(peers_dat, len_new=-1)
136          self.nodes[0].assert_start_raises_init_error(
137              expected_msg=init_error(f"Corrupt AddrMan serialization: nNew=-1, should be in \\[0, {max_len_new}\\]:.*"),
138              match=ErrorMatch.FULL_REGEX,
139          )
140  
141          self.log.info("Check that corrupt addrman cannot be read (large len_new)")
142          self.stop_node(0)
143          write_addrman(peers_dat, len_new=max_len_new + 1)
144          self.nodes[0].assert_start_raises_init_error(
145              expected_msg=init_error(f"Corrupt AddrMan serialization: nNew={max_len_new + 1}, should be in \\[0, {max_len_new}\\]:.*"),
146              match=ErrorMatch.FULL_REGEX,
147          )
148  
149          self.log.info("Check that corrupt addrman cannot be read (failed check)")
150          self.stop_node(0)
151          write_addrman(peers_dat, bucket_key=0)
152          self.nodes[0].assert_start_raises_init_error(
153              expected_msg=init_error("Corrupt data. Consistency check failed with code -16: .*"),
154              match=ErrorMatch.FULL_REGEX,
155          )
156  
157          self.log.info("Check that missing addrman is recreated")
158          self.restart_node(0, clear_addrman=True)
159          assert_equal(self.nodes[0].getnodeaddresses(), [])
160  
161  
162  if __name__ == "__main__":
163      AddrmanTest(__file__).main()