Untitled

asdfasdf

class  BitString(object): 
     '''  
     Allows bit-level manipulation of a string as if it were an array. 
      
     Example: 
     >>> x = pcs.BitString('\xff \xff ') 
     >>> print x 
     0b1111111111111111 
     >>> print repr (x.bytes) 
     '\xff \xff ' 
     >>> x[4:12] = 0 
     >>> print x 
     0b1111000000001111 
     >>> print bin(x[:8]) 
     0b11110000 
     >>> print bin(x[8:12]) 
     0b0 
     >>> print bin(x[12:]) 
     0b1111 
     >>> print repr (x.bytes) 
     '\xf0\x0f' 
     '''       
     def  __init__(self, bytes): 
         self.value = 0  
         self.length = len(bytes)*8  
         for  i,byte in  enumerate(bytes[::-1 ]):              
             self.value += ord(byte) << (i*8 ) 
     def  __getitem__(self, n):          
         if  n > len(self): 
             raise  IndexError 
         return  1  if  self.value & (1  << (len(self)-n-1 )) else  0  
     def  __getslice__(self, i, j): 
         retVal= 0  
         i = max(i,0 ) 
         j = min(j,len(self)) 
         for  n,bit in  enumerate(range(i,j)): 
             retVal <<= 1  
             retVal += self[bit] 
         return  retVal 
      @property 
     def  bytes(self): return  self.getBytes() 
     def  getBytes(self): 
         formatString = "%0"  + ("%s"  % (len(self)/8 )) + "x"  
         hexstring = formatString % self.value 
         byteString = binascii.unhexlify(hexstring) 
          
         while  len(byteString) < len(self)/8 : 
             byteString = "\x00"  + byteString 
         return  byteString          
     def  __len__(self): 
         return  self.length 
     def  __str__(self): 
         return  self.bin() 
     def  __repr__(self): 
         return  self.__class__.__name__ + "(%s)"  % repr(self.getBytes()) 
     def  __setitem__(self, n, x): 
         x = 1  if  x else  0  
         if  x: 
             self.value |= (x << (len(self)-n-1 )) 
         else : 
             self.value = self.value & self._makeMask(n) 
     def  __setslice__(self, i, j, x): 
         i = max(i,0 ) 
         j = min(j,len(self)) 
          
         isAList = True  
         if  isinstance(x,int) or  isinstance(x,long) or  isinstance(x,bool): 
             isAList = False  
          
         for  index,n in  enumerate(range(i,j)): 
             if  isAList: 
                 self[n] = x[index] 
             else : 
                 self[n] = x 
     def  _makeMask(self, bit): 
         mask = 0  
         bitSkip = (len(self)-bit-1 ) 
         for  i in  range(len(self)): 
             if  i == bitSkip: 
                 continue  
             mask += 1  << i 
         return  mask 
     def  hex(self): 
         return  hex(self.value) 
     def  bin(self): 
         return  bin(self.value) 

When used in conjunction with pcs.Field, I've set it up to calculate the value with the new method, but still *use* the value from the old method, to show the difference between the new vs. old method. Pay particular attention to syn, ack, fin, reset, and push.

>>> synAckPkt = tcp('09\xd4191\xf6\xae\x00\x00\x00\x01`\x12\xff\xff\xfe"\x00\x00')
Decoding sport --> 12345
Decoding dport --> 54321
Decoding sequence --> 959575726
Decoding ack_number --> 1
Decoding offset --> 6
Decoding reserved --> 0
Decoding urgent --> 0
Decoding ack --> 1
Decoding psh --> 0
Decoding reset --> 0
Decoding syn --> 1
Decoding fin --> 0
Decoding window --> 65535
Decoding checksum --> 65058
Decoding urg_pointer --> 0
>>> print repr(synAckPkt)
<class tcp {reset: 4, psh: 2, reserved: 0, sequence: 959575726, ack: 1, checksum: 65058, offset: 6, syn: 9, urgent: 0, window: 65535, ack_number: 1, dport: 54321, sport: 12345, fin: 0, urg_pointer: 0}>
>>> print repr(synAckPkt.data)
<class payload {payload: ''}> 

Read more...