def setUp(self) -> None:
opts = gateway_helpers.get_gateway_opts(8000, include_default_eth_args=True)
self.node = MockGatewayNode(opts)
self.connection = MagicMock(spec=AbstractGatewayBlockchainConnection)
self.connection.node = self.node
self.connection.is_active = MagicMock(return_value=True)
self.connection.network_num = 5
self.connection.format_connection_desc = "127.0.0.1:12345 - B"
self.node.set_known_total_difficulty = MagicMock()
self.node.node_conn = self.connection
self.node.message_converter = EthNormalMessageConverter()
self.cleanup_service = EthNormalBlockCleanupService(
self.node, NETWORK_NUM
)
self.node.block_cleanup_service = self.cleanup_service
self.node.block_processing_service = EthBlockProcessingService(
self.node
)
self.node.block_processing_service.queue_block_for_processing = MagicMock()
self.node.block_queuing_service = EthBlockQueuingService(self.node)
dummy_private_key = crypto_utils.make_private_key(
helpers.generate_bytearray(111)
)
dummy_public_key = crypto_utils.private_to_public_key(dummy_private_key)
self.sut = EthNodeConnectionProtocol(
self.connection, True, dummy_private_key, dummy_public_key
)
self.sut._waiting_checkpoint_headers_request = False
def setUp(self):
self.node = MockGatewayNode(
gateway_helpers.get_gateway_opts(8000,
include_default_btc_args=True,
include_default_eth_args=True))
self.relay_connection = AbstractRelayConnection(
MockSocketConnection(node=self.node,
ip_address="127.0.0.1",
port=12345), self.node)
self.blockchain_connection = EthBaseConnection(
MockSocketConnection(node=self.node,
ip_address="127.0.0.1",
port=12345), self.node)
self.node.message_converter = converter_factory.create_eth_message_converter(
self.node.opts)
dummy_private_key = crypto_utils.make_private_key(
helpers.generate_bytearray(111))
dummy_public_key = crypto_utils.private_to_public_key(
dummy_private_key)
self.blockchain_connection_protocol = EthNodeConnectionProtocol(
self.blockchain_connection, True, dummy_private_key,
dummy_public_key)
self.blockchain_connection.network_num = 0
self.blockchain_connection_protocol.publish_transaction = MagicMock()
self.relay_connection.state = ConnectionState.INITIALIZED
gateway_transaction_stats_service.set_node(self.node)
def setUp(self):
opts = gateway_helpers.get_gateway_opts(
8000,
include_default_eth_args=True,
track_detailed_sent_messages=True)
if opts.use_extensions:
helpers.set_extensions_parallelism()
self.node = MockGatewayNode(opts)
self.node.block_processing_service = MagicMock()
self.connection = MagicMock()
gateway_helpers.add_blockchain_peer(self.node, self.connection)
self.connection.node = self.node
self.connection.peer_ip = LOCALHOST
self.connection.peer_port = 8001
self.connection.network_num = 2
self.connection.endpoint = IpEndpoint(self.connection.peer_ip,
self.connection.peer_port)
self.node.blockchain_peers.add(
BlockchainPeerInfo(self.connection.peer_ip,
self.connection.peer_port))
gateway_bdn_performance_stats_service.set_node(self.node)
dummy_private_key = crypto_utils.make_private_key(
helpers.generate_bytearray(111))
dummy_public_key = crypto_utils.private_to_public_key(
dummy_private_key)
self.sut = EthNodeConnectionProtocol(self.connection, True,
dummy_private_key,
dummy_public_key)
def setup_ciphers(self, private_key1=None, private_key2=None):
if private_key1 is None:
private_key1 = crypto_utils.make_private_key(
helpers.generate_bytearray(111))
if private_key2 is None:
private_key2 = crypto_utils.make_private_key(
helpers.generate_bytearray(111))
public_key1 = crypto_utils.private_to_public_key(private_key1)
public_key2 = crypto_utils.private_to_public_key(private_key2)
cipher1 = RLPxCipher(True, private_key1, public_key2)
cipher2 = RLPxCipher(False, private_key2, public_key1)
self.assertFalse(cipher1.is_ready())
self.assertFalse(cipher2.is_ready())
auth_msg = cipher1.create_auth_message()
self.assertEqual(len(auth_msg), eth_common_constants.AUTH_MSG_LEN)
self.assertTrue(auth_msg)
enc_auth_msg = cipher1.encrypt_auth_message(auth_msg)
self.assertEqual(len(enc_auth_msg),
eth_common_constants.ENC_AUTH_MSG_LEN)
decrypted_auth_msg, size = cipher2.decrypt_auth_message(enc_auth_msg)
self.assertEqual(len(decrypted_auth_msg),
eth_common_constants.AUTH_MSG_LEN)
self.assertEqual(size, eth_common_constants.ENC_AUTH_MSG_LEN)
cipher2.parse_auth_message(decrypted_auth_msg)
auth_ack_message = cipher2.create_auth_ack_message()
enc_auth_ack_message = cipher2.encrypt_auth_ack_message(
auth_ack_message)
cipher1.decrypt_auth_ack_message(enc_auth_ack_message)
cipher1.setup_cipher()
cipher2.setup_cipher()
self.assertTrue(cipher1.is_ready())
self.assertTrue(cipher2.is_ready())
return cipher1, cipher2
def test_get_ecdh_key(self):
private_key1 = crypto_utils.make_private_key(helpers.generate_bytearray(111))
public_key1 = crypto_utils.private_to_public_key(private_key1)
private_key2 = crypto_utils.make_private_key(helpers.generate_bytearray(222))
public_key2 = crypto_utils.private_to_public_key(private_key2)
private_key3 = crypto_utils.make_private_key(helpers.generate_bytearray(333))
eccx1 = ECCx(raw_private_key=private_key1)
eccx2 = ECCx(raw_private_key=private_key2)
eccx3 = ECCx(raw_private_key=private_key3)
key1 = eccx1.get_ecdh_key(public_key2)
key2 = eccx2.get_ecdh_key(public_key1)
key3 = eccx3.get_ecdh_key(public_key1)
self.assertEqual(key1, key2)
self.assertNotEqual(key1, key3)
def test_sign_and_verify_signature__valid_signature(self):
dummy_private_key = crypto_utils.make_private_key(
helpers.generate_bytearray(111))
public_key = crypto_utils.private_to_public_key(dummy_private_key)
# generate random bytes
msg = helpers.generate_bytearray(222)
msg_hash = eth_common_utils.keccak_hash(msg)
signature = crypto_utils.sign(msg_hash, dummy_private_key)
self.assertTrue(
crypto_utils.verify_signature(public_key, signature, msg_hash))
def test_recover_public_key(self):
dummy_private_key = crypto_utils.make_private_key(
helpers.generate_bytearray(111))
public_key = crypto_utils.private_to_public_key(dummy_private_key)
msg = helpers.generate_bytearray(222)
msg_hash = eth_common_utils.keccak_hash(msg)
signature = crypto_utils.sign(msg_hash, dummy_private_key)
recovered_pub_key = crypto_utils.recover_public_key(
msg_hash, signature)
self.assertEqual(recovered_pub_key, public_key)
def test_hello_eth_message(self):
dummy_private_key = convert.hex_to_bytes(
"294549f8629f0eeb2b8e01aca491f701f5386a9662403b485c4efe7d447dfba3")
dummy_public_key = crypto_utils.private_to_public_key(
dummy_private_key)
self._test_msg_serialization(
HelloEthProtocolMessage,
False,
eth_common_constants.P2P_PROTOCOL_VERSION,
eth_common_constants.BX_ETH_CLIENT_NAME,
eth_common_constants.CAPABILITIES,
30303, # random port value
dummy_public_key)
def setUp(self):
self.local_node_fileno = 1
self.local_node_fileno_2 = 2
self.remote_node_fileno = 3
self.local_blockchain_ip = "127.0.0.1"
self.local_blockchain_port = 30303
self.local_blockchain_port_2 = 30302
eth_node_private_key = crypto_utils.make_private_key(helpers.generate_bytearray(111))
self.gateway_node = spies.make_spy_node(
EthGatewayNode, 8000, include_default_eth_args=True, blockchain_protocol="Ethereum",
blockchain_address=(self.local_blockchain_ip, self.local_blockchain_port),
blockchain_peers="enode://d76d7d11a822fab02836f8b0ea462205916253eb630935d15191fb6f9d218cd94a768fc5b3d5516b9ed5010a4765f95aea7124a39d0ab8aaf6fa3d57e21ef396@127.0.0.1:30302",
pub_key="d76d7d11a822fab02836f8b0ea462205916253eb630935d15191fb6f9d218cd94a768fc5b3d5516b9ed5010a4765f95aea7124a39d0ab8aaf6fa3d57e21ef396")
gateway_node_private_key = convert.hex_to_bytes(self.gateway_node.opts.private_key)
eth_node_public_key = crypto_utils.private_to_public_key(eth_node_private_key)
self.eth_node_cipher, gateway_cipher = self.setup_ciphers(eth_node_private_key, gateway_node_private_key)
self.gateway_node._node_public_key = eth_node_public_key
self.gateway_node._remote_public_key = eth_node_public_key
self.eth_node_connection = spies.make_spy_connection(EthNodeConnection, self.local_node_fileno,
self.local_blockchain_port, self.gateway_node)
self.eth_node_connection_2 = spies.make_spy_connection(EthNodeConnection, self.local_node_fileno_2,
self.local_blockchain_port_2, self.gateway_node)
self.eth_remote_node_connection = spies.make_spy_connection(EthRemoteConnection, self.remote_node_fileno, 8003,
self.gateway_node)
self.eth_node_connection._rlpx_cipher = gateway_cipher
self.eth_node_connection_2._rlpx_cipher = gateway_cipher
self.eth_node_connection.message_factory = EthProtocolMessageFactory(gateway_cipher)
self.eth_node_connection_2.message_factory = EthProtocolMessageFactory(gateway_cipher)
self.eth_remote_node_connection._rlpx_cipher = gateway_cipher
self.eth_remote_node_connection.message_factory = EthProtocolMessageFactory(gateway_cipher)
self.gateway_node.remote_node_conn = self.eth_remote_node_connection
self.gateway_node.connection_pool.add(
self.local_node_fileno, LOCALHOST, self.local_blockchain_port, self.eth_node_connection
)
self.gateway_node.connection_pool.add(
self.local_node_fileno_2, LOCALHOST, self.local_blockchain_port_2, self.eth_node_connection_2
)
self.gateway_node.connection_pool.add(self.remote_node_fileno, LOCALHOST, 8003, self.eth_remote_node_connection)
def setUp(self):
opts = gateway_helpers.get_gateway_opts(8000, include_default_eth_args=True,
track_detailed_sent_messages=True)
if opts.use_extensions:
helpers.set_extensions_parallelism()
self.node = MockGatewayNode(opts)
self.node.block_processing_service = MagicMock()
self.connection = MagicMock()
self.connection.node = self.node
self.connection.peer_ip = LOCALHOST
self.connection.peer_port = 8001
self.connection.network_num = 2
dummy_private_key = crypto_utils.make_private_key(helpers.generate_bytearray(111))
dummy_public_key = crypto_utils.private_to_public_key(dummy_private_key)
self.sut = EthBaseConnectionProtocol(self.connection, True, dummy_private_key, dummy_public_key)
def _init_ecc(self, raw_public_key, raw_private_key):
if raw_private_key:
assert not raw_public_key
raw_public_key = crypto_utils.private_to_public_key(
raw_private_key)
if raw_public_key:
assert len(raw_public_key) == eth_common_constants.PUBLIC_KEY_LEN
_, pubkey_x, pubkey_y, _ = self._decode_pubkey(raw_public_key)
else:
pubkey_x, pubkey_y = None, None
while True:
pyelliptic.ECC.__init__(self,
pubkey_x=pubkey_x,
pubkey_y=pubkey_y,
raw_privkey=raw_private_key,
curve=eth_common_constants.ECIES_CURVE)
# when raw_private_key is generated by pyelliptic it sometimes has 31 bytes so we try again!
if self.get_raw_private_key() and len(self.get_raw_private_key(
)) != eth_common_constants.PRIVATE_KEY_LEN:
continue
try:
if self.get_raw_private_key():
bitcoin.get_privkey_format(
self.get_raw_private_key()) # failed for some keys
valid_private_key = True
except AssertionError:
valid_private_key = False
if len(self.get_raw_public_key(
)) == eth_common_constants.PUBLIC_KEY_LEN and valid_private_key:
break
elif raw_private_key or raw_public_key:
raise Exception("invalid private or public key")
assert len(
self.get_raw_public_key()) == eth_common_constants.PUBLIC_KEY_LEN
def get_public_key(self) -> bytes:
return crypto_utils.private_to_public_key(self.get_private_key())
def _get_dummy_public_key(self):
dummy_private_key = crypto_utils.make_private_key(
helpers.generate_bytearray(111))
return crypto_utils.private_to_public_key(dummy_private_key)
def test_get_raw_public_key(self):
public_key = self._eccx.get_raw_public_key()
expected_public_key = crypto_utils.private_to_public_key(self._private_key)
self.assertEqual(public_key, expected_public_key)
def get_node_public_key(self, _ip, _port):
return crypto_utils.private_to_public_key(self.get_private_key())
def setUp(self):
self.node = MockGatewayNode(gateway_helpers.get_gateway_opts(
8000, include_default_eth_args=True, use_extensions=True),
block_queueing_cls=MagicMock())
self.node.message_converter = converter_factory.create_eth_message_converter(
self.node.opts)
self.node.block_processing_service = BlockProcessingService(self.node)
is_handshake_initiator = True
dummy_private_key = crypto_utils.make_private_key(
helpers.generate_bytearray(111))
dummy_public_key = crypto_utils.private_to_public_key(
dummy_private_key)
rlpx_cipher = RLPxCipher(is_handshake_initiator, dummy_private_key,
dummy_public_key)
node_ssl_service = MockNodeSSLService(EthGatewayNode.NODE_TYPE,
MagicMock())
local_ip = "127.0.0.1"
eth_port = 30303
eth_opts = gateway_helpers.get_gateway_opts(
1234,
include_default_eth_args=True,
blockchain_address=(local_ip, eth_port),
pub_key=convert.bytes_to_hex(dummy_public_key))
self.eth_node = EthGatewayNode(eth_opts, node_ssl_service)
self.blockchain_connection = EthNodeConnection(
MockSocketConnection(1,
node=self.node,
ip_address=local_ip,
port=30303), self.node)
self.blockchain_connection.on_connection_established()
self.node.connection_pool.add(19, local_ip, eth_port,
self.blockchain_connection)
self.blockchain_connection_1 = EthNodeConnection(
MockSocketConnection(1,
node=self.node,
ip_address=local_ip,
port=333), self.node)
self.blockchain_connection_1.on_connection_established()
self.node.mock_add_blockchain_peer(self.blockchain_connection_1)
self.node_1_endpoint = IpEndpoint(local_ip, 333)
self.node.connection_pool.add(20, self.node_1_endpoint.ip_address,
self.node_1_endpoint.port,
self.blockchain_connection_1)
self.blockchain_connection_2 = EthNodeConnection(
MockSocketConnection(1,
node=self.node,
ip_address=local_ip,
port=444), self.node)
self.blockchain_connection_2.on_connection_established()
self.node.mock_add_blockchain_peer(self.blockchain_connection_2)
self.node_2_endpoint = IpEndpoint(local_ip, 444)
self.node.connection_pool.add(21, self.node_2_endpoint.ip_address,
self.node_2_endpoint.port,
self.blockchain_connection_2)
self.blockchain_connection_1.network_num = 0
self.tx_blockchain_connection_protocol = EthNodeConnectionProtocol(
self.blockchain_connection_1, is_handshake_initiator, rlpx_cipher)
self.block_blockchain_connection_protocol = EthNodeConnectionProtocol(
self.blockchain_connection_1, is_handshake_initiator, rlpx_cipher)
self.tx_blockchain_connection_protocol.publish_transaction = MagicMock(
)
self.block_blockchain_connection_protocol.publish_transaction = MagicMock(
)
self.tx_blockchain_connection_protocol_2 = EthNodeConnectionProtocol(
self.blockchain_connection_2, is_handshake_initiator, rlpx_cipher)
self.block_blockchain_connection_protocol_2 = EthNodeConnectionProtocol(
self.blockchain_connection_2, is_handshake_initiator, rlpx_cipher)
self.tx_blockchain_connection_protocol_2.publish_transaction = MagicMock(
)
self.block_blockchain_connection_protocol_2.publish_transaction = MagicMock(
)
self.relay_connection = AbstractRelayConnection(
MockSocketConnection(1,
node=self.node,
ip_address=local_ip,
port=12345), self.node)
self.relay_connection.state = ConnectionState.INITIALIZED
gateway_bdn_performance_stats_service.set_node(self.node)
self.node.account_id = "12345"
