Update: Finish capture and show.

Author: Youggls

tools/utils.py

@@ -1,6 +1,87 @@
+import time
+import pcap
+import dpkt
+import threading
 from winpcapy import WinPcapUtils, WinPcapDevices
 
 
 def get_devices():
     devices = WinPcapDevices.list_devices()
     return devices
+
+
+def iter2string(ip):
+    return f'{ip[0]}.{ip[1]}.{ip[2]}.{ip[3]}'
+
+
+def parse_raw_package(ts, data):
+    eth = dpkt.ethernet.Ethernet(data)
+    if not isinstance(eth.data, dpkt.ip.IP):
+        return 0, '', '', ''
+    timestamp = time.strftime('%Y-%m-%d %H:%M:%S', (time.localtime(ts)))
+    ip = eth.data
+    src = iter2string(ip.src)
+    dst = iter2string(ip.dst)
+    if ip.p == 17:
+        udp = ip.data
+        protocol = 'UDP'
+        if udp.sport == 443 or udp.dport == 443:
+            protocol += '-HTTPS'
+        elif udp.sport == 80 or udp.dport == 80:
+            protocol += '-HTTP'
+        elif udp.sport == 53 or udp.dport == 53:
+            protocol += '-DNS'
+    elif ip.p == 6:
+        tcp = ip.data
+        protocol = 'TCP'
+        if tcp.sport == 443 or tcp.dport == 443:
+            protocol += '-HTTPS'
+        elif tcp.sport == 80 or tcp.dport == 80:
+            protocol += '-HTTP'
+    else:
+        protocol = str(ip.p)
+    return timestamp, protocol, src, dst
+
+
+def capture_package(device, ip_address, event, task_list):
+    while True:
+        p = pcap.pcap(device, promisc=True)
+        filter_str = 'ip and host ' + ip_address
+        p.setfilter(filter_str)
+        for ts, data in p:
+            if event.is_set():
+                task = ThreadWorker(ts, data)
+                task_list.append(task)
+                task.setDaemon(True)
+                task.start()
+            else:
+                return
+
+
+class ThreadWorker(threading.Thread):
+    def __init__(self, ts, data):
+        super(ThreadWorker, self).__init__()
+        self.result = None
+        self.ts = ts
+        self.data = data
+
+    def run(self):
+        self.result = parse_raw_package(self.ts, self.data)
+
+    def get_result(self):
+        return self.result
+
+
+class MainCaptureWorker(threading.Thread):
+    def __init__(self, device, ip_address, event):
+        super(MainCaptureWorker, self).__init__()
+        self.device = device
+        self.ip_address = ip_address
+        self.event = event
+        self.sub_task_list = []
+
+    def run(self):
+        capture_package(self.device, self.ip_address, self.event, self.sub_task_list)
+
+    def get_result(self):
+        return [worker.get_result() for worker in self.sub_task_list]

ui/DeviceChooser.py

@@ -1,6 +1,4 @@
-from PyQt5.QtCore import QRect
-from PyQt5.QtWidgets import QWidget, QLabel, QDialog, QListWidget, QListWidgetItem, QPushButton, QHBoxLayout, \
-    QTableWidget, QTableWidgetItem, QVBoxLayout, QMessageBox
+from PyQt5.QtWidgets import QDialog, QPushButton, QTableWidget, QTableWidgetItem, QVBoxLayout, QMessageBox
 from tools import utils
 
 
@@ -19,19 +17,24 @@ def __init__(self, main_window):
         self.__init_ui()
 
     def __init_ui(self):
+        # Set window size
         self.setGeometry(self.main_window.main_window_rect)
         self.resize(self.main_window.main_window_size)
         self.setFixedSize(self.main_window.main_window_size)
 
+        # V Box Layout container
         total_container = QVBoxLayout()
+        # Choose device and start capture button
         confirm_button = QPushButton('Choose and Start Capture', self)
         confirm_button.clicked.connect(self.start_button_listener)
         total_container.addWidget(confirm_button)
 
+        # Set table widget, column name, number and row count
         self.table.setRowCount(len(self.device_dic))
         self.table.setColumnCount(2)
         self.table.setHorizontalHeaderLabels(['device name', 'device id'])
         self.table.setVerticalHeaderLabels([str(i) for i in range(len(self.device_dic))])
+        # set each index
         for idx, device in enumerate(self.device_dic):
             device_name_item = QTableWidgetItem(self.device_dic[device])
             device_id_item = QTableWidgetItem(device)
@@ -46,6 +49,8 @@ def __init_ui(self):
     def start_button_listener(self):
         row = self.table.currentRow()
         if row == -1:
+            # It's illegal when row is -1, warning.
             QMessageBox.warning(self, 'Error!', 'Please choose legal row!')
-        self.main_window.set_device(self.device_id_list[row], self.device_dic[self.device_id_list[row]])
-        self.close()
+        else:
+            self.main_window.set_device(self.device_id_list[row], self.device_dic[self.device_id_list[row]])
+            self.close()

ui/MainWindow.py

@@ -1,6 +1,11 @@
+import threading
+import time
+
 from PyQt5.QtCore import QRect, QSize
-from PyQt5.QtWidgets import QWidget, QLabel, QPushButton, QLineEdit, QApplication, QVBoxLayout, QHBoxLayout
+from PyQt5.QtWidgets import QWidget, QLabel, QPushButton, QLineEdit, QApplication, QVBoxLayout, QHBoxLayout, \
+    QTableWidget, QMessageBox, QTableWidgetItem
 from .DeviceChooser import DeviceChooser
+from tools import utils
 
 
 class MainWindow(QWidget):
@@ -9,11 +14,23 @@ class MainWindow(QWidget):
     """
     def __init__(self, window_name, is_debug=True):
         super().__init__()
-        # Get resolution of current monitor
-        self.device_name = 'Name: NULL'
-        self.device_id = 'ID: NULL'
+        # Timer
+        self.event = threading.Event()
+
+        # Basic value of device, ip address and duration time
+        self.device_name = 'Device Name: NULL'
+        self.device_id = 'Device ID: NULL'
+        self.ip_address = '-1.-1.-1.-1'
+        self.duration_time = -1
+
+        # Basic component
         self.device_id_label = QLabel(self.device_id, self)
         self.device_name_label = QLabel(self.device_name, self)
+        self.time_input = QLineEdit(self)
+        self.ip_input = QLineEdit(self)
+        self.table = QTableWidget()
+
+        # Get resolution of current monitor
         self.desktop = QApplication.desktop()
         self.screen_rect = self.desktop.screenGeometry()
         self.height = self.screen_rect.height()
@@ -22,16 +39,21 @@ def __init__(self, window_name, is_debug=True):
         # calculate the window size by monitor size.
         self.window_height = int(self.height / 2)
         self.window_width = int(self.width / 3)
+
         # The start position of main window.
         self.window_pos_x = int(self.width / 2 - self.window_width / 2)
         self.window_pos_y = int(self.height / 2 - self.window_height / 2)
+
         # Main windows rect
         self.main_window_rect = QRect(self.window_pos_x, self.window_pos_y, self.window_width, self.window_height)
         self.main_window_size = QSize(self.window_width, self.window_height)
+
         # Set main window title
         self.setWindowTitle(window_name)
+
         # Call init_ui to init window.
         self.init_ui()
+
         # If is_debug is True, print basic information of main window.
         if is_debug:
             self.__print_info()
@@ -54,41 +76,87 @@ def init_ui(self):
         total_container = QVBoxLayout()
         top_container = QHBoxLayout()
         middle_container = QHBoxLayout()
+        bottom_container = QHBoxLayout()
 
         choose_device_btn = QPushButton('Choose device', self)
-        # choose_device_btn.move(20, 20)
         choose_device_btn.clicked.connect(self.choose_device_button_listener)
         top_container.addWidget(choose_device_btn)
         top_container.addWidget(self.device_id_label)
         top_container.addWidget(self.device_name_label)
-        # self.device_id_label.move(220, 27)
 
-        # Middle h-box, input capture duration time.
         time_hint = QLabel('Capture duration (s)', self)
-        # time_hint.move(20, 60)
-        time_input = QLineEdit(self)
-        # time_input.move(220, 57)
-
+        ip_address_hint = QLabel('IP address', self)
         middle_container.addWidget(time_hint)
-        middle_container.addWidget(time_input)
+        middle_container.addWidget(self.time_input)
+        middle_container.addWidget(ip_address_hint)
+        middle_container.addWidget(self.ip_input)
+
+        self.table.setColumnCount(4)
+        self.table.setHorizontalHeaderLabels(['Time', 'Protocol', 'Origin Address', 'Target Address'])
+        bottom_container.addWidget(self.table)
 
         total_container.addLayout(top_container)
         total_container.addLayout(middle_container)
+        total_container.addLayout(bottom_container)
 
         self.setLayout(total_container)
-
         self.show()
 
     def choose_device_button_listener(self):
         chooser = DeviceChooser(self)
         chooser.show()
         chooser.exec_()
 
+    def __get_input(self):
+        self.duration_time = self.time_input.text()
+        self.ip_address = self.ip_input.text()
+
+    def __check_and_transform_input_value(self):
+        self.__get_input()
+        try:
+            self.duration_time = int(self.duration_time)
+        except ValueError:
+            QMessageBox.warning(self, 'Value Error', 'Please input correct time!')
+            return False
+        if self.duration_time <= 0:
+            QMessageBox.warning(self, 'Value Error', 'Please input positive time!')
+            return False
+        if self.ip_address == '' or self.ip_address == '-1.-1.-1.-1' or self.ip_address is None:
+            QMessageBox.warning(self, 'Value Error', 'Please input right ip address')
+            return False
+        return True
+
+    def __show_result(self):
+        res = self.capture_task.get_result()
+        self.table.setRowCount(len(res))
+        for i, line in enumerate(res):
+            for j, item in enumerate(line):
+                self.table.setItem(i, j, QTableWidgetItem(item))
+        self.show()
+
+    def __time_control(self):
+        time.sleep(self.duration_time)
+        self.event.clear()
+        self.__show_result()
+
+    def __handle_capture(self):
+        if self.__check_and_transform_input_value():
+            self.event.set()
+            self.capture_task = utils.MainCaptureWorker(self.device_id, self.ip_address, self.event)
+            controller = threading.Thread(
+                target=self.__time_control
+            )
+            self.capture_task.start()
+            controller.start()
+        else:
+            return
+
     def set_device(self, device_id, device_name):
         self.device_id = device_id
-        self.device_id_label.setText('ID: ' + device_id)
+        self.device_id_label.setText('Device ID: ' + device_id)
         self.device_name = device_name
-        self.device_name_label.setText('Name: ' + device_name)
+        self.device_name_label.setText('Device Name: ' + device_name)
         self.device_id_label.adjustSize()
         self.device_name_label.adjustSize()
         self.show()
+        self.__handle_capture()