def __init__(self, promisc=True, buffer_size=None, read_timeout=100, show_packets=False): self._pcap_t = None self._packets = None assert promisc in (True, False), "promisc must be either True or False" self._promisc = promisc self._buffer_size = buffer_size self._read_timeout = read_timeout assert show_packets in ( True, False), "show_packets must be either True or False" self._show_packets = show_packets self._pcap_lock = threading.Lock() try: from impacket.ImpactDecoder import LinuxSLLDecoder self._decoder = LinuxSLLDecoder() except ImportError: self._decoder = None
def __init__(self, pcapObj, server_ports, ws_path, soap_request_handler, server): # Query the type of the link and instantiate a decoder accordingly. datalink = pcapObj.datalink() if pcapy.DLT_EN10MB == datalink: self.decoder = EthDecoder() elif pcapy.DLT_LINUX_SLL == datalink: self.decoder = LinuxSLLDecoder() else: raise Exception('Datalink type not supported: %s' % (datalink, )) self.pcap = pcapObj self.server_ports = set(server_ports) self.ws_path = ws_path self.server = server self.soap_request_handler = soap_request_handler self.valid_http_methods = set(['GET', 'POST']) self._shortest_method_name = min( [len(x) for x in self.valid_http_methods]) self._longest_method_name = max( [len(x) for x in self.valid_http_methods]) Thread.__init__(self) self.packet_counter = 0 self.connections = ConnectionManager() self.http_request_counter = Counter() self.soap_call_counter = Counter() self.server_conn = None self._needs_server_update = False self._last_server_update = 0
def __init__(self, pcapObj): datalink = pcapObj.datalink() if pcapy.DLT_EN10MB == datalink: self.decoder = EthDecoder() elif pcapy.DLT_LINUX_SLL == datalink: self.decoder = LinuxSLLDecoder() else: raise Exception("Tipo de datalink não suportado: " % datalink) self.pcap = pcapObj Thread.__init__(self)
def __init__(self, cap_stream): multiprocessing.Process.__init__(self) self.cap_stream = cap_stream self.datalink = cap_stream.datalink() if pcapy.DLT_EN10MB == self.datalink: self.decoder = EthDecoder() elif pcapy.DLT_LINUX_SLL == self.datalink: self.decoder = LinuxSLLDecoder() else: raise Exception("Datalink type not supported: " % self.datalink)
def __init__(self, pcapObj): # Query the type of the link and instantiate a decoder accordingly. datalink = pcapObj.datalink() if pcapy.DLT_EN10MB == datalink: self.decoder = EthDecoder() elif pcapy.DLT_LINUX_SLL == datalink: self.decoder = LinuxSLLDecoder() else: raise Exception("Datalink type not supported: " % datalink) self.pcap = pcapObj Thread.__init__(self)
def __init__(self, pcapObj=None, Interface=None): datalink = pcapObj.datalink() self.Interface = Interface if pcapy.DLT_EN10MB == datalink: self.decoder = EthDecoder() elif pcapy.DLT_LINUX_SLL == datalink: self.decoder = LinuxSLLDecoder() else: raise Exception("Unsupported datalink type: " % datalink) self.pcap = pcapObj self.buffer_traffic = [] Thread.__init__(self)
def __init__(self, pcapObj): """ Query the type of the link and instantiate a decoder accordingly. """ datalink = pcapObj.datalink() if pcapy.DLT_EN10MB == datalink: self.decoder = EthDecoder() elif pcapy.DLT_LINUX_SLL == datalink: self.decoder = LinuxSLLDecoder() else: raise Exception("Datalink type not supported: " % datalink) self.pcap = pcapObj self.buffer = [] # init internal buffer self.quit = False # quit thread? Thread.__init__(self)
def __init__(self, bridge, subnet, arptable): # Open interface for capturing. self.pcap = open_live(bridge.bridgename, 65536, 1, 100) # Query the type of the link and instantiate a decoder accordingly. datalink = self.pcap.datalink() if pcapy.DLT_EN10MB == datalink: self.decoder = EthDecoder() elif pcapy.DLT_LINUX_SLL == datalink: self.decoder = LinuxSLLDecoder() else: raise Exception("Datalink type not supported: " % datalink) self.bridge = bridge self.subnet = subnet self.arptable = arptable self.protocols = args.discovery_protos or self.protocols Thread.__init__(self)
def start(self): self.p = open_live(self.interface, 1600, 0, 100) ## self.p.setnonblock(1) if self.filter: self.p.setfilter(self.filter) # Query the type of the link and instantiate a decoder accordingly. datalink = self.p.datalink() if pcapy.DLT_EN10MB == datalink: self.decoder = EthDecoder() elif pcapy.DLT_LINUX_SLL == datalink: self.decoder = LinuxSLLDecoder() else: raise Exception("Datalink type not supported: " % datalink) self.tk.after(POLL_PERIOD, self.poll) self.tk.after(REFRESH_PERIOD, self.timerDraw) self.tk.bind('q', self.quit) self.tk.mainloop()
def __init__(self, callback, dev='any', port=3333, ignoreIp=None): Thread.__init__(self) DEV = dev # interface to listen on MAX_LEN = 1514 # max size of packet to capture PROMISCUOUS = 1 # promiscuous mode? READ_TIMEOUT = 100 # in milliseconds self.MAX_PKTS = -1 # number of packets to capture; -1 => no limit self.p = open_live(DEV, MAX_LEN, PROMISCUOUS, READ_TIMEOUT) myfilter = 'udp and port ' + str(port) if ignoreIp: myfilter += ' and not dst host ' + ignoreIp self.p.setfilter(myfilter) self.callback = callback self.packets = 0 datalink = self.p.datalink() if pcapy.DLT_EN10MB == datalink: self.decoder = EthDecoder() elif pcapy.DLT_LINUX_SLL == datalink: self.decoder = LinuxSLLDecoder() else: raise Exception("Datalink type not supported: " % datalink)
print " bytes = the approximate maximum size of the little files" print "" if len(sys.argv) < 3: showUsage() sys.exit(1) fileCount = 1 p = open_offline(sys.argv[1]) datalink = p.datalink() if DLT_EN10MB == datalink: decoder = EthDecoder() elif DLT_LINUX_SLL == datalink: decoder = LinuxSLLDecoder() else: raise Exception("Datalink type not supported: " % datalink) while 1: try: (hdr, data) = p.next() filename = "%s_%d.cap" % (sys.argv[2], fileCount) pktCount = 0 capSize = 0 d = p.dump_open(filename) while capSize < int(sys.argv[3]): pkt = decoder.decode(data) try: bytes = len(pkt.get_packet()) except:
def run(self): global maxcount global maxbytes global history global persistant global running global last_dump flows = {} count = 0 # Arguments here are: # device # snaplen (maximum number of bytes to capture _per_packet_) # promiscious mode (1 for true) # timeout (in milliseconds) cap = pcapy.open_live(FLAGS.i, 1500, 1, 1000) # We get layer 1 packets. Therefore we need to use the right decoder. datalink = cap.datalink() if pcapy.DLT_EN10MB == datalink: decoder = EthDecoder() elif pcapy.DLT_LINUX_SLL == datalink: decoder = LinuxSLLDecoder() else: print '%s Datalink type not supported: ' %(datetime.datetime.now(), datalink) sys.exit(1) # Read packets -- header contains information about the data from pcap, # payload is the actual packet as a string (header, payload) = cap.next() while header: count += 1 if FLAGS.verbose: print ('%s captured %d bytes, truncated to %d bytes' %(datetime.datetime.now(), header.getlen(), header.getcaplen())) try: # The link level packet contains a payload l = decoder.decode(payload) p = l.child() key = None if p.ethertype == 0x800: # This is an IP packet ip = p.child() ips = [p.get_ip_src(), p.get_ip_dst()] ips.sort() if ip.protocol == 1: # ICMP if FLAGS.verbose: print (' ICMP: %s -> %s type %s' %(p.get_ip_src(), p.get_ip_dst(), ip.get_type_name(ip.get_icmp_type()))) key = 'ICMP %s' % repr(ips) elif ip.protocol == 6: # TCP if FLAGS.verbose: print ' TCP: %s:%d -> %s:%d' %(p.get_ip_src(), ip.get_th_sport(), p.get_ip_dst(), ip.get_th_dport()) ports = [ip.get_th_sport(), ip.get_th_dport()] ports.sort() key = 'TCP %s %s' %(repr(ips), repr(ports)) elif ip.protocol == 17: # UDP if FLAGS.verbose: print ' UDP: %s:%d -> %s:%d' %(p.get_ip_src(), ip.get_uh_sport(), p.get_ip_dst(), ip.get_uh_dport()) ports = [ip.get_uh_sport(), ip.get_uh_dport()] ports.sort() key = 'TCP %s %s' %(repr(ips), repr(ports)) elif ip.protocol: print '%s Unknown IP protocol %s' %(datetime.datetime.now(), ip.protocol) if key: flows.setdefault(key, (0, 0, 0, 0)) (a_count, a_bytes, b_count, b_bytes) = flows[key] if ips == [p.get_ip_src(), p.get_ip_dst()]: a_count += 1 a_bytes += header.getlen() else: b_count += 1 b_bytes += header.getlen() flows[key] = (a_count, a_bytes, b_count, b_bytes) else: print '%s Unknown ethertype %x' %(datetime.datetime.now(), p.ethertype) except impacket.ImpactPacket.ImpactPacketException, e: print '%s Sniffer skipped packet: %s' %(datetime.datetime.now(), e) self.data_lock.acquire() if time.time() - last_dump > 30: # Recalibrate maximums maxcount = 100 maxbytes = 100 for flow in flows: (acount, abytes, bcount, bbytes) = flows[flow] if acount > maxcount: maxcount = acount if bcount > maxcount: maxcount = bcount if abytes > maxbytes: maxbytes = abytes if bbytes > maxbytes: maxbytes = bbytes # Append to history history.append(flows) history = history[-30:] # Write to persistant history as well persistant.setdefault('history', {}) persistant['history'][time.time()] = flows persistant.sync() if len(persistant['history']) > 29: print '%s Committing suicide' % datetime.datetime.now() persistant.close() running = False raise SystemExit() print ('%s Sniffer captured %d packets in the last 30 seconds' %(datetime.datetime.now(), count)) count = 0 flows = {} last_dump = time.time() self.data_lock.release() del header del payload (header, payload) = cap.next()