class SCTPChunkError(_SCTPChunkGuessPayload, Packet):
fields_desc = [ByteEnumField("type", 9, sctpchunktypes),
XByteField("flags", None),
FieldLenField("len", None, length_of="error_causes", adjust=lambda pkt, x:x + 4), # noqa: E501
PadField(StrLenField("error_causes", "", length_from=lambda pkt: pkt.len - 4), # noqa: E501
4, padwith=b"\x00"),
]
class SCTPChunkCookieEcho(SCTPChunkError):
fields_desc = [ByteEnumField("type", 10, sctpchunktypes),
XByteField("flags", None),
FieldLenField("len", None, length_of="cookie", adjust=lambda pkt, x:x + 4), # noqa: E501
PadField(StrLenField("cookie", "", length_from=lambda pkt: pkt.len - 4), # noqa: E501
4, padwith=b"\x00"),
]
class L2TP(Packet):
name = "L2TP"
fields_desc = [
FlagsField("hdr", 0, 12, ['res00', 'res01', 'res02', 'res03', 'priority', 'offset', # noqa: E501
'res06', 'sequence', 'res08', 'res09', 'length', 'control']), # noqa: E501
BitEnumField("version", 2, 4, {2: 'L2TPv2'}),
ConditionalField(ShortField("len", 0),
lambda pkt: pkt.hdr & 'control+length'),
ShortField("tunnel_id", 0),
ShortField("session_id", 0),
ConditionalField(ShortField("ns", 0),
lambda pkt: pkt.hdr & 'sequence+control'),
ConditionalField(ShortField("nr", 0),
lambda pkt: pkt.hdr & 'sequence+control'),
ConditionalField(
PadField(ShortField("offset", 0), 4, b"\x00"),
lambda pkt: not (pkt.hdr & 'control') and pkt.hdr & 'offset'
)
]
def post_build(self, pkt, pay):
if self.len is None and self.hdr & 'control+length':
tmp_len = len(pkt) + len(pay)
pkt = pkt[:2] + struct.pack("!H", tmp_len) + pkt[4:]
return pkt + pay
class NetflowDataflowsetV9(Packet):
name = "Netflow DataFlowSet V9"
fields_desc = [
ShortField("templateID", 255),
FieldLenField("length",
None,
length_of="records",
adjust=lambda pkt, x: x + 4), # noqa: E501
PadField(
PacketListField(
"records", [],
NetflowRecordV9,
length_from=lambda pkt: pkt.length - 4), # noqa: E501
4,
padwith=b"\x00")
]
@classmethod
def dispatch_hook(cls, _pkt=None, *args, **kargs):
if _pkt:
if _pkt[:2] == b"\x00\x01":
return NetflowOptionsFlowsetV9
if _pkt[:2] == b"\x00\x00":
return NetflowFlowsetV9
return cls
class MKABasicParamSet(Packet):
"""
Basic Parameter Set (802.1X-2010, section 11.11).
"""
#########################################################################
#
# IEEE 802.1X-2010 standard
# Section 11.11
#########################################################################
#
name = "Basic Parameter Set"
fields_desc = [
ByteField("mka_version_id", 0),
ByteField("key_server_priority", 0),
BitField("key_server", 0, 1),
BitField("macsec_desired", 0, 1),
BitField("macsec_capability", 0, 2),
BitField("param_set_body_len", 0, 12),
PacketField("SCI", MACsecSCI(), MACsecSCI),
XStrFixedLenField("actor_member_id", "", length=12),
XIntField("actor_message_number", 0),
XIntField("algorithm_agility", 0),
PadField(XStrLenField("cak_name",
"",
length_from=lambda pkt:
(pkt.param_set_body_len - 28)),
4,
padwith=b"\x00")
]
def extract_padding(self, s):
return "", s
class MKADistributedCAKParamSet(MKAParamSet):
"""
Distributed CAK Parameter Set (802.1X-2010, section 11.11).
"""
#########################################################################
#
# IEEE 802.1X-2010 standard
# Section 11.11
#########################################################################
#
name = "Distributed CAK parameter set"
fields_desc = [
PadField(
ByteEnumField(
"param_set_type",
5,
_parameter_set_types
),
2,
padwith=b"\x00"
),
ShortField("param_set_body_len", 0),
XStrFixedLenField(
"cak_aes_key_wrap",
"",
length=MKAParamSet.EAPOL_MKA_DEFAULT_KEY_WRAP_LEN
),
XStrField("cak_key_name", "")
]
class MKAICVSet(MKAParamSet):
"""
ICV (802.1X-2010, section 11.11).
"""
#########################################################################
#
# IEEE 802.1X-2010 standard
# Section 11.11
#########################################################################
#
name = "ICV"
fields_desc = [
PadField(
ByteEnumField(
"param_set_type",
255,
_parameter_set_types
),
2,
padwith=b"\x00"
),
ShortField("param_set_body_len", 0),
XStrFixedLenField("icv", "", length=MKAParamSet.MACSEC_DEFAULT_ICV_LEN)
]
class DCPControlBlock(Packet):
fields_desc = [
ByteEnumField("option", 5, DCP_OPTIONS),
MultiEnumField("sub_option",
4,
DCP_SUBOPTIONS,
fmt='B',
depends_on=lambda p: p.option),
LenField("dcp_block_length", 3),
ByteEnumField("response", 2, DCP_OPTIONS),
MultiEnumField("response_sub_option",
2,
DCP_SUBOPTIONS,
fmt='B',
depends_on=lambda p: p.option),
ByteEnumField("block_error", 0, BLOCK_ERRORS),
PadField(StrLenField("padding",
b"\x00",
length_from=lambda p: p.dcp_block_length % 2),
1,
padwith=b"\x00")
]
def extract_padding(self, s):
return '', s
class MKAPotentialPeerListParamSet(MKAParamSet):
"""
Potential Peer List parameter sets (802.1X-2010, section 11.11).
"""
#########################################################################
#
# IEEE 802.1X-2010 standard
# Section 11.11
#########################################################################
#
name = "Potential Peer List Parameter Set"
fields_desc = [
PadField(
ByteEnumField(
"param_set_type",
2,
_parameter_set_types
),
2,
padwith=b"\x00"
),
ShortField("param_set_body_len", 0),
PacketListField("member_id_message_num", [], MKAPeerListTuple)
]
class DCPAliasNameBlock(Packet):
fields_desc = [
ByteEnumField("option", 2, DCP_OPTIONS),
MultiEnumField("sub_option",
6,
DCP_SUBOPTIONS,
fmt='B',
depends_on=lambda p: p.option),
FieldLenField("dcp_block_length",
None,
length_of="alias_name",
adjust=lambda p, x: x + 2),
ShortEnumField("block_info", 0, BLOCK_INFOS),
StrLenField("alias_name",
"et200sp",
length_from=lambda x: x.dcp_block_length - 2),
PadField(StrLenField("padding",
b"\x00",
length_from=lambda p: p.dcp_block_length % 2),
1,
padwith=b"\x00")
]
def extract_padding(self, s):
return '', s
class DCPFullIPBlock(Packet):
fields_desc = [
ByteEnumField("option", 1, DCP_OPTIONS),
MultiEnumField("sub_option",
3,
DCP_SUBOPTIONS,
fmt='B',
depends_on=lambda p: p.option),
LenField("dcp_block_length", None),
ShortEnumField("block_info", 1, IP_BLOCK_INFOS),
IPField("ip", "192.168.0.2"),
IPField("netmask", "255.255.255.0"),
IPField("gateway", "192.168.0.1"),
FieldListField("dnsaddr", [],
IPField("", "0.0.0.0"),
count_from=lambda x: 4),
PadField(StrLenField("padding",
b"\x00",
length_from=lambda p: p.dcp_block_length % 2),
1,
padwith=b"\x00")
]
def extract_padding(self, s):
return '', s
class DCPNameOfStationBlock(Packet):
fields_desc = [
ByteEnumField("option", 2, DCP_OPTIONS),
MultiEnumField("sub_option",
2,
DCP_SUBOPTIONS,
fmt='B',
depends_on=lambda p: p.option),
FieldLenField("dcp_block_length",
None,
length_of="name_of_station",
adjust=lambda p, x: x + 2),
# FieldLenField("dcp_block_length", None, length_of= "name_of_station", adjust=lambda p,x: x +2),
# TODO it should take the len from name_of_station, but it takes the len of the rest of the packet
ShortEnumField("block_info", 0, BLOCK_INFOS),
StrLenField(
"name_of_station",
"et200sp",
length_from=lambda x: x.dcp_block_length - 2), # this works
PadField(StrLenField("padding",
b"\x00",
length_from=lambda p: p.dcp_block_length % 2),
1,
padwith=b"\x00")
]
def extract_padding(self, s):
return '', s
class SCTPChunkParamRandom(_SCTPChunkParam, Packet):
fields_desc = [ShortEnumField("type", 0x8002, sctpchunkparamtypes),
FieldLenField("len", None, length_of="random",
adjust=lambda pkt, x:x + 4),
PadField(StrLenField("random", RandBin(32),
length_from=lambda pkt: pkt.len - 4),
4, padwith=b"\x00"), ]
class SCTPChunkParamHostname(_SCTPChunkParam, Packet):
fields_desc = [ShortEnumField("type", 11, sctpchunkparamtypes),
FieldLenField("len", None, length_of="hostname",
adjust=lambda pkt, x:x + 4),
PadField(StrLenField("hostname", "",
length_from=lambda pkt: pkt.len - 4),
4, padwith=b"\x00"), ]
class QueryCmdHcaCapOut(Packet):
fields_desc = [
ByteField('status', 0),
BitField('reserved1', 0, 24),
IntField('syndrome', 0),
StrFixedLenField('reserved2', None, length=8),
PadField(PacketField('capability', CmdHcaCap(), CmdHcaCap), 2048, padwith=b"\x00"),
]
class SCTPChunkParamRequestedHMACFunctions(_SCTPChunkParam, Packet):
fields_desc = [ShortEnumField("type", 0x8004, sctpchunkparamtypes),
FieldLenField("len", None, length_of="HMAC_functions_list",
adjust=lambda pkt, x:x + 4),
PadField(FieldListField("HMAC_functions_list", ["SHA-1"],
ShortEnumField("HMAC_function", 1, hmactypes), # noqa: E501
length_from=lambda pkt: pkt.len - 4), # noqa: E501
4, padwith=b"\x00"), ]
class SCTPChunkAbort(_SCTPChunkGuessPayload, Packet):
fields_desc = [ByteEnumField("type", 6, sctpchunktypes),
BitField("reserved", None, 7),
BitField("TCB", 0, 1),
FieldLenField("len", None, length_of="error_causes", adjust=lambda pkt, x:x + 4), # noqa: E501
PadField(StrLenField("error_causes", "", length_from=lambda pkt: pkt.len - 4), # noqa: E501
4, padwith=b"\x00"),
]
class SCTPChunkParamErrorIndication(_SCTPChunkParam, Packet):
fields_desc = [ShortEnumField("type", 0xc003, sctpchunkparamtypes),
FieldLenField("len", None, length_of="error_causes",
adjust=lambda pkt, x:x + 8),
XIntField("correlation_id", None),
PadField(StrLenField("error_causes", "",
length_from=lambda pkt: pkt.len - 4),
4, padwith=b"\x00"), ]
class SCTPChunkParamChunkList(_SCTPChunkParam, Packet):
fields_desc = [ShortEnumField("type", 0x8003, sctpchunkparamtypes),
FieldLenField("len", None, length_of="chunk_list",
adjust=lambda pkt, x:x + 4),
PadField(FieldListField("chunk_list", None,
ByteEnumField("chunk", None, sctpchunktypes), # noqa: E501
length_from=lambda pkt: pkt.len - 4), # noqa: E501
4, padwith=b"\x00"), ]
class SCTPChunkParamSupportedAddrTypes(_SCTPChunkParam, Packet):
fields_desc = [ShortEnumField("type", 12, sctpchunkparamtypes),
FieldLenField("len", None, length_of="addr_type_list",
adjust=lambda pkt, x:x + 4),
PadField(FieldListField("addr_type_list", ["IPv4"],
ShortEnumField("addr_type", 5, sctpchunkparamtypes), # noqa: E501
length_from=lambda pkt: pkt.len - 4), # noqa: E501
4, padwith=b"\x00"), ]
class HCI_Cmd_LE_Set_Advertising_Data(Packet):
name = "LE Set Advertising Data"
fields_desc = [
FieldLenField("len", None, length_of="data", fmt="B"),
PadField(PacketListField("data", [],
EIR_Hdr,
length_from=lambda pkt: pkt.len),
align=31,
padwith=b"\0"),
]
class SCTPChunkAuthentication(_SCTPChunkGuessPayload, Packet):
fields_desc = [ByteEnumField("type", 15, sctpchunktypes),
XByteField("flags", None),
FieldLenField("len", None, length_of="HMAC",
adjust=lambda pkt, x:x + 8),
ShortField("shared_key_id", None),
ShortField("HMAC_function", None),
PadField(StrLenField("HMAC", "", length_from=lambda pkt: pkt.len - 8), # noqa: E501
4, padwith=b"\x00"),
]
class SCTPChunkParamSupportedExtensions(_SCTPChunkParam, Packet):
fields_desc = [ShortEnumField("type", 0x8008, sctpchunkparamtypes),
FieldLenField("len", None, length_of="supported_extensions",
adjust=lambda pkt, x:x + 4),
PadField(FieldListField("supported_extensions",
["authentication",
"address-configuration",
"address-configuration-ack"],
ByteEnumField("supported_extensions", # noqa: E501
None, sctpchunktypes),
length_from=lambda pkt: pkt.len - 4), # noqa: E501
4, padwith=b"\x00"), ]
class Dot11EltCountry(Dot11Elt):
name = "802.11 Country"
fields_desc = [
ByteField("ID", 7),
ByteField("len", None),
StrFixedLenField("country_string", b"\0\0\0", length=3),
PadField(PacketListField("descriptors", [],
Dot11EltCountryConstraintTriplet,
length_from=lambda pkt: pkt.len -
(pkt.len % 3)),
2,
padwith=b"\x00")
]
class IFETlv(Packet):
"""
Parent Class interhit by all ForCES TLV strucutures
"""
name = "IFETlv"
fields_desc = [
ShortEnumField("type", 0, IFE_META_TYPES),
FieldLenField("length",
None,
length_of="value",
adjust=lambda pkt, x: x + 4),
MultipleTypeField([
(PadField(ShortField("value", 0), 4, padwith=b'\x00'),
lambda pkt: pkt.type in IFE_TYPES_SHORT),
(PadField(IntField("value", 0), 4,
padwith=b'\x00'), lambda pkt: pkt.type in IFE_TYPES_INT),
], PadField(IntField("value", 0), 4, padwith=b'\x00')),
]
def extract_padding(self, s):
return "", s
class SAPHDBPartError(PacketNoPadded):
"""SAP HANA SQL Command Network Protocol Error Part
"""
part_kind = 6
name = "SAP HANA SQL Command Network Protocol Error Part"
fields_desc = [
LESignedIntField("error_code", 0),
LESignedIntField("error_position", 0),
FieldLenField("error_text_length", None, length_of="error_text", fmt="<i"),
EnumField("error_level", 0, hdb_error_level_vals, fmt="<b"),
StrFixedLenField("sql_state", "HY000", 5),
PadField(StrFixedLenField("error_text", "", length_from=lambda pkt: pkt.error_text_length), 8),
]
def __init__(self, tblfld):
assert isinstance(tblfld, PacketField)
assert hasattr(
tblfld.cls,
'index'), 'No index() method defined for OmciTableField row object'
assert hasattr(
tblfld.cls, 'is_delete'
), 'No delete() method defined for OmciTableField row object'
super(OmciTableField,
self).__init__([(IntField('table_length', 0),
(self.cond_pkt, self.cond_pkt_val)),
(PadField(StrField('me_type_table', None),
OmciTableField.PDU_SIZE),
(self.cond_pkt2, self.cond_pkt_val2))], tblfld)
class DCPMACBlock(Packet):
fields_desc = [
ByteEnumField("option", 1, DCP_OPTIONS),
MultiEnumField("sub_option", 1, DCP_SUBOPTIONS, fmt='B',
depends_on=lambda p: p.option),
FieldLenField("dcp_block_length", None),
ShortEnumField("block_info", 0, BLOCK_INFOS),
MACField("mac", "00:00:00:00:00:00"),
PadField(StrLenField("padding", b"\x00",
length_from=lambda p: p.dcp_block_length % 2), 1,
padwith=b"\x00")
]
def extract_padding(self, s):
return '', s
class SCTPChunkData(_SCTPChunkGuessPayload, Packet):
# TODO : add a padding function in post build if this layer is used to generate SCTP chunk data # noqa: E501
fields_desc = [ByteEnumField("type", 0, sctpchunktypes),
BitField("reserved", None, 4),
BitField("delay_sack", 0, 1),
BitField("unordered", 0, 1),
BitField("beginning", 0, 1),
BitField("ending", 0, 1),
FieldLenField("len", None, length_of="data", adjust=lambda pkt, x:x + 16), # noqa: E501
XIntField("tsn", None),
XShortField("stream_id", None),
XShortField("stream_seq", None),
IntEnumField("proto_id", None, SCTP_PAYLOAD_PROTOCOL_INDENTIFIERS), # noqa: E501
PadField(StrLenField("data", None, length_from=lambda pkt: pkt.len - 16), # noqa: E501
4, padwith=b"\x00"),
]
class DCPDeviceInstanceBlock(Packet):
fields_desc = [
ByteEnumField("option", 2, DCP_OPTIONS),
MultiEnumField("sub_option", 7, DCP_SUBOPTIONS, fmt='B',
depends_on=lambda p: p.option),
LenField("dcp_block_length", 4),
ShortEnumField("block_info", 0, BLOCK_INFOS),
XByteField("device_instance_high", 0x00),
XByteField("device_instance_low", 0x01),
PadField(StrLenField("padding", b"\x00",
length_from=lambda p: p.dcp_block_length % 2), 1,
padwith=b"\x00")
]
def extract_padding(self, s):
return '', s
