def _post_raw(self, raw_value, bit, protocol_container, protocol_bits): """ """ cksum_rev_offset = 0 # checking if user not defined his own value of checksum if _bits.get_bits(raw_value, self.get_field('_checksum').bits, cksum_rev_offset, rev_offset=True) == 0: # Payload if self.payload: cksum = self.payload.__dict__['__raw_value'] else: cksum = 0 offset = protocol_bits # UDP Header cksum |= raw_value << offset offset += bit # Pseudo Header # # create pseudo header object pheader = _layer4_ipv6.PseudoHeader(self.protocol_id, self.get_field('_length').fillout()) # generate raw value of it pheader_raw = pheader.get_raw(protocol_container, protocol_bits)[0] # added pseudo header bits to cksum value cksum |= pheader_raw << offset # finally, calcute and apply checksum raw_cksum = _net.in_cksum(cksum) cksum_cal = ((raw_cksum << 8) | (raw_cksum >> 8)) & 0xFFFF raw_value |= cksum_cal << cksum_rev_offset return raw_value, bit
def _post_raw(self, raw_value, bit, protocol_container, protocol_bits): """ Handle with fields after calling fillout() for them. Calculate header checksum. @type raw_value: C{int} @param raw_value: currently raw value for the packet. @type bit: C{int} @param bit: currently length of the protocol. @type protocol_container: C{tuple} @param protocol_container: tuple of protocols included in the packet. @type protocol_bits: C{int} @param protocol_bits: currently length of the packet. @return: C{raw_value, bit} """ # Header Checksum # a checksum on the header only. cksum_offset = bit - self.get_offset('_checksum') - \ self.get_field('_checksum').bits # check if user doesn't provide own values of bits if _bits.get_bits(raw_value, self.get_field('_checksum').bits, cksum_offset, rev_offset=True) == 0: # calculate and add checksum to the raw_value cksum = _net.in_cksum(raw_value) raw_value |= cksum << cksum_offset return raw_value, bit
def _post_raw(self, raw_value, bit, protocol_container, protocol_bits): """ """ print "proto bit " print protocol_bits # Fill checksum only if it's zero (not supplied by user) cksum_offset = bit - self.get_offset('_checksum') - \ self.get_field('_checksum').bits if _bits.get_bits(raw_value,self.get_field('_checksum').bits,cksum_offset,rev_offset=True) == 0: # calculate checksum and place it at the correct offset in raw_value cksum = _net.in_cksum(raw_value) raw_value |= cksum << cksum_offset return raw_value, bit
def _post_raw(self, raw_value, bit, protocol_container, protocol_bits): """ """ # Fill checksum only if it's zero (not supplied by user) cksum_offset = bit - self.get_offset('_checksum') - \ self.get_field('_checksum').bits #self.get_field('_checksum')._tmp_value = 32699 if _bits.get_bits(raw_value,self.get_field('_checksum').bits,cksum_offset,rev_offset=True) == 0: # Payload if self.payload: cksum = self.payload.__dict__['__raw_value'] else: cksum = 0 offset = protocol_bits # TCP Header cksum |= raw_value << offset offset += bit # calculate checksum and place it at the correct offset in raw_value total_length = offset total_length /= 8 pheader = _layer4_ipv6.PseudoHeader6(self.protocol_id, total_length) pheader_raw = pheader.get_raw(protocol_container, protocol_bits)[0] cksum |= pheader_raw << offset raw_cksum = _net.in_cksum(cksum) cksum_cal = ((raw_cksum << 8) | (raw_cksum >> 8)) & 0xFFFF raw_value |= cksum_cal << cksum_offset #cksum = _net.in_cksum(raw_value) #raw_value |= cksum << cksum_offset #self.get_field('_checksum')._tmp_value = 32699 return raw_value, bit
def _post_raw(self, raw_value, bit, protocol_container, protocol_bits): """ Handle with fields after calling fillout() for them. Calculate header checksum with new instance of PseudoHeader object. @type raw_value: C{int} @param raw_value: currently raw value for the packet. @type bit: C{int} @param bit: currently length of the protocol. @type protocol_container: C{tuple} @param protocol_container: tuple of protocols included in the packet. @type protocol_bits: C{int} @param protocol_bits: currently length of the packet. @return: C{raw_value, bit} """ # rev_offset it the offset from the right side cksum_rev_offset = bit - self.get_offset('_checksum') - \ self.get_field('_checksum').bits # checking if user not defined his own value of checksum if _bits.get_bits(raw_value, self.get_field('_checksum').bits, cksum_rev_offset, rev_offset=True) == 0: # Payload if self.payload: cksum = self.payload.__dict__['__raw_value'] else: cksum = 0 offset = protocol_bits # TCP Header cksum |= raw_value << offset offset += bit # Pseudo Header # # TCP header length...converted to bits unit total_length = self.get_field('_hdr_len').fillout() * 32 # add payload total_length += protocol_bits # conversion to bytes unit total_length /= 8 # create pseudo header object #in _layer4_ipv6 also need to add ipv6 notation # pheader = _layer4_ipv6.PseudoHeader6(self.protocol_id, total_length) # generate raw value of it pheader_raw = pheader.get_raw(protocol_container, protocol_bits)[0] # added pseudo header bits to cksum value cksum |= pheader_raw << offset # finally, calcute and apply checksum raw_cksum = _net.in_cksum(cksum) # To swap last two byte of tcp checksum cksum_cal = ((raw_cksum << 8) | (raw_cksum >> 8)) & 0xFFFF raw_value |= cksum_cal << cksum_rev_offset return raw_value, bit
def _post_raw(self, raw_value, bit, protocol_container, protocol_bits): """ Handle with fields after calling fillout() for them. Calculate header checksum with new instance of PseudoHeader object. @type raw_value: C{int} @param raw_value: currently raw value for the packet. @type bit: C{int} @param bit: currently length of the protocol. @type protocol_container: C{tuple} @param protocol_container: tuple of protocols included in the packet. @type protocol_bits: C{int} @param protocol_bits: currently length of the packet. @return: C{raw_value, bit} """ # rev_offset it the offset from the right side cksum_rev_offset = bit - self.get_offset('_checksum') - \ self.get_field('_checksum').bits # checking if user not defined his own value of checksum if _bits.get_bits(raw_value, self.get_field('_checksum').bits, cksum_rev_offset, rev_offset=True) == 0: # Payload if self.payload: cksum = self.payload.__dict__['__raw_value'] else: cksum = 0 offset = protocol_bits # TCP Header cksum |= raw_value << offset offset += bit # Pseudo Header # # TCP header length...converted to bits unit total_length = self.get_field('_hdr_len').fillout()*32 # add payload total_length += protocol_bits # conversion to bytes unit total_length /= 8 # create pseudo header object #in _layer4_ipv6 also need to add ipv6 notation # pheader = _layer4_ipv6.PseudoHeader6(self.protocol_id, total_length) # generate raw value of it pheader_raw = pheader.get_raw(protocol_container, protocol_bits)[0] # added pseudo header bits to cksum value cksum |= pheader_raw << offset # finally, calcute and apply checksum raw_cksum = _net.in_cksum(cksum) # To swap last two byte of tcp checksum cksum_cal = ((raw_cksum << 8) | (raw_cksum >> 8)) & 0xFFFF raw_value |= cksum_cal << cksum_rev_offset return raw_value, bit
def _post_raw(self, raw_value, bit, protocol_container, protocol_bits): """ Handle with fields after calling fillout() for them. Calculate header checksum with new instance of PseudoHeader object. @type raw_value: C{int} @param raw_value: currently raw value for the packet. @type bit: C{int} @param bit: currently length of the protocol. @type protocol_container: C{tuple} @param protocol_container: tuple of protocols included in the packet. @type protocol_bits: C{int} @param protocol_bits: currently length of the packet. @return: C{raw_value, bit} """ cksum_rev_offset = 0 # checking if user not defined his own value of checksum if _bits.get_bits(raw_value, self.get_field('_checksum').bits, cksum_rev_offset, rev_offset=True) == 0: # Payload if self.payload: cksum = self.payload.__dict__['__raw_value'] else: cksum = 0 offset = protocol_bits # UDP Header cksum |= raw_value << offset offset += bit # Pseudo Header # # create pseudo header object it = iter(protocol_container) for proto in it: if isinstance(proto, IPV6): pheader = _layer4_ipv6.PseudoHeader6( self.protocol_id, self.get_field('_length').fillout()) pheader_raw = pheader.get_raw(protocol_container, protocol_bits)[0] cksum |= pheader_raw << offset raw_cksum = _net.in_cksum(cksum) if proto.dst == '0000:0000:0000:0000:0000:0000:0000:0001' and proto.src == '0000:0000:0000:0000:0000:0000:0000:0001': cksum_cal = ((raw_cksum << 8) | (raw_cksum >> 8)) & 0xFFFF else: cksum_cal = raw_cksum #cksum_cal = ((raw_cksum << 8) | (raw_cksum >> 8)) & 0xFFFF #cksum_cal = raw_cksum raw_value |= cksum_cal << cksum_rev_offset elif isinstance(proto, IP): pheader = _layer4.PseudoHeader( self.protocol_id, self.get_field('_length').fillout()) pheader_raw = pheader.get_raw(protocol_container, protocol_bits)[0] cksum |= pheader_raw << offset raw_cksum = _net.in_cksum(cksum) raw_value |= raw_cksum << cksum_rev_offset #pheader = _layer4.PseudoHeader(self.protocol_id,self.get_field('_length').fillout()) # generate raw value of it #pheader_raw = pheader.get_raw(protocol_container, protocol_bits)[0] # added pseudo header bits to cksum value #cksum |= pheader_raw << offset # finally, calcute and apply checksum #raw_cksum = _net.in_cksum(cksum) #raw_value |= raw_cksum << cksum_rev_offset return raw_value, bit