def _calc_sum(self): """Recalculate the TCP-checksum This won't reset changed state.""" # TCP and underwriting are freaky bitches: we need the IP pseudoheader to calculate their checksum. try: # we need src/dst for checksum-calculation src, dst = self._lower_layer.src, self._lower_layer.dst self.sum = 0 # logger.debug("TCP sum recalc: IP=%d / %s / %s" % (len(src), src, dst)) tcp_bin = self.header_bytes + self.body_bytes # IP-pseudoheader, check if version 4 or 6 if len(src) == 4: s = pack(">4s4sxBH", src, dst, 6, len(tcp_bin)) # 6 = TCP else: s = pack(">16s16sxBH", src, dst, 6, len(tcp_bin)) # 6 = TCP # Get checksum of concatenated pseudoheader+TCP packet # logger.debug("pseudoheader: %r" % s) # logger.debug("tcp_bin: %r" % tcp_bin) # assign via non-shadowed variable to trigger re-packing self.sum = checksum.in_cksum(s + tcp_bin) # logger.debug(">>> new checksum: %0X" % self._sum) except Exception: # not an IP packet as lower layer (src, dst not present) or invalid src/dst # logger.debug("could not calculate checksum: %r" % e) pass
def _calc_sum(self): """Recalculate the UDP-checksum.""" # TCP and underwriting are freaky bitches: we need the IP pseudoheader to calculate their checksum # logger.debug("UDP sum recalc: %s/%s/%s" % (src, dst, changed)) try: # we need src/dst for checksum-calculation src, dst = self._lower_layer.src, self._lower_layer.dst # logger.debug(src + b" / "+ dst) self.sum = 0 udp_bin = self.header_bytes + self.body_bytes # IP-pseudoheader, check if version 4 or 6 if len(src) == 4: s = pack_ipv4(src, dst, 17, len(udp_bin)) # 17 = UDP else: s = pack_ipv6(src, dst, 17, len(udp_bin)) # 17 = UDP csum = checksum.in_cksum(s + udp_bin) if csum == 0: csum = 0xffff # RFC 768, p2 # get the checksum of concatenated pseudoheader+TCP packet # assign via non-shadowed variable to trigger re-packing self.sum = csum except (AttributeError, struct.error): # not an IP packet as lower layer (src, dst not present) or invalid src/dst pass
def _update_fields(self): if self.sum_au_active and self._changed(): # logger.debug(">>> IP: calculating sum") # reset checksum for recalculation, mark as changed / clear cache self.sum = 0 # logger.debug(">>> IP: bytes for sum: %s" % self.header_bytes) self.sum = checksum.in_cksum(pypacker.Packet.bin(self, update_auto_fields=True))
def __calc_sum(self): """Recalculate checksum.""" # logger.debug(">>> IP: calculating sum") # reset checksum for recalculation, mark as changed / clear cache self._sum = 0 # logger.debug(">>> IP: bytes for sum: %s" % self.pack_hdr()) self._sum = checksum.in_cksum(self.pack_hdr())
def _calc_sum(self): """Recalculate the TCP-checksum. This won't reset changed state.""" # TCP and underwriting are freaky bitches: we need the IP pseudoheader # to calculate their checksum. try: # we need src/dst for checksum-calculation src, dst = self._lower_layer.src, self._lower_layer.dst self.sum = 0 # logger.debug("TCP sum recalc: IP=%d / %s / %s" % (len(src), src, dst)) tcp_bin = self.header_bytes + self.body_bytes # IP-pseudoheader, check if version 4 or 6 if len(src) == 4: s = pack_ipv4_header(src, dst, 6, len(tcp_bin)) # 6 = TCP else: s = pack_ipv6_header(src, dst, 6, len(tcp_bin)) # 6 = TCP # Get checksum of concatenated pseudoheader+TCP packet # logger.debug("pseudoheader: %r" % s) # logger.debug("tcp_bin: %r" % tcp_bin) # assign via non-shadowed variable to trigger re-packing self.sum = checksum.in_cksum(s + tcp_bin) # logger.debug(">>> new checksum: %0X" % self._sum) except (AttributeError, struct.error): # not an IP packet as lower layer (src, dst not present) or invalid src/dst # logger.debug("could not calculate checksum: %r" % e) pass
def _calc_sum(self): """Recalculate the UDP-checksum.""" # TCP and underwriting are freaky bitches: we need the IP pseudoheader to calculate their checksum # logger.debug("UDP sum recalc: %s/%s/%s" % (src, dst, changed)) try: # we need src/dst for checksum-calculation src, dst = self._lower_layer.src, self._lower_layer.dst # logger.debug(src + b" / "+ dst) self.sum = 0 udp_bin = self.header_bytes + self.body_bytes # IP-pseudoheader: IP src, dst, \x00, UDP upper proto, length # check if version 4 or 6 if len(src) == 4: s = pack(">4s4sBBH", src, dst, 0, 17, len(udp_bin)) # 17 = UDP else: s = pack(">16s16sxBH", src, dst, 17, len(udp_bin)) # 17 = UDP csum = checksum.in_cksum(s + udp_bin) if csum == 0: csum = 0xffff # RFC 768, p2 # get the checksum of concatenated pseudoheader+TCP packet # assign via non-shadowed variable to trigger re-packing self.sum = csum except (AttributeError, struct.error): # not an IP packet as lower layer (src, dst not present) or invalid src/dst pass
def _update_fields(self): # logger.debug("sum is: %d" % self.sum) if self.sum_au_active and self._changed(): # logger.debug("sum is: %d" % self.sum) # logger.debug("header: %r", self.header_bytes) # logger.debug("body: %r", self.body_bytes) self.sum = 0 self.sum = checksum.in_cksum(self.header_bytes + self.body_bytes)
def bin(self, update_auto_fields=True): # logger.debug("sum is: %d" % self.sum) if update_auto_fields and self.sum_au_active and self._changed(): # logger.debug("sum is: %d" % self.sum) self.sum = 0 self.sum = checksum.in_cksum(self._pack_header() + self.body_bytes) # logger.debug("sum is: %d" % self.sum) return pypacker.Packet.bin(self, update_auto_fields=update_auto_fields)
def bin(self, update_auto_fields=True): if update_auto_fields and self.sum_au_active and self._changed(): # logger.debug(">>> IP: calculating sum") # reset checksum for recalculation, mark as changed / clear cache self.sum = 0 # logger.debug(">>> IP: bytes for sum: %s" % self.header_bytes) self.sum = checksum.in_cksum(pypacker.Packet.bin(self, update_auto_fields=True)) return pypacker.Packet.bin(self, update_auto_fields=update_auto_fields)
def create_gre_obj(cls, utg_gre): # type: (Packet.GRE) -> object obj = GRE() #bin_headers = '0x' + binascii.hexlify(obj.bin()).decode('utf-8') obj.version_number = utg_gre.version #bin_headers = '0x' + binascii.hexlify(obj.bin()).decode('utf-8') if utg_gre.use_checksum is True: obj.opts.append(GREOptionChecksum(checksum=0)) obj.opts.append(GREOptionReserve_1()) obj.checksum_bit = 1 #bin_headers = '0x' + binascii.hexlify(obj.bin()).decode('utf-8') if utg_gre.key_field is not None: obj.opts.append( GREOptionKey( key=Converter.convertstring2int(utg_gre.key_field))) obj.key_bit = 1 #bin_headers = '0x' + binascii.hexlify(obj.bin()).decode('utf-8') if utg_gre.sequence_number is not None: obj.opts.append( GREOptionSequence(sequence=Converter.convertstring2int( utg_gre.sequence_number))) obj.sequence_bit = 1 #bin_headers = '0x' + binascii.hexlify(obj.bin()).decode('utf-8') if utg_gre.use_checksum is True: innerPacketData = obj.bin() if utg_gre.l3_proto is TGEnums.L3_PROTO.IPV4: obj.protocol_type = ETH_TYPE_IP packer_v4 = utg_gre.ipv4.to_packer() innerPacketData += packer_v4.bin() elif utg_gre.l3_proto is TGEnums.L3_PROTO.IPV6: obj.protocol_type = ETH_TYPE_IP6 v6 = utg_gre.ipv6.to_packer() innerPacketData += v6.bin() else: proto = Converter.remove_non_hexa_sumbols(utg_gre.l3_proto) proto = Converter.hexaString2int(proto) obj.protocol_type = proto if utg_gre.l4_proto is TGEnums.L4_PROTO.UDP: packer_udp = utg_gre.udp.to_packer() innerPacketData += packer_udp.bin() elif utg_gre.l4_proto is TGEnums.L4_PROTO.TCP: packer_tcp = utg_gre.tcp.to_packer() innerPacketData += packer_tcp.bin() s = checksum.in_cksum(innerPacketData) obj.opts[0].checksum = s #bin_headers = '0x' + binascii.hexlify(obj.bin()).decode('utf-8') return obj
def _calc_sum(self): try: # we need src/dst for checksum-calculation src, dst = self._lower_layer.src, self._lower_layer.dst # logger.debug("TCP sum recalc: IP=%d / %s / %s" % (len(src), src, dst)) # pseudoheader # packet length = length of upper layers self.sum = 0 pkt = self.header_bytes + self.body_bytes hdr = pack_ipv6_icmp6(src, dst, len(pkt), 58) self.sum = checksum.in_cksum(hdr + pkt) #logger.debug(">>> new checksum: %0X" % self._sum) except Exception: # not an IP packet as lower layer (src, dst not present) or invalid src/dst # logger.debug("could not calculate checksum: %r" % e) pass
def __calc_sum(self): """Recalculate the TCP-checksum This won't reset changed state.""" self._sum = 0 tcp_bin = self.pack_hdr() + self.data # we need src/dst for checksum-calculation src, dst, changed = self._callback("ip_src_dst_changed") #logger.debug("TCP sum recalc: IP=%d/%s/%s/%s" % (len(src), src, dst, changed)) # IP-pseudoheader, check if version 4 or 6 if len(src) == 4: s = pack(">4s4sxBH", src, dst, 6, len(tcp_bin)) # 6 = TCP else: s = pack(">16s16sxBH", src, dst, 6, len(tcp_bin)) # 6 = TCP # Get checksum of concatenated pseudoheader+TCP packet self._sum = checksum.in_cksum(s + tcp_bin)
def _calc_sum(self): try: # we need src/dst for checksum-calculation src, dst = self._lower_layer.src, self._lower_layer.dst except Exception: # not an IP packet as lower layer (src, dst not present) or invalid src/dst # logger.debug("could not calculate checksum: %r" % e) return # pseudoheader # packet length = length of upper layers self.sum = 0 # logger.debug("TCP sum recalc: IP6= len(src)=%d\n%s\n%s\nhdr=%s\nbody=%s" % # (len(src), src, dst, self.header_bytes, self.body_bytes)) pkt = self.header_bytes + self.body_bytes hdr = pack_ipv6_icmp6(src, dst, len(pkt), 58) # this will set the header status to changes, should be reset by calling bin() self.sum = checksum.in_cksum(hdr + pkt)
def bin(self, update_auto_fields=True): if update_auto_fields: if self._changed(): self.len = len(self) # length changed so we have to recalculate checksum # logger.debug("updating checksum") # logger.debug(">>> IP: calculating sum") # reset checksum for recalculation, mark as changed / clear cache self.sum = 0 # Update header length. NOTE: needs to be a multiple of 4 Bytes. # logger.debug("updating: %r" % self._packet) # options length need to be multiple of 4 Bytes self._hl = int(self.header_len / 4) & 0xf # logger.debug(">>> IP: bytes for sum: %s" % self.header_bytes) self.sum = checksum.in_cksum(self._pack_header()) # logger.debug("IP: new hl: %d / %d" % (self._packet.hdr_len, hdr_len_off)) # logger.debug("new sum: %0X" % self.sum) return pypacker.Packet.bin(self, update_auto_fields=update_auto_fields)
def __calc_sum(self): """Recalculate the UDP-checksum.""" # mark as achanged self._sum = 0 udp_bin = self.pack_hdr() + self.data src, dst, changed = self._callback("ip_src_dst_changed") #logger.debug("UDP sum recalc: %s/%s/%s" % (src, dst, changed)) # IP-pseudoheader, check if version 4 or 6 if len(src) == 4: s = pack(">4s4sxBH", src, dst, 17, len(udp_bin)) # 17 = UDP else: s = pack(">16s16sxBH", src, dst, 17, len(udp_bin)) # 17 = UDP sum = checksum.in_cksum(s + udp_bin) if sum == 0: sum = 0xffff # RFC 768, p2 # get the checksum of concatenated pseudoheader+TCP packet self._sum = sum
def _calc_checksum(self, payload): """ Using a Pseudoheader of: - Source address - Destination address - L4 protocol type (UDP) - UDP header, excluding checksum """ assert isinstance(self._src, SCIONAddr), type(self._src) assert isinstance(self._dst, SCIONAddr), type(self._dst) pseudo_header = b"".join([ self._dst.isd_as.pack(), self._src.isd_as.pack(), self._dst.host.pack(), self._src.host.pack(), b"\x00", struct.pack("!B", L4Proto.UDP), self.pack(payload, checksum=bytes(2)), payload, ]) chk_int = checksum.in_cksum(pseudo_header) return struct.pack("!H", chk_int)
def __calc_sum(self): self._sum = 0 object.__setattr__(self, "_sum", checksum.in_cksum(pypacker.Packet.bin()) )
def __calc_sum(self): # mark as changed self._sum = 0 self._sum = checksum.in_cksum( pypacker.Packet.bin(self) )
def bin(self, update_auto_fields=True): if update_auto_fields and self.sum_au_active and self._changed(): self.sum = 0 self.sum = checksum.in_cksum(pypacker.Packet.bin(self)) return pypacker.Packet.bin(self, update_auto_fields=update_auto_fields)
def _update_fields(self): if self.sum_au_active and self._changed(): self.sum = 0 self.sum = checksum.in_cksum(pypacker.Packet.bin(self))
def __str__(self): data = "".join(map(str, self.data)) if not self.sum: self.sum = checksum.in_cksum(self.pack_hdr() + data) return self.pack_hdr() + data
def __calc_sum(self): self._sum = 0 self._sum = checksum.in_cksum(pypacker.Packet.bin(self))
def bin(self, update_auto_fields=True): if update_auto_fields and self._changed(): self.sum = 0 self.sum = checksum.in_cksum(pypacker.Packet.bin(self)) return pypacker.Packet.bin(self, update_auto_fields=update_auto_fields)
def __calc_sum(self): # mark as changed / clear cache self._sum = 0 self._sum = checksum.in_cksum(self.pack_hdr() + self.data)