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 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 map(self, s=""):
Layer.__init__(self)
Layer.map(self, s)
s = s[1 : 1 + self.cm_length()]
while len(s) >= 1:
self.append(Int("cm", Type="uint8", Dict=CompressionMethod_dict))
self[-1].map(s)
s = s[2:]
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 map(self, s=""):
Layer.__init__(self)
Layer.map(self, s)
s = s[2 : 2 + self.cs_length()]
while len(s) >= 2:
self.append(Int("cs", Type="uint16", Dict=CipherSuite_dict))
self[-1].map(s)
s = s[2:]
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 map(self, s=''):
Layer.map(self, s)
if len(self.components) / 3.0 == self.Nf():
cpn_s = self.components()
self.remove(self.components)
while len(cpn_s) > 0:
self.append(SOFComponent())
self[-1].map(cpn_s)
cpn_s = cpn_s[3:]
def map(self, s=''):
if len(s) < 1:
return ''
if len(self.elementList) != 2:
self.__init__()
Layer.map(self, s[0])
if self.Form() and self.L():
self.append(Bit('L_ext', BitLen=self.L() * 8, Repr='hum'))
self[-1].map(s[1:])
def map(self, s=''):
Layer.map(self, s)
if self.id() == 16:
# NAS-PDU, try to parse it
naspdu = NAS_PDU()
naspdu.map(self.value())
self.value.Pt = naspdu
self.value.Val = None
self.value.Repr = 'hum'
def map(self, s=''):
if len(s) < 1:
return ''
if len(self.elementList) != 2:
self.__init__()
Layer.map(self, s[0])
if self.Form() and self.L():
self.append( Bit('L_ext', BitLen=self.L()*8, Repr='hum') )
self[-1].map(s[1:])
def map(self, s=''):
Layer.map(self, s)
if len(self.pay) % 2 == 0:
pay = str(self.pay)
self.remove(self[-1])
while len(pay) > 0:
self.append(DACComponent())
self[-1].map(pay)
pay = pay[2:]
def map(self, s=''):
Layer.map(self, s)
if len(self.pay) % 2 == 0:
pay = str(self.pay)
self.remove(self[-1])
while len(pay) > 0:
self.append(DACComponent())
self[-1].map(pay)
pay = pay[2:]
def map(self, s=''):
Layer.map(self, s)
if len(self.components) / 3.0 == self.Nf():
cpn_s = self.components()
self.remove(self.components)
while len(cpn_s) > 0:
self.append(SOFComponent())
self[-1].map(cpn_s)
cpn_s = cpn_s[3:]
def map(self, s=''):
Layer.map(self, s)
if len(self.components) / 2.0 == self.Nf():
cpn_s = self.components()
self.remove(self.components)
pos = 4
while len(cpn_s) > 0:
self.insert(pos, SOSComponent())
self[pos].map(cpn_s)
cpn_s = cpn_s[2:]
pos += 1
def map(self, s=''):
Layer.map(self, s)
if len(self.components) / 2.0 == self.Nf():
cpn_s = self.components()
self.remove(self.components)
pos = 4
while len(cpn_s) > 0:
self.insert(pos, SOSComponent())
self[pos].map(cpn_s)
cpn_s = cpn_s[2:]
pos += 1
def map(self, s=''):
s_len = len(s)
if s_len < 6:
self.TP_UD.Trans = True
if s_len < 5:
self.TP_UDL.Trans = True
if s_len < 4:
self.TP_DCS.Trans = True
if s_len < 3:
self.TP_PID.Trans = True
Layer.map(self, s)
def map(self, s=''):
s_len = len(s)
if s_len < 13:
self.TP_UD.Trans = True
if s_len < 12:
self.TP_UDL.Trans = True
if s_len < 11:
self.TP_DCS.Trans = True
if s_len < 10:
self.TP_PID.Trans = True
Layer.map(self, s)
def map(self, s=''):
Layer.map(self, s)
# try to parse it as L3Mobile
try:
nas = parse_L3(self.naspdu())
except:
pass
else:
self.naspdu.Pt = nas
self.naspdu.Val = None
self.naspdu.Repr = 'hum'
def map(self, s=''):
Layer.map(self, s)
values, pos = self.V(), 0
self.remove(self[-1])
for i in self[5:21]:
for j in range(1, i()+1):
ith = int(i.CallName[1:])
self.append(\
Int('V%i%i'%(ith,j), \
ReprName='Value %i for huffman code of length %i'%(j,ith), \
Val=ord(values[pos]), Type='uint8'))
pos += 1
def map(self, s=''):
Layer.map(self, s)
values, pos = self.V(), 0
self.remove(self[-1])
for i in self[5:21]:
for j in range(1, i() + 1):
ith = int(i.CallName[1:])
self.append(\
Int('V%i%i'%(ith,j), \
ReprName='Value %i for huffman code of length %i'%(j,ith), \
Val=ord(values[pos]), Type='uint8'))
pos += 1
def map(self, s=''):
Layer.map(self, s)
# additional VP interpretation
val = self.TP_VPF()
#if val == 1:
if val == 2:
vp = TP_VP_rel()
vp.map( self.TP_VP() )
self.replace( self.TP_VP, vp )
elif val == 3:
vp = TP_VP_abs()
vp.map( self.TP_VP() )
self.replace( self.TP_VP, vp )
def map(self, s=""):
self.__init__()
Layer.map(self, s)
s = s[3 : 3 + self.certs_length()]
while len(s) >= 3:
self.append(Int("cert_length", Pt=0, Type="uint24"))
self[-1].map(s)
self.append(Str("cert", Pt=""))
self[-1].map(s[3 : 3 + int(self[-2])])
self[-2].PtFunc = lambda x: len(self[-1])
self[-1].Len = self[-2]
self[-1].LenFunc = lambda l: int(l)
s = s[3 + int(self[-2]) :]
def map(self, s='', ipcp=True):
if s:
Layer.map(self, s)
if ipcp:
data, ipcp_list = self.Data(), []
while data:
ipcp = IPCP()
ipcp.map(data)
data = data[len(ipcp):]
ipcp_list.append(ipcp)
if ipcp_list:
self.Data.Val = None
self.Data.Pt = tuple(ipcp_list)
def map(self, s='', ipcp=True):
if s:
Layer.map(self, s)
if ipcp:
data, ipcp_list = self.Data(), []
while data:
ipcp = IPCP()
ipcp.map(data)
data = data[len(ipcp):]
ipcp_list.append( ipcp )
if ipcp_list:
self.Data.Val = None
self.Data.Pt = tuple(ipcp_list)
def map(self, s=''):
s_len = len(s)
Layer.map(self, s)
addr_len = len(self.TP_Recipient_Address)
if s_len < 22+addr_len:
self.TP_UD.Trans = True
if s_len < 21+addr_len:
self.TP_UDL.Trans = True
if s_len < 20+addr_len:
self.TP_DCS.Trans = True
if s_len < 19+addr_len:
self.TP_PID.Trans = True
if s_len < 18+addr_len:
self.TP_PI.Trans = True
def map(self, s=''):
# this is to adapt DIB header size to common most applications
self.DIBHeaderSize
expected_size = self.DIBHeaderSize()
self[0].map(s[:4])
real_size = self.DIBHeaderSize()
# remove last values from the header structure
if real_size < expected_size:
to_remove = (expected_size-real_size)/4
for i in range(to_remove):
self.remove(self[-1])
elif real_size > expected_size:
debug(self.dbg, 2, 'DIB header not long enough: not standard')
Layer.map(self, s)
def map(self, s=''):
# this is to adapt DIB header size to common most applications
self.DIBHeaderSize
expected_size = self.DIBHeaderSize()
self[0].map(s[:4])
real_size = self.DIBHeaderSize()
# remove last values from the header structure
if real_size < expected_size:
to_remove = (expected_size - real_size) / 4
for i in range(to_remove):
self.remove(self[-1])
elif real_size > expected_size:
debug(self.dbg, 2, 'DIB header not long enough: not standard')
Layer.map(self, s)
def decode_bit_str_val(self, obj):
tlv = self.handle_tag_dec(obj)
# obj._val: (BE uint value, BE uint bit length)
# map to a Layer including the pad_len initial octet
v_str = str(tlv[2])
if len(v_str) > 1:
pad_len = ord(v_str[0])
bit_len = 8*(len(v_str)-1)-pad_len
V = Layer('V')
V.append(Int('pad_len'), Type='uint8')
V.append(Bit('val', BitLen=bit_len, Repr=self._REPR_BIT_STR))
if pad_len > 0:
V.append(Bit('pad', BitLen=pad_len, Repr=self._REPR_BIT_STR))
V.map(v_str)
tlv.set(V)
#
obj._val = (V[1](), bit_len)
else:
obj._val = (0, 0)
def decode_bit_str_val(self, obj):
tlv = self.handle_tag_dec(obj)
# obj._val: (BE uint value, BE uint bit length)
# map to a Layer including the pad_len initial octet
v_str = str(tlv[2])
if len(v_str) > 1:
pad_len = ord(v_str[0])
bit_len = 8 * (len(v_str) - 1) - pad_len
V = Layer('V')
V.append(Int('pad_len'), Type='uint8')
V.append(Bit('val', BitLen=bit_len, Repr=self._REPR_BIT_STR))
if pad_len > 0:
V.append(Bit('pad', BitLen=pad_len, Repr=self._REPR_BIT_STR))
V.map(v_str)
tlv.set(V)
#
obj._val = (V[1](), bit_len)
else:
obj._val = (0, 0)
def map(self, s=''):
if len(s) < 1:
return ''
if len(self.elementList) != 3:
self.__init__()
Layer.map(self, s[0])
if self.T() == 31:
s = s[1:]
# extended form: consume the buffer until a MSBit is null
cur = 0
while cur < len(s) - 1:
if ord(s[cur]) & 0x80 == 0x80:
cur += 1
else:
break
tag_str = s[:cur + 1]
self.append(Str('T_ext', Pt=tag_str, Repr='hex'))
# get the integral value after removing MSBit of each byte
self._val = reduce(lambda x, y: (x << 7) + y,
map(lambda c: ord(c) & 0x7F, tag_str))
def map(self, s=''):
if len(s) < 1:
return ''
if len(self.elementList) != 3:
self.__init__()
Layer.map(self, s[0])
if self.T() == 31:
s = s[1:]
# extended form: consume the buffer until a MSBit is null
cur = 0
while cur < len(s)-1:
if ord(s[cur]) & 0x80 == 0x80:
cur += 1
else:
break
tag_str = s[:cur+1]
self.append( Str('T_ext', Pt=tag_str, Repr='hex') )
# get the integral value after removing MSBit of each byte
self._val = reduce(lambda x,y: (x<<7)+y,
map(lambda c: ord(c)&0x7F, tag_str))
def map(self, s=""):
Layer.map(self, s)
# map extensions
if len(s) >= len(self) + 2:
s = s[len(self) :]
# add extensions length
extl = Int("ext_length", Type="uint16")
extl.map(s)
self.append(extl)
s = s[2:]
l = extl()
if len(s) > l:
# truncate the buffer
s = s[:l]
elif len(s) < l:
# error
return
# add extensions
while s:
self.append(Extension())
self[-1].map(s)
s = s[len(self[-1]) :]
def map(self, string="\0"):
# check bit 128, 127 for format: bit map 0, or range / variable
# check bit 124 for format range 1024
# check bit 123, 122 for little ranges and var bit map
MSB = ord(string[0])
# we have to select the right format from self._fmts
if (MSB >> 6) == 0:
self._rebuild("map0")
elif (MSB >> 6) == 2:
if ((MSB >> 3) & 0b1) == 0:
self._rebuild("r1024")
else:
fmt_ext = (MSB >> 1) & 0b11
if fmt_ext == 0:
self._rebuild("r512")
elif fmt_ext == 1:
self._rebuild("r256")
elif fmt_ext == 2:
self._rebuild("r128")
elif fmt_ext == 3:
self._rebuild("mapvar")
Layer.map(self, string)
def map(self, s=''):
Layer.map(self, s)
self._map_tp()
def map(self, s=''):
if len(s) == 2:
self[-1].Trans = True
Layer.map(self, s)
def map(self, string="\0"):
self.MA_RFchan.BitLen = len(string[:8]) * 8
Layer.map(self, string)
def map(self, string=''):
Layer.map(self, string)
self.tID.Dict = TransformID[int(self.type)]
def map(self, string=''):
if len(string) > 0:
self.fmt < ord(string[0])&0b1
Layer.map(self, string)
def map(self, s=''):
Layer.map(self, s)
if len(s) <= self.L()+3:
self[-1].Trans = True
def map(self, string=''):
Layer.map(self, string)
self.tID.Dict = TransformID[int(self.type)]
