def __init__(self, src=15*'\0'+'\x01', dst=15*'\0'+'\x01'):
Layer.__init__(self, CallName='ipv6', ReprName='IPv6 header')
self.src.Pt = src
self.dst.Pt = dst
# manages payload length
self.plen.Pt = self.get_payload
self.plen.PtFunc = lambda pay: pay()
def __init__(self, n=None):
Layer.__init__(self, CallName='N', ReprName='Nonce')
self.n.Pt = n
self.n.Len = self.len
self.n.LenFunc = lambda len: int(len)-4
self.len.Pt = self.n
self.len.PtFunc = lambda n: len(n)+4
def __init__(self, type=8, code=0, data='\0\0mitsh'):
Layer.__init__(self, CallName='icmp', ReprName='ICMP')
self.typ.Pt = type
self.cod.Pt = code
self.data.Pt = data
self.cs.Pt = 0
self.cs.PtFunc = lambda x: self.cksum()
def __init__(self, iv=None):
Layer.__init__(self, CallName='Enc', ReprName='Encrypted')
self.iv.Pt = iv
# encrypt all layers appended after pay_Enc(),
# does not need to check for payloads
self.len.Pt = self.get_index
self.len.PtFunc = lambda ind: self.__get_length( ind() )
def __init__(self, type=1, tID=11):
Layer.__init__(self, CallName='Trans', ReprName='Transform')
self.type.Pt = type
self.tID.Pt = tID
self.tID.Dict = TransformID[int(self.type)]
self.len.Pt = self.get_payload
self.len.PtFunc = lambda pay: len(pay())+8
def __init__(self, prefix=''):
Layer.__init__(self)
self.L > self.Prefix
self.L.PtFunc = lambda pref: len(pref) * 8
self.Prefix > prefix
self.Prefix.Len = self.L
self.Prefix.LenFunc = lambda l: l() // 8
def __init__(self):
Layer.__init__(self, CallName='full_ID', ReprName='AT_FULLAUTH_ID_REQ')
self.res.PtFunc = lambda res: self.pad4( str(res) )
self.res.Len = self.L
self.res.LenFunc = lambda L: ( int(L)*4 ) - 2
self.L.Pt = self.res
self.L.PtFunc = lambda res: self.len4( len(res) + 2 )
def __init__(self, data='\xFF\xFF'):
Layer.__init__(CallName='gtpv1_ext', ReprName='GTPv1 extension header'),
self.len.Pt = self.cont
self.len.PtFunc = lambda cont: (len(cont)+2)//4
self.cont.Pt = data
self.cont.Len = self.len
self.cont.LenFunc = lambda len: len()*4-2
def __init__(self, CallName='', ReprName='', V='\0'):
Layer.__init__(self, CallName=CallName, ReprName=ReprName, Trans=False)
self.L.Pt = self.V
self.L.PtFunc = lambda V: len(V)
self.V.Len = self.L
self.V.LenFunc = lambda L: int(L)
self.V.Pt = V
def __init__(self, type=1, tID=11):
Layer.__init__(self, CallName='Trans', ReprName='Transform')
self.type.Pt = type
self.tID.Pt = tID
self.tID.Dict = TransformID[int(self.type)]
self.len.Pt = self.get_payload
self.len.PtFunc = lambda pay: len(pay()) + 8
def __init__(self, n=None):
Layer.__init__(self, CallName='N', ReprName='Nonce')
self.n.Pt = n
self.n.Len = self.len
self.n.LenFunc = lambda len: int(len) - 4
self.len.Pt = self.n
self.len.PtFunc = lambda n: len(n) + 4
def __init__(self, iv=None):
Layer.__init__(self, CallName='Enc', ReprName='Encrypted')
self.iv.Pt = iv
# encrypt all layers appended after pay_Enc(),
# does not need to check for payloads
self.len.Pt = self.get_index
self.len.PtFunc = lambda ind: self.__get_length(ind())
def __init__(self, vid=None):
Layer.__init__(self, CallName='V', ReprName='Vendor ID')
self.vid.Pt = vid
self.vid.Len = self.len
self.vid.LenFunc = lambda len: int(len) - 4
self.len.Pt = self.vid
self.len.PtFunc = lambda vid: len(vid) + 4
def parse(self, buf=''):
self.__init__(self.CallName)
self.map(buf)
L = len(self)
#
# parse nested BER_TLV structures within the Value
if self[0].PC():
# indefinite form
indef = self[1]() == -1
# parsing further internal Value
buf = str(self[2])
inner = []
marker = None
while buf:
tlv = BER_TLV()
tlv.parse(buf)
buf = buf[len(tlv):]
if indef and (tlv[0]() == 0 and tlv[1]() == 0):
marker = tlv
marker.CallName = '_end_'
break
else:
inner.append(tlv)
if inner:
self.remove(self[2])
V = Layer('V')
V.extend(inner)
self.append(V)
if marker:
self.append(marker)
# returns the length parsed
return L
def __init__(self, src=0, dst=0, verif=4 * "\0"):
Layer.__init__(self, CallName="hdr", ReprName="SCTP header")
self.src.Pt = src
self.dst.Pt = dst
self.verif.Pt = verif
self.crc.Pt = self.get_payload
self.crc.PtFunc = lambda pay: crc32c(str(self.src) + str(self.dst) + str(self.verif) + 4 * "\0" + str(pay()))
def __init__(self, **kwargs):
Layer.__init__(self, **kwargs)
# length automation
self.pay.Len = self.len
self.pay.LenFunc = lambda l: l()-2
self.len.Pt = self.pay
self.len.PtFunc = lambda p: len(p)+2
def __init__(self, val=""):
Layer.__init__(self, CallName="raw", ReprName="SCTP raw data")
self.val.Pt = val
self.pad.Pt = self.val
self.pad.PtFunc = lambda val: self._pad(s=val)
self.pad.Len = self.val
self.pad.LenFunc = lambda val: len(val) % 4
def __init__(self, vid=None):
Layer.__init__(self, CallName='V', ReprName='Vendor ID')
self.vid.Pt = vid
self.vid.Len = self.len
self.vid.LenFunc = lambda len: int(len)-4
self.len.Pt = self.vid
self.len.PtFunc = lambda vid: len(vid)+4
def map(self, s='\0'):
# extended length set
if ord(s[0]) & 0x10 == 0x10:
self.L.Type = 'uint16'
else:
self.L.Type = 'uint8'
Layer.map(self, s)
def __init__(self):
Layer.__init__(self, CallName='res_IND', ReprName='AT_RESULT_IND')
self.res.PtFunc = lambda res: self.pad4( str(res) )
self.res.Len = self.L
self.res.LenFunc = lambda L: ( int(L)*4 ) - 2
self.L.Pt = self.res
self.L.PtFunc = lambda res: self.len4( len(res) + 2 )
def __init__(self, **kwargs):
Layer.__init__(self, **kwargs)
#
# 23.038, section 4
#
# for group 0b11, without groupext 0b11,
# IndActive/Reserved/IndType are there
self.IndActive.Trans = self.Group
self.IndActive.TransFunc = self._lsb_type
self.Reserved.Trans = self.Group
self.Reserved.TransFunc = self._lsb_type
self.IndType.Trans = self.Group
self.IndType.TransFunc = self._lsb_type
#
# otherwise, Class/Charset are there
#self.GroupExt.Trans = self.Group
#self.GroupExt.TransFunc = lambda g: not self._lsb_type(g)
self.Class.Trans = self.Group
self.Class.TransFunc = lambda g: not self._lsb_type(g)
self.Charset.Trans = self.Group
self.Charset.TransFunc = lambda g: not self._lsb_type(g)
#
# for group 0b00, 0b01 and group-groupext 0b1111
self.GroupExt.Dict = self.Group
self.GroupExt.DictFunc = lambda g: TP_DCS_general_ext_dict \
if g() in (0, 1) else {}
self.Class.Dict = self.Group
self.Class.DictFunc = self._cl_1111
self.Charset.Dict = self.Group
self.Charset.DictFunc = self._cs_1111
def map(self, s="\0"):
# extended length set
if ord(s[0]) & 0x10 == 0x10:
self.L.Type = "uint16"
else:
self.L.Type = "uint8"
Layer.map(self, s)
def __init__(self, **kwargs):
Layer.__init__(self, **kwargs)
# length automation
self.pay.Len = self.len
self.pay.LenFunc = lambda l: l() - 2
self.len.Pt = self.pay
self.len.PtFunc = lambda p: len(p) + 2
def __init__(self, prefix=""):
Layer.__init__(self)
self.L > self.Prefix
self.L.PtFunc = lambda pref: len(pref) * 8
self.Prefix > prefix
self.Prefix.Len = self.L
self.Prefix.LenFunc = lambda l: l() // 8
def __init__(self):
Layer.__init__(self, CallName='Small', ReprName='AT_COUNTER_TOO_SMALL')
self.res.PtFunc = lambda res: self.pad4( str(res) )
self.res.Len = self.L
self.res.LenFunc = lambda L: ( int(L)*4 ) - 2
self.L.Pt = self.res
self.L.PtFunc = lambda res: self.len4( len(res) + 2 )
def __init__(self, sqn=0):
Layer.__init__(self,
CallName='asconf-ack',
ReprName='SCTP ASCONF_ACK chunk')
self.sqn.Pt = sqn
self.len.Pt = self.get_payload
self.len.PtFunc = lambda pay: len(pay()) + 8
def __init__(self, CallName='', ReprName='', V='\0'):
Layer.__init__(self, CallName=CallName, ReprName=ReprName, Trans=False)
self.L.Pt = self.V
self.L.PtFunc = lambda V: len(V)
self.V.Len = self.L
self.V.LenFunc = lambda L: int(L)
self.V.Pt = V
def __init__(self, cookie=''):
Layer.__init__(self,
CallName='cook_echo',
ReprName='SCTP COOKIE_ECHO chunk')
self.cook.Pt = cookie
self.len.Pt = self.cook
self.len.PtFunc = lambda cook: len(cook) + 4
def __init__(self, val=''):
Layer.__init__(self, CallName='raw', ReprName='SCTP raw data')
self.val.Pt = val
self.pad.Pt = self.val
self.pad.PtFunc = lambda val: self._pad(s=val)
self.pad.Len = self.val
self.pad.LenFunc = lambda val: len(val) % 4
def parse(self, buf=''):
self.__init__(self.CallName)
self.map(buf)
L = len(self)
#
# parse nested BER_TLV structures within the Value
if self[0].PC():
# indefinite form
indef = self[1]() == -1
# parsing further internal Value
buf = str(self[2])
inner = []
marker = None
while buf:
tlv = BER_TLV()
tlv.parse(buf)
buf = buf[len(tlv):]
if indef and (tlv[0]() == 0 and tlv[1]() == 0):
marker = tlv
marker.CallName = '_end_'
break
else:
inner.append(tlv)
if inner:
self.remove(self[2])
V = Layer('V')
V.extend(inner)
self.append(V)
if marker:
self.append(marker)
# returns the length parsed
return L
def __init__(self, **kwargs):
Layer.__init__(self, **kwargs)
# fmt, fmt_ext and lsb_data: length automation
self.fmt_ext.Trans = self.fmt
self.fmt_ext.TransFunc = lambda f: False if f() else True
self.lsb_data.BitLen = self.fmt
self.lsb_data.BitLenFunc = lambda f: 2 if f() else 3
def __init__(self, ctsn=0):
Layer.__init__(self,
CallName='fwdtsn',
ReprName='SCTP FORWARD_TSN chunk')
self.ctsn.Pt = ctsn
self.len.Pt = self.get_payload
self.len.PtFunc = lambda pay: len(pay()) + 8
def __init__(self, ck=''):
Layer.__init__(self, CallName='Check', ReprName='AT_CHECKCODE')
self.ck.Pt = ck
self.ck.PtFunc = lambda ck: self.pad4( str(ck), const=4 )
self.ck.Len = self.L
self.ck.LenFunc = lambda L: ( int(L)*4 ) - 4
self.L.Pt = self.ck
self.L.PtFunc = lambda ck: self.len4( len(ck) + 4 )
def __init__(self, ctsn=0, a_rwnd=0x00100000):
Layer.__init__(self, CallName='sack', ReprName='SCTP SACK chunk')
self.len.Pt = self.get_payload
self.len.PtFunc = lambda pay: len(pay()) + 4
self.ctsn.Pt = ctsn
self.a_rwnd.Pt = a_rwnd
self.numgap.Pt = 0
self.numdup.Pt = 0
def __init__(self, type='ftyp', data=''):
Layer.__init__(self, CallName='atom', ReprName='MPEG4 atom')
self.type.Pt = type
self.data.Pt = data
self.data.Len = self.size
self.data.LenFunc = lambda size: int(size) - 8
self.size.Pt = (self.data, self.get_payload)
self.size.PtFunc = lambda (data, pay): len(data) + len(pay()) + 8
def __init__(self, count='\x00\x00'):
Layer.__init__(self, CallName='Count_OF', ReprName='AT_COUNTER_OVERFLOW')
self.count.Pt = count
self.count.PtFunc = lambda count: self.pad4( str(count) )
self.count.Len = self.L
self.count.LenFunc = lambda L: ( int(L)*4 ) - 2
self.L.Pt = self.count
self.L.PtFunc = lambda count: self.len4( len(count) + 2 )
def __init__(self, **kwargs):
Layer.__init__(self, **kwargs)
# length automation
self.len.Pt = self.L1
self.len.PtFunc = lambda x: sum(map(len, self[21:])) + 19
# huffman values length automation
self.V.Len = self.L1
self.V.LenFunc = lambda x: sum(map(int, self[5:21]))
def __init__(self, ver="\x00\x01"):
Layer.__init__(self, CallName='SEL_VER', ReprName='AT_SELECTED_VERSION')
self.ver.Pt = ver
self.ver.PtFunc = lambda vr: self.pad4( str(ver) )
self.ver.Len = self.L
self.ver.LenFunc = lambda L: ( int(L)*4 ) - 2
self.L.Pt = self.ver
self.L.PtFunc = lambda ver: self.len4( len(ver) + 2 )
def __init__(self, n_mt=''):
Layer.__init__(self, CallName='N_MT', ReprName='AT_NONCE_MT')
self.n_mt.Pt = n_mt
self.n_mt.PtFunc = lambda n_mt: self.pad4( str(n_mt), const=4 )
self.n_mt.Len = self.L
self.n_mt.LenFunc = lambda L: ( int(L)*4 ) - 4
self.L.Pt = self.n_mt
self.L.PtFunc = lambda n_mt: self.len4( len(n_mt) + 4 )
def __init__(self, err='\x00\x00'):
Layer.__init__(self, CallName='ERR_OF', ReprName='AT_CLIENT_ERROR_CODE_OVERFLOW')
self.err.Pt = err
self.err.PtFunc = lambda err: self.pad4( str(err) )
self.err.Len = self.L
self.err.LenFunc = lambda L: ( int(L)*4 ) - 2
self.L.Pt = self.err
self.L.PtFunc = lambda err: self.len4( len(err) + 2 )
def __init__(self, notif='\x40\x00'):
Layer.__init__(self, CallName='NOT_OF', ReprName='AT_NOTIFICATION_OVERFLOW')
self.notif.Pt = notif
self.notif.PtFunc = lambda notif: self.pad4( str(notif) )
self.notif.Len = self.L
self.notif.LenFunc = lambda L: ( int(L)*4 ) - 2
self.L.Pt = self.notif
self.L.PtFunc = lambda notif: self.len4( len(notif) + 2 )
def __init__(self, n_s=''):
Layer.__init__(self, CallName='N_S', ReprName='AT_NONCE_S')
self.n_s.Pt = n_s
self.n_s.PtFunc = lambda n_s: self.pad4( str(n_s), const=4 )
self.n_s.Len = self.L
self.n_s.LenFunc = lambda L: ( int(L)*4 ) - 4
self.L.Pt = self.n_s
self.L.PtFunc = lambda n_s: self.len4( len(n_s) + 4 )
def map(self, s):
if unpack('!B', s[0])[0] & 0x80 == 0x80:
self.T.BitLen = 15
self.T.BitLenFunc = None
#BitLenFunc, self.T.BitLenFunc = self.T.BitLenFunc, None
if unpack('!B', s[self.T.bit_len()//8+1])[0] & 0x80 == 0x80:
self.L.BitLen = 15
Layer.map(self, s)
def __init__(self, CallName='', ReprName='', T=0, V=0, \
Trans=False, Dict=None):
Layer.__init__(self, CallName=CallName, ReprName=ReprName, Trans=Trans)
self.T.Pt = T
self.V.Pt = V
if Dict:
self.V.Dict = Dict
self.V.Repr = 'hum'
def __init__(self, encr=''):
Layer.__init__(self, CallName='ENCR', ReprName='AT_ENCR_DATA')
self.encr.Pt = encr
self.encr.PtFunc = lambda encr: self.pad4( str(encr), const=4 )
self.encr.Len = self.L
self.encr.LenFunc = lambda L: ( int(L)*4 ) - 4
self.L.Pt = self.encr
self.L.PtFunc = lambda encr: self.len4( len(encr) + 4 )
def __init__(self, mac=''):
Layer.__init__(self, CallName='MAC', ReprName='AT_MAC')
self.mac.Pt = mac
self.mac.PtFunc = lambda mac: self.pad4( str(mac), const=4 )
self.mac.Len = self.L
self.mac.LenFunc = lambda L: ( int(L)*4 ) - 4
self.L.Pt = self.mac
self.L.PtFunc = lambda mac: self.len4( len(mac) + 4 )
