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