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_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_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_ipv4_parsing_ipv4_option_value(ipv4_option_value: pyrflx.MessageValue) -> None:
expected = b"\x44\x03\x2a"
ipv4_option_value.parse(expected)
assert ipv4_option_value.get("Copied") == "False"
assert ipv4_option_value.get("Option_Class") == "IPv4::Debugging_And_Measurement"
assert ipv4_option_value.get("Option_Number") == 4
assert ipv4_option_value.get("Option_Length") == 3
ip_option = ipv4_option_value.get("Option_Data")
assert isinstance(ip_option, bytes)
assert len(ip_option) == 1
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_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_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_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_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_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_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_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_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_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(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_bitstring(tlv_checksum: MessageValue) -> None:
with pytest.raises(ValueError, match="Bitstring does not consist of only 0 and 1"):
Bitstring("123")
assert Bitstring("01") + Bitstring("00") == Bitstring("0100")
test_bytes = b"\x40"
with pytest.raises(
IndexError,
match=(
"Bitstring representing the message is too short"
" - stopped while parsing field: Length"
),
):
tlv_checksum.parse(test_bytes)
assert not tlv_checksum.valid_message
def test_in_ipv4_generating_udp_in_ipv4_in_ethernet(
ethernet_frame_value: pyrflx.MessageValue,
ipv4_packet_value: pyrflx.MessageValue,
udp_datagram_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)
parsed_frame = ethernet_frame_value.bytestring
b = b""
for _ in itertools.repeat(None, 18):
b += b"\x00"
udp_datagram_value.set("Source_Port", 53)
udp_datagram_value.set("Destination_Port", 53)
udp_datagram_value.set("Length", 26)
udp_datagram_value.set("Checksum", int("014E", 16))
udp_datagram_value.set("Payload", b)
udp_binary = udp_datagram_value.bytestring
ipv4_packet_value.set("Version", 4)
ipv4_packet_value.set("IHL", 5)
ipv4_packet_value.set("DSCP", 0)
ipv4_packet_value.set("ECN", 0)
ipv4_packet_value.set("Total_Length", 46)
ipv4_packet_value.set("Identification", 1)
ipv4_packet_value.set("Flag_R", "False")
ipv4_packet_value.set("Flag_DF", "False")
ipv4_packet_value.set("Flag_MF", "False")
ipv4_packet_value.set("Fragment_Offset", 0)
ipv4_packet_value.set("TTL", 64)
ipv4_packet_value.set("Protocol", "P_UDP")
ipv4_packet_value.set("Header_Checksum", int("7CBC", 16))
ipv4_packet_value.set("Source", int("7f000001", 16))
ipv4_packet_value.set("Destination", int("7f000001", 16))
ipv4_packet_value.set("Options", [])
ipv4_packet_value.set("Payload", udp_binary)
ip_binary = ipv4_packet_value.bytestring
ethernet_frame_value.set("Destination", int("FFFFFFFFFFFF", 16))
ethernet_frame_value.set("Source", int("0", 16))
ethernet_frame_value.set("Type_Length_TPID", int("0800", 16))
ethernet_frame_value.set("Type_Length", int("0800", 16))
ethernet_frame_value.set("Payload", ip_binary)
assert ethernet_frame_value.valid_message
assert ethernet_frame_value.bytestring == parsed_frame
def test_incorrect_nested_message(frame: MessageValue) -> None:
incorrect_message = (
b"\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00"
b"\x81\x00\x00\x01\x08\x00\x45\x00\x00\xe2\x00\x01"
b"\x00\x00\x40\x00\x7c\xe7\x7f\x00\x00\x01\x7f\x00"
b"\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
b"\x00\x00\x00\x00\x0a"
)
with pytest.raises(
ValueError,
match="Error while setting value for field Payload: "
"Error while parsing nested message IPv4.Packet: "
"Bitstring representing the message is too short - "
"stopped while parsing field: Payload",
):
frame.parse(incorrect_message)
def test_ipv4_parsing_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)
assert ipv4_packet_value.get("Version") == 4
assert ipv4_packet_value.get("IHL") == 5
assert ipv4_packet_value.get("DSCP") == 0
assert ipv4_packet_value.get("ECN") == 0
assert ipv4_packet_value.get("Total_Length") == 44
assert ipv4_packet_value.get("Identification") == 1
assert ipv4_packet_value.get("Flag_R") == "False"
assert ipv4_packet_value.get("Flag_DF") == "False"
assert ipv4_packet_value.get("Flag_MF") == "False"
assert ipv4_packet_value.get("Fragment_Offset") == 0
assert ipv4_packet_value.get("TTL") == 64
assert ipv4_packet_value.get("Protocol") == "IPv4::P_UDP"
assert ipv4_packet_value.get("Header_Checksum") == int("7CBE", 16)
assert ipv4_packet_value.get("Source") == int("7f000001", 16)
assert ipv4_packet_value.get("Destination") == int("7f000001", 16)
assert ipv4_packet_value._fields["Payload"].typeval.size == expr.Number(192)
def test_tlv_parsing_tlv_data(tlv_message_value: pyrflx.MessageValue) -> None:
test_bytes = b"\x01\x00\x04\x00\x00\x00\x00"
tlv_message_value.parse(test_bytes)
assert tlv_message_value.valid_message
assert tlv_message_value.bytestring == test_bytes
def test_ethernet_parsing_ieee_802_3(ethernet_frame_value: pyrflx.MessageValue) -> None:
with open(CAPTURED_DIR / "ethernet_802.3.raw", "rb") as file:
msg_as_bytes: bytes = file.read()
ethernet_frame_value.parse(msg_as_bytes)
assert ethernet_frame_value.valid_message
assert ethernet_frame_value.bytestring == msg_as_bytes
def test_array_parse_from_bytes(array_message: MessageValue, array_type_foo: MessageValue) -> None:
array_message.parse(b"\x02\x05\x06")
assert array_message.bytestring == b"\x02\x05\x06"
array_type_foo.parse(b"\x03\x05\x06\x07")
assert array_type_foo.bytestring == b"\x03\x05\x06\x07"
def test_odd_length_binary(message_odd_length: MessageValue) -> None:
test_bytes = b"\x01\x02\x01\xff\xb8"
message_odd_length.parse(test_bytes)
assert message_odd_length.valid_message
def test_tlv_parsing_tlv_data_zero(tlv_message_value: pyrflx.MessageValue) -> None:
test_bytes = b"\x01\x00\x00"
tlv_message_value.parse(test_bytes)
assert tlv_message_value.get("Tag") == "TLV::Msg_Data"
assert tlv_message_value.get("Length") == 0
assert tlv_message_value.valid_message
def test_tlv_parsing_tlv_error(tlv_message_value: pyrflx.MessageValue) -> None:
test_bytes = b"\x03"
tlv_message_value.parse(test_bytes)
assert tlv_message_value.get("Tag") == "TLV::Msg_Error"
assert tlv_message_value.valid_message
def test_tlv_parsing_tlv_data_zero(tlv: MessageValue) -> None:
test_bytes = b"\x40\x00"
tlv.parse(test_bytes)
assert tlv.get("Tag") == "Msg_Data"
assert tlv.get("Length") == 0
assert tlv.valid_message
def test_ipv4_parsing_ipv4_with_options(ipv4_packet_value: pyrflx.MessageValue) -> None:
with open(CAPTURED_DIR / "ipv4-options_udp.raw", "rb") as file:
msg_as_bytes: bytes = file.read()
ipv4_packet_value.parse(msg_as_bytes)
assert ipv4_packet_value.valid_message
def test_tlv_parsing_tlv_error(tlv: MessageValue) -> None:
test_bytes = b"\xc0"
tlv.parse(test_bytes)
assert tlv.get("Tag") == "Msg_Error"
assert tlv.valid_message
