async def test_wait_neighbours(nursery):
service = MockDiscoveryService([])
addresses = [
AddressFactory(ip='10.0.0.1'),
AddressFactory(ip='10.0.0.2'),
AddressFactory(ip='10.0.0.3'),
AddressFactory(ip='10.0.0.4')
]
sender = NodeFactory(address=addresses[0])
# All our nodes are on the same network as the sender to ensure they pass the
# check_relayed_addr() check, otherwise in some rare cases we may get a random IP address
# that doesn't and it will be ignored by wait_neighbours, causing the test to fail.
neighbours = tuple(NodeFactory(address=address) for address in addresses[1:])
# Schedule a call to service.recv_neighbours_v4() simulating a neighbours response from the
# node we expect.
expiration = _get_msg_expiration()
neighbours_msg_payload = [
[n.address.to_endpoint() + [n.pubkey.to_bytes()] for n in neighbours],
expiration]
nursery.start_soon(service.recv_neighbours_v4, sender, neighbours_msg_payload, b'')
received_neighbours = await service.wait_neighbours(sender)
assert neighbours == received_neighbours
# Ensure wait_neighbours() cleaned up after itself.
assert not service.neighbours_channels.already_waiting_for(sender)
# If wait_neighbours() times out, we get an empty list of neighbours.
received_neighbours = await service.wait_neighbours(sender)
assert received_neighbours == tuple()
assert not service.neighbours_channels.already_waiting_for(sender)
async def test_lookup_and_maybe_update_enr_existing_node_different_address():
discovery = MockDiscoveryService([])
privkey = PrivateKeyFactory()
address = AddressFactory()
# If the address given is different than the one we have in our DB, though, a stub ENR would
# be created and stored in our DB, replacing the existing one.
enr = ENRFactory(private_key=privkey.to_bytes(), address=address)
discovery.enr_db.set_enr(enr)
new_address = AddressFactory()
lookedup_enr = discovery.lookup_and_maybe_update_enr(privkey.public_key, new_address)
assert lookedup_enr != enr
assert lookedup_enr.public_key == enr.public_key
assert lookedup_enr.sequence_number == 0
assert Node(lookedup_enr).address == new_address
assert lookedup_enr == discovery.enr_db.get_enr(enr.node_id)
def test_v5_handlers(monkeypatch):
# Ensure we dispatch v5 messages to the appropriate handlers.
# These are hex-encoded messages sent by geth over the wire, obtained via wireshark using the
# ethereum dissectors (https://github.com/ConsenSys/ethereum-dissectors).
v5_handlers = dict(
recv_topic_register=
'74656d706f7261727920646973636f766572792076354b1f9f999e3cf283e42270742eb3b52b1c0b63ede116ea58632517ffccc7516c794f6fc20f199b3a3a887f3e961b453bb9213eebad4581aaf9b2a60da7e5ba7b0106e2da954c455332406434653536373430663837366165663883666f6f8204d283666f6f', # noqa: E501
recv_pong_v5=
'74656d706f7261727920646973636f766572792076356cb538da9382c022cc6d9b860b7cc7660718c731e1e6331de86a7cabfba8f01c061b5d6c09dd84de1d6c653536bb8ad31fb140d55d317dfaea5225a6907f49450102f855cb84a5a587f2827660827660a0b484b40a3712766dbbe8498f110bab968a543f9d0d57ec4cfa3b38b32ef2f237831f5ca3a0bd1ea218eaf7cddc6b068a414ae08876315f92bd134e214d5f3961d1a3e8e35b4ec13c', # noqa: E501
recv_ping_v5=
'74656d706f7261727920646973636f76657279207635c26911f1d2a320f17fa683397028e6cc7ebe114623e28e933d870634aa6050f45960679170192ec0f133dbc3f4e627eef468dbdb48bf4a7848412938da21be8a0001f84104d79000000000000000000000000000000000827660827660cb84b0201d9282848b82848b845b7e5593d6954c4553324064346535363734306638373661656638', # noqa: E501
recv_find_nodehash=
'74656d706f7261727920646973636f7665727920763558dc895847c5d2cc9ab6f722f25b9ff1b9c188af6ff7ed7c716a3cde2e93f3ec1e2b897acb1a33aa1d345c72ea34912287b21480c80ef99241d4bd9fd53711ee0105e6a038f7bb96e94bcd39866baa56038367ad6145de1ee8f4a8b0993ebdf8883a0ad8845b7e5593', # noqa: E501
recv_topic_query=
'74656d706f7261727920646973636f76657279207635308621f1ed59a67613da52da3f84bac3d927d0dc1650b27552b10a0a823fb2133cebf3680f68bf88457bb0c07787031357430985d03afa1af0574e8ef0eab7fc0007d7954c455332406434653536373430663837366165663880', # noqa: E501
recv_topic_nodes=
'74656d706f7261727920646973636f76657279207635e33166b59d20f206f0df2502be59186cb971c76ee91dba94ea9b1bbeb1308a5f4efbdf945ead9ba89d7c2c55d5d841dacdef69a455c98e1a5415e489508afa450008f87ea0cff0456ecbf2e6b0a40bc6541bd209c60ced192509470b405c256a17443674b3f85bf8599000000000000000000000ffff904c1f9c82765f82765fb840e7d624c642b86d3d48cea3e395305345c3a0226fc4c2dfdfbeb94cb6891e5e72b4467c69684ac14b072d2e4fa9c7a731cc1fdf0283abe41186d00b4c879f80ed', # noqa: E501
recv_neighbours_v5=
'74656d706f7261727920646973636f766572792076358f6671ae9611c82c9cb04538aeed13a8b4e8eb8ad0d0dbba4b161ded52b195846c6086a0d42eef44cfcc0b793a0b9420613727958a8956139c127810b94d4e830004f90174f9016cf8599000000000000000000000ffff59401a22826597826597b840d723e264da67820fb0cedb0d03d5d975cc82bffdadd2879f3e5fa58b5525de5fdd0b90002bba44ac9232247dfbccb2a730e5ea98201bab1f1fe72422aa58143ff8599000000000000000000000ffffae6c601a82765f82765fb840779f19056e0a0486c3f6838896a931bf920cd8f551f664022a50690d4cca4730b50a97058aac11a5aa0cc55db6f9207e12a9cd389269f414a98e5b6a2f6c9f89f8599000000000000000000000ffff287603df827663827663b84085c85d7143ae8bb96924f2b54f1b3e70d8c4d367af305325d30a61385a432f247d2c75c45c6b4a60335060d072d7f5b35dd1d4c45f76941f62a4f83b6e75daaff8599000000000000000000000ffff0d4231b0820419820419b8407b46cc366b6cbaec088a7d15688a2c12bb8ba4cf7ee8e01b22ab534829f9ff13f7cc4130f10a4021f7d77e9b9c80a9777f5ddc035efb130fe3b6786434367973845b7e5569', # noqa: E501
)
proto = DiscoveryProtocolFactory()
addr = AddressFactory()
for handler, msg in v5_handlers.items():
mock_handler = MockHandler()
monkeypatch.setattr(proto, handler, mock_handler)
proto.datagram_received(decode_hex(msg), (addr.ip, addr.udp_port))
assert mock_handler.called
async def get_listening_discovery_protocol(event_loop):
addr = AddressFactory.localhost()
proto = DiscoveryProtocolFactory(address=addr)
await event_loop.create_datagram_endpoint(lambda: proto,
local_addr=(addr.ip,
addr.udp_port),
family=socket.AF_INET)
return proto
def __init__(self, bootnodes):
privkey = eth_keys.keys.PrivateKey(keccak(b"seed"))
self.messages = []
enr_db = ENRDB(MemoryDB(), default_identity_scheme_registry)
socket = trio.socket.socket(family=trio.socket.AF_INET, type=trio.socket.SOCK_DGRAM)
event_bus = None
address = AddressFactory()
super().__init__(
privkey, address.udp_port, address.tcp_port, bootnodes, event_bus, socket, enr_db)
def __init__(self, bootnodes):
privkey = keys.PrivateKey(keccak(b"seed"))
self.messages = []
enr_db = MemoryEnrDb(default_identity_scheme_registry)
socket = trio.socket.socket(family=trio.socket.AF_INET,
type=trio.socket.SOCK_DGRAM)
event_bus = None
super().__init__(privkey, AddressFactory(), bootnodes, event_bus,
socket, enr_db)
def __init__(self, bootnodes, honest_nodes: Set[NodeAPI],
malicious_nodes: Set[NodeAPI], malpg):
privkey = keys.PrivateKey(keccak(b"seed"))
self.messages = []
self.honest_nodes = honest_nodes
self.malicious_nodes = malicious_nodes
self.malpg = malpg
super().__init__(privkey, AddressFactory(), bootnodes,
CancelToken("discovery-test"))
def test_node_constructor():
privkey = PrivateKeyFactory()
address = AddressFactory()
enr = ENRFactory(private_key=privkey.to_bytes(), address=address)
node = Node(enr)
assert node.id == keccak(privkey.public_key.to_bytes())
assert node.address == address
def test_node_from_enr_uri():
privkey = PrivateKeyFactory()
address = AddressFactory()
enr = ENRFactory(private_key=privkey.to_bytes(), address=address)
node = Node.from_uri(repr(enr))
assert node.id == keccak(privkey.public_key.to_bytes())
assert node.address == address
def __init__(self, bootnodes):
privkey = keys.PrivateKey(keccak(b"seed"))
self.messages = []
socket = trio.socket.socket(family=trio.socket.AF_INET,
type=trio.socket.SOCK_DGRAM)
super().__init__(privkey,
AddressFactory(),
bootnodes,
event_bus=None,
socket=socket)
def test_discover_v4_message_pack():
sender, recipient = AddressFactory.create_batch(2)
version = rlp.sedes.big_endian_int.serialize(PROTO_VERSION)
payload = (version, sender.to_endpoint(), recipient.to_endpoint())
privkey = PrivateKeyFactory()
message = _pack_v4(CMD_PING.id, payload, privkey)
pubkey, cmd_id, payload, _ = _unpack_v4(message)
assert pubkey == privkey.public_key
assert cmd_id == CMD_PING.id
async def test_lookup_and_maybe_update_enr_existing_node():
discovery = MockDiscoveryService([])
privkey = PrivateKeyFactory()
address = AddressFactory()
# When we have an ENR for the given pubkey, and its address matches the given one, the
# existing ENR is returned.
enr = ENRFactory(private_key=privkey.to_bytes(), address=address)
discovery.enr_db.set_enr(enr)
lookedup_enr = discovery.lookup_and_maybe_update_enr(privkey.public_key, address)
assert lookedup_enr == enr
async def test_lookup_and_maybe_update_enr_new_node():
discovery = MockDiscoveryService([])
privkey = PrivateKeyFactory()
address = AddressFactory()
# When looking up the ENR for a node we haven't heard about before, we'll create a stub ENR
# and add that into our DB.
enr = discovery.lookup_and_maybe_update_enr(privkey.public_key, address)
assert enr.sequence_number == 0
node = Node(enr)
assert node.pubkey == privkey.public_key
assert node.address == address
db_enr = discovery.enr_db.get_enr(node.id)
assert db_enr == enr
def __init__(self, bootnodes):
privkey = keys.PrivateKey(keccak(b"seed"))
self.messages = []
super().__init__(privkey, AddressFactory(), bootnodes,
CancelToken("discovery-test"))
