class MRI(Packet):
fields_desc = [
ShortField("count", 0),
PacketListField("swtraces", [],
SwitchTrace,
count_from=lambda pkt: (pkt.count * 1))
]
class Ann_unit(Packet):
name = "CoLoR_Ann_unit"
fields_desc = [
BitField("N", 1, 1, tot_size=1),
BitField("L", 1, 1),
BitField("I", 1, 1),
BitField("AM", 1, 2), # 1注册，2更新，3取消
BitField("r", 0, 3, end_tot_size=1),
ByteField("Unit_length", None),
FieldLenField("Strategy_N",
None,
fmt="B",
count_of="Strategy_unit_list"),
ConditionalField(XStrFixedLenField("N_sid", "", 16),
lambda pkt: pkt.N == 1),
ConditionalField(XStrFixedLenField("L_sid", "", 20),
lambda pkt: pkt.L == 1),
ConditionalField(XStrFixedLenField("nid", "", 16),
lambda pkt: pkt.I == 1),
PacketListField("Strategy_unit_list",
None,
Strategy_unit,
count_from=lambda pkt: pkt.Strategy_N)
]
def post_build(self, pkt, pay):
if self.Unit_length is None:
self.Unit_length = len(pkt)
pkt = pkt[:1] + int2Bytes(self.Unit_length, 1) + pkt[2:]
return pkt + pay
class nodeCount(Packet):
name = "nodeCount"
fields_desc = [
ShortField("count", 0),
PacketListField("INT", [],
InBandNetworkTelemetry,
count_from=lambda pkt: (pkt.count * 1))
]
class Template(Packet):
name = "Template"
fields_desc = [
ShortField("templateID", 256),
FieldLenField("fieldCount", None, count_of="fields"),
PacketListField(
"templateFields", [], FieldSpecifier, count_from=lambda p: p.fieldCount
),
]
class MRI2(Packet):
fields_desc = [FieldLenField("length", None,
length_of="swtraces",
adjust=lambda pkt,l:l*23+4),
ShortField("count", 0),
PacketListField("swtraces",
[],
SwitchTrace2,
count_from=lambda pkt:(pkt.count*1))]
class CoLoR_Ann(Packet):
name = "CoLoR_Ann"
fields_desc = [
BitField("Version", 7, 4, tot_size=1),
BitField("Package", 1, 4, end_tot_size=1),
ByteField("TTL", 64),
LEShortField("pkg_length", None),
XShortField("checksum", None),
FlagsField("Flags", 0, 8, "rrrrrPKF"),
BitField("unit_num", None, 4, tot_size=1),
BitField("PX_num", None, 4, end_tot_size=1),
PacketListField("Announce_unit_list",
None,
Ann_unit,
count_from=lambda pkt: pkt.unit_num),
ConditionalField(
FieldLenField("Public_key_len",
None,
fmt="H",
length_of="Public_key"),
lambda pkt: pkt.Flags.K == True),
ConditionalField(
StrLenField("Public_key",
"",
length_from=lambda pkt: pkt.Public_key_len),
lambda pkt: pkt.Flags.K == True),
ConditionalField(
FieldLenField("AS_PATH_len", None, fmt="B", count_of="AID_list"),
lambda pkt: pkt.Flags.P == True),
ConditionalField(
FieldListField("AID_list",
None,
StrFixedLenField("", "", 1),
count_from=lambda pkt: pkt.AS_PATH_len),
lambda pkt: pkt.Flags.P == True),
FieldListField("PX_list",
None,
StrFixedLenField("", "", 2),
count_from=lambda pkt: pkt.PX_num)
]
def post_build(self, pkt, pay):
if self.pkg_length is None:
self.pkg_length = len(pkt)
pkt = pkt[:2] + int2BytesLE(self.pkg_length, 2) + pkt[4:]
if self.checksum is None:
self.checksum = CalcChecksum(pkt)
pkt = pkt[:4] + int2Bytes(self.checksum, 2) + pkt[6:]
if self.unit_num is None and self.PX_num is None:
self.unit_num = len(self.Announce_unit_list)
self.PX_num = len(self.PX_list)
pkt = pkt[:7] + int2Bytes(self.unit_num << 4 | self.PX_num,
1) + pkt[8:]
return pkt + pay
class IPOption_MRI(IPOption):
name = "MRI"
option = 31
fields_desc = [ _IPOption_HDR,
FieldLenField("length", None, fmt="B",
length_of="swtraces",
adjust=lambda pkt,l:l*2+4),
ShortField("count", 0),
PacketListField("swtraces",
[],
SwitchTrace,
count_from=lambda pkt:(pkt.count*1)) ]
class IPOption_INT(IPOption):
name = "INTLoss"
option = 31
fields_desc = [ _IPOption_HDR,
FieldLenField("length", None, fmt="B",
length_of="swtraces",
adjust=lambda pkt,l:l*2+4),
BitField("loss_bit", 0, 1),
BitField("count", 0, 15),
PacketListField("swtraces",
[],
SwitchTrace,
count_from=lambda pkt:(pkt.count*1)) ]
class DTLS(Packet):
"""Representation of DTLS message"""
name = "DTLS"
fields_desc = [PacketListField("records", None, DTLSRecord)]
CONTENT_TYPE_MAP = {0x15: TLSAlert, 0x16: DTLSHandshakes, 0x17: TLSPlaintext}
def __init__(self, *args, **fields):
self.tls_ctx = fields.pop("ctx", None)
self._origin = fields.pop("_origin", None)
self.guessed_next_layer = DTLSRecord
Packet.__init__(self, *args, **fields)
@classmethod
def from_records(cls, records, ctx=None):
"""Merges record into object"""
pkt_str = "".join(list(map(str, records)))
return cls(pkt_str, ctx)
def pre_dissect(self, raw_bytes): # pylint: disable=arguments-differ
self.fields_desc = [PacketListField("records", None, self.guessed_next_layer)]
return raw_bytes
def do_dissect(self, raw_bytes): # pylint: disable=arguments-differ
pos = 0
record = self.guessed_next_layer
record_header_len = len(record())
records = []
# Consume all bytes passed to us by the underlayer. We're expecting no
# further payload on top of us. If there is additional data on top of our layer
# We will incorrectly parse it
while pos < len(raw_bytes) - record_header_len:
payload_len = record(raw_bytes[pos : pos + record_header_len]).length
if self.tls_ctx is not None:
payload = record(
raw_bytes[pos : pos + record_header_len + payload_len],
ctx=self.tls_ctx,
)
# Perform inline decryption if required
# payload = self.do_decrypt_payload(payload)
self.tls_ctx.insert(payload, origin=self._origin)
else:
payload = record(raw_bytes[pos : pos + record_header_len + payload_len])
# Populate our list of found records
records.append(payload)
# Move to the next record
pos += record_header_len + payload.length
self.fields["records"] = records
# This will always be empty (equivalent to returning "")
return raw_bytes[pos:]
class IPOption_INT(IPOption):
name = "INT"
option = 31
fields_desc = [
_IPOption_HDR,
FieldLenField("length",
None,
fmt="B",
length_of="int_headers",
adjust=lambda pkt, l: l * 2 + 8),
ShortField("count", 0),
PacketListField("int_headers", [],
SwitchTrace,
count_from=lambda pkt: (pkt.count * 1))
]
class DDOSD(Packet):
name = "DDOSD"
fields_desc = [
IntField("pkt_num", None),
IntField("src_entropy", None),
IntField("src_ewma", None),
IntField("src_ewmmd", None),
IntField("dst_entropy", None),
IntField("dst_ewma", None),
IntField("dst_ewmmd", None),
ByteField("alarm", None),
ByteField("protocol", None),
FieldLenField("count_ip", None, count_of="IPs"),
PacketListField("IPs", [], alarm, count_from=lambda pkt: pkt.count_ip)
]
class CodingHdrR(Packet):
global payload_size
fields_desc = [
XByteField("num_switch_stats", 0x0),
PacketListField("swtraces", [],
SwitchStatsHdr,
count_from=lambda pkt: (pkt.num_switch_stats * 1)),
StrFixedLenField("P", "P", length=1),
StrFixedLenField("Four", "4", length=1),
XByteField("version", 0x01),
XByteField("stream_id", 0x01),
XByteField("packet_todo", 0x01),
StrFixedLenField("packet_contents", ' ', length=1),
IntField("coded_packets_batch_num", 0),
StrFixedLenField("packet_payload",
' ' * (payload_size / 8),
length=payload_size / 8)
]
class DsToRioUdp(Packet):
name = 'DS to RIO UDP Packet'
fields_desc = [
ShortField('seq_num', None),
ByteField('comm_ver', 0),
FlagsField('control', 0, 8, [
'test', 'auton', 'enabled', 'fms_connected', 'reserved4',
'reserved5', 'reserved6', 'estop'
]),
FlagsField('request', 0, 8, [
'reserved0', 'reserved1', 'restart_code', 'reboot_rio',
'reserved4', 'reserved5', 'reserved6', 'reserved7'
]),
ByteEnumField(
'alliance', None,
['red_0', 'red_1', 'red_2', 'blue_0', 'blue_1', 'blue_2']),
PacketListField('tags', [], Tag)
]
def pre_dissect(self, raw_bytes): # pylint: disable=arguments-differ
self.fields_desc = [PacketListField("records", None, self.guessed_next_layer)]
return raw_bytes
class RioToDsTcp(Packet):
name = 'RIO to DS TCP Packet'
fields_desc = [
PacketListField('tags', [], Tag)
]
