test: Functional test for opportunistic encryption

Author: dhruv

test/functional/p2p_v2.py

@@ -0,0 +1,91 @@
+#!/usr/bin/env python3
+# Copyright (c) 2022 The Bitcoin Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+"""
+Test BIP324 v2 transport
+"""
+
+from test_framework.test_framework import BitcoinTestFramework
+from test_framework.util import assert_equal
+
+class P2PV2Test(BitcoinTestFramework):
+    def set_test_params(self):
+        self.setup_clean_chain = True
+        self.num_nodes = 5
+        self.extra_args = [["-v2transport=1"], ["-v2transport=1"], ["-v2transport=0"], ["-v2transport=0"], ["-v2transport=0"]]
+
+    def run_test(self):
+        sending_ellswift = "sending 64 byte v2 p2p ellswift key to peer"
+        downgrading_to_v1 = "downgrading to v1 transport protocol for peer"
+        self.disconnect_nodes(0, 1)
+        self.disconnect_nodes(1, 2)
+        self.disconnect_nodes(2, 3)
+        self.disconnect_nodes(3, 4)
+
+        # V2 nodes can sync with V2 nodes
+        assert_equal(self.nodes[0].getblockcount(), 0)
+        assert_equal(self.nodes[1].getblockcount(), 0)
+        self.nodes[0].generatetoaddress(5, "bcrt1q0yq2azut8gn2xu3y2g0xucf8pny6w8uxmyf220", invalid_call=False)
+        assert_equal(self.nodes[0].getblockcount(), 5)
+        assert_equal(self.nodes[1].getblockcount(), 0)
+        with self.nodes[0].assert_debug_log(expected_msgs=[sending_ellswift],
+                                            unexpected_msgs=[downgrading_to_v1]):
+            self.connect_nodes(0, 1, True)
+        # sync_all() verifies that the block tips match
+        self.sync_all(self.nodes[0:2])
+        assert_equal(self.nodes[1].getblockcount(), 5)
+
+        # V1 nodes can sync with each other
+        assert_equal(self.nodes[2].getblockcount(), 0)
+        assert_equal(self.nodes[3].getblockcount(), 0)
+        self.nodes[2].generatetoaddress(8, "bcrt1qyr5lnc2g8aa3qa9c4th9d46n5uu4y0m9nvq2cv", invalid_call=False)
+        assert_equal(self.nodes[2].getblockcount(), 8)
+        assert_equal(self.nodes[3].getblockcount(), 0)
+        with self.nodes[2].assert_debug_log(expected_msgs=[],
+                                            unexpected_msgs=[sending_ellswift, downgrading_to_v1]):
+            self.connect_nodes(2, 3, False)
+        self.sync_all(self.nodes[2:4])
+        assert_equal(self.nodes[3].getblockcount(), 8)
+        assert self.nodes[0].getbestblockhash() != self.nodes[2].getbestblockhash()
+
+        # V1 nodes can sync with V2 nodes
+        self.disconnect_nodes(0, 1)
+        self.disconnect_nodes(2, 3)
+        with self.nodes[2].assert_debug_log(expected_msgs=[],
+                                            unexpected_msgs=[sending_ellswift, downgrading_to_v1]):
+            self.connect_nodes(2, 1, True)
+        self.sync_all(self.nodes[1:3])
+        assert_equal(self.nodes[1].getblockcount(), 8)
+        assert self.nodes[0].getbestblockhash() != self.nodes[1].getbestblockhash()
+
+        # V2 nodes can sync with V1 nodes
+        self.disconnect_nodes(1, 2)
+        with self.nodes[0].assert_debug_log(expected_msgs=[],
+                                            unexpected_msgs=[sending_ellswift, downgrading_to_v1]):
+            self.connect_nodes(0, 3, False)
+        self.sync_all([self.nodes[0], self.nodes[3]])
+        assert_equal(self.nodes[0].getblockcount(), 8)
+
+        # V2 node mines another block and everyone gets it
+        self.connect_nodes(0, 1, True)
+        self.connect_nodes(1, 2, False)
+        self.nodes[1].generatetoaddress(1, "bcrt1q3zsxn3qx0cqyyxgv90k7j6786mpe543wc4vy2v", invalid_call=False)
+        self.sync_all(self.nodes[0:4])
+        assert_equal(self.nodes[0].getblockcount(), 9) # sync_all() verifies tip hashes match
+
+        # V1 node mines another block and everyone gets it
+        self.nodes[3].generatetoaddress(2, "bcrt1q3zsxn3qx0cqyyxgv90k7j6786mpe543wc4vy2v", invalid_call=False)
+        self.sync_all(self.nodes[0:4])
+        assert_equal(self.nodes[2].getblockcount(), 11) # sync_all() verifies tip hashes match
+
+        assert_equal(self.nodes[4].getblockcount(), 0)
+        # Peer 4 is v1 p2p, but is falsely advertised as v2.
+        with self.nodes[1].assert_debug_log(expected_msgs=[sending_ellswift, downgrading_to_v1]):
+            self.connect_nodes(1, 4, True)
+        self.sync_all()
+        assert_equal(self.nodes[4].getblockcount(), 11)
+
+
+if __name__ == '__main__':
+    P2PV2Test().main()

test/functional/test_framework/test_framework.py

@@ -588,26 +588,47 @@ def restart_node(self, i, extra_args=None):
     def wait_for_node_exit(self, i, timeout):
         self.nodes[i].process.wait(timeout)
 
-    def connect_nodes(self, a, b):
+    def connect_nodes(self, a, b, peer_advertises_v2=False):
         from_connection = self.nodes[a]
         to_connection = self.nodes[b]
         from_num_peers = 1 + len(from_connection.getpeerinfo())
         to_num_peers = 1 + len(to_connection.getpeerinfo())
         ip_port = "127.0.0.1:" + str(p2p_port(b))
-        from_connection.addnode(ip_port, "onetry")
+
+        if peer_advertises_v2:
+            from_connection.addnode(ip_port, "onetry", True)
+        else:
+            # skip the optional third argument (default false) for
+            # compatibility with older clients
+            from_connection.addnode(ip_port, "onetry")
+
+        min_verack_msg_bytes = 21 if peer_advertises_v2 else 24
         # poll until version handshake complete to avoid race conditions
         # with transaction relaying
         # See comments in net_processing:
         # * Must have a version message before anything else
         # * Must have a verack message before anything else
-        self.wait_until(lambda: sum(peer['version'] != 0 for peer in from_connection.getpeerinfo()) == from_num_peers)
-        self.wait_until(lambda: sum(peer['version'] != 0 for peer in to_connection.getpeerinfo()) == to_num_peers)
-        self.wait_until(lambda: sum(peer['bytesrecv_per_msg'].pop('verack', 0) == 24 for peer in from_connection.getpeerinfo()) == from_num_peers)
-        self.wait_until(lambda: sum(peer['bytesrecv_per_msg'].pop('verack', 0) == 24 for peer in to_connection.getpeerinfo()) == to_num_peers)
-        # The message bytes are counted before processing the message, so make
-        # sure it was fully processed by waiting for a ping.
-        self.wait_until(lambda: sum(peer["bytesrecv_per_msg"].pop("pong", 0) >= 32 for peer in from_connection.getpeerinfo()) == from_num_peers)
-        self.wait_until(lambda: sum(peer["bytesrecv_per_msg"].pop("pong", 0) >= 32 for peer in to_connection.getpeerinfo()) == to_num_peers)
+        # * The message bytes are counted before processing the message, so make
+        #   sure it was fully processed by waiting for a ping.
+
+        def check_initiator_handshake():
+            peerinfo = from_connection.getpeerinfo()
+            if len(peerinfo) != from_num_peers:
+                return False
+
+            responder = list(filter(lambda x: x["addr"] == ip_port, peerinfo))[0]
+            return responder['version'] != 0 and responder['bytesrecv_per_msg'].pop('verack', 0) >= min_verack_msg_bytes and responder['bytesrecv_per_msg'].pop("pong", 0) >= 29
+
+        def check_responder_handshake():
+            peerinfo = to_connection.getpeerinfo()
+            if len(peerinfo) != to_num_peers:
+                return False
+
+            initiator = list(filter(lambda x: x["addrbind"] == ip_port, peerinfo))[0]
+            return initiator['version'] != 0 and initiator['bytesrecv_per_msg'].pop('verack', 0) >= min_verack_msg_bytes and initiator['bytesrecv_per_msg'].pop("pong", 0) >= 29
+
+        self.wait_until(check_initiator_handshake)
+        self.wait_until(check_responder_handshake)
 
     def disconnect_nodes(self, a, b):
         def disconnect_nodes_helper(node_a, node_b):

test/functional/test_runner.py

@@ -232,6 +232,7 @@
     'p2p_invalid_locator.py',
     'p2p_invalid_block.py',
     'p2p_invalid_tx.py',
+    'p2p_v2.py',
     'p2p_v2_transport.py',
     'example_test.py',
     'wallet_txn_doublespend.py --legacy-wallet',