def test_ipv4_parsing_udp_in_ipv4(ipv4: MessageValue) -> None: with open("tests/ipv4_udp.raw", "rb") as file: msg_as_bytes: bytes = file.read() ipv4.parse(msg_as_bytes) nested_udp = ipv4.get("Payload") assert isinstance(nested_udp, MessageValue) assert nested_udp.valid_message
def test_in_ipv4_parsing_udp_in_ipv4(ipv4_packet_value: pyrflx.MessageValue) -> None: with open(CAPTURED_DIR / "ipv4_udp.raw", "rb") as file: msg_as_bytes: bytes = file.read() ipv4_packet_value.parse(msg_as_bytes) nested_udp = ipv4_packet_value.get("Payload") assert isinstance(nested_udp, pyrflx.MessageValue) assert nested_udp.valid_message
def test_ethernet_set_nonlinear(ethernet_frame_value: MessageValue) -> None: assert ethernet_frame_value.accessible_fields == [ "Destination", "Source", "Type_Length_TPID" ] ethernet_frame_value.set("Type_Length_TPID", 0x8100) ethernet_frame_value.set("TCI", 100) assert ethernet_frame_value.valid_fields == ["Type_Length_TPID", "TCI"]
def test_no_verification_sequence_nested_messages( sequence_message_package: Package, message_sequence_value: MessageValue) -> None: sequence_message_one = sequence_message_package.new_message( "Sequence_Element") sequence_message_one.set("Byte", 5) sequence_message_two = sequence_message_package.new_message( "Sequence_Element") sequence_message_two.set("Byte", 6) sequence: List[TypeValue] = [sequence_message_one, sequence_message_two] message_sequence_value.set("Length", 2) message_sequence_value.set("Sequence_Field", sequence) assert message_sequence_value.valid_message pyrflx_ = PyRFLX.from_specs( [SPEC_DIR / "sequence_message.rflx"], skip_model_verification=True, skip_message_verification=True, ) sequence_message_package_unv = pyrflx_.package("Sequence_Message") sequence_message_unv = sequence_message_package_unv.new_message( "Message_Sequence") sequence_element_one_unv = sequence_message_package_unv.new_message( "Sequence_Element") sequence_element_one_unv.set("Byte", 5) sequence_element_two_unv = sequence_message_package_unv.new_message( "Sequence_Element") sequence_element_two_unv.set("Byte", 6) sequence_unv: List[TypeValue] = [ sequence_element_one_unv, sequence_element_two_unv ] sequence_message_unv.set("Length", 2) sequence_message_unv.set("Sequence_Field", sequence_unv) assert sequence_message_unv.valid_message assert sequence_message_unv.bytestring == message_sequence_value.bytestring
def test_ethernet_802_3(frame: MessageValue) -> None: frame.set("Destination", 2 ** 48 - 1) frame.set("Source", 0) frame.set("Type_Length_TPID", 46) frame.set("Type_Length", 46) frame.set( "Payload", ( b"\x45\x00\x00\x14" b"\x00\x01\x00\x00" b"\x40\x00\x7c\xe7" b"\x7f\x00\x00\x01" b"\x7f\x00\x00\x01" b"\x00\x00\x00\x00" b"\x00\x00\x00\x00" b"\x00\x00\x00\x00" b"\x00\x00\x00\x00" b"\x00\x00\x00\x00" b"\x00\x00\x00\x00" b"\x00\x00" ), ) assert frame.valid_message with open(f"{TESTDIR}/ethernet_802.3.raw", "rb") as raw: assert frame.bytestring == raw.read()
def test_tlv_parsing_invalid_tlv_invalid_tag(tlv: MessageValue) -> None: test_bytes = b"\x00\x00" with pytest.raises( ValueError, match="Error while setting value for field Tag: 'Number 0 is not a valid enum value'", ): tlv.parse(test_bytes) assert not tlv.valid_message
def test_tls_invalid_outgoing(tls_record: MessageValue) -> None: tls_record.set("Tag", "INVALID") with pytest.raises( ValueError, match=r"none of the field conditions .* for field Length" " have been met by the assigned value: 16385", ): tls_record.set("Length", 2 ** 14 + 1)
def test_tlv_set_invalid_field(tlv_checksum: MessageValue) -> None: tlv_checksum.set("Tag", "Msg_Data") with pytest.raises(KeyError, match=r"cannot access field Value"): tlv_checksum.set("Value", b"") with pytest.raises(KeyError, match=r"cannot access field Checksum"): tlv_checksum.set("Checksum", 8) tlv_checksum.set("Tag", "Msg_Error") with pytest.raises(KeyError, match=r"cannot access field Length"): tlv_checksum.set("Length", 8)
def test_tlv_value(tlv_checksum: MessageValue) -> None: v1 = b"\x01\x02\x03\x04\x05\x06\x07\x08" tlv_checksum.set("Tag", "Msg_Data") tlv_checksum.set("Length", 8) tlv_checksum.set("Value", v1) tlv_checksum.set("Checksum", 2 ** 32 - 1) assert tlv_checksum.get("Tag") == "Msg_Data" assert tlv_checksum.get("Length") == 8 assert tlv_checksum.get("Value") == v1 assert tlv_checksum.get("Checksum") == 0xFFFFFFFF
def test_tls_fields(tls_record: MessageValue) -> None: assert tls_record.accessible_fields == ["Tag", "Legacy_Record_Version", "Length"] tls_record.set("Tag", "INVALID") tls_record.set("Length", 3) assert tls_record.accessible_fields == [ "Tag", "Legacy_Record_Version", "Length", "Fragment", ]
def test_array_nested_messages(array_message_package: Package, array_message: MessageValue) -> None: array_message_one = array_message_package["Foo"] array_message_one.set("Byte", 5) array_message_two = array_message_package["Foo"] array_message_two.set("Byte", 6) foos: List[TypeValue] = [array_message_one, array_message_two] array_message.set("Length", 2) array_message.set("Bar", foos) assert array_message.valid_message assert array_message.bytestring == b"\x02\x05\x06"
def test_ethernet_parsing_invalid_ethernet_2_too_long(frame: MessageValue) -> None: with open("tests/ethernet_invalid_too_long.raw", "rb") as file: msg_as_bytes: bytes = file.read() with pytest.raises( ValueError, match=r"none of the field conditions .* for field Payload" " have been met by the assigned value: [01]*", ): frame.parse(msg_as_bytes) assert not frame.valid_message
def test_ethernet_parsing_ieee_802_3_invalid_length(frame: MessageValue) -> None: with open("tests/ethernet_802.3_invalid_length.raw", "rb") as file: msg_as_bytes: bytes = file.read() with pytest.raises( IndexError, match="Bitstring representing the message is too short" " - stopped while parsing field: Payload", ): frame.parse(msg_as_bytes) assert not frame.valid_message
def test_icmp_parse_binary(icmp_message_value: MessageValue) -> None: test_bytes = ( b"\x08\x00\xe1\x1e\x00\x11\x00\x01\x4a\xfc\x0d\x00\x00\x00\x00\x00" b"\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f" b"\x20\x21\x22\x23\x24\x25\x26\x27\x28\x29\x2a\x2b\x2c\x2d\x2e\x2f" b"\x30\x31\x32\x33\x34\x35\x36\x37") icmp_message_value.parse(test_bytes) assert icmp_message_value.valid_message assert icmp_message_value.bytestring == test_bytes assert icmp_message_value.accepted_type == bytes assert icmp_message_value.size == Number(448)
def test_check_nodes_opaque(tlv_checksum: MessageValue, frame: MessageValue) -> None: # pylint: disable=protected-access assert tlv_checksum._is_valid_opaque_field("Length") assert not tlv_checksum._is_valid_opaque_field("Value") frame.set("Destination", 2 ** 48 - 1) frame.set("Source", 0) frame.set("Type_Length_TPID", 1501) assert not frame._is_valid_opaque_field("Payload")
def test_tlv_first_unchecked(tlv_checksum: MessageValue) -> None: # pylint: disable=protected-access tlv_checksum.set("Tag", "Msg_Error") assert not isinstance(tlv_checksum._get_first_unchecked("Checksum"), Number) tlv_checksum.set("Tag", "Msg_Data") assert not isinstance(tlv_checksum._get_first_unchecked("Checksum"), Number) tlv_checksum.set("Length", 1) assert isinstance(tlv_checksum._get_first_unchecked("Checksum"), Number)
def test_ethernet_parsing_invalid_ethernet_2_too_long( ethernet_frame_value: pyrflx.MessageValue, ) -> None: with open(CAPTURED_DIR / "ethernet_invalid_too_long.raw", "rb") as file: msg_as_bytes: bytes = file.read() with pytest.raises( PyRFLXError, match=r"^pyrflx: error: none of the field conditions .* for field Payload" " have been met by the assigned value: [01]*$", ): ethernet_frame_value.parse(msg_as_bytes) assert not ethernet_frame_value.valid_message
def test_in_ipv4_parsing_udp_in_ipv4_in_ethernet(ethernet_frame_value: pyrflx.MessageValue) -> None: with open(CAPTURED_DIR / "ethernet_ipv4_udp.raw", "rb") as file: msg_as_bytes: bytes = file.read() ethernet_frame_value.parse(msg_as_bytes) nested_ipv4 = ethernet_frame_value.get("Payload") assert isinstance(nested_ipv4, pyrflx.MessageValue) assert nested_ipv4.valid_message assert nested_ipv4.identifier == ID("IPv4") * "Packet" nested_udp = nested_ipv4.get("Payload") assert isinstance(nested_udp, pyrflx.MessageValue) assert nested_udp.valid_message assert nested_udp.identifier == ID("UDP") * "Datagram"
def test_ethernet_parsing_ethernet_2(frame: MessageValue) -> None: with open("tests/ethernet_ipv4_udp.raw", "rb") as file: msg_as_bytes: bytes = file.read() frame.parse(msg_as_bytes) assert frame.get("Destination") == int("ffffffffffff", 16) assert frame.get("Source") == int("0", 16) assert frame.get("Type_Length_TPID") == int("0800", 16) k = frame._fields["Payload"].typeval.size assert isinstance(k, Number) assert k.value // 8 == 46 assert frame.valid_message assert frame.bytestring == msg_as_bytes
def test_ethernet_parsing_ethernet_2(ethernet_frame_value: pyrflx.MessageValue) -> None: with open(CAPTURED_DIR / "ethernet_ipv4_udp.raw", "rb") as file: msg_as_bytes: bytes = file.read() ethernet_frame_value.parse(msg_as_bytes) assert ethernet_frame_value.get("Destination") == int("ffffffffffff", 16) assert ethernet_frame_value.get("Source") == int("0", 16) assert ethernet_frame_value.get("Type_Length_TPID") == int("0800", 16) k = ethernet_frame_value._fields["Payload"].typeval.size assert isinstance(k, expr.Number) assert k.value // 8 == 46 assert ethernet_frame_value.valid_message assert ethernet_frame_value.bytestring == msg_as_bytes
def test_array_nested_values(array_type_foo: MessageValue) -> None: a = IntegerValue(ModularInteger("Array_Type.Byte_One", Number(256))) b = IntegerValue(ModularInteger("Array_Type.Byte_Two", Number(256))) c = IntegerValue(ModularInteger("Array_Type.Byte_Three", Number(256))) a.assign(5) b.assign(6) c.assign(7) byte_array = [a, b, c] array_type_foo.set("Length", 3) array_type_foo.set("Bytes", byte_array) assert array_type_foo.valid_message assert array_type_foo.bytestring == b"\x03\x05\x06\x07"
def test_ethernet_parse_binary(frame: MessageValue) -> None: test_bytes = ( b"\xe0\x28\x6d\x39\x80\x1e\x1c\x1b\x0d\xe0\xd8\xa8\x08\x00\x45\x00" b"\x00\x4c\x1f\x04\x40\x00\x40\x01\xe1\x6a\xc0\xa8\xbc\x3d\xac\xd9" b"\x10\x83\x08\x00\xe1\x26\x00\x09\x00\x01\x4a\xfc\x0d\x00\x00\x00" b"\x00\x00\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d" b"\x1e\x1f\x20\x21\x22\x23\x24\x25\x26\x27\x28\x29\x2a\x2b\x2c\x2d" b"\x2e\x2f\x30\x31\x32\x33\x34\x35\x36\x37" ) frame.parse(test_bytes) assert frame.valid_message assert frame.bytestring == test_bytes
def test_ipv4_parsing_udp_in_ipv4_in_ethernet(frame: MessageValue) -> None: with open("tests/ethernet_ipv4_udp.raw", "rb") as file: msg_as_bytes: bytes = file.read() frame.parse(msg_as_bytes) nested_ipv4 = frame.get("Payload") assert isinstance(nested_ipv4, MessageValue) assert nested_ipv4.valid_message assert nested_ipv4.identifier == ID("IPv4.Packet") nested_udp = nested_ipv4.get("Payload") assert isinstance(nested_udp, MessageValue) assert nested_udp.valid_message assert nested_udp.identifier == ID("UDP.Datagram")
def test_valid_message(tlv_checksum: MessageValue) -> None: assert not tlv_checksum.valid_message tlv_checksum.set("Tag", "Msg_Error") assert tlv_checksum.valid_message tlv_checksum.set("Tag", "Msg_Data") assert not tlv_checksum.valid_message tlv_checksum.set("Length", 1) assert not tlv_checksum.valid_message tlv_checksum.set("Value", b"\x01") assert not tlv_checksum.valid_message tlv_checksum.set("Checksum", 0xFFFFFFFF) assert tlv_checksum.valid_message
def test_ethernet_final(frame: MessageValue) -> None: assert not frame.valid_message frame.set("Destination", 0) assert not frame.valid_message frame.set("Source", 1) assert not frame.valid_message frame.set("Type_Length_TPID", 46) assert not frame.valid_message frame.set("Type_Length", 46) assert not frame.valid_message frame.set("Payload", bytes(46)) assert frame.valid_message
def test_tlv_parsing_invalid_tlv_invalid_tag(tlv_message_value: pyrflx.MessageValue) -> None: test_bytes = b"\x00\x00" with pytest.raises( PyRFLXError, match=( "^" "pyrflx: error: cannot set value for field Tag\n" "pyrflx: error: Number 0 is not a valid enum value" "$" ), ): tlv_message_value.parse(test_bytes) assert not tlv_message_value.valid_message
def test_ethernet_parsing_incomplete(ethernet_frame_value: pyrflx.MessageValue) -> None: test_bytes = b"\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x02" with pytest.raises( PyRFLXError, match="^pyrflx: error: Bitstring representing the message is too short" " - stopped while parsing field: Type_Length_TPID$", ): ethernet_frame_value.parse(test_bytes) assert ethernet_frame_value.get("Destination") == int("000000000001", 16) assert ethernet_frame_value.get("Source") == int("000000000002", 16) assert len(ethernet_frame_value.valid_fields) == 2 assert not ethernet_frame_value.valid_message
def test_ethernet_parsing_ieee_802_3_invalid_length( ethernet_frame_value: pyrflx.MessageValue, ) -> None: with open(CAPTURED_DIR / "ethernet_802.3_invalid_length.raw", "rb") as file: msg_as_bytes: bytes = file.read() with pytest.raises( PyRFLXError, match="^pyrflx: error: Bitstring representing the message is too short" " - stopped while parsing field: Payload$", ): ethernet_frame_value.parse(msg_as_bytes) assert not ethernet_frame_value.valid_message
def test_ethernet_parsing_incomplete(frame: MessageValue) -> None: test_bytes = b"\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x02" with pytest.raises( IndexError, match="Bitstring representing the message is too short" " - stopped while parsing field: Type_Length_TPID", ): frame.parse(test_bytes) assert frame.get("Destination") == int("000000000001", 16) assert frame.get("Source") == int("000000000002", 16) assert len(frame.valid_fields) == 2 assert not frame.valid_message
def test_ipv4_generating_ipv4_option_value(ipv4_option_value: pyrflx.MessageValue) -> None: ipv4_option_value.set("Copied", "False") ipv4_option_value.set("Option_Class", "Debugging_And_Measurement") ipv4_option_value.set("Option_Number", 4) ipv4_option_value.set("Option_Length", 3) ipv4_option_value.set("Option_Data", b"\x2a") assert ipv4_option_value.valid_message