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
