async def test_packet_decoder_error():
datagram_send_channel, datagram_receive_channel = trio.open_memory_channel(
1)
packet_send_channel, packet_receive_channel = trio.open_memory_channel(1)
async with background_service(
PacketDecoder(datagram_receive_channel, packet_send_channel)):
# send invalid packet
await datagram_send_channel.send(
IncomingDatagram(
datagram=b"not a valid packet",
sender_endpoint=EndpointFactory(),
))
# send valid packet
packet = AuthTagPacketFactory()
sender_endpoint = EndpointFactory()
await datagram_send_channel.send(
IncomingDatagram(
datagram=packet.to_wire_bytes(),
sender_endpoint=sender_endpoint,
))
# ignore the invalid one, only receive the valid one
with trio.fail_after(0.5):
incoming_packet = await packet_receive_channel.receive()
assert incoming_packet.packet == packet
assert incoming_packet.sender_endpoint.ip_address == sender_endpoint.ip_address
assert incoming_packet.sender_endpoint.port == sender_endpoint.port
def test_auth_tag_packet_encoding_decoding(tag, auth_tag,
encrypted_message_size):
encrypted_message = b"\x00" * encrypted_message_size
original_packet = AuthTagPacketFactory(
tag=tag,
auth_tag=auth_tag,
encrypted_message=encrypted_message,
)
encoded_packet = original_packet.to_wire_bytes()
decoded_packet = decode_message_packet(encoded_packet)
assert isinstance(decoded_packet, AuthTagPacket)
assert decoded_packet == original_packet
async def test_packet_decoder():
datagram_send_channel, datagram_receive_channel = trio.open_memory_channel(1)
packet_send_channel, packet_receive_channel = trio.open_memory_channel(1)
service = PacketDecoder(datagram_receive_channel, packet_send_channel)
async with background_trio_service(service):
packet = AuthTagPacketFactory()
sender_endpoint = EndpointFactory()
await datagram_send_channel.send(IncomingDatagram(
datagram=packet.to_wire_bytes(),
sender_endpoint=sender_endpoint,
))
with trio.fail_after(0.5):
incoming_packet = await packet_receive_channel.receive()
assert incoming_packet.packet == packet
assert incoming_packet.sender_endpoint.ip_address == sender_endpoint.ip_address
assert incoming_packet.sender_endpoint.port == sender_endpoint.port
async def test_packet_encoder():
packet_send_channel, packet_receive_channel = trio.open_memory_channel(1)
datagram_send_channel, datagram_receive_channel = trio.open_memory_channel(1)
service = PacketEncoder(packet_receive_channel, datagram_send_channel)
async with background_trio_service(service):
receiver_endpoint = EndpointFactory()
outgoing_packet = OutgoingPacket(
packet=AuthTagPacketFactory(),
receiver_endpoint=receiver_endpoint,
)
await packet_send_channel.send(outgoing_packet)
with trio.fail_after(0.5):
outgoing_datagram = await datagram_receive_channel.receive()
assert outgoing_datagram.datagram == outgoing_packet.packet.to_wire_bytes()
assert outgoing_datagram.receiver_endpoint.ip_address == receiver_endpoint.ip_address
assert outgoing_datagram.receiver_endpoint.port == receiver_endpoint.port
def test_oversize_auth_tag_packet_encoding():
packet = AuthTagPacketFactory(encrypted_message=b"\x00" *
(MAX_PACKET_SIZE -
(1 + TAG_SIZE) - NONCE_SIZE + 1), )
with pytest.raises(ValidationError):
packet.to_wire_bytes()
(b"\x00" * 11, b"", 0)), # invalid nonce
# too long
b"\x00" * MAGIC_SIZE + rlp.encode(
(b"\x00" * NONCE_SIZE, b"\x00" * 2000, 0)),
))
def test_invalid_who_are_you_decoding(encoded_packet):
with pytest.raises(ValidationError):
decode_who_are_you_packet(encoded_packet)
def test_invalid_who_are_you_encoding():
packet = WhoAreYouPacket(
magic=b"\x00" * MAGIC_SIZE,
token=b"\x00" * NONCE_SIZE,
id_nonce=b"\x00" * 2000,
enr_sequence_number=0,
)
with pytest.raises(ValidationError):
packet.to_wire_bytes()
@pytest.mark.parametrize("packet", (
WhoAreYouPacketFactory(),
AuthTagPacketFactory(),
AuthHeaderPacketFactory(),
))
def test_packet_decoding(packet):
encoded_packet = packet.to_wire_bytes()
decoded_packet = decode_packet(encoded_packet)
assert decoded_packet == packet