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.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