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_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_tlv_prev(tlv_checksum: MessageValue) -> None:
# pylint: disable=protected-access
tlv_checksum.set("Tag", "Msg_Data")
assert tlv_checksum._prev_field("Tag") == INITIAL.name
assert tlv_checksum._prev_field(INITIAL.name) == ""
tlv_checksum.set("Tag", "Msg_Error")
assert tlv_checksum._prev_field("Length") == ""
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_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_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_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_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_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_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
def test_ethernet_payload(frame: MessageValue) -> None:
frame.set("Source", 0)
frame.set("Destination", 0)
frame.set("Type_Length_TPID", 47)
frame.set("Type_Length", 1537)
assert frame.accessible_fields == [
"Destination",
"Source",
"Type_Length_TPID",
"Type_Length",
"Payload",
]
frame.set("Payload", bytes(46))
assert frame.valid_message
def test_ethernet_set_tltpid(ethernet_frame_value: MessageValue) -> None:
ethernet_frame_value.set("Destination", 0)
ethernet_frame_value.set("Source", 1)
ethernet_frame_value.set("Type_Length_TPID", 0x8100)
assert ethernet_frame_value.valid_fields == [
"Destination", "Source", "Type_Length_TPID"
]
assert ethernet_frame_value.accessible_fields == [
"Destination",
"Source",
"Type_Length_TPID",
"TPID",
"TCI",
"Type_Length",
]
ethernet_frame_value.set("Type_Length_TPID", 64)
assert ethernet_frame_value.valid_fields == [
"Destination", "Source", "Type_Length_TPID"
]
assert ethernet_frame_value.accessible_fields == [
"Destination",
"Source",
"Type_Length_TPID",
"Type_Length",
]
def test_ethernet_generating_ethernet_2(ethernet_frame_value: pyrflx.MessageValue) -> None:
payload = (
b"\x45\x00\x00\x2e\x00\x01\x00\x00\x40\x11\x7c\xbc"
b"\x7f\x00\x00\x01\x7f\x00\x00\x01\x00\x35\x00\x35"
b"\x00\x1a\x01\x4e\x00\x00\x00\x00\x00\x00\x00\x00"
b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
)
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", payload)
with open(CAPTURED_DIR / "ethernet_ipv4_udp.raw", "rb") as file:
msg_as_bytes: bytes = file.read()
assert ethernet_frame_value.bytestring == msg_as_bytes
def test_tlv_generate(tlv_checksum: MessageValue) -> None:
test_payload = b"\x01\x02\x03\x04\x05\x06\x07\x08"
test_data = b"\x40\x08" + test_payload + b"\xff\xff\xff\xff"
tlv_checksum.set("Tag", "Msg_Data")
tlv_checksum.set("Length", 8)
tlv_checksum.set("Value", test_payload)
tlv_checksum.set("Checksum", 0xFFFFFFFF)
assert tlv_checksum.bytestring == test_data
def test_ethernet_invalid(frame: MessageValue) -> None:
frame.set("Destination", 2 ** 48 - 1)
frame.set("Source", 0)
frame.set("Type_Length_TPID", 1501)
with pytest.raises(
ValueError,
match=r"none of the field conditions .* for field Type_Length"
" have been met by the assigned value: 1501",
):
frame.set("Type_Length", 1501)
def test_tlv_required_fields(tlv_checksum: MessageValue) -> None:
assert tlv_checksum.required_fields == ["Tag"]
tlv_checksum.set("Tag", "Msg_Data")
assert tlv_checksum.required_fields == ["Length"]
tlv_checksum.set("Length", 1)
assert tlv_checksum.required_fields == ["Value", "Checksum"]
tlv_checksum.set("Value", b"\x01")
assert tlv_checksum.required_fields == ["Checksum"]
tlv_checksum.set("Checksum", 0xFFFFFFFF)
assert tlv_checksum.required_fields == []
def test_sequence_message_serialization(
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
assert message_sequence_value.as_json() == {
"Length": {
"first": 0,
"last": 7,
"value": 2
},
"Sequence_Field": {
"first":
8,
"last":
23,
"value": [
{
"Byte": {
"first": 0,
"last": 7,
"value": 5
}
},
{
"Byte": {
"first": 0,
"last": 7,
"value": 6
}
},
],
},
}
def test_tlv_generating_tlv_data(tlv_message_value: pyrflx.MessageValue) -> None:
expected = b"\x01\x00\x04\x00\x00\x00\x00"
tlv_message_value.set("Tag", "Msg_Data")
tlv_message_value.set("Length", 4)
tlv_message_value.set("Value", b"\x00\x00\x00\x00")
assert tlv_message_value.valid_message
assert tlv_message_value.bytestring == expected
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_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_tls_invalid_path(alert: MessageValue) -> None:
alert.set("Level", "WARNING")
alert.set("Description", "CLOSE_NOTIFY")
assert alert.valid_message
assert alert.valid_fields == ["Level", "Description"]
alert.set("Level", "FATAL")
assert not alert.valid_message
assert alert.valid_fields == ["Level"]
def test_ethernet_802_3(ethernet_frame_value: MessageValue) -> None:
ethernet_frame_value.set("Destination", 2**48 - 1)
ethernet_frame_value.set("Source", 0)
ethernet_frame_value.set("Type_Length_TPID", 46)
ethernet_frame_value.set("Type_Length", 46)
ethernet_frame_value.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 ethernet_frame_value.valid_message
with open(CAPTURED_DIR / "ethernet_802.3.raw", "rb") as raw:
assert ethernet_frame_value.bytestring == raw.read()
def test_ethernet_generating_ieee_802_3(ethernet_frame_value: pyrflx.MessageValue) -> None:
payload = (
b"\x45\x00\x00\x14\x00\x01\x00\x00\x40\x00\x7c\xe7"
b"\x7f\x00\x00\x01\x7f\x00\x00\x01\x00\x00\x00\x00"
b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
)
ethernet_frame_value.set("Destination", int("FFFFFFFFFFFF", 16))
ethernet_frame_value.set("Source", int("0", 16))
ethernet_frame_value.set("Type_Length_TPID", 46)
ethernet_frame_value.set("Type_Length", 46)
ethernet_frame_value.set("Payload", payload)
assert ethernet_frame_value.valid_message
with open(CAPTURED_DIR / "ethernet_802.3.raw", "rb") as file:
msg_as_bytes: bytes = file.read()
assert ethernet_frame_value.bytestring == msg_as_bytes
def test_tls_invalid_path(tls_alert_value: MessageValue) -> None:
tls_alert_value.set("Level", "WARNING")
tls_alert_value.set("Description", "CLOSE_NOTIFY")
assert tls_alert_value.valid_message
assert tls_alert_value.valid_fields == ["Level", "Description"]
tls_alert_value.set("Level", "FATAL")
assert not tls_alert_value.valid_message
assert tls_alert_value.valid_fields == ["Level"
] # type: ignore[unreachable]
def test_no_verification_ethernet(ethernet_frame_value: MessageValue) -> None:
payload = (b"\x45\x00\x00\x2e\x00\x01\x00\x00\x40\x11\x7c\xbc"
b"\x7f\x00\x00\x01\x7f\x00\x00\x01\x00\x35\x00\x35"
b"\x00\x1a\x01\x4e\x00\x00\x00\x00\x00\x00\x00\x00"
b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00")
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", payload)
assert ethernet_frame_value.valid_message
pyrflx_ = PyRFLX.from_specs(
[SPEC_DIR / "ethernet.rflx"],
skip_model_verification=True,
skip_message_verification=True,
)
frame_unv = pyrflx_.package("Ethernet").new_message("Frame")
frame_unv.set("Destination", int("FFFFFFFFFFFF", 16))
frame_unv.set("Source", int("0", 16))
frame_unv.set("Type_Length_TPID", int("0800", 16))
frame_unv.set("Type_Length", int("0800", 16))
frame_unv.set("Payload", payload)
assert frame_unv.valid_message
assert frame_unv.bytestring == ethernet_frame_value.bytestring
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_set_value(tlv_checksum: MessageValue) -> None:
v1 = b"\x01\x02\x03\x04\x05\x06\x07\x08"
v2 = b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10"
tlv_checksum.set("Tag", "Msg_Data")
tlv_checksum.set("Length", 8)
tlv_checksum.set("Value", v1)
with pytest.raises(
ValueError,
match="invalid data length: input length is 80 while expected input length is 64",
):
tlv_checksum.set("Value", v2)
def test_value_parse_from_bitstring(tlv: MessageValue, enum_value: EnumValue) -> None:
# pylint: disable=protected-access
intval = IntegerValue(ModularInteger("Test.Int", Number(256)))
intval.parse(b"\x02")
assert intval.value == 2
enum_value.parse(b"\x01")
assert enum_value.value == "One"
msg_array = ArrayValue(Array("Test.MsgArray", tlv._type))
tlv.set("Tag", "Msg_Data")
tlv.set("Length", 4)
tlv.set("Value", b"\x00\x00\x00\x00")
msg_array.parse(tlv.bytestring)
