test: send initial_v2_handshake bytes manually

Author: stratospher

test/functional/p2p_v2_earlykeyresponse.py

@@ -15,7 +15,7 @@ class TestEncryptedP2PState(EncryptedP2PState):
     """ Modify v2 P2P protocol functions for testing that "The responder waits until one byte is received which does
     not match the 16 bytes consisting of the network magic followed by "version\x00\x00\x00\x00\x00"." (see BIP 324)
 
-    - if `send_net_magic` is True, send first 4 bytes of ellswift (match network magic) else send remaining 60 bytes
+    - `magic_sent` is initially False and set to True when network magic is sent
     - `can_data_be_received` is a variable used to assert if data is received on recvbuf.
             - v2 TestNode shouldn't respond back if we send V1_PREFIX and data shouldn't be received on recvbuf.
               This state is represented using `can_data_be_received` = False.
@@ -25,43 +25,30 @@ class TestEncryptedP2PState(EncryptedP2PState):
 
     def __init__(self):
         super().__init__(initiating=True, net='regtest')
-        self.send_net_magic = True
+        self.magic_sent = False
         self.can_data_be_received = False
 
     def initiate_v2_handshake(self, garbage_len=random.randrange(4096)):
-        """Initiator begins the v2 handshake by sending its ellswift bytes and garbage.
-        Here, the 64 bytes ellswift is assumed to have it's 4 bytes match network magic bytes. It is sent in 2 phases:
-            1. when `send_network_magic` = True, send first 4 bytes of ellswift (matches network magic bytes)
-            2. when `send_network_magic` = False, send remaining 60 bytes of ellswift
-        """
-        if self.send_net_magic:
-            self.privkey_ours, self.ellswift_ours = ellswift_create()
-            self.sent_garbage = random.randbytes(garbage_len)
-            self.send_net_magic = False
-            return b"\xfa\xbf\xb5\xda"
-        else:
-            self.can_data_be_received = True
-            return self.ellswift_ours[4:] + self.sent_garbage
+        self.privkey_ours, self.ellswift_ours = ellswift_create()
+        self.sent_garbage = random.randbytes(random.randrange(4096))
+        return b""
 
 
 class PeerEarlyKey(P2PInterface):
     """Custom implementation of P2PInterface which uses modified v2 P2P protocol functions for testing purposes."""
     def __init__(self):
         super().__init__()
         self.v2_state = None
-        self.connection_opened = False
 
     def connection_made(self, transport):
         """64 bytes ellswift is sent in 2 parts during `initial_v2_handshake()`"""
         self.v2_state = TestEncryptedP2PState()
         super().connection_made(transport)
 
     def data_received(self, t):
-        # check that data can be received on recvbuf only when mismatch from V1_PREFIX happens (send_net_magic = False)
-        assert self.v2_state.can_data_be_received and not self.v2_state.send_net_magic
+        # check that data can be received on recvbuf only when mismatch from V1_PREFIX happens (magic_sent = True)
+        assert self.v2_state.can_data_be_received and self.v2_state.magic_sent
 
-    def on_open(self):
-        self.connection_opened = True
 
 class P2PEarlyKey(BitcoinTestFramework):
     def set_test_params(self):
@@ -74,13 +61,15 @@ def run_test(self):
         node0 = self.nodes[0]
         self.log.info('Sending first 4 bytes of ellswift which match network magic')
         self.log.info('If a response is received, assertion failure would happen in our custom data_received() function')
-        # send happens in `initiate_v2_handshake()` in `connection_made()`
         peer1 = node0.add_p2p_connection(PeerEarlyKey(), wait_for_verack=False, send_version=False, supports_v2_p2p=True)
-        self.wait_until(lambda: peer1.connection_opened)
+        # Send only the network magic first
+        peer1.send_raw_message(b"\xfa\xbf\xb5\xda") # peer1.send_raw_message(peer1.v2_state.ellswift_ours[:4])
+        peer1.v2_state.magic_sent = True
         self.log.info('Sending remaining ellswift and garbage which are different from V1_PREFIX. Since a response is')
         self.log.info('expected now, our custom data_received() function wouldn\'t result in assertion failure')
-        ellswift_and_garbage_data = peer1.v2_state.initiate_v2_handshake()
-        peer1.send_raw_message(ellswift_and_garbage_data)
+        peer1.send_raw_message(peer1.v2_state.ellswift_ours[4:] + peer1.v2_state.sent_garbage)
+        import time; time.sleep(2)
+        peer1.v2_state.can_data_be_received = True
         peer1.wait_for_disconnect(timeout=5)
         self.log.info('successful disconnection when MITM happens in the key exchange phase')