Version: 3.3 Update

.github/ISSUE_TEMPLATE/问题反馈.md

@@ -1,7 +1,7 @@
 ---
 name: 问题反馈
 about: 尽可能详细的描述问题并反馈
-title: "[BUG] "
+title: "[BUG] 问题标题"
 labels: bug
 assignees: ''
 
@@ -10,11 +10,11 @@ assignees: ''
 ## 使用环境
 
 ```
-HaE版本：
-是否有自定义的HaE规则：
-BurpSuite版本：
-JDK版本：
+HaE 版本：
+有无自定义规则：
+BurpSuite 版本：
 操作系统版本：
+有无仔细阅读README：
 ```
 
 ## 问题详情

README.md

@@ -1,25 +1,30 @@
 <div align="center">
 <img src="images/logo.png" style="width: 20%" />
 <h4><a href="https://gh0st.cn/HaE/">赋能白帽，高效作战！</a></h4>
-<h5>第一作者： <a href="https://github.com/gh0stkey">EvilChen</a>（中孚信息元亨实验室）, 第二作者： <a href="https://github.com/0chencc">0chencc</a>（米斯特安全团队）</h5>
+<h5>第一作者： <a href="https://github.com/gh0stkey">EvilChen</a>（中孚信息元亨实验室）<br>第二作者： <a href="https://github.com/0chencc">0chencc</a>（米斯特安全团队）<br>第三作者： <a href="https://github.com/vaycore">vaycore</a>（独立安全研究员）</h5>
 </div>
 
 ## 项目介绍
 
-**HaE**是一款网络安全（数据安全）领域下的辅助型框架式项目，旨在实现对HTTP消息（包含WebSocket）的高亮标记和信息提取。本项目通过自定义正则表达式匹配响应报文或请求报文，并对匹配成功的报文进行标记和提取。
+**HaE**是一款**网络安全（数据安全）领域**下的框架式项目，采用了**乐高积木式**模块化设计理念，巧妙地融入了**人工智能大模型辅助技术**，实现对HTTP消息（包含WebSocket）精细化的标记和提取。
+
+通过运用**多引擎**的自定义正则表达式，HaE能够准确匹配并处理HTTP请求与响应报文（包含WebSocket），对匹配成功的内容进行有效的标记和信息抽取，从而提升网络安全（数据安全）领域下的**漏洞和数据分析效率**。
 
 > 随着现代化Web应用采用前后端分离的开发模式，日常漏洞挖掘的过程中，捕获的HTTP请求流量也相应增加。若想全面评估一个Web应用，会花费大量时间在无用的报文上。**HaE的出现旨在解决这类情况**，借助HaE，您能够**有效减少**测试时间，将更多精力集中在**有价值且有意义**的报文上，从而**提高漏洞挖掘效率**。
 
 **注意事项**: 
 
-1. 由于HaE 3.0版本开始采用`Montoya API`进行开发，因此使用新版HaE需要升级你的BurpSuite版本（>=2023.12.1）。
-2. 自定义HaE规则必须用左右括号`()`将所需提取的表达式内容包含，例如你要匹配一个**Shiro应用**的响应报文，正常匹配规则为`rememberMe=delete`，在HaE的规则中就需要变成`(rememberMe=delete)`。
+1. HaE 3.3版本开启了AI+新功能，该功能目前仅支持阿里的`Qwen-Long`模型（支持超长文本）和月之暗面的`moonshot-v1-128k`模型（支持短文本），请配置和使用时注意。
+2. HaE 3.0版本开始采用`Montoya API`进行开发，使用新版HaE需要升级你的BurpSuite版本（>=2023.12.1）。
+3. HaE 2.6版本后对规则字段进行了更新，因此无法适配<=2.6版本的规则，请用户自行前往[规则转换页面](https://gh0st.cn/HaE/ConversionRule.html)进行转换。
+4. HaE官方规则库存放在[Github](https://raw.githubusercontent.com/gh0stkey/HaE/gh-pages/Rules.yml)上，因此点击`Update`升级HaE官方规则库时需使用代理（BApp审核考虑安全性，不允许使用CDN）。
+5. 自定义HaE规则必须用左右括号`()`将所需提取的表达式内容包含，例如你要匹配一个**Shiro应用**的响应报文，正常匹配规则为`rememberMe=delete`，在HaE的规则中就需要变成`(rememberMe=delete)`。
 
 ## 使用方法
 
 插件装载: `Extender - Extensions - Add - Select File - Next`
 
-初次装载`HaE`会自动获取官方规则库`https://raw.githubusercontent.com/gh0stkey/HaE/gh-pages/Rules.yml`，配置文件（`Config.yml`）和规则文件（`Rules.yml`）会放在固定目录下：
+初次装载`HaE`会从Jar包中加载离线的规则库，如果更新的话则会向官方规则库地址拉取`https://raw.githubusercontent.com/gh0stkey/HaE/gh-pages/Rules.yml`，配置文件（`Config.yml`）和规则文件（`Rules.yml`）会放在固定目录下：
 
 1. Linux/Mac用户的配置文件目录：`~/.config/HaE/`
 2. Windows用户的配置文件目录：`%USERPROFILE%/.config/HaE/`
@@ -28,9 +33,7 @@
 
 ### 规则释义
 
-HaE目前的规则一共有8个字段，分别是规则名称、规则正则、规则作用域、正则引擎、规则匹配颜色、规则敏感性。
-
-详细的含义如下所示：
+HaE目前的规则一共有8个字段，详细的含义如下所示：
 
 | 字段      | 含义                                                                                                                                                                                                   |
 |-----------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
@@ -38,7 +41,7 @@ HaE目前的规则一共有8个字段，分别是规则名称、规则正则、
 | F-Regex     | 规则正则，主要用于填写正则表达式。在HaE中所需提取匹配的内容需要用`(`、`)`将正则表达式进行包裹。|
 | S-Regex     | 规则正则，作用及使用同F-Regex。S-Regex为二次正则，可以用于对F-Regex匹配的数据结果进行二次的匹配提取，如不需要的情况下可以留空。|
 | Format     | 格式化输出，在NFA引擎的正则表达式中，我们可以通过`{0}`、`{1}`、`{2}`…的方式进行取分组格式化输出。默认情况下使用`{0}`即可。          |
-| Scope     | 规则作用域，主要用于表示当前规则作用于HTTP报文的哪个部分。                                                                                                                                               |
+| Scope     | 规则作用域，主要用于表示当前规则作用于HTTP报文的哪个部分。支持请求、响应的行、头、体，以及完整的报文。                                                                                                                                               |
 | Engine    | 正则引擎，主要用于表示当前规则的正则表达式所使用的引擎。**DFA引擎**：对于文本串里的每一个字符只需扫描一次，速度快、特性少；**NFA引擎**：要翻来覆去标注字符、取消标注字符，速度慢，但是特性（如:分组、替换、分割）丰富。 |
 | Color     | 规则匹配颜色，主要用于表示当前规则匹配到对应HTTP报文时所需标记的高亮颜色。在HaE中具备颜色升级算法，当出现相同颜色时会自动向上升级一个颜色进行标记。                                                                                                                               |
 | Sensitive | 规则敏感性，主要用于表示当前规则对于大小写字母是否敏感，敏感（`True`）则严格按照大小写要求匹配，不敏感（`False`）则反之。                                                                                      |
@@ -46,25 +49,23 @@ HaE目前的规则一共有8个字段，分别是规则名称、规则正则、
 
 ## 优势特点
 
-1. 精细配置：高度自由的配置选项，以满足各类精细化场景需求。
-2. 分类标签：使用标签对规则进行分类，便于管理和组织规则。
-3. 高亮标记：在HTTP History页面，通过颜色高亮和注释判断请求的价值。
-4. 易读配置：使用易读的YAML格式存储配置文件，方便阅读和修改。
-5. 数据集合：将匹配到的数据、请求和响应集中在数据面板中，提高测试和梳理效率。
-6. 简洁可视：清晰可视的界面设计，更轻松地了解和配置HaE，操作简单、使用便捷。
-7. 颜色升级：内置颜色升级算法，避免“屠龙者终成恶龙”场景，突出最具价值的请求。
-8. 实战规则：官方规则库是基于实战化场景总结输出，提升数据发现的有效性、精准性。
+1. **功能**：通过对HTTP报文的颜色高亮、注释和提取，帮助使用者获取有意义的信息，**聚焦高价值报文**。
+2. **界面**：清晰可视的界面设计，以及**简洁的界面交互**，帮助使用者更轻松的了解和配置项目，**避免`多按钮`式的复杂体验**。
+3. **查询**：将HTTP报文的高亮、注释和提取到的相关信息**集中在一个数据面板**，可以一键查询、提取信息，从而提高测试和梳理效率。
+4. **算法**：内置高亮颜色的升级算法，当出现相同颜色时**会自动向上升级一个颜色**进行标记，**避免`屠龙者终成恶龙`场景**。
+5. **管理**：支持对数据的一键导出、导入，以**自定义`.hae`文件的方式**进行项目数据存储，**便于存储和共享项目数据**。
+6. **实战**：官方规则库和规则字段作用功能，都是**基于实战化场景总结输出**的，**以此提高数据的有效性、精准性发现**。
+7. **智能**：融入**人工智能（AI）大模型**API，对匹配的数据进行优化处理，**提高数据式漏洞挖掘效率**。
 
 | 界面名称                  | 界面展示                                              |
 | ------------------------ | ---------------------------------------------------- |
 | Rules（规则管理）     | <img src="images/rules.png" style="width: 80%" />     |
-| Config（配置管理）    | <img src="images/config.png" style="width: 80%" />    |
+| Config-Setting（Setting配置管理）    | <img src="images/config-setting.png" style="width: 80%" />    |
+| Config-AI+（AI+配置管理）    | <img src="images/config-ai.png" style="width: 80%" />    |
 | Databoard（数据集合） | <img src="images/databoard.png" style="width: 80%" /> |
 | MarkInfo（数据展示） | <img src="images/markinfo.png" style="width: 80%" /> |
 
-## 文末随笔
-
-正义感是一个不可丢失的东西。
+## 支持项目
 
 如果你觉得HaE好用，可以打赏一下作者，给作者持续更新下去的动力！
 

build.gradle

@@ -20,8 +20,8 @@ sourceSets {
 dependencies {
     implementation 'net.portswigger.burp.extensions:montoya-api:2023.12.1'
     implementation 'org.yaml:snakeyaml:2.0'
-    implementation 'net.sourceforge.jregex:jregex:1.2_01'
     implementation 'dk.brics.automaton:automaton:1.11-8'
+    implementation 'com.github.ben-manes.caffeine:caffeine:3.1.8'
 }
 
 test {
@@ -34,4 +34,4 @@ jar {
     from {
         configurations.runtimeClasspath.collect { it.isDirectory() ? it : zipTree(it) }
     }
-}
+}

src/main/java/hae/Config.java

@@ -8,34 +8,40 @@ import java.util.concurrent.ConcurrentHashMap;
 public class Config {
     public static String suffix = "3g2|3gp|7z|aac|abw|aif|aifc|aiff|apk|arc|au|avi|azw|bat|bin|bmp|bz|bz2|cmd|cmx|cod|com|csh|css|csv|dll|doc|docx|ear|eot|epub|exe|flac|flv|gif|gz|ico|ics|ief|jar|jfif|jpe|jpeg|jpg|less|m3u|mid|midi|mjs|mkv|mov|mp2|mp3|mp4|mpa|mpe|mpeg|mpg|mpkg|mpp|mpv2|odp|ods|odt|oga|ogg|ogv|ogx|otf|pbm|pdf|pgm|png|pnm|ppm|ppt|pptx|ra|ram|rar|ras|rgb|rmi|rtf|scss|sh|snd|svg|swf|tar|tif|tiff|ttf|vsd|war|wav|weba|webm|webp|wmv|woff|woff2|xbm|xls|xlsx|xpm|xul|xwd|zip";
 
-    public static String[] scope = new String[] {
+    public static String host = "gh0st.cn";
+
+    public static String[] scope = new String[]{
             "any",
             "any header",
             "any body",
             "response",
+            "response line",
             "response header",
             "response body",
             "request",
+            "request line",
             "request header",
             "request body"
     };
 
+    public static String scopeOptions = "Suite|Target|Proxy|Scanner|Intruder|Repeater|Logger|Sequencer|Decoder|Comparer|Extensions|Organizer|Recorded login replayer";
+
     public static String[] ruleFields = {
-        "Loaded", "Name", "F-Regex", "S-Regex", "Format", "Color", "Scope", "Engine", "Sensitive"
+            "Loaded", "Name", "F-Regex", "S-Regex", "Format", "Color", "Scope", "Engine", "Sensitive"
     };
 
-    public static Object[][] ruleTemplate = new Object[][] {
+    public static Object[][] ruleTemplate = new Object[][]{
             {
                     false, "New Name", "(First Regex)", "(Second Regex)", "{0}", "gray", "any", "nfa", false
             }
     };
 
-    public static String[] engine = new String[] {
+    public static String[] engine = new String[]{
             "nfa",
             "dfa"
     };
 
-    public static String[] color = new String[] {
+    public static String[] color = new String[]{
             "red",
             "orange",
             "yellow",
@@ -47,6 +53,11 @@ public class Config {
             "gray"
     };
 
+    public static String prompt = "You are a data security expert in the field of cyber security. Your task is to optimize the information provided by the user and then output it in JSON format. The user-supplied information is data that has been extracted by regular expressions. The user-supplied information is divided into two parts, the first part is RuleName which represents the name of the regular expression and the second part is MarkInfo which represents the data extracted by the regular expression. You need to find the matching or similar data in MarkInfo according to the meaning of RuleName, and output the original rows of these data in JSON format.(garbled and meaningless data rows should be removed)\n" +
+            "You must ensure that the extracted data is accurately expressed and correctly formatted in the JSON structure. Your output data must comply with the original MarkInfo content rows without modification, and strictly adhere to the following JSON format for return, no other text, code and formatting (e.g., line breaks, carriage returns, indentation, spaces), once the return of other irrelevant content will cause irreparable damage to the user: {\"data\":[\"data1\", \"data2\"]}.";
+
+    public static String userTextFormat = "User Input: \r\nRuleName: %s\r\nMarkInfo: %s";
+
     public static Map<String, Object[][]> globalRules = new HashMap<>();
 
     public static ConcurrentHashMap<String, Map<String, List<String>>> globalDataMap = new ConcurrentHashMap<>();

src/main/java/hae/HaE.java

@@ -2,7 +2,9 @@ package hae;
 
 import burp.api.montoya.BurpExtension;
 import burp.api.montoya.MontoyaApi;
+import burp.api.montoya.extension.ExtensionUnloadingHandler;
 import burp.api.montoya.logging.Logging;
+import hae.cache.CachePool;
 import hae.component.Main;
 import hae.component.board.message.MessageTableModel;
 import hae.instances.editor.RequestEditor;
@@ -10,19 +12,19 @@ import hae.instances.editor.ResponseEditor;
 import hae.instances.editor.WebSocketEditor;
 import hae.instances.http.HttpMessageHandler;
 import hae.instances.websocket.WebSocketMessageHandler;
-import hae.utils.config.ConfigLoader;
+import hae.utils.ConfigLoader;
 
 public class HaE implements BurpExtension {
     @Override
     public void initialize(MontoyaApi api) {
         // 设置扩展名称
-        String version = "3.0";
+        String version = "3.3";
         api.extension().setName(String.format("HaE (%s) - Highlighter and Extractor", version));
 
         // 加载扩展后输出的项目信息
         Logging logging = api.logging();
         logging.logToOutput("[ HACK THE WORLD - TO DO IT ]");
-        logging.logToOutput("[#] Author: EvilChen && 0chencc");
+        logging.logToOutput("[#] Author: EvilChen && 0chencc && vaycore");
         logging.logToOutput("[#] Github: https://github.com/gh0stkey/HaE");
 
         // 配置文件加载
@@ -34,14 +36,23 @@ public class HaE implements BurpExtension {
         api.userInterface().registerSuiteTab("HaE", new Main(api, configLoader, messageTableModel));
 
         // 注册HTTP处理器
-        api.http().registerHttpHandler(new HttpMessageHandler(api, messageTableModel));
+        api.http().registerHttpHandler(new HttpMessageHandler(api, configLoader, messageTableModel));
 
         // 注册WebSocket处理器
         api.proxy().registerWebSocketCreationHandler(proxyWebSocketCreation -> proxyWebSocketCreation.proxyWebSocket().registerProxyMessageHandler(new WebSocketMessageHandler(api)));
 
         // 注册消息编辑框（用于展示数据）
-        api.userInterface().registerHttpRequestEditorProvider(new RequestEditor(api));
-        api.userInterface().registerHttpResponseEditorProvider(new ResponseEditor(api));
-        api.userInterface().registerWebSocketMessageEditorProvider(new WebSocketEditor(api));
+        api.userInterface().registerHttpRequestEditorProvider(new RequestEditor(api, configLoader));
+        api.userInterface().registerHttpResponseEditorProvider(new ResponseEditor(api, configLoader));
+        api.userInterface().registerWebSocketMessageEditorProvider(new WebSocketEditor(api, configLoader));
+
+        api.extension().registerUnloadingHandler(new ExtensionUnloadingHandler() {
+            @Override
+            public void extensionUnloaded() {
+                // 卸载清空数据
+                Config.globalDataMap.clear();
+                CachePool.clear();
+            }
+        });
     }
 }

src/main/java/hae/cache/CachePool.java

@@ -1,19 +1,34 @@
 package hae.cache;
 
-import java.util.*;
+import com.github.benmanes.caffeine.cache.Cache;
+import com.github.benmanes.caffeine.cache.Caffeine;
+
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
 
 public class CachePool {
-    private static final Map<String, Map<String, Map<String, Object>>> cache = new HashMap<>();
+    private static final int MAX_SIZE = 100000;
+    private static final int EXPIRE_DURATION = 5;
 
-    public static void addToCache(String key, Map<String, Map<String, Object>> value) {
+    private static final Cache<String, Map<String, Map<String, Object>>> cache =
+            Caffeine.newBuilder()
+                    .maximumSize(MAX_SIZE)
+                    .expireAfterWrite(EXPIRE_DURATION, TimeUnit.HOURS)
+                    .build();
+
+    public static void put(String key, Map<String, Map<String, Object>> value) {
         cache.put(key, value);
     }
 
-    public static Map<String, Map<String, Object>> getFromCache(String key) {
-        return cache.get(key);
+    public static Map<String, Map<String, Object>> get(String key) {
+        return cache.getIfPresent(key);
     }
 
-    public static void removeFromCache(String key) {
-        cache.remove(key);
+    public static void remove(String key) {
+        cache.invalidate(key);
+    }
+
+    public static void clear() {
+        cache.invalidateAll();
     }
 }

src/main/java/hae/component/Main.java

@@ -5,7 +5,7 @@ import hae.component.board.Databoard;
 import hae.component.board.message.MessageTableModel;
 import hae.component.config.Config;
 import hae.component.rule.Rules;
-import hae.utils.config.ConfigLoader;
+import hae.utils.ConfigLoader;
 
 import javax.swing.*;
 import java.awt.*;
@@ -28,35 +28,26 @@ public class Main extends JPanel {
 
     private void initComponents() {
         setLayout(new GridBagLayout());
-        ((GridBagLayout)getLayout()).columnWidths = new int[] {0, 0};
-        ((GridBagLayout)getLayout()).rowHeights = new int[] {0, 0};
-        ((GridBagLayout)getLayout()).columnWeights = new double[] {1.0, 1.0E-4};
-        ((GridBagLayout)getLayout()).rowWeights = new double[] {1.0, 1.0E-4};
+        ((GridBagLayout) getLayout()).columnWidths = new int[]{0, 0};
+        ((GridBagLayout) getLayout()).rowHeights = new int[]{0, 0};
+        ((GridBagLayout) getLayout()).columnWeights = new double[]{1.0, 1.0E-4};
+        ((GridBagLayout) getLayout()).rowWeights = new double[]{1.0, 1.0E-4};
 
         JTabbedPane mainTabbedPane = new JTabbedPane();
 
         // 新增Logo
         JTabbedPane HaETabbedPane = new JTabbedPane();
-        HaETabbedPane.addTab("", getImageIcon(false), mainTabbedPane);
+        boolean isDarkBg = isDarkBg(HaETabbedPane);
+        HaETabbedPane.addTab("", getImageIcon(isDarkBg), mainTabbedPane);
         // 中文Slogan：赋能白帽，高效作战
         HaETabbedPane.addTab(" Highlighter and Extractor - Empower ethical hacker for efficient operations. ", null);
         HaETabbedPane.setEnabledAt(1, false);
         HaETabbedPane.addPropertyChangeListener("background", new PropertyChangeListener() {
             @Override
             public void propertyChange(PropertyChangeEvent e) {
-                boolean isDarkBg = isDarkBg();
+                boolean isDarkBg = isDarkBg(HaETabbedPane);
                 HaETabbedPane.setIconAt(0, getImageIcon(isDarkBg));
             }
-
-            private boolean isDarkBg() {
-                Color bg = HaETabbedPane.getBackground();
-                int r = bg.getRed();
-                int g = bg.getGreen();
-                int b = bg.getBlue();
-                int avg = (r + g + b) / 3;
-
-                return avg < 128;
-            }
         });
 
         add(HaETabbedPane, new GridBagConstraints(0, 0, 1, 1, 0.0, 0.0,
@@ -66,17 +57,27 @@ public class Main extends JPanel {
         // 依次添加Rules、Config、Databoard
         Rules rules = new Rules(api, configLoader);
         mainTabbedPane.addTab("Rules", rules);
-        mainTabbedPane.addTab("Config", new Config(api, configLoader, rules));
         mainTabbedPane.addTab("Databoard", new Databoard(api, configLoader, messageTableModel));
+        mainTabbedPane.addTab("Config", new Config(api, configLoader, rules));
+    }
+
+    private boolean isDarkBg(JTabbedPane HaETabbedPane) {
+        Color bg = HaETabbedPane.getBackground();
+        int r = bg.getRed();
+        int g = bg.getGreen();
+        int b = bg.getBlue();
+        int avg = (r + g + b) / 3;
+
+        return avg < 128;
     }
 
     private ImageIcon getImageIcon(boolean isDark) {
         ClassLoader classLoader = getClass().getClassLoader();
         URL imageURL;
         if (isDark) {
-            imageURL = classLoader.getResource("logo.png");
+            imageURL = classLoader.getResource("logo/logo.png");
         } else {
-            imageURL = classLoader.getResource("logo_black.png");
+            imageURL = classLoader.getResource("logo/logo_black.png");
         }
         ImageIcon originalIcon = new ImageIcon(imageURL);
         Image originalImage = originalIcon.getImage();

src/main/java/hae/component/board/Databoard.java

@@ -2,38 +2,60 @@ package hae.component.board;
 
 import burp.api.montoya.MontoyaApi;
 import hae.Config;
+import hae.component.board.message.MessageEntry;
 import hae.component.board.message.MessageTableModel;
-import hae.utils.string.StringProcessor;
-import hae.utils.config.ConfigLoader;
 import hae.component.board.message.MessageTableModel.MessageTable;
+import hae.component.board.table.Datatable;
+import hae.instances.http.utils.RegularMatcher;
+import hae.utils.ConfigLoader;
+import hae.utils.project.ProjectProcessor;
+import hae.utils.project.model.HaeFileContent;
+import hae.utils.string.StringProcessor;
 
-import java.util.*;
-import java.util.concurrent.ConcurrentHashMap;
-import javax.swing.event.*;
+import javax.swing.*;
+import javax.swing.event.DocumentEvent;
+import javax.swing.event.DocumentListener;
+import javax.swing.filechooser.FileNameExtensionFilter;
 import javax.swing.table.TableColumnModel;
 import javax.swing.table.TableModel;
 import javax.swing.table.TableRowSorter;
 import java.awt.*;
 import java.awt.event.*;
+import java.io.File;
 import java.util.List;
-import javax.swing.*;
+import java.util.*;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.function.Function;
+import java.util.stream.Collectors;
 
 public class Databoard extends JPanel {
     private final MontoyaApi api;
     private final ConfigLoader configLoader;
+    private final ProjectProcessor projectProcessor;
     private final MessageTableModel messageTableModel;
+
     private JTextField hostTextField;
     private JTabbedPane dataTabbedPane;
     private JSplitPane splitPane;
     private MessageTable messageTable;
+    private JProgressBar progressBar;
 
     private static Boolean isMatchHost = false;
-    private DefaultComboBoxModel comboBoxModel = new DefaultComboBoxModel();
-    private JComboBox hostComboBox = new JComboBox(comboBoxModel);
+    private final DefaultComboBoxModel comboBoxModel = new DefaultComboBoxModel();
+    private final JComboBox hostComboBox = new JComboBox(comboBoxModel);
+
+    private SwingWorker<Map<String, List<String>>, Void> handleComboBoxWorker;
+    private SwingWorker<Void, Void> applyHostFilterWorker;
+    private SwingWorker<List<String>, Void> exportActionWorker;
+    private SwingWorker<List<String>, Void> importActionWorker;
 
     public Databoard(MontoyaApi api, ConfigLoader configLoader, MessageTableModel messageTableModel) {
         this.api = api;
         this.configLoader = configLoader;
+        this.projectProcessor = new ProjectProcessor(api);
         this.messageTableModel = messageTableModel;
 
         initComponents();
@@ -41,24 +63,31 @@ public class Databoard extends JPanel {
 
     private void initComponents() {
         setLayout(new GridBagLayout());
-        ((GridBagLayout)getLayout()).columnWidths = new int[] {25, 0, 0, 0,20, 0};
-        ((GridBagLayout)getLayout()).rowHeights = new int[] {0, 65, 20, 0};
-        ((GridBagLayout)getLayout()).columnWeights = new double[] {0.0, 0.0, 1.0, 0.0, 0.0, 1.0E-4};
-        ((GridBagLayout)getLayout()).rowWeights = new double[] {0.0, 1.0, 0.0, 1.0E-4};
+        ((GridBagLayout) getLayout()).columnWidths = new int[]{25, 0, 0, 0, 20, 0};
+        ((GridBagLayout) getLayout()).rowHeights = new int[]{0, 65, 20, 0, 0};
+        ((GridBagLayout) getLayout()).columnWeights = new double[]{0.0, 0.0, 1.0, 0.0, 0.0, 1.0E-4};
+        ((GridBagLayout) getLayout()).rowWeights = new double[]{0.0, 1.0, 0.0, 0.0, 1.0E-4};
 
         JLabel hostLabel = new JLabel("Host:");
 
         JButton clearButton = new JButton("Clear");
+        JButton exportButton = new JButton("Export");
+        JButton importButton = new JButton("Import");
         JButton actionButton = new JButton("Action");
-        JPanel menuPanel = new JPanel(new GridLayout(1, 1));
+        JPanel menuPanel = new JPanel(new GridLayout(3, 1, 0, 5));
         menuPanel.setBorder(BorderFactory.createEmptyBorder(3, 3, 3, 3));
         JPopupMenu menu = new JPopupMenu();
         menuPanel.add(clearButton);
+        menuPanel.add(exportButton);
+        menuPanel.add(importButton);
         menu.add(menuPanel);
 
         hostTextField = new JTextField();
         splitPane = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT);
+
         dataTabbedPane = new JTabbedPane(JTabbedPane.TOP);
+        dataTabbedPane.setPreferredSize(new Dimension(500, 0));
+        dataTabbedPane.setTabLayoutPolicy(JTabbedPane.SCROLL_TAB_LAYOUT);
 
         actionButton.addActionListener(e -> {
             int x = 0;
@@ -67,6 +96,10 @@ public class Databoard extends JPanel {
         });
 
         clearButton.addActionListener(this::clearActionPerformed);
+        exportButton.addActionListener(this::exportActionPerformed);
+        importButton.addActionListener(this::importActionPerformed);
+
+        progressBar = new JProgressBar();
 
         splitPane.addComponentListener(new ComponentAdapter() {
             @Override
@@ -76,16 +109,21 @@ public class Databoard extends JPanel {
         });
 
         splitPane.setVisible(false);
+        progressBar.setVisible(false);
 
         add(hostLabel, new GridBagConstraints(1, 0, 1, 1, 0.0, 0.0, GridBagConstraints.CENTER, GridBagConstraints.BOTH,
                 new Insets(8, 0, 5, 5), 0, 0));
         add(hostTextField, new GridBagConstraints(2, 0, 1, 1, 0.0, 0.0, GridBagConstraints.CENTER, GridBagConstraints.BOTH,
                 new Insets(8, 0, 5, 5), 0, 0));
-        add(actionButton,  new GridBagConstraints(3, 0, 1, 1, 0.0, 0.0, GridBagConstraints.CENTER, GridBagConstraints.BOTH,
+        add(actionButton, new GridBagConstraints(3, 0, 1, 1, 0.0, 0.0, GridBagConstraints.CENTER, GridBagConstraints.BOTH,
                 new Insets(8, 0, 5, 5), 0, 0));
-        add(splitPane, new GridBagConstraints(1, 1, 3, 3, 0.0, 0.0,
+
+        add(splitPane, new GridBagConstraints(1, 1, 3, 1, 0.0, 1.0,
                 GridBagConstraints.CENTER, GridBagConstraints.BOTH,
-                new Insets(8, 0, 5, 5), 0, 0));
+                new Insets(0, 5, 0, 5), 0, 0));
+        add(progressBar, new GridBagConstraints(1, 2, 3, 1, 1.0, 0.0,
+                GridBagConstraints.CENTER, GridBagConstraints.HORIZONTAL,
+                new Insets(0, 5, 0, 5), 0, 0));
         hostComboBox.setMaximumRowCount(5);
         add(hostComboBox, new GridBagConstraints(2, 0, 1, 1, 0.0, 0.0, GridBagConstraints.CENTER, GridBagConstraints.BOTH,
                 new Insets(8, 0, 5, 5), 0, 0));
@@ -105,6 +143,24 @@ public class Databoard extends JPanel {
         columnModel.getColumn(5).setPreferredWidth((int) (totalWidth * 0.1));
     }
 
+    private void setProgressBar(boolean status) {
+        setProgressBar(status, progressBar, "Loading ...");
+    }
+
+
+    public static void setProgressBar(boolean status, JProgressBar progressBar, String showString) {
+        progressBar.setIndeterminate(status);
+        if (!status) {
+            progressBar.setMaximum(100);
+            progressBar.setString("OK");
+            progressBar.setStringPainted(true);
+            progressBar.setValue(progressBar.getMaximum());
+        } else {
+            progressBar.setString(showString);
+            progressBar.setStringPainted(true);
+        }
+    }
+
     private void setAutoMatch() {
         hostComboBox.setSelectedItem(null);
         hostComboBox.addActionListener(this::handleComboBoxAction);
@@ -137,9 +193,58 @@ public class Databoard extends JPanel {
 
     private void handleComboBoxAction(ActionEvent e) {
         if (!isMatchHost && hostComboBox.getSelectedItem() != null) {
+            progressBar.setVisible(true);
+            setProgressBar(true);
             String selectedHost = hostComboBox.getSelectedItem().toString();
-            hostTextField.setText(selectedHost);
-            populateTabbedPaneByHost(selectedHost);
+
+            if (getHostByList().contains(selectedHost)) {
+                hostTextField.setText(selectedHost);
+
+                if (handleComboBoxWorker != null && !handleComboBoxWorker.isDone()) {
+                    handleComboBoxWorker.cancel(true);
+                }
+
+                handleComboBoxWorker = new SwingWorker<Map<String, List<String>>, Void>() {
+                    @Override
+                    protected Map<String, List<String>> doInBackground() {
+                        return getSelectedMapByHost(selectedHost);
+                    }
+
+                    @Override
+                    protected void done() {
+                        if (!isCancelled()) {
+                            try {
+                                Map<String, List<String>> selectedDataMap = get();
+                                if (!selectedDataMap.isEmpty()) {
+                                    dataTabbedPane.removeAll();
+
+                                    for (Map.Entry<String, List<String>> entry : selectedDataMap.entrySet()) {
+                                        String tabTitle = String.format("%s (%s)", entry.getKey(), entry.getValue().size());
+                                        Datatable datatablePanel = new Datatable(api, configLoader, entry.getKey(), entry.getValue());
+                                        datatablePanel.setTableListener(messageTableModel);
+                                        dataTabbedPane.addTab(tabTitle, datatablePanel);
+                                    }
+
+                                    JSplitPane messageSplitPane = messageTableModel.getSplitPane();
+                                    splitPane.setLeftComponent(dataTabbedPane);
+                                    splitPane.setRightComponent(messageSplitPane);
+                                    messageTable = messageTableModel.getMessageTable();
+                                    resizePanel();
+
+                                    splitPane.setVisible(true);
+                                    hostTextField.setText(selectedHost);
+
+                                    hostComboBox.setPopupVisible(false);
+                                    applyHostFilter(selectedHost);
+                                }
+                            } catch (Exception ignored) {
+                            }
+                        }
+                    }
+                };
+
+                handleComboBoxWorker.execute();
+            }
         }
     }
 
@@ -158,7 +263,6 @@ public class Databoard extends JPanel {
         if (keyCode == KeyEvent.VK_ENTER) {
             isMatchHost = false;
             handleComboBoxAction(null);
-            hostComboBox.setPopupVisible(false);
         }
 
         if (keyCode == KeyEvent.VK_ESCAPE) {
@@ -168,10 +272,40 @@ public class Databoard extends JPanel {
         isMatchHost = false;
     }
 
+    private Map<String, List<String>> getSelectedMapByHost(String selectedHost) {
+        ConcurrentHashMap<String, Map<String, List<String>>> dataMap = Config.globalDataMap;
+        Map<String, List<String>> selectedDataMap;
+
+        if (selectedHost.contains("*")) {
+            selectedDataMap = new HashMap<>();
+            dataMap.keySet().forEach(key -> {
+                if ((StringProcessor.matchesHostPattern(key, selectedHost) || selectedHost.equals("*")) && !key.contains("*")) {
+                    Map<String, List<String>> ruleMap = dataMap.get(key);
+                    for (String ruleKey : ruleMap.keySet()) {
+                        List<String> dataList = ruleMap.get(ruleKey);
+                        if (selectedDataMap.containsKey(ruleKey)) {
+                            List<String> mergedList = new ArrayList<>(selectedDataMap.get(ruleKey));
+                            mergedList.addAll(dataList);
+                            HashSet<String> uniqueSet = new HashSet<>(mergedList);
+                            selectedDataMap.put(ruleKey, new ArrayList<>(uniqueSet));
+                        } else {
+                            selectedDataMap.put(ruleKey, dataList);
+                        }
+                    }
+                }
+            });
+        } else {
+            selectedDataMap = dataMap.get(selectedHost);
+        }
+
+        return selectedDataMap;
+    }
+
     private void filterComboBoxList() {
         isMatchHost = true;
         comboBoxModel.removeAllElements();
         String input = hostTextField.getText().toLowerCase();
+
         if (!input.isEmpty()) {
             for (String host : getHostByList()) {
                 String lowerCaseHost = host.toLowerCase();
@@ -190,96 +324,330 @@ public class Databoard extends JPanel {
         isMatchHost = false;
     }
 
-    private void populateTabbedPaneByHost(String selectedHost) {
-        if (!Objects.equals(selectedHost, "")) {
-            ConcurrentHashMap<String, Map<String, List<String>>> dataMap = Config.globalDataMap;
-            Map<String, List<String>> selectedDataMap;
-
-            dataTabbedPane.removeAll();
-            dataTabbedPane.setPreferredSize(new Dimension(500,0));
-            dataTabbedPane.setTabLayoutPolicy(JTabbedPane.SCROLL_TAB_LAYOUT);
-            splitPane.setLeftComponent(dataTabbedPane);
-
-            if (selectedHost.contains("*")) {
-                // 通配符数据
-                selectedDataMap = new HashMap<>();
-                String hostPattern = StringProcessor.replaceFirstOccurrence(selectedHost, "*.", "");
-                for (String key : dataMap.keySet()) {
-                    if (key.contains(hostPattern) || selectedHost.equals("*")) {
-                        Map<String, List<String>> ruleMap = dataMap.get(key);
-                        for (String ruleKey : ruleMap.keySet()) {
-                            List<String> dataList = ruleMap.get(ruleKey);
-                            if (selectedDataMap.containsKey(ruleKey)) {
-                                List<String> mergedList = new ArrayList<>(selectedDataMap.get(ruleKey));
-                                mergedList.addAll(dataList);
-                                HashSet<String> uniqueSet = new HashSet<>(mergedList);
-                                selectedDataMap.put(ruleKey, new ArrayList<>(uniqueSet));
-                            } else {
-                                selectedDataMap.put(ruleKey, dataList);
-                            }
-                        }
-                    }
-                }
-            } else {
-                selectedDataMap = dataMap.get(selectedHost);
-            }
-
-            for (Map.Entry<String, List<String>> entry : selectedDataMap.entrySet()) {
-                String tabTitle = String.format("%s (%s)", entry.getKey(), entry.getValue().size());
-                Datatable datatablePanel = new Datatable(api, entry.getKey(), entry.getValue());
-                datatablePanel.setTableListener(messageTableModel);
-                dataTabbedPane.addTab(tabTitle, datatablePanel);
-            }
-
-            // 展示请求消息表单
-            JSplitPane messageSplitPane = messageTableModel.getSplitPane();
-            this.splitPane.setRightComponent(messageSplitPane);
-            messageTable = messageTableModel.getMessageTable();
-
-            resizePanel();
-            splitPane.setVisible(true);
-
-            applyHostFilter(selectedHost);
-            hostTextField.setText(selectedHost);
-        }
-    }
-
     private void applyHostFilter(String filterText) {
         TableRowSorter<TableModel> sorter = (TableRowSorter<TableModel>) messageTable.getRowSorter();
-
         String cleanedText = StringProcessor.replaceFirstOccurrence(filterText, "*.", "");
 
-        if (cleanedText.contains("*")) {
-            cleanedText = "";
+        if (applyHostFilterWorker != null && !applyHostFilterWorker.isDone()) {
+            applyHostFilterWorker.cancel(true);
         }
 
-        RowFilter<TableModel, Integer> filter = RowFilter.regexFilter(cleanedText, 1);
-        sorter.setRowFilter(filter);
+        applyHostFilterWorker = new SwingWorker<Void, Void>() {
+            @Override
+            protected Void doInBackground() throws Exception {
+                RowFilter<Object, Object> rowFilter = new RowFilter<Object, Object>() {
+                    public boolean include(Entry<?, ?> entry) {
+                        if (cleanedText.equals("*")) {
+                            return true;
+                        } else {
+                            String host = StringProcessor.getHostByUrl((String) entry.getValue(1));
+                            return StringProcessor.matchesHostPattern(host, filterText);
+                        }
+                    }
+                };
 
-        messageTableModel.applyHostFilter(filterText);
+                sorter.setRowFilter(rowFilter);
+                messageTableModel.applyHostFilter(filterText);
+
+                return null;
+            }
+
+            @Override
+            protected void done() {
+                setProgressBar(false);
+            }
+        };
+
+        applyHostFilterWorker.execute();
     }
 
     private List<String> getHostByList() {
-        return new ArrayList<>(Config.globalDataMap.keySet());
+        if (!Config.globalDataMap.keySet().isEmpty()) {
+            return new ArrayList<>(Config.globalDataMap.keySet());
+        }
+        return new ArrayList<>();
+    }
+
+    private void exportActionPerformed(ActionEvent e) {
+        String selectedHost = hostTextField.getText().trim();
+
+        if (selectedHost.isEmpty()) {
+            return;
+        }
+
+        String exportDir = selectDirectory(true);
+
+        if (exportDir.isEmpty()) {
+            return;
+        }
+
+        if (exportActionWorker != null && !exportActionWorker.isDone()) {
+            exportActionWorker.cancel(true);
+        }
+
+        exportActionWorker = new SwingWorker<List<String>, Void>() {
+            @Override
+            protected List<String> doInBackground() {
+                ConcurrentHashMap<String, Map<String, List<String>>> dataMap = Config.globalDataMap;
+                return exportData(selectedHost, exportDir, dataMap);
+            }
+
+            @Override
+            protected void done() {
+                try {
+                    List<String> taskStatusList = get();
+                    if (!taskStatusList.isEmpty()) {
+                        String exportStatusMessage = String.format("Exported File List Status:\n%s", String.join("\n", taskStatusList));
+
+                        JOptionPane.showMessageDialog(Databoard.this, generateTaskStatusPane(exportStatusMessage), "Info", JOptionPane.INFORMATION_MESSAGE);
+                    }
+                } catch (Exception ignored) {
+                }
+            }
+        };
+
+        exportActionWorker.execute();
+    }
+
+    private JScrollPane generateTaskStatusPane(String message) {
+        JTextArea textArea = new JTextArea(message);
+        textArea.setEditable(false);
+        textArea.setLineWrap(true);
+        JScrollPane scrollPane = new JScrollPane(textArea);
+        scrollPane.setPreferredSize(new Dimension(400, 200));
+
+        return scrollPane;
+    }
+
+    private List<String> exportData(String selectedHost, String exportDir, Map<String, Map<String, List<String>>> dataMap) {
+        return dataMap.entrySet().stream()
+                .filter(entry -> selectedHost.equals("*") || StringProcessor.matchesHostPattern(entry.getKey(), selectedHost))
+                .filter(entry -> !entry.getKey().contains("*"))
+                .map(entry -> exportEntry(entry, exportDir))
+                .filter(Objects::nonNull)
+                .collect(Collectors.toList());
+    }
+
+    private String exportEntry(Map.Entry<String, Map<String, List<String>>> entry, String exportDir) {
+        String key = entry.getKey();
+        Map<String, List<String>> ruleMap = entry.getValue();
+
+        if (ruleMap == null || ruleMap.isEmpty()) {
+            return null;
+        }
+
+        List<MessageEntry> messageEntryList = messageTableModel.getLogs();
+
+        Map<MessageEntry, String> entryUUIDMap = messageEntryList.stream()
+                .collect(Collectors.toMap(
+                        messageEntry -> messageEntry,
+                        messageEntry -> StringProcessor.getRandomUUID(),
+                        (existing, replacement) -> existing // 在冲突时保留现有的映射
+                ));
+
+        Map<String, Map<String, Object>> httpMap = processEntries(
+                messageEntryList,
+                key,
+                entryUUIDMap,
+                this::createHttpItemMap
+        );
+
+        Map<String, Map<String, Object>> urlMap = processEntries(
+                messageEntryList,
+                key,
+                entryUUIDMap,
+                this::creteUrlItemMap
+        );
+
+        String hostName = key.replace(":", "_");
+        String filename = String.format("%s/%s-%s.hae", exportDir, StringProcessor.getCurrentTime(), hostName);
+        boolean createdStatus = projectProcessor.createHaeFile(filename, key, ruleMap, urlMap, httpMap);
+
+        return String.format("Filename: %s, Status: %s", filename, createdStatus);
+    }
+
+
+    private Map<String, Map<String, Object>> processEntries(List<MessageEntry> messageEntryList, String key, Map<MessageEntry, String> entryUUIDMap, Function<MessageEntry, Map<String, Object>> mapFunction) {
+        return messageEntryList.stream()
+                .filter(messageEntry -> !StringProcessor.getHostByUrl(messageEntry.getUrl()).isEmpty())
+                .filter(messageEntry -> StringProcessor.getHostByUrl(messageEntry.getUrl()).equals(key))
+                .collect(Collectors.toMap(
+                        entryUUIDMap::get,
+                        mapFunction,
+                        (existing, replacement) -> existing
+                ));
+    }
+
+    private Map<String, Object> creteUrlItemMap(MessageEntry entry) {
+        Map<String, Object> urlItemMap = new LinkedHashMap<>();
+        urlItemMap.put("url", entry.getUrl());
+        urlItemMap.put("method", entry.getMethod());
+        urlItemMap.put("status", entry.getStatus());
+        urlItemMap.put("length", entry.getLength());
+        urlItemMap.put("comment", entry.getComment());
+        urlItemMap.put("color", entry.getColor());
+        urlItemMap.put("size", String.valueOf(entry.getRequestResponse().request().toByteArray().length()));
+        return urlItemMap;
+    }
+
+    private Map<String, Object> createHttpItemMap(MessageEntry entry) {
+        Map<String, Object> httpItemMap = new LinkedHashMap<>();
+        httpItemMap.put("request", entry.getRequestResponse().request().toByteArray().getBytes());
+        httpItemMap.put("response", entry.getRequestResponse().response().toByteArray().getBytes());
+        return httpItemMap;
+    }
+
+    private void importActionPerformed(ActionEvent e) {
+        String exportDir = selectDirectory(false);
+        if (exportDir.isEmpty()) {
+            return;
+        }
+
+        if (importActionWorker != null && !importActionWorker.isDone()) {
+            importActionWorker.cancel(true);
+        }
+
+        importActionWorker = new SwingWorker<List<String>, Void>() {
+            @Override
+            protected List<String> doInBackground() {
+                List<String> filesWithExtension = findFilesWithExtension(new File(exportDir), ".hae");
+                return filesWithExtension.stream()
+                        .map(Databoard.this::importData)
+                        .collect(Collectors.toList());
+            }
+
+            @Override
+            protected void done() {
+                try {
+                    List<String> taskStatusList = get();
+                    if (!taskStatusList.isEmpty()) {
+                        String importStatusMessage = "Imported File List Status:\n" + String.join("\n", taskStatusList);
+                        JOptionPane.showMessageDialog(Databoard.this, generateTaskStatusPane(importStatusMessage), "Info", JOptionPane.INFORMATION_MESSAGE);
+                    }
+                } catch (Exception ignored) {
+                }
+            }
+        };
+
+        importActionWorker.execute();
+    }
+
+    private String importData(String filename) {
+        ExecutorService executor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors() * 2);
+
+        HaeFileContent haeFileContent = projectProcessor.readHaeFile(filename);
+        boolean readStatus = haeFileContent != null;
+
+        List<Callable<Void>> tasks = new ArrayList<>();
+
+        if (readStatus) {
+            try {
+                String host = haeFileContent.getHost();
+                haeFileContent.getDataMap().forEach((key, value) -> RegularMatcher.putDataToGlobalMap(host, key, value));
+
+                haeFileContent.getUrlMap().forEach((key, urlItemMap) -> {
+                    tasks.add(() -> {
+                        String url = urlItemMap.get("url");
+                        String comment = urlItemMap.get("comment");
+                        String color = urlItemMap.get("color");
+                        String length = urlItemMap.get("length");
+                        String method = urlItemMap.get("method");
+                        String status = urlItemMap.get("status");
+                        String path = haeFileContent.getHttpPath();
+
+                        messageTableModel.add(null, url, method, status, length, comment, color, key, path);
+                        return null;
+                    });
+                });
+
+                executor.invokeAll(tasks);
+            } catch (Exception e) {
+                api.logging().logToError("importData: " + e.getMessage());
+            } finally {
+                executor.shutdown();
+            }
+        }
+
+        return String.format("Filename: %s, Status: %s", filename, readStatus);
+    }
+
+    private List<String> findFilesWithExtension(File directory, String extension) {
+        List<String> filePaths = new ArrayList<>();
+        if (directory.isDirectory()) {
+            File[] files = directory.listFiles();
+            if (files != null) {
+                for (File file : files) {
+                    if (file.isDirectory()) {
+                        filePaths.addAll(findFilesWithExtension(file, extension));
+                    } else if (file.isFile() && file.getName().toLowerCase().endsWith(extension)) {
+                        filePaths.add(file.getAbsolutePath());
+                    }
+                }
+            }
+        } else {
+            filePaths.add(directory.getAbsolutePath());
+        }
+        return filePaths;
+    }
+
+    private String selectDirectory(boolean forDirectories) {
+        JFileChooser chooser = new JFileChooser();
+        chooser.setCurrentDirectory(new java.io.File(configLoader.getRulesFilePath()));
+        chooser.setDialogTitle(String.format("Select a Directory%s", forDirectories ? "" : " or File"));
+        FileNameExtensionFilter filter = new FileNameExtensionFilter(".hae Files", "hae");
+        chooser.addChoosableFileFilter(filter);
+        chooser.setFileFilter(filter);
+
+        chooser.setFileSelectionMode(forDirectories ? JFileChooser.DIRECTORIES_ONLY : JFileChooser.FILES_AND_DIRECTORIES);
+        chooser.setAcceptAllFileFilterUsed(!forDirectories);
+
+        if (chooser.showOpenDialog(this) == JFileChooser.APPROVE_OPTION) {
+            File selectedDirectory = chooser.getSelectedFile();
+            return selectedDirectory.getAbsolutePath();
+        }
+
+        return "";
     }
 
     private void clearActionPerformed(ActionEvent e) {
-        int retCode = JOptionPane.showConfirmDialog(null, "Do you want to clear data?", "Info",
+        int retCode = JOptionPane.showConfirmDialog(this, "Do you want to clear data?", "Info",
                 JOptionPane.YES_NO_OPTION);
         String host = hostTextField.getText();
         if (retCode == JOptionPane.YES_OPTION && !host.isEmpty()) {
             dataTabbedPane.removeAll();
             splitPane.setVisible(false);
+            progressBar.setVisible(false);
 
-            String cleanedHost = StringProcessor.replaceFirstOccurrence(host, "*.", "");
+            Config.globalDataMap.keySet().parallelStream().forEach(key -> {
+                if (StringProcessor.matchesHostPattern(key, host) || host.equals("*")) {
+                    Config.globalDataMap.remove(key);
+                }
+            });
 
-            if (host.contains("*")) {
-                Config.globalDataMap.keySet().removeIf(i -> i.contains(cleanedHost) || cleanedHost.contains("*"));
-            } else {
-                Config.globalDataMap.remove(host);
+            // 删除无用的数据
+            Set<String> wildcardKeys = Config.globalDataMap.keySet().stream()
+                    .filter(key -> key.startsWith("*."))
+                    .collect(Collectors.toSet());
+
+            Set<String> existingSuffixes = Config.globalDataMap.keySet().stream()
+                    .filter(key -> !key.startsWith("*."))
+                    .map(key -> {
+                        int dotIndex = key.indexOf(".");
+                        return dotIndex != -1 ? key.substring(dotIndex) : "";
+                    })
+                    .collect(Collectors.toSet());
+
+            Set<String> keysToRemove = wildcardKeys.stream()
+                    .filter(key -> !existingSuffixes.contains(key.substring(1)))
+                    .collect(Collectors.toSet());
+
+            keysToRemove.forEach(Config.globalDataMap::remove);
+
+            if (Config.globalDataMap.keySet().size() == 1 && Config.globalDataMap.keySet().stream().anyMatch(key -> key.equals("*"))) {
+                Config.globalDataMap.keySet().remove("*");
             }
 
-            messageTableModel.deleteByHost(cleanedHost);
+            messageTableModel.deleteByHost(host);
         }
     }
 }

src/main/java/hae/component/board/Datatable.java

@@ -1,226 +0,0 @@
-package hae.component.board;
-
-import burp.api.montoya.MontoyaApi;
-import hae.component.board.message.MessageTableModel;
-import jregex.Pattern;
-import jregex.REFlags;
-
-import java.awt.*;
-import java.awt.event.FocusEvent;
-import java.awt.event.FocusListener;
-import java.awt.event.MouseAdapter;
-import java.awt.event.MouseEvent;
-import java.util.*;
-import java.util.List;
-import javax.swing.*;
-import java.awt.datatransfer.*;
-import javax.swing.event.*;
-import javax.swing.table.*;
-
-public class Datatable extends JPanel {
-    private final MontoyaApi api;
-    private final JTable dataTable;
-    private final DefaultTableModel dataTableModel;
-    private final JTextField searchField;
-    private final TableRowSorter<DefaultTableModel> sorter;
-    private final JCheckBox searchMode = new JCheckBox("Reverse search");
-    private final String tabName;
-
-    public Datatable(MontoyaApi api, String tabName, List<String> dataList) {
-        this.api = api;
-        this.tabName = tabName;
-
-
-        String[] columnNames = {"#", "Information"};
-
-        dataTableModel = new DefaultTableModel(columnNames, 0);
-        dataTable = new JTable(dataTableModel);
-        sorter = new TableRowSorter<>(dataTableModel);
-
-        searchField = new JTextField();
-
-        initComponents(dataList);
-    }
-
-    private void initComponents(List<String> dataList) {
-        // 设置ID排序
-        sorter.setComparator(0, new Comparator<Integer>() {
-            @Override
-            public int compare(Integer s1, Integer s2) {
-                return s1.compareTo(s2);
-            }
-        });
-
-        dataTable.setRowSorter(sorter);
-        TableColumn idColumn = dataTable.getColumnModel().getColumn(0);
-        idColumn.setMaxWidth(50);
-
-        for (String item : dataList) {
-            if (!item.isEmpty()) {
-                addRowToTable(new Object[]{item});
-            }
-        }
-
-        // 设置灰色默认文本
-        String searchText = "Search";
-        addPlaceholder(searchField, searchText);
-
-        // 监听输入框内容输入、更新、删除
-        searchField.getDocument().addDocumentListener(new DocumentListener() {
-            @Override
-            public void insertUpdate(DocumentEvent e) {
-                performSearch();
-            }
-
-            @Override
-            public void removeUpdate(DocumentEvent e) {
-                performSearch();
-            }
-
-            @Override
-            public void changedUpdate(DocumentEvent e) {
-                performSearch();
-            }
-
-        });
-
-        // 设置布局
-        JScrollPane scrollPane = new JScrollPane(dataTable);
-        scrollPane.setVerticalScrollBarPolicy(ScrollPaneConstants.VERTICAL_SCROLLBAR_ALWAYS);
-
-        searchMode.addItemListener(e -> performSearch());
-
-        setLayout(new BorderLayout(0, 5));
-
-        JPanel optionsPanel = new JPanel();
-        optionsPanel.setBorder(BorderFactory.createEmptyBorder(2, 3, 5, 5));
-        optionsPanel.setLayout(new BoxLayout(optionsPanel, BoxLayout.X_AXIS));
-
-        // 新增复选框要在这修改rows
-        JPanel menuPanel = new JPanel(new GridLayout(1, 1));
-        menuPanel.setBorder(BorderFactory.createEmptyBorder(3, 3, 3, 3));
-        JPopupMenu menu = new JPopupMenu();
-        menuPanel.add(searchMode);
-        menu.add(menuPanel);
-
-        JButton settingsButton = new JButton("Settings");
-        settingsButton.addActionListener(e -> {
-            int x = settingsButton.getX();
-            int y = settingsButton.getY() - menu.getPreferredSize().height;
-            menu.show(settingsButton, x, y);
-        });
-
-        optionsPanel.add(settingsButton);
-        optionsPanel.add(Box.createHorizontalStrut(5));
-        optionsPanel.add(searchField);
-
-        dataTable.setTransferHandler(new TransferHandler() {
-            @Override
-            public void exportToClipboard(JComponent comp, Clipboard clip, int action) throws IllegalStateException {
-                if (comp instanceof JTable) {
-                    StringSelection stringSelection = new StringSelection(getSelectedData(
-                            (JTable) comp));
-                    clip.setContents(stringSelection, null);
-                } else {
-                    super.exportToClipboard(comp, clip, action);
-                }
-            }
-        });
-
-        add(scrollPane, BorderLayout.CENTER);
-        add(optionsPanel, BorderLayout.SOUTH);
-    }
-
-    public static void addPlaceholder(JTextField textField, String placeholderText) {
-        textField.setForeground(Color.GRAY);
-        textField.setText(placeholderText);
-        textField.addFocusListener(new FocusListener() {
-            @Override
-            public void focusGained(FocusEvent e) {
-                if (textField.getText().equals(placeholderText)) {
-                    textField.setText("");
-                    textField.setForeground(Color.BLACK);
-                }
-            }
-
-            @Override
-            public void focusLost(FocusEvent e) {
-                if (textField.getText().isEmpty()) {
-                    textField.setForeground(Color.GRAY);
-                    textField.setText(placeholderText);
-                }
-            }
-        });
-    }
-
-    private void addRowToTable(Object[] data) {
-        int rowCount = dataTableModel.getRowCount();
-        int id = rowCount > 0 ? (Integer) dataTableModel.getValueAt(rowCount - 1, 0) + 1 : 1;
-        Object[] rowData = new Object[data.length + 1];
-        rowData[0] = id;
-        System.arraycopy(data, 0, rowData, 1, data.length);
-        dataTableModel.addRow(rowData);
-    }
-
-    private void performSearch() {
-        if (searchField.getForeground().equals(Color.BLACK)) {
-            RowFilter<Object, Object> rowFilter = new RowFilter<Object, Object>() {
-                public boolean include(Entry<?, ?> entry) {
-                    String searchFieldTextText = searchField.getText();
-                    Pattern pattern = null;
-                    try {
-                        pattern = new Pattern(searchFieldTextText, REFlags.IGNORE_CASE);
-                    } catch (Exception ignored) {
-                    }
-
-                    String entryValue = ((String) entry.getValue(1)).toLowerCase();
-                    searchFieldTextText = searchFieldTextText.toLowerCase();
-                    if (pattern != null) {
-                        return searchFieldTextText.isEmpty() || pattern.matcher(entryValue).find() != searchMode.isSelected();
-                    } else {
-                        return searchFieldTextText.isEmpty() || entryValue.contains(searchFieldTextText) != searchMode.isSelected();
-                    }
-                }
-            };
-            sorter.setRowFilter(rowFilter);
-        }
-    }
-
-    public static String getSelectedData(JTable table) {
-        int[] selectRows = table.getSelectedRows();
-        StringBuilder selectData = new StringBuilder();
-        for (int row : selectRows) {
-            selectData.append(table.getValueAt(row, 1).toString()).append("\n");
-        }
-
-        // 便于单行复制，去除最后一个换行符
-        if (!selectData.isEmpty()){
-            selectData.deleteCharAt(selectData.length() - 1);
-        }
-
-        return selectData.toString();
-    }
-
-    public JTable getDataTable() {
-        return this.dataTable;
-    }
-
-    public void setTableListener(MessageTableModel messagePanel) {
-        dataTable.setDefaultEditor(Object.class, null);
-
-        // 表格内容双击事件
-        dataTable.addMouseListener(new MouseAdapter() {
-            @Override
-            public void mouseClicked(MouseEvent e) {
-                if (e.getClickCount() == 2) {
-                    int selectedRow = dataTable.getSelectedRow();
-                    if (selectedRow != -1) {
-                        String rowData = dataTable.getValueAt(selectedRow, 1).toString();
-                        messagePanel.applyMessageFilter(tabName, rowData);
-                    }
-                }
-            }
-        });
-    }
-}
-

src/main/java/hae/component/board/message/MessageEntry.java

@@ -11,8 +11,10 @@ public class MessageEntry {
     private final String status;
     private final String color;
     private final String method;
+    private final String hash;
+    private final String path;
 
-    MessageEntry(HttpRequestResponse requestResponse, String method, String url, String comment, String length, String color, String status) {
+    MessageEntry(HttpRequestResponse requestResponse, String method, String url, String comment, String length, String color, String status, String hash, String path) {
         this.requestResponse = requestResponse;
         this.method = method;
         this.url = url;
@@ -20,6 +22,8 @@ public class MessageEntry {
         this.length = length;
         this.color = color;
         this.status = status;
+        this.hash = hash;
+        this.path = path;
     }
 
     public String getColor() {
@@ -49,4 +53,12 @@ public class MessageEntry {
     public HttpRequestResponse getRequestResponse() {
         return this.requestResponse;
     }
+
+    public String getHash() {
+        return this.hash;
+    }
+
+    public String getPath() {
+        return this.path;
+    }
 }

src/main/java/hae/component/board/message/MessageRenderer.java

@@ -1,20 +1,19 @@
 package hae.component.board.message;
 
-import java.awt.Color;
-import java.awt.Component;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import javax.swing.JTable;
+import javax.swing.*;
 import javax.swing.table.DefaultTableCellRenderer;
+import java.awt.*;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.Map;
 
 public class MessageRenderer extends DefaultTableCellRenderer {
 
-    private List<MessageEntry> log;
-    private Map<String, Color> colorMap = new HashMap<>();
-    private JTable table; // 保存对表格的引用
+    private final LinkedList<MessageEntry> log;
+    private final Map<String, Color> colorMap = new HashMap<>();
+    private final JTable table; // 保存对表格的引用
 
-    public MessageRenderer(List<MessageEntry> log, JTable table) {
+    public MessageRenderer(LinkedList<MessageEntry> log, JTable table) {
         this.log = log;
         // 与BurpSuite的颜色保持一致
         this.colorMap.put("red", new Color(0xFF, 0x64, 0x64));
@@ -42,7 +41,7 @@ public class MessageRenderer extends DefaultTableCellRenderer {
 
         if (isSelected) {
             // 通过更改RGB颜色来达成阴影效果
-            component.setBackground(new Color(color.getRed()-0x20, color.getGreen()-0x20, color.getBlue()-0x20));
+            component.setBackground(new Color(color.getRed() - 0x20, color.getGreen() - 0x20, color.getBlue() - 0x20));
         } else {
             // 否则使用原始颜色
             component.setBackground(color);

src/main/java/hae/component/board/message/MessageTableModel.java

@@ -11,21 +11,18 @@ import burp.api.montoya.ui.editor.HttpRequestEditor;
 import burp.api.montoya.ui.editor.HttpResponseEditor;
 import hae.Config;
 import hae.cache.CachePool;
+import hae.utils.project.FileProcessor;
 import hae.utils.string.HashCalculator;
 import hae.utils.string.StringProcessor;
 
-import java.nio.charset.StandardCharsets;
-import java.text.MessageFormat;
-import java.util.*;
-import javax.swing.JScrollPane;
-import javax.swing.JSplitPane;
-import javax.swing.JTabbedPane;
-import javax.swing.JTable;
-import javax.swing.SwingWorker;
+import javax.swing.*;
 import javax.swing.table.AbstractTableModel;
 import javax.swing.table.DefaultTableModel;
 import javax.swing.table.TableModel;
 import javax.swing.table.TableRowSorter;
+import java.nio.charset.StandardCharsets;
+import java.text.MessageFormat;
+import java.util.*;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.stream.Collectors;
 
@@ -34,16 +31,16 @@ import static burp.api.montoya.ui.editor.EditorOptions.READ_ONLY;
 public class MessageTableModel extends AbstractTableModel {
     private final MontoyaApi api;
     private final MessageTable messageTable;
-    private final JTabbedPane messageTab;
     private final JSplitPane splitPane;
-    private final List<MessageEntry> log = new ArrayList<MessageEntry>();
-    private LinkedList<MessageEntry> filteredLog;
+    private final LinkedList<MessageEntry> log = new LinkedList<>();
+    private final LinkedList<MessageEntry> filteredLog;
+    private SwingWorker<Void, Void> currentWorker;
 
     public MessageTableModel(MontoyaApi api) {
         this.filteredLog = new LinkedList<>();
         this.api = api;
 
-        messageTab = new JTabbedPane();
+        JTabbedPane messageTab = new JTabbedPane();
         UserInterface userInterface = api.userInterface();
         HttpRequestEditor requestViewer = userInterface.createHttpRequestEditor(READ_ONLY);
         HttpResponseEditor responseViewer = userInterface.createHttpResponseEditor(READ_ONLY);
@@ -74,6 +71,7 @@ public class MessageTableModel extends AbstractTableModel {
                 int index2 = getIndex(s2);
                 return Integer.compare(index1, index2);
             }
+
             private int getIndex(String color) {
                 for (int i = 0; i < Config.color.length; i++) {
                     if (Config.color[i].equals(color)) {
@@ -95,32 +93,32 @@ public class MessageTableModel extends AbstractTableModel {
         splitPane.setRightComponent(messageTab);
     }
 
-    public void add(HttpRequestResponse messageInfo, String comment, String color) {
-        synchronized(log) {
-            HttpRequest httpRequest = messageInfo.request();
-            String url = httpRequest.url();
-            String method = httpRequest.method();
+    public void add(HttpRequestResponse messageInfo, String url, String method, String status, String length, String comment, String color, String hash, String path) {
+        synchronized (log) {
+            boolean isDuplicate = false;
+            MessageEntry logEntry = new MessageEntry(messageInfo, method, url, comment, length, color, status, hash, path);
 
-            HttpResponse httpResponse = messageInfo.response();
-            String status = String.valueOf(httpResponse.statusCode());
-            String length = String.valueOf(httpResponse.body().length());
+            byte[] reqByteA = new byte[0];
+            byte[] resByteA = new byte[0];
 
-            MessageEntry logEntry = new MessageEntry(messageInfo, method, url, comment, length, color, status);
+            if (messageInfo != null) {
+                HttpRequest httpRequest = messageInfo.request();
+                HttpResponse httpResponse = messageInfo.response();
 
+                reqByteA = httpRequest.toByteArray().getBytes();
+                resByteA = httpResponse.toByteArray().getBytes();
+            }
+
+            // 比较Hash，如若存在重复的请求或响应，则不放入消息内容里
             try {
-                // 比较Hash，如若存在重复的请求或响应，则不放入消息内容里
-                byte[] reqByteA = httpRequest.toByteArray().getBytes();
-                byte[] resByteA = httpResponse.toByteArray().getBytes();
-                boolean isDuplicate = false;
-
-                if (log.size() > 0) {
+                if (!log.isEmpty()) {
                     for (MessageEntry entry : log) {
                         HttpRequestResponse reqResMessage = entry.getRequestResponse();
                         byte[] reqByteB = reqResMessage.request().toByteArray().getBytes();
                         byte[] resByteB = reqResMessage.response().toByteArray().getBytes();
                         try {
                             // 通过URL、请求和响应报文、匹配数据内容，多维度进行对比
-                            if ((entry.getUrl().toString().equals(url.toString()) || (Arrays.equals(reqByteB, reqByteA) || Arrays.equals(resByteB, resByteA))) && (areMapsEqual(getCacheData(reqByteB), getCacheData(reqByteA)) && areMapsEqual(getCacheData(resByteB), getCacheData(resByteA)))) {
+                            if ((entry.getUrl().equals(url) || (Arrays.equals(reqByteB, reqByteA) || Arrays.equals(resByteB, resByteA))) && (areMapsEqual(getCacheData(reqByteB), getCacheData(reqByteA)) && areMapsEqual(getCacheData(resByteB), getCacheData(resByteA)))) {
                                 isDuplicate = true;
                                 break;
                             }
@@ -128,12 +126,12 @@ public class MessageTableModel extends AbstractTableModel {
                         }
                     }
                 }
-
-                if (!isDuplicate) {
-                    log.add(logEntry);
-                }
             } catch (Exception ignored) {
             }
+
+            if (!isDuplicate) {
+                log.add(logEntry);
+            }
         }
 
     }
@@ -141,49 +139,86 @@ public class MessageTableModel extends AbstractTableModel {
     public void deleteByHost(String filterText) {
         filteredLog.clear();
         List<Integer> rowsToRemove = new ArrayList<>();
-        for (int i = 0; i < log.size(); i++) {
-            MessageEntry entry = log.get(i);
-            String host = StringProcessor.getHostByUrl(entry.getUrl());
-            if (!host.isEmpty()) {
-                if (StringProcessor.matchFromEnd(host, filterText) || filterText.contains("*")) {
-                    rowsToRemove.add(i);
+
+        if (currentWorker != null && !currentWorker.isDone()) {
+            currentWorker.cancel(true);
+        }
+
+        currentWorker = new SwingWorker<Void, Void>() {
+            @Override
+            protected Void doInBackground() {
+                for (int i = 0; i < log.size(); i++) {
+                    MessageEntry entry = log.get(i);
+                    String host = StringProcessor.getHostByUrl(entry.getUrl());
+                    if (!host.isEmpty()) {
+                        if (StringProcessor.matchesHostPattern(host, filterText) || filterText.equals("*")) {
+                            rowsToRemove.add(i);
+                        }
+                    }
                 }
+
+                for (int i = rowsToRemove.size() - 1; i >= 0; i--) {
+                    int row = rowsToRemove.get(i);
+                    log.remove(row);
+                }
+
+                return null;
             }
-        }
+        };
 
-        for (int i = rowsToRemove.size() - 1; i >= 0; i--) {
-            int row = rowsToRemove.get(i);
-            log.remove(row);
-        }
-
-        if (!rowsToRemove.isEmpty()) {
-            int[] rows = rowsToRemove.stream().mapToInt(Integer::intValue).toArray();
-            fireTableRowsDeleted(rows[0], rows[rows.length - 1]);
-        }
+        currentWorker.execute();
     }
 
     public void applyHostFilter(String filterText) {
         filteredLog.clear();
-        fireTableDataChanged();
-        String cleanedText = StringProcessor.replaceFirstOccurrence(filterText, "*.", "");
 
-        for (MessageEntry entry : log) {
-            String host = StringProcessor.getHostByUrl(entry.getUrl());
+        log.forEach(entry -> {
+            MessageEntry finalEntry = getEntryByFile(entry);
+            String host = StringProcessor.getHostByUrl(finalEntry.getUrl());
             if (!host.isEmpty()) {
-                if (filterText.contains("*.") && StringProcessor.matchFromEnd(host, cleanedText)) {
-                    filteredLog.add(entry);
-                } else if (host.equals(filterText) || filterText.contains("*")) {
-                    filteredLog.add(entry);
+                if (StringProcessor.matchesHostPattern(host, filterText) || filterText.contains("*")) {
+                    filteredLog.add(finalEntry);
                 }
             }
+        });
+
+        fireTableDataChanged();
+    }
+
+    private MessageEntry getEntryByFile(MessageEntry entry) {
+        HttpRequestResponse requestResponse = entry.getRequestResponse();
+        if (requestResponse == null) {
+            String url = entry.getUrl();
+            String method = entry.getMethod();
+            String status = entry.getStatus();
+            String comment = entry.getComment();
+            String color = entry.getColor();
+            String path = entry.getPath();
+            String hash = entry.getHash();
+            int length = Integer.parseInt(entry.getLength());
+
+            byte[] contents = FileProcessor.readFileContent(path, hash);
+
+            if (contents.length > length) {
+                byte[] response = Arrays.copyOf(contents, length);
+                byte[] request = Arrays.copyOfRange(contents, length, contents.length);
+                requestResponse = StringProcessor.createHttpRequestResponse(url, request, response);
+
+                int index = log.indexOf(entry);
+                entry = new MessageEntry(requestResponse, method, url, comment, String.valueOf(length), color, status, "", "");
+                log.set(index, entry);
+            }
         }
 
-        fireTableDataChanged();
+        return entry;
     }
 
     public void applyMessageFilter(String tableName, String filterText) {
         filteredLog.clear();
         for (MessageEntry entry : log) {
+            // 标志变量，表示是否满足过滤条件
+            AtomicBoolean isMatched = new AtomicBoolean(false);
+
             HttpRequestResponse requestResponse = entry.getRequestResponse();
             HttpRequest httpRequest = requestResponse.request();
             HttpResponse httpResponse = requestResponse.response();
@@ -200,9 +235,6 @@ public class MessageTableModel extends AbstractTableModel {
                     .map(HttpHeader::toString)
                     .collect(Collectors.joining("\n"));
 
-            // 标志变量，表示是否满足过滤条件
-            AtomicBoolean isMatched = new AtomicBoolean(false);
-
             Config.globalRules.keySet().forEach(i -> {
                 for (Object[] objects : Config.globalRules.get(i)) {
                     String name = objects[1].toString();
@@ -243,6 +275,14 @@ public class MessageTableModel extends AbstractTableModel {
                                 case "response body":
                                     isMatch = matchingString(format, filterText, responseBody);
                                     break;
+                                case "request line":
+                                    String requestLine = requestString.split("\\r?\\n", 2)[0];
+                                    isMatch = matchingString(format, filterText, requestLine);
+                                    break;
+                                case "response line":
+                                    String responseLine = responseString.split("\\r?\\n", 2)[0];
+                                    isMatch = matchingString(format, filterText, responseLine);
+                                    break;
                                 default:
                                     break;
                             }
@@ -285,7 +325,7 @@ public class MessageTableModel extends AbstractTableModel {
 
     private Map<String, Map<String, Object>> getCacheData(byte[] content) {
         String hashIndex = HashCalculator.calculateHash(content);
-        return CachePool.getFromCache(hashIndex);
+        return CachePool.get(hashIndex);
     }
 
     private boolean areMapsEqual(Map<String, Map<String, Object>> map1, Map<String, Map<String, Object>> map2) {
@@ -300,7 +340,7 @@ public class MessageTableModel extends AbstractTableModel {
             if (!map2.containsKey(key)) {
                 return false;
             }
-            if (!areInnerMapsEqual(map1.get(key), map2.get(key))) {
+            if (areInnerMapsEqual(map1.get(key), map2.get(key))) {
                 return false;
             }
         }
@@ -310,45 +350,41 @@ public class MessageTableModel extends AbstractTableModel {
 
     private boolean areInnerMapsEqual(Map<String, Object> innerMap1, Map<String, Object> innerMap2) {
         if (innerMap1.size() != innerMap2.size()) {
-            return false;
+            return true;
         }
 
         for (String key : innerMap1.keySet()) {
             if (!innerMap2.containsKey(key)) {
-                return false;
+                return true;
             }
             Object value1 = innerMap1.get(key);
             Object value2 = innerMap2.get(key);
 
             // 如果值是Map，则递归对比
             if (value1 instanceof Map && value2 instanceof Map) {
-                if (!areInnerMapsEqual((Map<String, Object>) value1, (Map<String, Object>) value2)) {
-                    return false;
+                if (areInnerMapsEqual((Map<String, Object>) value1, (Map<String, Object>) value2)) {
+                    return true;
                 }
             } else if (!value1.equals(value2)) {
-                return false;
+                return true;
             }
         }
 
-        return true;
+        return false;
     }
 
-
-    public JSplitPane getSplitPane()
-    {
+    public JSplitPane getSplitPane() {
         return splitPane;
     }
 
-    public MessageTable getMessageTable()
-    {
+    public MessageTable getMessageTable() {
         return messageTable;
     }
 
-    public List<MessageEntry> getLogs() {
+    public LinkedList<MessageEntry> getLogs() {
         return log;
     }
 
-
     @Override
     public int getRowCount() {
         return filteredLog.size();
@@ -360,27 +396,32 @@ public class MessageTableModel extends AbstractTableModel {
     }
 
     @Override
-    public Object getValueAt(int rowIndex, int columnIndex)
-    {
-        if (filteredLog.isEmpty()) {
-            return "";
-        }
-        MessageEntry messageEntry = filteredLog.get(rowIndex);
+    public Object getValueAt(int rowIndex, int columnIndex) {
+        if (!filteredLog.isEmpty()) {
+            try {
+                MessageEntry messageEntry = filteredLog.get(rowIndex);
 
-        return switch (columnIndex) {
-            case 0 -> messageEntry.getMethod();
-            case 1 -> messageEntry.getUrl();
-            case 2 -> messageEntry.getComment();
-            case 3 -> messageEntry.getStatus();
-            case 4 -> messageEntry.getLength();
-            case 5 -> messageEntry.getColor();
-            default -> "";
-        };
+                if (messageEntry != null) {
+                    return switch (columnIndex) {
+                        case 0 -> messageEntry.getMethod();
+                        case 1 -> messageEntry.getUrl();
+                        case 2 -> messageEntry.getComment();
+                        case 3 -> messageEntry.getStatus();
+                        case 4 -> messageEntry.getLength();
+                        case 5 -> messageEntry.getColor();
+                        default -> "";
+                    };
+                }
+            } catch (Exception e) {
+                api.logging().logToError("getValueAt: " + e.getMessage());
+            }
+        }
+
+        return "";
     }
 
     @Override
-    public String getColumnName(int columnIndex)
-    {
+    public String getColumnName(int columnIndex) {
         return switch (columnIndex) {
             case 0 -> "Method";
             case 1 -> "URL";
@@ -393,10 +434,8 @@ public class MessageTableModel extends AbstractTableModel {
     }
 
     public class MessageTable extends JTable {
-        private MessageEntry MessageEntry;
+        private MessageEntry messageEntry;
         private SwingWorker<Object, Void> currentWorker;
-        // 设置响应报文返回的最大长度为3MB
-        private final int MAX_LENGTH = 3145728;
         private int lastSelectedIndex = -1;
         private final HttpRequestEditor requestEditor;
         private final HttpResponseEditor responseEditor;
@@ -410,47 +449,36 @@ public class MessageTableModel extends AbstractTableModel {
         @Override
         public void changeSelection(int row, int col, boolean toggle, boolean extend) {
             super.changeSelection(row, col, toggle, extend);
-            int selectedIndex = convertRowIndexToModel(row);
-            if (lastSelectedIndex != selectedIndex) {
-                lastSelectedIndex = selectedIndex;
-                MessageEntry = filteredLog.get(selectedIndex);
 
-                requestEditor.setRequest(HttpRequest.httpRequest("Loading..."));
-                responseEditor.setResponse(HttpResponse.httpResponse("Loading..."));
+            requestEditor.setRequest(HttpRequest.httpRequest("Loading..."));
+            responseEditor.setResponse(HttpResponse.httpResponse("Loading..."));
 
-                if (currentWorker != null && !currentWorker.isDone()) {
-                    currentWorker.cancel(true);
-                }
-
-                currentWorker = new SwingWorker<>() {
-                    @Override
-                    protected ByteArray[] doInBackground() {
-                        ByteArray requestByte = MessageEntry.getRequestResponse().request().toByteArray();
-                        ByteArray responseByte = MessageEntry.getRequestResponse().response().toByteArray();
-
-                        if (responseByte.length() > MAX_LENGTH) {
-                            String ellipsis = "\r\n......";
-                            responseByte = responseByte.subArray(0, MAX_LENGTH).withAppended(ellipsis);
-                        }
-
-                        return new ByteArray[]{requestByte, responseByte};
-                    }
-
-                    @Override
-                    protected void done() {
-                        if (!isCancelled()) {
-                            try {
-                                ByteArray[] result = (ByteArray[]) get();
-                                requestEditor.setRequest(HttpRequest.httpRequest(MessageEntry.getRequestResponse().httpService(), result[0]));
-                                responseEditor.setResponse(HttpResponse.httpResponse(result[1]));
-                            } catch (Exception e) {
-                                e.printStackTrace();
-                            }
-                        }
-                    }
-                };
-                currentWorker.execute();
+            if (currentWorker != null && !currentWorker.isDone()) {
+                currentWorker.cancel(true);
             }
+
+            currentWorker = new SwingWorker<>() {
+                @Override
+                protected Void doInBackground() {
+                    int selectedIndex = convertRowIndexToModel(row);
+                    if (lastSelectedIndex != selectedIndex) {
+                        lastSelectedIndex = selectedIndex;
+                        messageEntry = filteredLog.get(selectedIndex);
+
+                        HttpRequestResponse httpRequestResponse = messageEntry.getRequestResponse();
+
+                        ByteArray requestByte = httpRequestResponse.request().toByteArray();
+                        ByteArray responseByte = httpRequestResponse.response().toByteArray();
+
+                        requestEditor.setRequest(HttpRequest.httpRequest(messageEntry.getRequestResponse().httpService(), requestByte));
+                        responseEditor.setResponse(HttpResponse.httpResponse(responseByte));
+
+                    }
+
+                    return null;
+                }
+            };
+            currentWorker.execute();
         }
     }
 }

src/main/java/hae/component/board/table/AIPower.java

@@ -0,0 +1,157 @@
+package hae.component.board.table;
+
+import burp.api.montoya.MontoyaApi;
+import burp.api.montoya.http.RequestOptions;
+import burp.api.montoya.http.message.HttpRequestResponse;
+import burp.api.montoya.http.message.requests.HttpRequest;
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.google.gson.reflect.TypeToken;
+import hae.Config;
+import hae.utils.ConfigLoader;
+import hae.utils.http.HttpUtils;
+import okhttp3.*;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.lang.reflect.Type;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class AIPower {
+    private final MontoyaApi api;
+    private final HttpUtils httpUtils;
+    private final ConfigLoader configLoader;
+    private final String apiAuth;
+    private final String aiModel;
+    private final String aiBaseUrl;
+
+    public AIPower(MontoyaApi api, ConfigLoader configLoader, String aiModel, String aiBaseUrl, String[] apiKey) {
+        this.api = api;
+        this.configLoader = configLoader;
+        this.httpUtils = new HttpUtils(api);
+        this.aiModel = aiModel;
+        this.aiBaseUrl = aiBaseUrl;
+
+        this.apiAuth = String.format("Bearer %s", apiKey[new Random().nextInt(apiKey.length)]);
+    }
+
+    // Stream Response
+    public String chatWithAPI(String ruleName, String data) {
+        OkHttpClient httpClient = new OkHttpClient();
+        String fileId = uploadFileToAIService(ruleName, data);
+        Gson gson = new Gson();
+
+        if (fileId != null) {
+            String chatUrl = String.format("%s/chat/completions", aiBaseUrl);
+            String chatMessage = generateJsonData(configLoader.getAIPrompt(), fileId);
+            Request request = new Request.Builder()
+                    .url(chatUrl)
+                    .header("Authorization", apiAuth)
+                    .post(RequestBody.create(MediaType.parse("application/json"), chatMessage))
+                    .build();
+
+            try (Response response = httpClient.newCall(request).execute()) {
+                if (!response.isSuccessful()) {
+                    throw new IOException("Unexpected code " + response);
+                }
+
+                BufferedReader reader = new BufferedReader(new InputStreamReader(response.body().byteStream()));
+                StringBuilder chatReturn = new StringBuilder();
+                String line;
+
+                while ((line = reader.readLine()) != null) {
+                    if (line.startsWith("data: ") && !line.contains("[DONE]")) {
+                        String jsonData = line.substring(6);
+                        Type type = new TypeToken<Map<String, Object>>() {
+                        }.getType();
+                        Map<String, Object> map = gson.fromJson(jsonData, type);
+                        String content = getDeltaContent(map);
+                        if (content != null) {
+                            chatReturn.append(content);
+                        }
+                    }
+                }
+
+                deleteFileOnAIService(fileId);
+
+                return chatReturn.toString();
+            } catch (Exception e) {
+                return "";
+            }
+        }
+
+        return "";
+    }
+
+    private String getDeltaContent(Map<String, Object> map) {
+        List<Map<String, Map<String, String>>> choices = (List<Map<String, Map<String, String>>>) map.get("choices");
+        if (choices != null && !choices.isEmpty()) {
+            Map<String, String> delta = choices.get(0).get("delta");
+            return delta.get("content");
+        }
+        return null;
+    }
+
+    private String uploadFileToAIService(String ruleName, String data) {
+        String uploadUrl = String.format("%s/files", aiBaseUrl);
+        String uploadParam = "file";
+        String filename = "hae.txt";
+        String content = String.format(Config.userTextFormat, ruleName, data);
+
+        HttpRequest uploadFileRequest = httpUtils.generateRequestByMultipartUploadMethod(uploadUrl, uploadParam, filename, content).withAddedHeader("Authorization", apiAuth);
+
+        HttpRequestResponse uploadFileRequestResponse = api.http().sendRequest(uploadFileRequest, RequestOptions.requestOptions().withUpstreamTLSVerification());
+        String responseBody = uploadFileRequestResponse.response().bodyToString();
+        Pattern pattern = Pattern.compile("\"id\":\"(.*?)\",");
+        Matcher matcher = pattern.matcher(responseBody);
+
+        return matcher.find() ? matcher.group(1) : null;
+    }
+
+    private void deleteFileOnAIService(String fileId) {
+        String deleteFileUrl = String.format("%s/files/%s", aiBaseUrl, fileId);
+        HttpRequest deleteFileRequest = httpUtils.generateRequestByDeleteMethod(deleteFileUrl).withAddedHeader("Authorization", apiAuth);
+        api.http().sendRequest(deleteFileRequest, RequestOptions.requestOptions().withUpstreamTLSVerification());
+    }
+
+    private String getFileContentOnAiService(String fileId) {
+        String getFileContentUrl = String.format("%s/files/%s/content", aiBaseUrl, fileId);
+        HttpRequest getFileContentRequest = HttpRequest.httpRequestFromUrl(getFileContentUrl).withAddedHeader("Authorization", apiAuth);
+        HttpRequestResponse getFileRequestResponse = api.http().sendRequest(getFileContentRequest, RequestOptions.requestOptions().withUpstreamTLSVerification());
+        String responseBody = getFileRequestResponse.response().bodyToString();
+        Pattern pattern = Pattern.compile("\"content\":\"(.*?)\",\"file_type\"");
+        Matcher matcher = pattern.matcher(responseBody);
+
+        return matcher.find() ? matcher.group(1) : null;
+    }
+
+    private String generateJsonData(String prompt, String fileId) {
+        Map<String, Object> data = new HashMap<>();
+        data.put("model", aiModel);
+        data.put("stream", true);
+        data.put("messages", new Object[]{
+                new HashMap<String, Object>() {{
+                    put("role", "system");
+                    put("content", prompt);
+                }},
+                new HashMap<String, Object>() {{
+                    put("role", "system");
+                    put("content", aiModel.equals("qwen-long") ? String.format("fileid://%s", fileId) : getFileContentOnAiService(fileId));
+                }},
+                new HashMap<String, Object>() {{
+                    put("role", "user");
+                    put("content", "Start");
+                }}
+        });
+
+        Gson gson = new GsonBuilder().setPrettyPrinting().create();
+        return gson.toJson(data);
+    }
+
+}

src/main/java/hae/component/board/table/Datatable.java

@@ -0,0 +1,347 @@
+package hae.component.board.table;
+
+import burp.api.montoya.MontoyaApi;
+import com.google.gson.Gson;
+import com.google.gson.reflect.TypeToken;
+import hae.component.board.Databoard;
+import hae.component.board.message.MessageTableModel;
+import hae.utils.ConfigLoader;
+import hae.utils.UIEnhancer;
+
+import javax.swing.*;
+import javax.swing.event.DocumentEvent;
+import javax.swing.event.DocumentListener;
+import javax.swing.event.PopupMenuEvent;
+import javax.swing.event.PopupMenuListener;
+import javax.swing.table.DefaultTableModel;
+import javax.swing.table.TableColumn;
+import javax.swing.table.TableRowSorter;
+import java.awt.*;
+import java.awt.datatransfer.Clipboard;
+import java.awt.datatransfer.StringSelection;
+import java.awt.event.ActionEvent;
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+import java.lang.reflect.Type;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Map;
+import java.util.regex.Pattern;
+
+public class Datatable extends JPanel {
+    private final MontoyaApi api;
+    private final ConfigLoader configLoader;
+    private final JTable dataTable;
+    private final DefaultTableModel dataTableModel;
+    private final JTextField searchField;
+    private final TableRowSorter<DefaultTableModel> sorter;
+    private final JCheckBox searchMode = new JCheckBox("Reverse search");
+    private final String tabName;
+    private final JProgressBar progressBar;
+    private final JPopupMenu aiEmpoweredMenu;
+    private final JPanel footerPanel;
+
+    public Datatable(MontoyaApi api, ConfigLoader configLoader, String tabName, List<String> dataList) {
+        this.api = api;
+        this.configLoader = configLoader;
+        this.tabName = tabName;
+        this.progressBar = new JProgressBar();
+
+        String[] columnNames = {"#", "Information"};
+        this.dataTableModel = new DefaultTableModel(columnNames, 0);
+
+        this.dataTable = new JTable(dataTableModel);
+        this.sorter = new TableRowSorter<>(dataTableModel);
+        this.searchField = new JTextField();
+        this.aiEmpoweredMenu = new JPopupMenu();
+        this.footerPanel = new JPanel(new BorderLayout(0, 5));
+
+        initComponents(dataList);
+    }
+
+    private void initComponents(List<String> dataList) {
+        progressBar.setVisible(false);
+
+        // 设置ID排序
+        sorter.setComparator(0, new Comparator<Integer>() {
+            @Override
+            public int compare(Integer s1, Integer s2) {
+                return s1.compareTo(s2);
+            }
+        });
+
+        dataTable.setRowSorter(sorter);
+        TableColumn idColumn = dataTable.getColumnModel().getColumn(0);
+        idColumn.setMaxWidth(50);
+
+        for (String item : dataList) {
+            if (!item.isEmpty()) {
+                addRowToTable(new Object[]{item});
+            }
+        }
+
+        // 设置灰色默认文本
+        String searchText = "Search";
+        UIEnhancer.setTextFieldPlaceholder(searchField, searchText);
+
+        // 监听输入框内容输入、更新、删除
+        searchField.getDocument().addDocumentListener(new DocumentListener() {
+            @Override
+            public void insertUpdate(DocumentEvent e) {
+                performSearch();
+            }
+
+            @Override
+            public void removeUpdate(DocumentEvent e) {
+                performSearch();
+            }
+
+            @Override
+            public void changedUpdate(DocumentEvent e) {
+                performSearch();
+            }
+
+        });
+
+        // 设置布局
+        JScrollPane scrollPane = new JScrollPane(dataTable);
+        scrollPane.setVerticalScrollBarPolicy(ScrollPaneConstants.VERTICAL_SCROLLBAR_ALWAYS);
+
+        setLayout(new BorderLayout(0, 5));
+
+        JPanel optionsPanel = new JPanel();
+        optionsPanel.setLayout(new BoxLayout(optionsPanel, BoxLayout.X_AXIS));
+
+        // Settings按钮
+        JPanel settingMenuPanel = new JPanel(new GridLayout(1, 1));
+        settingMenuPanel.setBorder(BorderFactory.createEmptyBorder(3, 3, 3, 3));
+        JPopupMenu settingMenu = new JPopupMenu();
+        settingMenuPanel.add(searchMode);
+        searchMode.addItemListener(e -> performSearch());
+        settingMenu.add(settingMenuPanel);
+
+        JButton settingsButton = new JButton("Settings");
+        setMenuShow(settingMenu, settingsButton);
+
+        // AI Empowered按钮
+        JPanel aiEmpoweredPanel = new JPanel(new GridLayout(2, 1));
+        aiEmpoweredPanel.setBorder(BorderFactory.createEmptyBorder(3, 3, 3, 3));
+        JButton empoweredByAlibabaButton = new JButton("Alibaba - QwenLong");
+        empoweredByAlibabaButton.addActionListener(e -> {
+            aiEmpoweredByAlibabaActionPerformed(e, tabName, getTableData(dataTable));
+        });
+        JButton empoweredByMoonshotButton = new JButton("Moonshot - Kimi");
+        empoweredByMoonshotButton.addActionListener(e -> {
+            aiEmpoweredByMoonshotActionPerformed(e, tabName, getTableData(dataTable));
+        });
+        aiEmpoweredPanel.add(empoweredByAlibabaButton);
+        aiEmpoweredPanel.add(empoweredByMoonshotButton);
+        aiEmpoweredMenu.add(aiEmpoweredPanel);
+
+        JButton aiEmpoweredButton = new JButton("AI Empowered");
+        setMenuShow(aiEmpoweredMenu, aiEmpoweredButton);
+        aiEmpoweredMenu.addPopupMenuListener(new PopupMenuListener() {
+            @Override
+            public void popupMenuWillBecomeVisible(PopupMenuEvent e) {
+                empoweredByAlibabaButton.setEnabled(!configLoader.getAlibabaAIAPIKey().isEmpty());
+                empoweredByMoonshotButton.setEnabled(!configLoader.getMoonshotAIAPIKey().isEmpty());
+            }
+
+            @Override
+            public void popupMenuWillBecomeInvisible(PopupMenuEvent e) {
+
+            }
+
+            @Override
+            public void popupMenuCanceled(PopupMenuEvent e) {
+
+            }
+        });
+
+        optionsPanel.add(settingsButton);
+        optionsPanel.add(Box.createHorizontalStrut(5));
+        optionsPanel.add(searchField);
+        optionsPanel.add(Box.createHorizontalStrut(5));
+        optionsPanel.add(aiEmpoweredButton);
+
+        footerPanel.setBorder(BorderFactory.createEmptyBorder(2, 3, 5, 3));
+        footerPanel.add(optionsPanel, BorderLayout.CENTER);
+        footerPanel.add(progressBar, BorderLayout.SOUTH);
+
+        add(scrollPane, BorderLayout.CENTER);
+        add(footerPanel, BorderLayout.SOUTH);
+
+        setProgressBar(false);
+    }
+
+    private void setMenuShow(JPopupMenu menu, JButton button) {
+        button.addActionListener(e -> {
+            Point buttonLocation = button.getLocationOnScreen();
+            Dimension menuSize = menu.getPreferredSize();
+            int x = buttonLocation.x + (button.getWidth() - menuSize.width) / 2;
+            int y = buttonLocation.y - menuSize.height;
+            menu.show(button, x - buttonLocation.x, y - buttonLocation.y);
+        });
+    }
+
+    private void setProgressBar(boolean status) {
+        Databoard.setProgressBar(status, progressBar, "AI+ ...");
+    }
+
+    private void addRowToTable(Object[] data) {
+        int rowCount = dataTableModel.getRowCount();
+        int id = rowCount > 0 ? (Integer) dataTableModel.getValueAt(rowCount - 1, 0) + 1 : 1;
+        Object[] rowData = new Object[data.length + 1];
+        rowData[0] = id;
+        System.arraycopy(data, 0, rowData, 1, data.length);
+        dataTableModel.addRow(rowData);
+    }
+
+    private void aiEmpoweredByAlibabaActionPerformed(ActionEvent e, String ruleName, String data) {
+        AIPower aiPower = new AIPower(api, configLoader, "qwen-long", "https://dashscope.aliyuncs.com/compatible-mode/v1", configLoader.getAlibabaAIAPIKey().split("\\|"));
+        aiEmpoweredButtonAction(ruleName, data, aiPower);
+    }
+
+    private void aiEmpoweredByMoonshotActionPerformed(ActionEvent e, String ruleName, String data) {
+        AIPower aiPower = new AIPower(api, configLoader, "moonshot-v1-128k", "https://api.moonshot.cn/v1", configLoader.getMoonshotAIAPIKey().split("\\|"));
+        aiEmpoweredButtonAction(ruleName, data, aiPower);
+    }
+
+    private void aiEmpoweredButtonAction(String ruleName, String data, AIPower aiPower) {
+        progressBar.setVisible(true);
+        aiEmpoweredMenu.setVisible(true);
+        setProgressBar(true);
+
+        SwingWorker<String, Void> worker = new SwingWorker<String, Void>() {
+            @Override
+            protected String doInBackground() throws Exception {
+                return aiPower.chatWithAPI(ruleName, data);
+            }
+
+            @Override
+            protected void done() {
+                setProgressBar(false);
+
+                try {
+                    String chatReturn = get();
+                    if (!chatReturn.isEmpty()) {
+                        Gson gson = new Gson();
+                        Type type = new TypeToken<Map<String, Object>>() {
+                        }.getType();
+                        Map<String, List<String>> map = gson.fromJson(chatReturn, type);
+
+                        dataTableModel.setRowCount(0);
+                        for (String item : map.get("data")) {
+                            if (!item.isEmpty()) {
+                                addRowToTable(new Object[]{item});
+                            }
+                        }
+
+                        JOptionPane.showMessageDialog(Datatable.this, "AI+ has completed the AI empowered work.", "AI+ Info", JOptionPane.INFORMATION_MESSAGE);
+                    } else {
+                        JOptionPane.showMessageDialog(Datatable.this, "AI+ returns null, please check!", "AI+ Info", JOptionPane.WARNING_MESSAGE);
+                    }
+                } catch (Exception ignored) {
+                    JOptionPane.showMessageDialog(Datatable.this, "AI+ returns error, please check!", "AI+ Info", JOptionPane.ERROR_MESSAGE);
+                }
+            }
+        };
+        worker.execute();
+
+        aiEmpoweredMenu.setVisible(false);
+    }
+
+    private void performSearch() {
+        if (searchField.getForeground().equals(Color.BLACK)) {
+            RowFilter<Object, Object> rowFilter = new RowFilter<Object, Object>() {
+                public boolean include(Entry<?, ?> entry) {
+                    String searchFieldTextText = searchField.getText();
+                    Pattern pattern = null;
+                    try {
+                        pattern = Pattern.compile(searchFieldTextText, Pattern.CASE_INSENSITIVE);
+                    } catch (Exception ignored) {
+                    }
+
+                    String entryValue = ((String) entry.getValue(1)).toLowerCase();
+                    searchFieldTextText = searchFieldTextText.toLowerCase();
+                    if (pattern != null) {
+                        return searchFieldTextText.isEmpty() || pattern.matcher(entryValue).find() != searchMode.isSelected();
+                    } else {
+                        return searchFieldTextText.isEmpty() || entryValue.contains(searchFieldTextText) != searchMode.isSelected();
+                    }
+                }
+            };
+            sorter.setRowFilter(rowFilter);
+        }
+    }
+
+    public void setTableListener(MessageTableModel messagePanel) {
+        // 表格复制功能
+        dataTable.setTransferHandler(new TransferHandler() {
+            @Override
+            public void exportToClipboard(JComponent comp, Clipboard clip, int action) throws IllegalStateException {
+                if (comp instanceof JTable) {
+                    StringSelection stringSelection = new StringSelection(getSelectedDataAtTable((JTable) comp).replace("\0", "").replaceAll("[\\p{Cntrl}&&[^\r\n\t]]", ""));
+                    clip.setContents(stringSelection, null);
+                } else {
+                    super.exportToClipboard(comp, clip, action);
+                }
+            }
+        });
+
+        dataTable.setDefaultEditor(Object.class, null);
+
+        // 表格内容双击事件
+        dataTable.addMouseListener(new MouseAdapter() {
+            @Override
+            public void mouseClicked(MouseEvent e) {
+                if (e.getClickCount() == 2) {
+                    int selectedRow = dataTable.getSelectedRow();
+                    if (selectedRow != -1) {
+                        String rowData = dataTable.getValueAt(selectedRow, 1).toString();
+                        messagePanel.applyMessageFilter(tabName, rowData);
+                    }
+                }
+            }
+        });
+    }
+
+    private String getTableData(JTable table) {
+        StringBuilder selectData = new StringBuilder();
+        int rowCount = table.getRowCount();
+        for (int i = 0; i < rowCount; i++) {
+            selectData.append(table.getValueAt(i, 1).toString()).append("\r\n");
+        }
+
+        if (!selectData.isEmpty()) {
+            selectData.delete(selectData.length() - 2, selectData.length());
+        } else {
+            return "";
+        }
+
+        return selectData.toString();
+    }
+
+    public String getSelectedDataAtTable(JTable table) {
+        int[] selectRows = table.getSelectedRows();
+        StringBuilder selectData = new StringBuilder();
+
+        for (int row : selectRows) {
+            selectData.append(table.getValueAt(row, 1).toString()).append("\r\n");
+        }
+
+        if (!selectData.isEmpty()) {
+            selectData.delete(selectData.length() - 2, selectData.length());
+        } else {
+            return "";
+        }
+
+        return selectData.toString();
+    }
+
+
+    public JTable getDataTable() {
+        return this.dataTable;
+    }
+}
+

src/main/java/hae/component/config/Config.java

@@ -2,87 +2,394 @@ package hae.component.config;
 
 import burp.api.montoya.MontoyaApi;
 import hae.component.rule.Rules;
-import hae.utils.config.ConfigLoader;
+import hae.utils.ConfigLoader;
+import hae.utils.UIEnhancer;
 
 import javax.swing.*;
+import javax.swing.border.EmptyBorder;
+import javax.swing.border.TitledBorder;
+import javax.swing.event.DocumentEvent;
+import javax.swing.event.DocumentListener;
+import javax.swing.event.TableModelEvent;
+import javax.swing.event.TableModelListener;
+import javax.swing.table.DefaultTableModel;
 import java.awt.*;
+import java.awt.datatransfer.Clipboard;
+import java.awt.datatransfer.DataFlavor;
 import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.event.KeyAdapter;
+import java.awt.event.KeyEvent;
+import java.util.List;
+import java.util.*;
 
 public class Config extends JPanel {
     private final MontoyaApi api;
     private final ConfigLoader configLoader;
     private final Rules rules;
+    private JTextField addTextField;
+    private final String defaultText = "Enter a new item";
+    private final GridBagConstraints constraints = new GridBagConstraints();
 
     public Config(MontoyaApi api, ConfigLoader configLoader, Rules rules) {
         this.api = api;
         this.configLoader = configLoader;
         this.rules = rules;
 
+        constraints.weightx = 1.0;
+        constraints.fill = GridBagConstraints.HORIZONTAL;
+
         initComponents();
     }
 
     private void initComponents() {
-        setLayout(new GridBagLayout());
-        ((GridBagLayout) getLayout()).columnWidths = new int[] {0, 0, 0, 0, 0};
-        ((GridBagLayout) getLayout()).rowHeights = new int[] {0, 0, 0};
-        ((GridBagLayout) getLayout()).columnWeights = new double[] {0.0, 1.0, 0.0, 0.0, 1.0E-4};
-        ((GridBagLayout) getLayout()).rowWeights = new double[] {0.0, 0.0, 1.0E-4};
+        setLayout(new BorderLayout());
 
-        JLabel rulesFilePathLabel = new JLabel("Rules Path:");
-        JTextField rulesFilePathTextField = new JTextField();
-        JButton onlineUpdateButton = new JButton("Update");
-        JLabel excludeSuffixLabel = new JLabel("Exclude Suffix:");
-        JTextField excludeSuffixTextField = new JTextField();
-        JButton excludeSuffixSaveButton = new JButton("Save");
+        JPanel ruleInfoPanel = new JPanel(new GridBagLayout());
+        ruleInfoPanel.setBorder(new EmptyBorder(10, 15, 5, 15));
+
+        JLabel ruleLabel = new JLabel("Path:");
+        JTextField pathTextField = new JTextField();
+        pathTextField.setEditable(false);
+        pathTextField.setText(configLoader.getRulesFilePath());
         JButton reloadButton = new JButton("Reload");
+        JButton updateButton = new JButton("Update");
+        ruleInfoPanel.add(ruleLabel);
+        ruleInfoPanel.add(pathTextField, constraints);
+        ruleInfoPanel.add(Box.createHorizontalStrut(5));
+        ruleInfoPanel.add(reloadButton);
+        ruleInfoPanel.add(Box.createHorizontalStrut(5));
+        ruleInfoPanel.add(updateButton);
 
-        rulesFilePathTextField.setEditable(false);
-
-        onlineUpdateButton.addActionListener(this::onlineUpdateActionPerformed);
-        excludeSuffixSaveButton.addActionListener(e -> excludeSuffixSaveActionPerformed(e, excludeSuffixTextField.getText()));
         reloadButton.addActionListener(this::reloadActionPerformed);
+        updateButton.addActionListener(this::onlineUpdateActionPerformed);
 
-        rulesFilePathTextField.setText(configLoader.getRulesFilePath());
-        excludeSuffixTextField.setText(configLoader.getExcludeSuffix());
+        constraints.gridx = 1;
+        JTabbedPane configTabbedPanel = new JTabbedPane();
 
-        add(rulesFilePathTextField, new GridBagConstraints(1, 0, 1, 1, 0.0, 0.0,
-                GridBagConstraints.CENTER, GridBagConstraints.BOTH,
-                new Insets(5, 0, 5, 5), 0, 0));
-        add(rulesFilePathLabel, new GridBagConstraints(0, 0, 1, 1, 0.0, 0.0,
-                GridBagConstraints.WEST, GridBagConstraints.VERTICAL,
-                new Insets(5, 5, 5, 5), 0, 0));
-        add(onlineUpdateButton, new GridBagConstraints(2, 0, 1, 1, 0.0, 0.0,
-                GridBagConstraints.CENTER, GridBagConstraints.BOTH,
-                new Insets(5, 0, 5, 5), 0, 0));
-        add(reloadButton, new GridBagConstraints(3, 0, 1, 1, 0.0, 0.0,
-                GridBagConstraints.CENTER, GridBagConstraints.BOTH,
-                new Insets(5, 0, 5, 5), 0, 0));
-        add(excludeSuffixLabel, new GridBagConstraints(0, 1, 1, 1, 0.0, 0.0,
-                GridBagConstraints.SOUTHWEST, GridBagConstraints.NONE,
-                new Insets(0, 5, 5, 5), 0, 0));
-        add(excludeSuffixTextField, new GridBagConstraints(1, 1, 1, 1, 0.0, 0.0,
-                GridBagConstraints.SOUTH, GridBagConstraints.HORIZONTAL,
-                new Insets(0, 0, 0, 5), 0, 0));
-        add(excludeSuffixSaveButton, new GridBagConstraints(2, 1, 1, 1, 0.0, 0.0,
-                GridBagConstraints.SOUTH, GridBagConstraints.HORIZONTAL,
-                new Insets(0, 0, 0, 5), 0, 0));
+        String[] settingMode = new String[]{"Exclude suffix", "Block host"};
+        JPanel settingPanel = createConfigTablePanel(settingMode, "Setting");
+        JPanel scopePanel = getScopePanel();
+        JScrollPane scopeScrollPane = new JScrollPane(scopePanel);
+        scopeScrollPane.setBorder(new TitledBorder("Scope"));
+        settingPanel.add(scopeScrollPane, BorderLayout.NORTH);
+        configTabbedPanel.add("Setting", settingPanel);
+
+        String[] aiMode = new String[]{"Alibaba", "Moonshot"};
+        JPanel aiPanel = createConfigTablePanel(aiMode, "AI+");
+        JTextArea promptTextArea = new JTextArea();
+        promptTextArea.setLineWrap(true);
+        promptTextArea.getDocument().addDocumentListener(new DocumentListener() {
+            @Override
+            public void insertUpdate(DocumentEvent e) {
+                onTextChange();
+            }
+
+            @Override
+            public void removeUpdate(DocumentEvent e) {
+                onTextChange();
+            }
+
+            @Override
+            public void changedUpdate(DocumentEvent e) {
+                onTextChange();
+            }
+
+            private void onTextChange() {
+                String promptText = promptTextArea.getText();
+                configLoader.setAIPrompt(promptText);
+            }
+        });
+        promptTextArea.setText(configLoader.getAIPrompt());
+        JScrollPane promptScrollPane = new JScrollPane(promptTextArea);
+        promptScrollPane.setBorder(new TitledBorder("Prompt"));
+        promptScrollPane.setPreferredSize(new Dimension(0, 100));
+        aiPanel.add(promptScrollPane, BorderLayout.NORTH);
+        configTabbedPanel.add("AI+", aiPanel);
+        add(ruleInfoPanel, BorderLayout.NORTH);
+        add(configTabbedPanel, BorderLayout.CENTER);
+    }
+
+    private JPanel getScopePanel() {
+        JPanel scopePanel = new JPanel();
+        scopePanel.setLayout(new BoxLayout(scopePanel, BoxLayout.X_AXIS));
+
+        String[] scopeInit = hae.Config.scopeOptions.split("\\|");
+        String[] scopeMode = configLoader.getScope().split("\\|");
+        for (String scope : scopeInit) {
+            JCheckBox checkBox = new JCheckBox(scope);
+            scopePanel.add(checkBox);
+            for (String mode : scopeMode) {
+                if (scope.equals(mode)) {
+                    checkBox.setSelected(true);
+                }
+            }
+
+            checkBox.addActionListener(e -> updateScope(checkBox));
+        }
+        return scopePanel;
+    }
+
+    private TableModelListener craeteSettingTableModelListener(JComboBox<String> setTypeComboBox, DefaultTableModel model) {
+        return new TableModelListener() {
+            @Override
+            public void tableChanged(TableModelEvent e) {
+                String selected = (String) setTypeComboBox.getSelectedItem();
+                String values = getFirstColumnDataAsString(model);
+
+                if (selected.equals("Exclude suffix")) {
+                    if (!values.equals(configLoader.getExcludeSuffix()) && !values.isEmpty()) {
+                        configLoader.setExcludeSuffix(values);
+                    }
+                }
+
+                if (selected.equals("Block host")) {
+                    if (!values.equals(configLoader.getBlockHost()) && !values.isEmpty()) {
+                        configLoader.setBlockHost(values);
+                    }
+                }
+            }
+        };
+    }
+
+    private ActionListener createSettingActionListener(JComboBox<String> setTypeComboBox, DefaultTableModel model) {
+        return new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                String selected = (String) setTypeComboBox.getSelectedItem();
+                model.setRowCount(0);
+
+                if (selected.equals("Exclude suffix")) {
+                    addDataToTable(configLoader.getExcludeSuffix().replaceAll("\\|", "\r\n"), model);
+                }
+
+                if (selected.equals("Block host")) {
+                    addDataToTable(configLoader.getBlockHost().replaceAll("\\|", "\r\n"), model);
+                }
+            }
+        };
+    }
+
+    private TableModelListener craeteAITableModelListener(JComboBox<String> setTypeComboBox, DefaultTableModel model) {
+        return new TableModelListener() {
+            @Override
+            public void tableChanged(TableModelEvent e) {
+                String selected = (String) setTypeComboBox.getSelectedItem();
+                String values = getFirstColumnDataAsString(model);
+
+                if (selected.equals("Alibaba")) {
+                    if (!values.equals(configLoader.getAlibabaAIAPIKey()) && !values.isEmpty()) {
+                        configLoader.setAlibabaAIAPIKey(values);
+                    }
+                }
+
+                if (selected.equals("Moonshot")) {
+                    if (!values.equals(configLoader.getMoonshotAIAPIKey()) && !values.isEmpty()) {
+                        configLoader.setMoonshotAIAPIKey(values);
+                    }
+                }
+            }
+        };
+    }
+
+    private ActionListener createAIActionListener(JComboBox<String> setTypeComboBox, DefaultTableModel model) {
+        return new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                String selected = (String) setTypeComboBox.getSelectedItem();
+                model.setRowCount(0);
+
+                if (selected.equals("Alibaba")) {
+                    addDataToTable(configLoader.getAlibabaAIAPIKey().replaceAll("\\|", "\r\n"), model);
+                }
+
+                if (selected.equals("Moonshot")) {
+                    addDataToTable(configLoader.getMoonshotAIAPIKey().replaceAll("\\|", "\r\n"), model);
+                }
+            }
+        };
+    }
+
+    private JPanel createConfigTablePanel(String[] mode, String type) {
+        JPanel settingPanel = new JPanel(new BorderLayout());
+        DefaultTableModel model = new DefaultTableModel();
+
+        JTable table = new JTable(model);
+        model.addColumn("Value");
+        JScrollPane scrollPane = new JScrollPane(table);
+
+        JPanel buttonPanel = new JPanel();
+        buttonPanel.setBorder(new EmptyBorder(0, 3, 0, 0));
+        GridBagLayout layout = new GridBagLayout();
+        layout.rowHeights = new int[]{0, 0, 0, 0, 0, 0, 0};
+        layout.rowWeights = new double[]{0.0, 0.0, 0.0, 0.0, 0.0, 0.0, Double.MIN_VALUE};
+        buttonPanel.setLayout(layout);
+
+        JPanel inputPanel = new JPanel(new BorderLayout());
+        JPanel inputPanelB = new JPanel(new BorderLayout());
+        inputPanelB.setBorder(new EmptyBorder(0, 0, 3, 0));
+
+        JButton addButton = new JButton("Add");
+        JButton removeButton = new JButton("Remove");
+        JButton pasteButton = new JButton("Paste");
+        JButton clearButton = new JButton("Clear");
+
+        JComboBox<String> setTypeComboBox = new JComboBox<>();
+        setTypeComboBox.setModel(new DefaultComboBoxModel<>(mode));
+
+        setTypeComboBox.addActionListener(type.equals("AI+") ? createAIActionListener(setTypeComboBox, model) : createSettingActionListener(setTypeComboBox, model));
+
+        setTypeComboBox.setSelectedItem(mode[0]);
+
+        model.addTableModelListener(type.equals("AI+") ? craeteAITableModelListener(setTypeComboBox, model) : craeteSettingTableModelListener(setTypeComboBox, model));
+
+        constraints.insets = new Insets(0, 0, 3, 0);
+        constraints.gridy = 0;
+        buttonPanel.add(setTypeComboBox, constraints);
+        constraints.gridy = 1;
+        buttonPanel.add(addButton, constraints);
+        constraints.gridy = 2;
+        buttonPanel.add(removeButton, constraints);
+        constraints.gridy = 3;
+        buttonPanel.add(pasteButton, constraints);
+        constraints.gridy = 4;
+        buttonPanel.add(clearButton, constraints);
+
+        addTextField = new JTextField();
+        UIEnhancer.setTextFieldPlaceholder(addTextField, defaultText);
+
+        inputPanelB.add(addTextField, BorderLayout.CENTER);
+        inputPanel.add(scrollPane, BorderLayout.CENTER);
+        inputPanel.add(inputPanelB, BorderLayout.NORTH);
+
+        settingPanel.add(buttonPanel, BorderLayout.EAST);
+        settingPanel.add(inputPanel, BorderLayout.CENTER);
+
+
+        addButton.addActionListener(e -> addActionPerformed(e, model));
+
+        addTextField.addKeyListener(new KeyAdapter() {
+            @Override
+            public void keyPressed(KeyEvent e) {
+                if (e.getKeyCode() == KeyEvent.VK_ENTER) {
+                    addActionPerformed(null, model);
+                }
+            }
+        });
+
+        pasteButton.addActionListener(e -> {
+            Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
+            try {
+                String data = (String) clipboard.getData(DataFlavor.stringFlavor);
+
+                if (data != null && !data.isEmpty()) {
+                    addDataToTable(data, model);
+                }
+            } catch (Exception ignored) {
+            }
+        });
+
+        removeButton.addActionListener(e -> {
+            int selectedRow = table.getSelectedRow();
+            if (selectedRow != -1) {
+                model.removeRow(selectedRow);
+            }
+        });
+
+        clearButton.addActionListener(e -> model.setRowCount(0));
+
+
+        JPanel settingMainPanel = new JPanel(new BorderLayout());
+        settingMainPanel.setBorder(new EmptyBorder(5, 15, 10, 15));
+        JScrollPane settingScroller = new JScrollPane(settingPanel);
+        settingScroller.setBorder(new TitledBorder(type.equals("AI+") ? "API Key" : "Setting"));
+        settingMainPanel.add(settingScroller, BorderLayout.CENTER);
+
+        return settingMainPanel;
+    }
+
+
+    private String getFirstColumnDataAsString(DefaultTableModel model) {
+        StringBuilder firstColumnData = new StringBuilder();
+        int numRows = model.getRowCount();
+
+        for (int row = 0; row < numRows; row++) {
+            firstColumnData.append(model.getValueAt(row, 0));
+            if (row < numRows - 1) {
+                firstColumnData.append("|");
+            }
+        }
+
+        return firstColumnData.toString();
+    }
+
+    private void addDataToTable(String data, DefaultTableModel model) {
+        if (!data.isBlank()) {
+            String[] rows = data.split("\\r?\\n");
+            for (String row : rows) {
+                model.addRow(new String[]{row});
+            }
+            deduplicateTableData(model);
+        }
+    }
+
+    private void deduplicateTableData(DefaultTableModel model) {
+        // 使用 Map 存储每一行的数据，用于去重
+        Set<List<Object>> rowData = new LinkedHashSet<>();
+
+        int columnCount = model.getColumnCount();
+
+        // 将每一行数据作为一个列表，添加到 Set 中
+        for (int i = 0; i < model.getRowCount(); i++) {
+            List<Object> row = new ArrayList<>();
+            for (int j = 0; j < columnCount; j++) {
+                row.add(model.getValueAt(i, j));
+            }
+            rowData.add(row);
+        }
+
+        // 清除原始数据
+        model.setRowCount(0);
+
+        // 将去重后的数据添加回去
+        for (List<Object> uniqueRow : rowData) {
+            model.addRow(uniqueRow.toArray());
+        }
+    }
+
+    public void updateScope(JCheckBox checkBox) {
+        String boxText = checkBox.getText();
+        boolean selected = checkBox.isSelected();
+
+        Set<String> HaEScope = new HashSet<>(Arrays.asList(configLoader.getScope().split("\\|")));
+
+        if (selected) {
+            HaEScope.add(boxText);
+        } else {
+            HaEScope.remove(boxText);
+        }
+
+        configLoader.setScope(String.join("|", HaEScope));
+    }
+
+    private void addActionPerformed(ActionEvent e, DefaultTableModel model) {
+        String addTextFieldText = addTextField.getText();
+        if (!addTextFieldText.equals(defaultText)) {
+            addDataToTable(addTextFieldText, model);
+        }
+        addTextField.setText("");
+        addTextField.requestFocusInWindow();
     }
 
     private void onlineUpdateActionPerformed(ActionEvent e) {
         // 添加提示框防止用户误触导致配置更新
-        int retCode = JOptionPane.showConfirmDialog(null, "Do you want to update rules?", "Info", JOptionPane.YES_NO_OPTION);
+        int retCode = JOptionPane.showConfirmDialog(this, "Do you want to update rules?", "Info", JOptionPane.YES_NO_OPTION);
         if (retCode == JOptionPane.YES_OPTION) {
-            configLoader.initRules();
+            configLoader.initRulesByNet();
             reloadActionPerformed(null);
         }
     }
 
-    private void excludeSuffixSaveActionPerformed(ActionEvent e, String suffix) {
-        if (!suffix.equals(configLoader.getExcludeSuffix()) && !suffix.isEmpty()) {
-            configLoader.setExcludeSuffix(suffix);
-        }
-    }
-
     private void reloadActionPerformed(ActionEvent e) {
         rules.reloadRuleGroup();
     }

src/main/java/hae/component/rule/Rule.java

@@ -1,18 +1,17 @@
 package hae.component.rule;
 
 import burp.api.montoya.MontoyaApi;
+import hae.Config;
+import hae.utils.ConfigLoader;
+import hae.utils.rule.RuleProcessor;
 
 import javax.swing.*;
 import javax.swing.table.DefaultTableModel;
+import javax.swing.table.TableRowSorter;
 import java.awt.*;
 import java.awt.event.ActionEvent;
-import javax.swing.table.TableRowSorter;
 import java.util.Vector;
 
-import hae.Config;
-import hae.utils.config.ConfigLoader;
-import hae.utils.rule.RuleProcessor;
-
 import static javax.swing.JOptionPane.YES_OPTION;
 
 public class Rule extends JPanel {
@@ -32,10 +31,10 @@ public class Rule extends JPanel {
 
     private void initComponents(Object[][] data) {
         setLayout(new GridBagLayout());
-        ((GridBagLayout)getLayout()).columnWidths = new int[] {0, 0, 0};
-        ((GridBagLayout)getLayout()).rowHeights = new int[] {0, 0, 0, 0, 0};
-        ((GridBagLayout)getLayout()).columnWeights = new double[] {0.0, 1.0, 1.0E-4};
-        ((GridBagLayout)getLayout()).rowWeights = new double[] {0.0, 0.0, 0.0, 1.0, 1.0E-4};
+        ((GridBagLayout) getLayout()).columnWidths = new int[]{0, 0, 0};
+        ((GridBagLayout) getLayout()).rowHeights = new int[]{0, 0, 0, 0, 0};
+        ((GridBagLayout) getLayout()).columnWeights = new double[]{0.0, 1.0, 1.0E-4};
+        ((GridBagLayout) getLayout()).rowWeights = new double[]{0.0, 0.0, 0.0, 1.0, 1.0E-4};
 
         JButton addButton = new JButton("Add");
         JButton editButton = new JButton("Edit");
@@ -74,7 +73,7 @@ public class Rule extends JPanel {
 
         model.setDataVector(data, Config.ruleFields);
         model.addTableModelListener(e -> {
-            if (e.getColumn() == 0 && ruleTable.getSelectedRow() != -1){
+            if (e.getColumn() == 0 && ruleTable.getSelectedRow() != -1) {
                 int select = ruleTable.convertRowIndexToModel(ruleTable.getSelectedRow());
                 ruleProcessor.changeRule(model.getDataVector().get(select), select, tabbedPane.getTitleAt(tabbedPane.getSelectedIndex()));
             }
@@ -98,7 +97,7 @@ public class Rule extends JPanel {
         Display ruleDisplay = new Display();
         ruleDisplay.formatTextField.setText("{0}");
 
-        int showState = JOptionPane.showConfirmDialog(null, ruleDisplay, "Add Rule", JOptionPane.OK_OPTION);
+        int showState = JOptionPane.showConfirmDialog(this, ruleDisplay, "Add Rule", JOptionPane.OK_OPTION);
         if (showState == YES_OPTION) {
             Vector<Object> ruleData = new Vector<>();
             ruleData.add(false);
@@ -117,8 +116,8 @@ public class Rule extends JPanel {
         }
     }
 
-    private void ruleEditActionPerformed(ActionEvent e, JTable ruleTable, JTabbedPane tabbedPane){
-        if (ruleTable.getSelectedRowCount() >= 1){
+    private void ruleEditActionPerformed(ActionEvent e, JTable ruleTable, JTabbedPane tabbedPane) {
+        if (ruleTable.getSelectedRowCount() >= 1) {
             DefaultTableModel model = (DefaultTableModel) ruleTable.getModel();
             Display ruleDisplay = new Display();
 
@@ -129,12 +128,12 @@ public class Rule extends JPanel {
             ruleDisplay.colorComboBox.setSelectedItem(ruleTable.getValueAt(ruleTable.getSelectedRow(), 5).toString());
             ruleDisplay.scopeComboBox.setSelectedItem(ruleTable.getValueAt(ruleTable.getSelectedRow(), 6).toString());
             ruleDisplay.engineComboBox.setSelectedItem(ruleTable.getValueAt(ruleTable.getSelectedRow(), 7).toString());
-            ruleDisplay.sensitiveComboBox.setSelectedItem(ruleTable.getValueAt(ruleTable.getSelectedRow(),8));
+            ruleDisplay.sensitiveComboBox.setSelectedItem(ruleTable.getValueAt(ruleTable.getSelectedRow(), 8));
 
             ruleDisplay.formatTextField.setEnabled(ruleDisplay.engineComboBox.getSelectedItem().toString().equals("nfa"));
 
-            int showState = JOptionPane.showConfirmDialog(null, ruleDisplay, "Edit Rule", JOptionPane.OK_OPTION);
-            if (showState == 0){
+            int showState = JOptionPane.showConfirmDialog(this, ruleDisplay, "Edit Rule", JOptionPane.OK_OPTION);
+            if (showState == 0) {
                 int select = ruleTable.convertRowIndexToModel(ruleTable.getSelectedRow());
                 model.setValueAt(ruleDisplay.ruleNameTextField.getText(), select, 1);
                 model.setValueAt(ruleDisplay.firstRegexTextField.getText(), select, 2);
@@ -150,9 +149,9 @@ public class Rule extends JPanel {
         }
     }
 
-    private void ruleRemoveActionPerformed(ActionEvent e, JTable ruleTable, JTabbedPane tabbedPane){
-        if (ruleTable.getSelectedRowCount() >= 1){
-            if (JOptionPane.showConfirmDialog(null, "Are you sure you want to delete this rule?", "Info", JOptionPane.OK_OPTION) == 0){
+    private void ruleRemoveActionPerformed(ActionEvent e, JTable ruleTable, JTabbedPane tabbedPane) {
+        if (ruleTable.getSelectedRowCount() >= 1) {
+            if (JOptionPane.showConfirmDialog(this, "Are you sure you want to remove this rule?", "Info", JOptionPane.YES_NO_OPTION) == 0) {
                 DefaultTableModel model = (DefaultTableModel) ruleTable.getModel();
                 int select = ruleTable.convertRowIndexToModel(ruleTable.getSelectedRow());
 

src/main/java/hae/component/rule/Rules.java

@@ -2,7 +2,7 @@ package hae.component.rule;
 
 import burp.api.montoya.MontoyaApi;
 import hae.Config;
-import hae.utils.config.ConfigLoader;
+import hae.utils.ConfigLoader;
 import hae.utils.rule.RuleProcessor;
 
 import javax.swing.*;
@@ -11,7 +11,7 @@ import java.awt.event.*;
 
 public class Rules extends JTabbedPane {
     private final MontoyaApi api;
-    private final ConfigLoader configLoader;
+    private ConfigLoader configLoader;
     private final RuleProcessor ruleProcessor;
     private final JTextField ruleGroupNameTextField;
 
@@ -101,13 +101,15 @@ public class Rules extends JTabbedPane {
 
     public void reloadRuleGroup() {
         removeAll();
-        Config.globalRules.keySet().forEach(i-> addTab(i, new Rule(api, configLoader, hae.Config.globalRules.get(i), this)));
+
+        this.configLoader = new ConfigLoader(api);
+        Config.globalRules.keySet().forEach(i -> addTab(i, new Rule(api, configLoader, hae.Config.globalRules.get(i), this)));
         addTab("...", null);
     }
 
     private void deleteRuleGroupActionPerformed(ActionEvent e) {
         if (getTabCount() > 2) {
-            int retCode = JOptionPane.showConfirmDialog(null, "Do you want to delete this rule group?", "Info",
+            int retCode = JOptionPane.showConfirmDialog(this, "Do you want to delete this rule group?", "Info",
                     JOptionPane.YES_NO_OPTION);
             if (retCode == JOptionPane.YES_OPTION) {
                 String title = getTitleAt(getSelectedIndex());
@@ -118,7 +120,7 @@ public class Rules extends JTabbedPane {
         }
     }
 
-    private Action renameTitleActionPerformed = new AbstractAction() {
+    private final Action renameTitleActionPerformed = new AbstractAction() {
         @Override
         public void actionPerformed(ActionEvent e) {
             String title = ruleGroupNameTextField.getText();
@@ -134,7 +136,7 @@ public class Rules extends JTabbedPane {
         }
     };
 
-    private Action cancelActionPerformed = new AbstractAction() {
+    private final Action cancelActionPerformed = new AbstractAction() {
         @Override
         public void actionPerformed(ActionEvent e) {
             if (selectedIndex >= 0) {

src/main/java/hae/instances/editor/RequestEditor.java

@@ -1,16 +1,18 @@
 package hae.instances.editor;
 
 import burp.api.montoya.MontoyaApi;
-import burp.api.montoya.ui.editor.extension.EditorCreationContext;
-import burp.api.montoya.ui.editor.extension.ExtensionProvidedHttpRequestEditor;
-import burp.api.montoya.ui.editor.extension.HttpRequestEditorProvider;
 import burp.api.montoya.core.ByteArray;
 import burp.api.montoya.core.Range;
 import burp.api.montoya.http.message.HttpRequestResponse;
 import burp.api.montoya.http.message.requests.HttpRequest;
 import burp.api.montoya.ui.Selection;
-import hae.component.board.Datatable;
+import burp.api.montoya.ui.editor.extension.EditorCreationContext;
+import burp.api.montoya.ui.editor.extension.ExtensionProvidedHttpRequestEditor;
+import burp.api.montoya.ui.editor.extension.HttpRequestEditorProvider;
+import hae.component.board.table.Datatable;
 import hae.instances.http.utils.MessageProcessor;
+import hae.utils.ConfigLoader;
+import hae.utils.string.StringProcessor;
 
 import javax.swing.*;
 import java.awt.*;
@@ -20,27 +22,31 @@ import java.util.Map;
 
 public class RequestEditor implements HttpRequestEditorProvider {
     private final MontoyaApi api;
+    private final ConfigLoader configLoader;
 
-    public RequestEditor(MontoyaApi api) {
+    public RequestEditor(MontoyaApi api, ConfigLoader configLoader) {
         this.api = api;
+        this.configLoader = configLoader;
     }
 
     @Override
     public ExtensionProvidedHttpRequestEditor provideHttpRequestEditor(EditorCreationContext editorCreationContext) {
-        return new Editor(api, editorCreationContext);
+        return new Editor(api, configLoader, editorCreationContext);
     }
 
     private static class Editor implements ExtensionProvidedHttpRequestEditor {
         private final MontoyaApi api;
+        private final ConfigLoader configLoader;
         private final EditorCreationContext creationContext;
         private final MessageProcessor messageProcessor;
         private HttpRequestResponse requestResponse;
+        private List<Map<String, String>> dataList;
 
-        private JTabbedPane jTabbedPane = new JTabbedPane();
+        private final JTabbedPane jTabbedPane = new JTabbedPane();
 
-        public Editor(MontoyaApi api, EditorCreationContext creationContext)
-        {
+        public Editor(MontoyaApi api, ConfigLoader configLoader, EditorCreationContext creationContext) {
             this.api = api;
+            this.configLoader = configLoader;
             this.creationContext = creationContext;
             this.messageProcessor = new MessageProcessor(api);
         }
@@ -53,15 +59,32 @@ public class RequestEditor implements HttpRequestEditorProvider {
         @Override
         public void setRequestResponse(HttpRequestResponse requestResponse) {
             this.requestResponse = requestResponse;
+            generateTabbedPaneFromResultMap(api, configLoader, jTabbedPane, this.dataList);
         }
 
         @Override
         public synchronized boolean isEnabledFor(HttpRequestResponse requestResponse) {
             HttpRequest request = requestResponse.request();
-            if (request != null && !request.bodyToString().equals("Loading...")) {
-                List<Map<String, String>> result = messageProcessor.processRequest("", request, false);
-                jTabbedPane = generateTabbedPaneFromResultMap(api, result);
-                return jTabbedPane.getTabCount() > 0;
+            if (request != null) {
+                try {
+                    String host = StringProcessor.getHostByUrl(request.url());
+                    if (!host.isEmpty()) {
+                        String[] hostList = configLoader.getBlockHost().split("\\|");
+                        boolean isBlockHost = isBlockHost(hostList, host);
+
+                        List<String> suffixList = Arrays.asList(configLoader.getExcludeSuffix().split("\\|"));
+                        String toolType = creationContext.toolSource().toolType().toolName();
+                        boolean isToolScope = configLoader.getScope().contains(toolType);
+
+                        boolean matches = suffixList.contains(request.fileExtension().toLowerCase()) || isBlockHost || !isToolScope;
+
+                        if (!matches && !request.bodyToString().equals("Loading...")) {
+                            this.dataList = messageProcessor.processRequest("", request, false);
+                            return isListHasData(this.dataList);
+                        }
+                    }
+                } catch (Exception ignored) {
+                }
             }
             return false;
         }
@@ -81,7 +104,8 @@ public class RequestEditor implements HttpRequestEditorProvider {
             return new Selection() {
                 @Override
                 public ByteArray contents() {
-                    return ByteArray.byteArray(Datatable.getSelectedData(((Datatable) jTabbedPane.getSelectedComponent()).getDataTable()));
+                    Datatable dataTable = (Datatable) jTabbedPane.getSelectedComponent();
+                    return ByteArray.byteArray(dataTable.getSelectedDataAtTable(dataTable.getDataTable()));
                 }
 
                 @Override
@@ -97,19 +121,38 @@ public class RequestEditor implements HttpRequestEditorProvider {
         }
     }
 
-    public static JTabbedPane generateTabbedPaneFromResultMap(MontoyaApi api, List<Map<String, String>> result) {
-        JTabbedPane tabbedPane = new JTabbedPane();
-        if (result != null && !result.isEmpty() && result.size() > 0) {
+    public static boolean isBlockHost(String[] hostList, String host) {
+        boolean isBlockHost = false;
+        for (String hostName : hostList) {
+            String cleanedHost = StringProcessor.replaceFirstOccurrence(hostName, "*.", "");
+            if (hostName.contains("*.") && StringProcessor.matchFromEnd(host, cleanedHost)) {
+                isBlockHost = true;
+            } else if (host.equals(hostName) || hostName.equals("*")) {
+                isBlockHost = true;
+            }
+        }
+        return isBlockHost;
+    }
+
+    public static boolean isListHasData(List<Map<String, String>> dataList) {
+        if (dataList != null && !dataList.isEmpty()) {
+            Map<String, String> dataMap = dataList.get(0);
+            return dataMap != null && !dataMap.isEmpty();
+        }
+        return false;
+    }
+
+    public static void generateTabbedPaneFromResultMap(MontoyaApi api, ConfigLoader configLoader, JTabbedPane tabbedPane, List<Map<String, String>> result) {
+        tabbedPane.removeAll();
+        if (result != null && !result.isEmpty()) {
             Map<String, String> dataMap = result.get(0);
-            if (dataMap != null && !dataMap.isEmpty() && dataMap.size() > 0) {
-                dataMap.keySet().forEach(i->{
+            if (dataMap != null && !dataMap.isEmpty()) {
+                dataMap.keySet().forEach(i -> {
                     String[] extractData = dataMap.get(i).split("\n");
-                    Datatable dataPanel = new Datatable(api, i, Arrays.asList(extractData));
+                    Datatable dataPanel = new Datatable(api, configLoader, i, Arrays.asList(extractData));
                     tabbedPane.addTab(i, dataPanel);
                 });
             }
         }
-
-        return tabbedPane;
     }
 }

src/main/java/hae/instances/editor/ResponseEditor.java

@@ -1,45 +1,53 @@
 package hae.instances.editor;
 
 import burp.api.montoya.MontoyaApi;
+import burp.api.montoya.core.ByteArray;
+import burp.api.montoya.core.Range;
 import burp.api.montoya.http.message.HttpRequestResponse;
+import burp.api.montoya.http.message.requests.HttpRequest;
 import burp.api.montoya.http.message.responses.HttpResponse;
+import burp.api.montoya.ui.Selection;
 import burp.api.montoya.ui.editor.extension.EditorCreationContext;
 import burp.api.montoya.ui.editor.extension.ExtensionProvidedHttpResponseEditor;
 import burp.api.montoya.ui.editor.extension.HttpResponseEditorProvider;
-import burp.api.montoya.core.ByteArray;
-import burp.api.montoya.core.Range;
-import burp.api.montoya.ui.Selection;
-import hae.component.board.Datatable;
+import hae.component.board.table.Datatable;
 import hae.instances.http.utils.MessageProcessor;
+import hae.utils.ConfigLoader;
+import hae.utils.string.StringProcessor;
 
 import javax.swing.*;
 import java.awt.*;
+import java.util.Arrays;
 import java.util.List;
 import java.util.Map;
 
 public class ResponseEditor implements HttpResponseEditorProvider {
     private final MontoyaApi api;
+    private final ConfigLoader configLoader;
 
-    public ResponseEditor(MontoyaApi api) {
+    public ResponseEditor(MontoyaApi api, ConfigLoader configLoader) {
         this.api = api;
+        this.configLoader = configLoader;
     }
 
     @Override
     public ExtensionProvidedHttpResponseEditor provideHttpResponseEditor(EditorCreationContext editorCreationContext) {
-        return new Editor(api, editorCreationContext);
+        return new Editor(api, configLoader, editorCreationContext);
     }
 
     private static class Editor implements ExtensionProvidedHttpResponseEditor {
         private final MontoyaApi api;
+        private final ConfigLoader configLoader;
         private final EditorCreationContext creationContext;
         private final MessageProcessor messageProcessor;
         private HttpRequestResponse requestResponse;
+        private List<Map<String, String>> dataList;
 
-        private JTabbedPane jTabbedPane = new JTabbedPane();
+        private final JTabbedPane jTabbedPane = new JTabbedPane();
 
-        public Editor(MontoyaApi api, EditorCreationContext creationContext)
-        {
+        public Editor(MontoyaApi api, ConfigLoader configLoader, EditorCreationContext creationContext) {
             this.api = api;
+            this.configLoader = configLoader;
             this.creationContext = creationContext;
             this.messageProcessor = new MessageProcessor(api);
         }
@@ -52,16 +60,40 @@ public class ResponseEditor implements HttpResponseEditorProvider {
         @Override
         public void setRequestResponse(HttpRequestResponse requestResponse) {
             this.requestResponse = requestResponse;
+            RequestEditor.generateTabbedPaneFromResultMap(api, configLoader, jTabbedPane, this.dataList);
         }
 
         @Override
         public synchronized boolean isEnabledFor(HttpRequestResponse requestResponse) {
-            HttpResponse request = requestResponse.response();
-            if (request != null && !request.bodyToString().equals("Loading...")) {
-                List<Map<String, String>> result = messageProcessor.processResponse("", request, false);
-                jTabbedPane = RequestEditor.generateTabbedPaneFromResultMap(api, result);
-                return jTabbedPane.getTabCount() > 0;
+            HttpResponse response = requestResponse.response();
+
+            if (response != null) {
+                HttpRequest request = requestResponse.request();
+                boolean matches = false;
+
+                if (request != null) {
+                    try {
+                        String host = StringProcessor.getHostByUrl(request.url());
+                        if (!host.isEmpty()) {
+                            String[] hostList = configLoader.getBlockHost().split("\\|");
+                            boolean isBlockHost = RequestEditor.isBlockHost(hostList, host);
+
+                            List<String> suffixList = Arrays.asList(configLoader.getExcludeSuffix().split("\\|"));
+                            String toolType = creationContext.toolSource().toolType().toolName();
+                            boolean isToolScope = configLoader.getScope().contains(toolType);
+
+                            matches = suffixList.contains(request.fileExtension().toLowerCase()) || isBlockHost || !isToolScope;
+                        }
+                    } catch (Exception ignored) {
+                    }
+                }
+
+                if (!matches && !response.bodyToString().equals("Loading...")) {
+                    this.dataList = messageProcessor.processResponse("", response, false);
+                    return RequestEditor.isListHasData(this.dataList);
+                }
             }
+
             return false;
         }
 
@@ -80,7 +112,8 @@ public class ResponseEditor implements HttpResponseEditorProvider {
             return new Selection() {
                 @Override
                 public ByteArray contents() {
-                    return ByteArray.byteArray(Datatable.getSelectedData(((Datatable) jTabbedPane.getSelectedComponent()).getDataTable()));
+                    Datatable dataTable = (Datatable) jTabbedPane.getSelectedComponent();
+                    return ByteArray.byteArray(dataTable.getSelectedDataAtTable(dataTable.getDataTable()));
                 }
 
                 @Override

src/main/java/hae/instances/editor/WebSocketEditor.java

@@ -5,9 +5,12 @@ import burp.api.montoya.core.ByteArray;
 import burp.api.montoya.core.Range;
 import burp.api.montoya.ui.Selection;
 import burp.api.montoya.ui.contextmenu.WebSocketMessage;
-import burp.api.montoya.ui.editor.extension.*;
-import hae.component.board.Datatable;
+import burp.api.montoya.ui.editor.extension.EditorCreationContext;
+import burp.api.montoya.ui.editor.extension.ExtensionProvidedWebSocketMessageEditor;
+import burp.api.montoya.ui.editor.extension.WebSocketMessageEditorProvider;
+import hae.component.board.table.Datatable;
 import hae.instances.http.utils.MessageProcessor;
+import hae.utils.ConfigLoader;
 
 import javax.swing.*;
 import java.awt.*;
@@ -16,26 +19,31 @@ import java.util.Map;
 
 public class WebSocketEditor implements WebSocketMessageEditorProvider {
     private final MontoyaApi api;
+    private final ConfigLoader configLoader;
 
-    public WebSocketEditor(MontoyaApi api) {
+    public WebSocketEditor(MontoyaApi api, ConfigLoader configLoader) {
         this.api = api;
+        this.configLoader = configLoader;
     }
 
     @Override
     public ExtensionProvidedWebSocketMessageEditor provideMessageEditor(EditorCreationContext editorCreationContext) {
-        return new Editor(api, editorCreationContext);
+        return new Editor(api, configLoader, editorCreationContext);
     }
 
     private static class Editor implements ExtensionProvidedWebSocketMessageEditor {
         private final MontoyaApi api;
+        private final ConfigLoader configLoader;
         private final EditorCreationContext creationContext;
         private final MessageProcessor messageProcessor;
         private ByteArray message;
+        private List<Map<String, String>> dataList;
 
-        private JTabbedPane jTabbedPane = new JTabbedPane();
+        private final JTabbedPane jTabbedPane = new JTabbedPane();
 
-        public Editor(MontoyaApi api, EditorCreationContext creationContext) {
+        public Editor(MontoyaApi api, ConfigLoader configLoader, EditorCreationContext creationContext) {
             this.api = api;
+            this.configLoader = configLoader;
             this.creationContext = creationContext;
             this.messageProcessor = new MessageProcessor(api);
         }
@@ -48,15 +56,15 @@ public class WebSocketEditor implements WebSocketMessageEditorProvider {
         @Override
         public void setMessage(WebSocketMessage webSocketMessage) {
             this.message = webSocketMessage.payload();
+            RequestEditor.generateTabbedPaneFromResultMap(api, configLoader, jTabbedPane, this.dataList);
         }
 
         @Override
         public boolean isEnabledFor(WebSocketMessage webSocketMessage) {
             String websocketMessage = webSocketMessage.payload().toString();
             if (!websocketMessage.isEmpty()) {
-                List<Map<String, String>> result = messageProcessor.processMessage("", websocketMessage, false);
-                jTabbedPane = RequestEditor.generateTabbedPaneFromResultMap(api, result);
-                return jTabbedPane.getTabCount() > 0;
+                this.dataList = messageProcessor.processMessage("", websocketMessage, false);
+                return RequestEditor.isListHasData(this.dataList);
             }
             return false;
         }
@@ -76,7 +84,8 @@ public class WebSocketEditor implements WebSocketMessageEditorProvider {
             return new Selection() {
                 @Override
                 public ByteArray contents() {
-                    return ByteArray.byteArray(Datatable.getSelectedData(((Datatable) jTabbedPane.getSelectedComponent()).getDataTable()));
+                    Datatable dataTable = (Datatable) jTabbedPane.getSelectedComponent();
+                    return ByteArray.byteArray(dataTable.getSelectedDataAtTable(dataTable.getDataTable()));
                 }
 
                 @Override

src/main/java/hae/instances/http/HttpMessageHandler.java

@@ -6,28 +6,35 @@ import burp.api.montoya.core.HighlightColor;
 import burp.api.montoya.http.handler.*;
 import burp.api.montoya.http.message.HttpRequestResponse;
 import burp.api.montoya.http.message.requests.HttpRequest;
-import hae.Config;
 import hae.component.board.message.MessageTableModel;
+import hae.instances.editor.RequestEditor;
 import hae.instances.http.utils.MessageProcessor;
+import hae.utils.ConfigLoader;
 import hae.utils.string.StringProcessor;
 
-import java.util.*;
+import javax.swing.*;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
 
 public class HttpMessageHandler implements HttpHandler {
     private final MontoyaApi api;
-    private MessageTableModel messageTableModel;
+    private final ConfigLoader configLoader;
+    private final MessageTableModel messageTableModel;
     private final MessageProcessor messageProcessor;
-    private String host;
 
     // Montoya API对HTTP消息的处理分为了请求和响应，因此此处设置高亮和标记需要使用全局变量的方式，以此兼顾请求和响应
     // 同时采用 ThreadLocal 来保证多线程并发的情况下全局变量的安全性
+    private final ThreadLocal<String> host = ThreadLocal.withInitial(() -> "");
     private final ThreadLocal<List<String>> colorList = ThreadLocal.withInitial(ArrayList::new);
     private final ThreadLocal<List<String>> commentList = ThreadLocal.withInitial(ArrayList::new);
     private final ThreadLocal<Boolean> matches = ThreadLocal.withInitial(() -> false);
     private final ThreadLocal<HttpRequest> httpRequest = new ThreadLocal<>();
 
-    public HttpMessageHandler(MontoyaApi api, MessageTableModel messageTableModel) {
+    public HttpMessageHandler(MontoyaApi api, ConfigLoader configLoader, MessageTableModel messageTableModel) {
         this.api = api;
+        this.configLoader = configLoader;
         this.messageTableModel = messageTableModel;
         this.messageProcessor = new MessageProcessor(api);
     }
@@ -39,16 +46,25 @@ public class HttpMessageHandler implements HttpHandler {
 
         Annotations annotations = httpRequestToBeSent.annotations();
 
-        httpRequest.set(httpRequestToBeSent);
+        try {
+            httpRequest.set(httpRequestToBeSent);
+            host.set(StringProcessor.getHostByUrl(httpRequestToBeSent.url()));
 
-        host = StringProcessor.getHostByUrl(httpRequestToBeSent.url());
+            String[] hostList = configLoader.getBlockHost().split("\\|");
+            boolean isBlockHost = RequestEditor.isBlockHost(hostList, host.get());
 
-        List<String> suffixList = Arrays.asList(Config.suffix.split("\\|"));
-        matches.set(suffixList.contains(httpRequestToBeSent.fileExtension()));
+            String toolType = httpRequestToBeSent.toolSource().toolType().toolName();
+            boolean isToolScope = configLoader.getScope().contains(toolType);
 
-        if (!matches.get()) {
-            List<Map<String, String>> result = messageProcessor.processRequest(host, httpRequestToBeSent, true);
-            setColorAndCommentList(result);
+            List<String> suffixList = Arrays.asList(configLoader.getExcludeSuffix().split("\\|"));
+            matches.set(suffixList.contains(httpRequestToBeSent.fileExtension().toLowerCase()) || isBlockHost || !isToolScope);
+
+            if (!matches.get()) {
+                List<Map<String, String>> result = messageProcessor.processRequest(host.get(), httpRequestToBeSent, true);
+                setColorAndCommentList(result);
+            }
+        } catch (Exception e) {
+            api.logging().logToError("handleHttpRequestToBeSent: " + e.getMessage());
         }
 
         return RequestToBeSentAction.continueWith(httpRequestToBeSent, annotations);
@@ -59,7 +75,7 @@ public class HttpMessageHandler implements HttpHandler {
         Annotations annotations = httpResponseReceived.annotations();
 
         if (!matches.get()) {
-            List<Map<String, String>> result = messageProcessor.processResponse(host, httpResponseReceived, true);
+            List<Map<String, String>> result = messageProcessor.processResponse(host.get(), httpResponseReceived, true);
             setColorAndCommentList(result);
             // 设置高亮颜色和注释
             if (!colorList.get().isEmpty() && !commentList.get().isEmpty()) {
@@ -71,7 +87,19 @@ public class HttpMessageHandler implements HttpHandler {
                 HttpRequestResponse httpRequestResponse = HttpRequestResponse.httpRequestResponse(httpRequest.get(), httpResponseReceived);
 
                 // 添加到Databoard
-                messageTableModel.add(httpRequestResponse, comment, color);
+                String method = httpRequest.get().method();
+                String url = httpRequest.get().url();
+                String status = String.valueOf(httpResponseReceived.statusCode());
+                String length = String.valueOf(httpResponseReceived.toByteArray().length());
+
+                // 后台提交，防止线程阻塞
+                new SwingWorker<Void, Void>() {
+                    @Override
+                    protected Void doInBackground() {
+                        messageTableModel.add(httpRequestResponse, url, method, status, length, comment, color, "", "");
+                        return null;
+                    }
+                }.run();
             }
         }
 
@@ -79,7 +107,7 @@ public class HttpMessageHandler implements HttpHandler {
     }
 
     private void setColorAndCommentList(List<Map<String, String>> result) {
-        if (result != null && !result.isEmpty() && result.size() > 0) {
+        if (result != null && !result.isEmpty()) {
             colorList.get().add(result.get(0).get("color"));
             commentList.get().add(result.get(1).get("comment"));
         }

src/main/java/hae/instances/http/utils/MessageProcessor.java

@@ -24,6 +24,7 @@ public class MessageProcessor {
 
     public List<Map<String, String>> processMessage(String host, String message, boolean flag) {
         Map<String, Map<String, Object>> obj = null;
+
         try {
             obj = regularMatcher.match(host, "any", message, message, message);
         } catch (Exception ignored) {
@@ -34,6 +35,7 @@ public class MessageProcessor {
 
     public List<Map<String, String>> processResponse(String host, HttpResponse httpResponse, boolean flag) {
         Map<String, Map<String, Object>> obj = null;
+
         try {
             String response = new String(httpResponse.toByteArray().getBytes(), StandardCharsets.UTF_8);
             String body = new String(httpResponse.body().getBytes(), StandardCharsets.UTF_8);
@@ -57,6 +59,7 @@ public class MessageProcessor {
             String header = httpRequest.headers().stream()
                     .map(HttpHeader::toString)
                     .collect(Collectors.joining("\n"));
+
             obj = regularMatcher.match(host, "request", request, header, body);
         } catch (Exception ignored) {
         }
@@ -68,7 +71,7 @@ public class MessageProcessor {
         List<Map<String, String>> highlightList = new ArrayList<>();
         List<Map<String, String>> extractList = new ArrayList<>();
 
-        if (obj != null && !obj.isEmpty() && obj.size() > 0) {
+        if (obj != null && !obj.isEmpty()) {
             if (actionFlag) {
                 List<List<String>> resultList = extractColorsAndComments(obj);
                 List<String> colorList = resultList.get(0);
@@ -99,6 +102,7 @@ public class MessageProcessor {
             String data = tempMap.get("data").toString();
             extractedData.put(key, data);
         });
+
         return extractedData;
     }
 
@@ -114,10 +118,11 @@ public class MessageProcessor {
         List<List<String>> result = new ArrayList<>();
         result.add(colorList);
         result.add(commentList);
+
         return result;
     }
 
-    public List<Integer> retrieveColorIndices(List<String> colors){
+    public List<Integer> retrieveColorIndices(List<String> colors) {
         List<Integer> indices = new ArrayList<>();
         String[] colorArray = Config.color;
         int size = colorArray.length;
@@ -129,6 +134,7 @@ public class MessageProcessor {
                 }
             }
         }
+
         return indices;
     }
 
@@ -154,7 +160,7 @@ public class MessageProcessor {
         HashSet tmpList = new HashSet(stack);
         if (stack.size() == tmpList.size()) {
             stack.sort(Comparator.comparingInt(Integer::intValue));
-            if(stack.get(0) < 0) {
+            if (stack.get(0) < 0) {
                 finalColor = colorArray[0];
             } else {
                 finalColor = colorArray[stack.get(0)];

src/main/java/hae/instances/http/utils/RegularMatcher.java

@@ -9,12 +9,12 @@ import hae.Config;
 import hae.cache.CachePool;
 import hae.utils.string.HashCalculator;
 import hae.utils.string.StringProcessor;
-import jregex.Matcher;
-import jregex.Pattern;
 
 import java.text.MessageFormat;
 import java.util.*;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 
 public class RegularMatcher {
     private final MontoyaApi api;
@@ -27,7 +27,7 @@ public class RegularMatcher {
     public Map<String, Map<String, Object>> match(String host, String type, String message, String header, String body) {
         // 先从缓存池里判断是否有已经匹配好的结果
         String messageIndex = HashCalculator.calculateHash(message.getBytes());
-        Map<String, Map<String, Object>> map = CachePool.getFromCache(messageIndex);
+        Map<String, Map<String, Object>> map = CachePool.get(messageIndex);
         if (map != null) {
             return map;
         } else {
@@ -69,6 +69,10 @@ public class RegularMatcher {
                             case "response body":
                                 matchContent = body;
                                 break;
+                            case "request line":
+                            case "response line":
+                                matchContent = message.split("\\r?\\n", 2)[0];
+                                break;
                             default:
                                 break;
                         }
@@ -77,6 +81,7 @@ public class RegularMatcher {
                             result.addAll(matchByRegex(f_regex, s_regex, matchContent, format, engine, sensitive));
                         } catch (Exception e) {
                             api.logging().logToError(String.format("[x] Error Info:\nName: %s\nRegex: %s", name, f_regex));
+                            api.logging().logToError(e.getMessage());
                             continue;
                         }
 
@@ -85,61 +90,56 @@ public class RegularMatcher {
                         result.clear();
                         result.addAll(tmpList);
 
-                        String nameAndSize = String.format("%s (%s)", name, result.size());
                         if (!result.isEmpty()) {
                             tmpMap.put("color", color);
                             String dataStr = String.join("\n", result);
                             tmpMap.put("data", dataStr);
+
+                            String nameAndSize = String.format("%s (%s)", name, result.size());
                             finalMap.put(nameAndSize, tmpMap);
-                            // 添加到全局变量中，便于Databoard检索
-                            if (!Objects.equals(host, "") && host != null) {
-                                List<String> dataList = Arrays.asList(dataStr.split("\n"));
-                                if (Config.globalDataMap.containsKey(host)) {
-                                    ConcurrentHashMap<String, List<String>> gRuleMap = new ConcurrentHashMap<>(Config.globalDataMap.get(host));
-                                    if (gRuleMap.containsKey(name)) {
-                                        // gDataList为不可变列表，因此需要重新创建一个列表以便于使用addAll方法
-                                        List<String> gDataList = gRuleMap.get(name);
-                                        List<String> newDataList = new ArrayList<>(gDataList);
-                                        newDataList.addAll(dataList);
-                                        newDataList = new ArrayList<>(new HashSet<>(newDataList));
-                                        gRuleMap.remove(name);
-                                        gRuleMap.put(name, newDataList);
-                                    } else {
-                                        gRuleMap.put(name, dataList);
-                                    }
-                                    Config.globalDataMap.remove(host);
-                                    Config.globalDataMap.put(host, gRuleMap);
-                                } else {
-                                    Map<String, List<String>> ruleMap = new HashMap<>();
-                                    ruleMap.put(name, dataList);
-                                    // 添加单一Host
-                                    Config.globalDataMap.put(host, ruleMap);
-                                }
 
-                                String[] splitHost = host.split("\\.");
-                                String onlyHost = host.split(":")[0];
-
-                                String anyHost = (splitHost.length > 2 && !onlyHost.matches("\\b(?:\\d{1,3}\\.){3}\\d{1,3}\\b")) ? StringProcessor.replaceFirstOccurrence(onlyHost, splitHost[0], "*") : "";
-
-                                if (!Config.globalDataMap.containsKey(anyHost) && anyHost.length() > 0) {
-                                    // 添加通配符Host，实际数据从查询哪里将所有数据提取
-                                    Config.globalDataMap.put(anyHost, new HashMap<>());
-                                }
-
-                                if (!Config.globalDataMap.containsKey("*")) {
-                                    // 添加通配符全匹配，同上
-                                    Config.globalDataMap.put("*", new HashMap<>());
-                                }
-                            }
+                            putDataToGlobalMap(host, name, result);
                         }
                     }
                 }
             });
-            CachePool.addToCache(messageIndex, finalMap);
+            CachePool.put(messageIndex, finalMap);
             return finalMap;
         }
     }
 
+    public static void putDataToGlobalMap(String host, String name, List<String> dataList) {
+        // 添加到全局变量中，便于Databoard检索
+        if (!Objects.equals(host, "") && host != null) {
+            Config.globalDataMap.compute(host, (existingHost, existingMap) -> {
+                Map<String, List<String>> gRuleMap = Optional.ofNullable(existingMap).orElse(new ConcurrentHashMap<>());
+
+                gRuleMap.merge(name, new ArrayList<>(dataList), (existingList, newList) -> {
+                    Set<String> combinedSet = new LinkedHashSet<>(existingList);
+                    combinedSet.addAll(newList);
+                    return new ArrayList<>(combinedSet);
+                });
+
+                return gRuleMap;
+            });
+
+            String[] splitHost = host.split("\\.");
+            String onlyHost = host.split(":")[0];
+
+            String anyHost = (splitHost.length > 2 && !StringProcessor.matchHostIsIp(onlyHost)) ? StringProcessor.replaceFirstOccurrence(onlyHost, splitHost[0], "*") : "";
+
+            if (!Config.globalDataMap.containsKey(anyHost) && anyHost.length() > 0) {
+                // 添加通配符Host，实际数据从查询哪里将所有数据提取
+                Config.globalDataMap.put(anyHost, new HashMap<>());
+            }
+
+            if (!Config.globalDataMap.containsKey("*")) {
+                // 添加通配符全匹配，同上
+                Config.globalDataMap.put("*", new HashMap<>());
+            }
+        }
+    }
+
     private List<String> matchByRegex(String f_regex, String s_regex, String content, String format, String engine, boolean sensitive) {
         List<String> retList = new ArrayList<>();
         if ("nfa".equals(engine)) {
@@ -198,8 +198,8 @@ public class RegularMatcher {
         while (matcher.find()) {
             if (!matcher.group(1).isEmpty()) {
                 Object[] params = indexList.stream().map(i -> {
-                    if (!matcher.group(i+1).isEmpty()) {
-                        return matcher.group(i+1);
+                    if (!matcher.group(i + 1).isEmpty()) {
+                        return matcher.group(i + 1);
                     }
                     return "";
                 }).toArray();
@@ -225,7 +225,7 @@ public class RegularMatcher {
     }
 
     private Matcher createPatternMatcher(String regex, String content, boolean sensitive) {
-        Pattern pattern = (sensitive) ? new Pattern(regex) : new Pattern(regex, Pattern.IGNORE_CASE);
+        Pattern pattern = sensitive ? Pattern.compile(regex) : Pattern.compile(regex, Pattern.CASE_INSENSITIVE);
         return pattern.matcher(content);
     }
 
@@ -238,7 +238,7 @@ public class RegularMatcher {
 
     private LinkedList<Integer> parseIndexesFromString(String input) {
         LinkedList<Integer> indexes = new LinkedList<>();
-        Pattern pattern = new Pattern("\\{(\\d+)}");
+        Pattern pattern = Pattern.compile("\\{(\\d+)}");
         Matcher matcher = pattern.matcher(input);
 
         while (matcher.find()) {
@@ -260,7 +260,7 @@ public class RegularMatcher {
     }
 
     private String reorderIndex(String format) {
-        Pattern pattern = new Pattern("\\{(\\d+)}");
+        Pattern pattern = Pattern.compile("\\{(\\d+)}");
         Matcher matcher = pattern.matcher(format);
         int count = 0;
         while (matcher.find()) {

src/main/java/hae/utils/ConfigLoader.java

@@ -1,16 +1,7 @@
-package hae.utils.config;
-
-import java.io.*;
-import java.nio.charset.StandardCharsets;
-import java.nio.file.Files;
-import java.nio.file.Paths;
-import java.util.HashMap;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.ArrayList;
+package hae.utils;
 
 import burp.api.montoya.MontoyaApi;
+import burp.api.montoya.http.RequestOptions;
 import burp.api.montoya.http.message.HttpRequestResponse;
 import burp.api.montoya.http.message.requests.HttpRequest;
 import hae.Config;
@@ -18,6 +9,13 @@ import org.yaml.snakeyaml.DumperOptions;
 import org.yaml.snakeyaml.Yaml;
 import org.yaml.snakeyaml.representer.Representer;
 
+import java.io.*;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.*;
+
 public class ConfigLoader {
     private final MontoyaApi api;
     private final Yaml yaml;
@@ -32,7 +30,7 @@ public class ConfigLoader {
         this.yaml = new Yaml(representer, dop);
 
         String configPath = determineConfigPath();
-        this.configFilePath =  String.format("%s/%s", configPath, "Config.yml");
+        this.configFilePath = String.format("%s/%s", configPath, "Config.yml");
         this.rulesFilePath = String.format("%s/%s", configPath, "Rules.yml");
 
         // 构造函数，初始化配置
@@ -48,7 +46,7 @@ public class ConfigLoader {
 
         File rulesFilePath = new File(this.rulesFilePath);
         if (!(rulesFilePath.exists() && rulesFilePath.isFile())) {
-            initRules();
+            initRulesByRes();
         }
 
         Config.globalRules = getRules();
@@ -80,6 +78,7 @@ public class ConfigLoader {
     public void initConfig() {
         Map<String, Object> r = new LinkedHashMap<>();
         r.put("excludeSuffix", getExcludeSuffix());
+        r.put("blockHost", getBlockHost());
         try {
             Writer ws = new OutputStreamWriter(Files.newOutputStream(Paths.get(configFilePath)), StandardCharsets.UTF_8);
             yaml.dump(r, ws);
@@ -92,24 +91,6 @@ public class ConfigLoader {
         return rulesFilePath;
     }
 
-    public String getExcludeSuffix() {
-        File yamlSetting = new File(configFilePath);
-        if (!yamlSetting.exists() || !yamlSetting.isFile()) {
-            return Config.suffix;
-        }
-
-        try (InputStream inorder = Files.newInputStream(Paths.get(configFilePath))) {
-            Map<String, Object> r = new Yaml().load(inorder);
-
-            if (r.containsKey("excludeSuffix")) {
-                return r.get("excludeSuffix").toString();
-            }
-        }catch (Exception ignored) {
-        }
-
-        return Config.suffix;
-    }
-
     // 获取规则配置
     public Map<String, Object[][]> getRules() {
         Map<String, Object[][]> rules = new HashMap<>();
@@ -147,24 +128,130 @@ public class ConfigLoader {
             }
 
             return rules;
-        } catch (Exception ignored){
+        } catch (Exception ignored) {
         }
 
         return rules;
     }
 
+    public String getAlibabaAIAPIKey() {
+        return getValueFromConfig("AlibabaAIAPIKey", "");
+    }
+
+    public String getMoonshotAIAPIKey() {
+        return getValueFromConfig("MoonshotAIAPIKey", "");
+    }
+
+    public String getAIPrompt() {
+        return getValueFromConfig("AIPrompt", Config.prompt);
+    }
+
+    public String getBlockHost() {
+        return getValueFromConfig("blockHost", Config.host);
+    }
+
+    public String getExcludeSuffix() {
+        return getValueFromConfig("excludeSuffix", Config.suffix);
+    }
+
+    public String getScope() {
+        return getValueFromConfig("HaEScope", Config.scopeOptions);
+    }
+
+    private String getValueFromConfig(String name, String value) {
+        File yamlSetting = new File(configFilePath);
+        if (!yamlSetting.exists() || !yamlSetting.isFile()) {
+            return value;
+        }
+
+        try (InputStream inorder = Files.newInputStream(Paths.get(configFilePath))) {
+            Map<String, Object> r = new Yaml().load(inorder);
+
+            if (r.containsKey(name)) {
+                return r.get(name).toString();
+            }
+        } catch (Exception ignored) {
+        }
+
+        return value;
+    }
+
+    public void setAlibabaAIAPIKey(String apiKey) {
+        setValueToConfig("AlibabaAIAPIKey", apiKey);
+    }
+
+    public void setMoonshotAIAPIKey(String apiKey) {
+        setValueToConfig("MoonshotAIAPIKey", apiKey);
+    }
+
+    public void setAIPrompt(String prompt) {
+        setValueToConfig("AIPrompt", prompt);
+    }
+
     public void setExcludeSuffix(String excludeSuffix) {
-        Map<String,Object> r = new LinkedHashMap<>();
-        r.put("excludeSuffix", excludeSuffix);
-        try{
-            Writer ws = new OutputStreamWriter(Files.newOutputStream(Paths.get(configFilePath)), StandardCharsets.UTF_8);
-            yaml.dump(r, ws);
-            ws.close();
+        setValueToConfig("excludeSuffix", excludeSuffix);
+    }
+
+    public void setBlockHost(String blockHost) {
+        setValueToConfig("blockHost", blockHost);
+    }
+
+    public void setScope(String scope) {
+        setValueToConfig("HaEScope", scope);
+    }
+
+    private void setValueToConfig(String name, String value) {
+        Map<String, Object> currentConfig = loadCurrentConfig();
+        currentConfig.put(name, value);
+
+        try (Writer ws = new OutputStreamWriter(Files.newOutputStream(Paths.get(configFilePath)), StandardCharsets.UTF_8)) {
+            yaml.dump(currentConfig, ws);
         } catch (Exception ignored) {
         }
     }
 
-    public void initRules() {
+    private Map<String, Object> loadCurrentConfig() {
+        Path path = Paths.get(configFilePath);
+        if (!Files.exists(path)) {
+            return new LinkedHashMap<>(); // 返回空的Map，表示没有当前配置
+        }
+
+        try (InputStream in = Files.newInputStream(path)) {
+            return yaml.load(in);
+        } catch (Exception e) {
+            return new LinkedHashMap<>(); // 读取失败时也返回空的Map
+        }
+    }
+
+    public void initRulesByRes() {
+        boolean isCopySuccess = copyRulesToFile(this.rulesFilePath);
+        if (!isCopySuccess) {
+            api.extension().unload();
+        }
+    }
+
+    private boolean copyRulesToFile(String targetFilePath) {
+        InputStream inputStream = getClass().getClassLoader().getResourceAsStream("rules/Rules.yml");
+        File targetFile = new File(targetFilePath);
+
+        try (inputStream; OutputStream outputStream = new FileOutputStream(targetFile)) {
+            if (inputStream != null) {
+                byte[] buffer = new byte[1024];
+                int length;
+
+                while ((length = inputStream.read(buffer)) > 0) {
+                    outputStream.write(buffer, 0, length);
+                }
+
+                return true;
+            }
+        } catch (Exception ignored) {
+        }
+
+        return false;
+    }
+
+    public void initRulesByNet() {
         Thread t = new Thread() {
             public void run() {
                 pullRules();
@@ -181,7 +268,7 @@ public class ConfigLoader {
         try {
             String url = "https://raw.githubusercontent.com/gh0stkey/HaE/gh-pages/Rules.yml";
             HttpRequest httpRequest = HttpRequest.httpRequestFromUrl(url);
-            HttpRequestResponse requestResponse = api.http().sendRequest(httpRequest);
+            HttpRequestResponse requestResponse = api.http().sendRequest(httpRequest, RequestOptions.requestOptions().withUpstreamTLSVerification());
             String responseBody = requestResponse.response().bodyToString();
             if (responseBody.contains("rules")) {
                 FileOutputStream fileOutputStream = new FileOutputStream(rulesFilePath);

src/main/java/hae/utils/UIEnhancer.java

@@ -0,0 +1,30 @@
+package hae.utils;
+
+import javax.swing.*;
+import java.awt.*;
+import java.awt.event.FocusEvent;
+import java.awt.event.FocusListener;
+
+public class UIEnhancer {
+    public static void setTextFieldPlaceholder(JTextField textField, String placeholderText) {
+        textField.setForeground(Color.GRAY);
+        textField.setText(placeholderText);
+        textField.addFocusListener(new FocusListener() {
+            @Override
+            public void focusGained(FocusEvent e) {
+                if (textField.getText().equals(placeholderText)) {
+                    textField.setText("");
+                    textField.setForeground(Color.BLACK);
+                }
+            }
+
+            @Override
+            public void focusLost(FocusEvent e) {
+                if (textField.getText().isEmpty()) {
+                    textField.setForeground(Color.GRAY);
+                    textField.setText(placeholderText);
+                }
+            }
+        });
+    }
+}

src/main/java/hae/utils/http/HttpUtils.java

@@ -0,0 +1,42 @@
+package hae.utils.http;
+
+import burp.api.montoya.MontoyaApi;
+import burp.api.montoya.http.HttpService;
+import burp.api.montoya.http.message.requests.HttpRequest;
+import burp.api.montoya.http.message.requests.HttpTransformation;
+import burp.api.montoya.utilities.RandomUtils;
+
+public class HttpUtils {
+    private final MontoyaApi api;
+
+    public HttpUtils(MontoyaApi api) {
+        this.api = api;
+    }
+
+    public HttpRequest generateRequestByMultipartUploadMethod(String url, String name, String filename, String content) {
+        HttpRequest baseRequest = HttpRequest.httpRequestFromUrl(url).withTransformationApplied(HttpTransformation.TOGGLE_METHOD);
+
+        String boundary = api.utilities().randomUtils().randomString(32, RandomUtils.CharacterSet.ASCII_LETTERS);
+
+        StringBuilder newBody = new StringBuilder();
+        newBody.append(String.format("--%s\r\nContent-Disposition: form-data; name=\"%s\"; filename=\"%s\"\r\n\r\n%s\r\n", boundary, name, filename, content));
+        newBody.append(String.format("--%s\r\nContent-Disposition: form-data; name=\"%s\"\r\n\r\n%s\r\n", boundary, "purpose", "file-extract"));
+        newBody.append("--").append(boundary).append("--\r\n");
+
+        baseRequest = baseRequest.withUpdatedHeader("Content-Type", "multipart/form-data; boundary=" + boundary).withBody(newBody.toString());
+
+        return baseRequest;
+    }
+
+    public HttpRequest generateRequestByJsonMethod(String url, String data) {
+        HttpRequest baseRequest = HttpRequest.httpRequestFromUrl(url).withTransformationApplied(HttpTransformation.TOGGLE_METHOD);
+        HttpService baseService = baseRequest.httpService();
+        String requestString = baseRequest.toString().replace("application/x-www-form-urlencoded", "application/json");
+        baseRequest = HttpRequest.httpRequest(baseService, requestString).withBody(data);
+        return baseRequest;
+    }
+
+    public HttpRequest generateRequestByDeleteMethod(String url) {
+        return HttpRequest.httpRequestFromUrl(url).withMethod("DELETE");
+    }
+}

src/main/java/hae/utils/project/FileProcessor.java

@@ -0,0 +1,47 @@
+package hae.utils.project;
+
+import java.io.File;
+import java.nio.file.DirectoryStream;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Comparator;
+
+public class FileProcessor {
+    public static void deleteDirectoryWithContents(Path pathToBeDeleted) {
+        if (pathToBeDeleted != null) {
+            try {
+                Files.walk(pathToBeDeleted)
+                        .sorted(Comparator.reverseOrder())
+                        .map(Path::toFile)
+                        .forEach(File::delete);
+            } catch (Exception ignored) {
+            }
+        }
+    }
+
+    public static byte[] readFileContent(String basePath, String fileName) {
+        Path filePath = Paths.get(basePath, fileName);
+        Path path = Paths.get(basePath);
+        try {
+            byte[] fileContent = Files.readAllBytes(filePath);
+
+            Files.deleteIfExists(filePath);
+
+            boolean isEmpty = isDirectoryEmpty(path);
+            if (isEmpty) {
+                Files.deleteIfExists(path);
+            }
+
+            return fileContent;
+        } catch (Exception e) {
+            return new byte[0];
+        }
+    }
+
+    private static boolean isDirectoryEmpty(Path directory) throws Exception {
+        try (DirectoryStream<Path> dirStream = Files.newDirectoryStream(directory)) {
+            return !dirStream.iterator().hasNext();
+        }
+    }
+}

src/main/java/hae/utils/project/ProjectProcessor.java

@@ -0,0 +1,187 @@
+package hae.utils.project;
+
+import burp.api.montoya.MontoyaApi;
+import hae.utils.project.model.HaeFileContent;
+import org.yaml.snakeyaml.LoaderOptions;
+import org.yaml.snakeyaml.Yaml;
+
+import java.io.*;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
+import java.util.*;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipFile;
+import java.util.zip.ZipOutputStream;
+
+public class ProjectProcessor {
+    private final MontoyaApi api;
+
+    public ProjectProcessor(MontoyaApi api) {
+        this.api = api;
+    }
+
+    public boolean createHaeFile(String haeFilePath, String host, Map<String, List<String>> dataMap, Map<String, Map<String, Object>> urlMap, Map<String, Map<String, Object>> httpMap) {
+        ExecutorService executor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors() * 2);
+
+        List<Callable<Void>> tasks = new ArrayList<>();
+
+        ByteArrayOutputStream dataYamlStream = new ByteArrayOutputStream();
+        ByteArrayOutputStream urlYamlStream = new ByteArrayOutputStream();
+        Yaml yaml = new Yaml();
+
+        yaml.dump(dataMap, new OutputStreamWriter(dataYamlStream, StandardCharsets.UTF_8));
+        yaml.dump(urlMap, new OutputStreamWriter(urlYamlStream, StandardCharsets.UTF_8));
+
+        try (ZipOutputStream zipOut = new ZipOutputStream(new FileOutputStream(haeFilePath))) {
+            zipOut.putNextEntry(new ZipEntry("info"));
+            zipOut.write(host.getBytes(StandardCharsets.UTF_8));
+            zipOut.closeEntry();
+
+            zipOut.putNextEntry(new ZipEntry("data"));
+            zipOut.write(dataYamlStream.toByteArray());
+            zipOut.closeEntry();
+
+            zipOut.putNextEntry(new ZipEntry("url"));
+            zipOut.write(urlYamlStream.toByteArray());
+            zipOut.closeEntry();
+
+            for (String httpHash : httpMap.keySet()) {
+                Map<String, Object> httpItem = httpMap.get(httpHash);
+                tasks.add(() -> {
+                    try {
+                        ByteArrayOutputStream httpOutStream = new ByteArrayOutputStream();
+                        byte[] request = (byte[]) httpItem.get("request");
+                        byte[] response = (byte[]) httpItem.get("response");
+
+                        httpOutStream.write(response);
+                        httpOutStream.write(request);
+
+                        synchronized (zipOut) {
+                            zipOut.putNextEntry(new ZipEntry(String.format("http/%s", httpHash)));
+                            zipOut.write(httpOutStream.toByteArray());
+                            zipOut.closeEntry();
+                        }
+                    } catch (Exception e) {
+                        api.logging().logToError("createHaeFile: " + e.getMessage());
+                    }
+
+                    return null;
+                });
+            }
+
+            executor.invokeAll(tasks);
+        } catch (Exception e) {
+            api.logging().logToError("createHaeFile: " + e.getMessage());
+            return false;
+        } finally {
+            executor.shutdown();
+        }
+
+        return true;
+    }
+
+    public HaeFileContent readHaeFile(String haeFilePath) {
+        ExecutorService executor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors() * 2);
+        List<Callable<Void>> tasks = new ArrayList<>();
+
+        HaeFileContent haeFileContent = new HaeFileContent(api);
+        LoaderOptions loaderOptions = new LoaderOptions();
+        loaderOptions.setMaxAliasesForCollections(Integer.MAX_VALUE);
+        loaderOptions.setCodePointLimit(Integer.MAX_VALUE);
+        Yaml yaml = new Yaml(loaderOptions);
+        Path tempDirectory = null;
+
+        try {
+            if (hasValidStructure(haeFilePath)) {
+                tempDirectory = Files.createTempDirectory("hae");
+                haeFileContent.setHttpPath(tempDirectory.toString());
+
+                try (ZipFile zipFile = new ZipFile(haeFilePath)) {
+                    Enumeration<? extends ZipEntry> entries = zipFile.entries();
+                    while (entries.hasMoreElements()) {
+                        ZipEntry entry = entries.nextElement();
+                        String fileName = entry.getName();
+                        if (fileName.startsWith("http/")) {
+                            Path filePath = tempDirectory.resolve(fileName.substring("http/".length()));
+
+                            tasks.add(() -> {
+                                try (InputStream in = zipFile.getInputStream(entry)) {
+                                    Files.copy(in, filePath, StandardCopyOption.REPLACE_EXISTING);
+                                } catch (IOException e) {
+                                    api.logging().logToError("readHaeFile: " + e.getMessage());
+                                }
+
+                                return null;
+                            });
+                        } else {
+                            try (InputStream in = zipFile.getInputStream(entry)) {
+                                switch (fileName) {
+                                    case "info" ->
+                                            haeFileContent.setHost(new String(in.readAllBytes(), StandardCharsets.UTF_8));
+                                    case "data" ->
+                                            haeFileContent.setDataMap(yaml.load(new InputStreamReader(in, StandardCharsets.UTF_8)));
+                                    case "url" ->
+                                            haeFileContent.setUrlMap(yaml.load(new InputStreamReader(in, StandardCharsets.UTF_8)));
+                                }
+                            }
+                        }
+                    }
+
+                    executor.invokeAll(tasks);
+                }
+            }
+        } catch (Exception e) {
+            api.logging().logToError("readHaeFile: " + e.getMessage());
+            if (tempDirectory != null) {
+                FileProcessor.deleteDirectoryWithContents(tempDirectory);
+            }
+            haeFileContent = null;
+        } finally {
+            executor.shutdown();
+        }
+
+        return haeFileContent;
+    }
+
+    private boolean hasValidStructure(String zipFilePath) {
+        Set<String> requiredRootEntries = new HashSet<>();
+        requiredRootEntries.add("info");
+        requiredRootEntries.add("data");
+        requiredRootEntries.add("url");
+
+        boolean hasHttpDirectoryWithFiles = false;
+
+        try {
+            ZipFile zipFile = new ZipFile(zipFilePath);
+            Enumeration<? extends ZipEntry> entries = zipFile.entries();
+
+            while (entries.hasMoreElements()) {
+                ZipEntry entry = entries.nextElement();
+                String name = entry.getName();
+
+                if (!entry.isDirectory() && !name.contains("/")) {
+                    requiredRootEntries.remove(name);
+                }
+
+                if (name.startsWith("http/") && !entry.isDirectory()) {
+                    hasHttpDirectoryWithFiles = true;
+                }
+
+                if (requiredRootEntries.isEmpty() && hasHttpDirectoryWithFiles) {
+                    break;
+                }
+            }
+
+            zipFile.close();
+        } catch (Exception ignored) {
+        }
+
+        return requiredRootEntries.isEmpty() && hasHttpDirectoryWithFiles;
+    }
+}
+

src/main/java/hae/utils/project/model/HaeFileContent.java

@@ -0,0 +1,76 @@
+package hae.utils.project.model;
+
+import burp.api.montoya.MontoyaApi;
+
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class HaeFileContent {
+    private final MontoyaApi api;
+    private String host;
+    private String httpPath;
+    private final Map<String, List<String>> dataMap;
+    private final Map<String, Map<String, String>> urlMap;
+
+    public HaeFileContent(MontoyaApi api) {
+        this.api = api;
+        this.dataMap = new HashMap<>();
+        this.urlMap = new HashMap<>();
+    }
+
+    public String getHost() {
+        return host;
+    }
+
+    public Map<String, List<String>> getDataMap() {
+        return dataMap;
+    }
+
+    public Map<String, Map<String, String>> getUrlMap() {
+        return urlMap;
+    }
+
+    public String getHttpPath() {
+        return httpPath;
+    }
+
+    public void setHost(String host) {
+        this.host = host;
+    }
+
+    public void setHttpPath(String path) {
+        this.httpPath = path;
+    }
+
+    public void setDataMap(Map<String, List<Object>> dataMap) {
+        for (Map.Entry<String, List<Object>> entry : dataMap.entrySet()) {
+            List<String> values = new ArrayList<>();
+            for (Object value : entry.getValue()) {
+                try {
+                    values.add(new String((byte[]) value, StandardCharsets.UTF_8));
+                } catch (Exception e) {
+                    values.add(value.toString());
+                }
+            }
+            this.dataMap.put(entry.getKey(), values);
+        }
+    }
+
+    public void setUrlMap(Map<String, Map<String, Object>> urlMap) {
+        for (Map.Entry<String, Map<String, Object>> entry : urlMap.entrySet()) {
+            Map<String, String> newValues = new HashMap<>();
+            Map<String, Object> values = entry.getValue();
+            for (String key : values.keySet()) {
+                try {
+                    newValues.put(key, new String((byte[]) values.get(key), StandardCharsets.UTF_8));
+                } catch (Exception e) {
+                    newValues.put(key, values.get(key).toString());
+                }
+            }
+            this.urlMap.put(entry.getKey(), newValues);
+        }
+    }
+}

src/main/java/hae/utils/rule/RuleProcessor.java

@@ -2,11 +2,11 @@ package hae.utils.rule;
 
 import burp.api.montoya.MontoyaApi;
 import hae.Config;
+import hae.utils.ConfigLoader;
 import hae.utils.rule.model.Group;
 import hae.utils.rule.model.Info;
-import hae.utils.config.ConfigLoader;
-import org.yaml.snakeyaml.Yaml;
 import org.yaml.snakeyaml.DumperOptions;
+import org.yaml.snakeyaml.Yaml;
 import org.yaml.snakeyaml.representer.Representer;
 
 import java.io.File;
@@ -72,13 +72,14 @@ public class RuleProcessor {
     public void addRule(Vector data, String type) {
         ArrayList<Object[]> x = new ArrayList<>(Arrays.asList(Config.globalRules.get(type)));
         x.add(data.toArray());
-        Config.globalRules.put(type,x.toArray(new Object[x.size()][]));
+        Config.globalRules.put(type, x.toArray(new Object[x.size()][]));
         this.rulesFormatAndSave();
     }
-    public void removeRule(int select,String type) {
+
+    public void removeRule(int select, String type) {
         ArrayList<Object[]> x = new ArrayList<>(Arrays.asList(Config.globalRules.get(type)));
         x.remove(select);
-        Config.globalRules.put(type,x.toArray(new Object[x.size()][]));
+        Config.globalRules.put(type, x.toArray(new Object[x.size()][]));
         this.rulesFormatAndSave();
     }
 

src/main/java/hae/utils/string/HashCalculator.java

@@ -3,7 +3,7 @@ package hae.utils.string;
 import java.security.MessageDigest;
 
 public class HashCalculator {
-    public static String calculateHash(byte[] bytes){
+    public static String calculateHash(byte[] bytes) {
         MessageDigest digest;
         try {
             digest = MessageDigest.getInstance("MD5");

src/main/java/hae/utils/string/StringProcessor.java

@@ -1,8 +1,17 @@
 package hae.utils.string;
 
+import burp.api.montoya.core.ByteArray;
+import burp.api.montoya.http.HttpService;
+import burp.api.montoya.http.message.HttpRequestResponse;
+import burp.api.montoya.http.message.requests.HttpRequest;
+import burp.api.montoya.http.message.responses.HttpResponse;
+
 import java.net.URL;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.UUID;
 
 public class StringProcessor {
     public static String replaceFirstOccurrence(String original, String find, String replace) {
@@ -32,6 +41,47 @@ public class StringProcessor {
         return patternIndex == -1;
     }
 
+    public static String extractHostname(String hostWithPort) {
+        if (hostWithPort == null || hostWithPort.isEmpty()) {
+            return "";
+        }
+        int colonIndex = hostWithPort.indexOf(":");
+        if (colonIndex != -1) {
+            return hostWithPort.substring(0, colonIndex);
+        } else {
+            return hostWithPort;
+        }
+    }
+
+    public static boolean matchesHostPattern(String host, String selectedHost) {
+        String hostname = StringProcessor.extractHostname(host);
+        String hostPattern = selectedHost.replace("*.", "");
+        boolean matchesDirectly = selectedHost.equals("*") || host.equals(selectedHost);
+        boolean matchesPattern = !host.contains("*") &&
+                (hostPattern.equals(selectedHost) ?
+                        StringProcessor.matchFromEnd(host, hostPattern) :
+                        StringProcessor.matchFromEnd(hostname, hostPattern));
+        return matchesDirectly || matchesPattern;
+    }
+
+    public static HttpRequestResponse createHttpRequestResponse(String url, byte[] request, byte[] response) {
+        HttpService httpService = HttpService.httpService(url);
+        HttpRequest httpRequest = HttpRequest.httpRequest(httpService, ByteArray.byteArray(request));
+        HttpResponse httpResponse = HttpResponse.httpResponse(ByteArray.byteArray(response));
+        return HttpRequestResponse.httpRequestResponse(httpRequest, httpResponse);
+    }
+
+    public static String getCurrentTime() {
+        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyyMMdd_HHmmss");
+        LocalDateTime now = LocalDateTime.now();
+        return now.format(formatter);
+    }
+
+    public static String getRandomUUID() {
+        UUID uuid = UUID.randomUUID();
+        return uuid.toString();
+    }
+
     public static String mergeComment(String comment) {
         if (!comment.contains(",")) {
             return comment;
@@ -69,6 +119,10 @@ public class StringProcessor {
         return host;
     }
 
+    public static boolean matchHostIsIp(String host) {
+        return host.matches("\\b(?:\\d{1,3}\\.){3}\\d{1,3}\\b");
+    }
+
     private static Map<String, Integer> getStringIntegerMap(String comment) {
         Map<String, Integer> itemCounts = new HashMap<>();
         String[] items = comment.split(", ");

src/main/resources/rules/Rules.yml

@@ -0,0 +1,284 @@
+rules:
+- group: Fingerprint
+  rule:
+  - name: Shiro
+    loaded: true
+    f_regex: (=deleteMe|rememberMe=)
+    s_regex: ''
+    format: '{0}'
+    color: green
+    scope: any header
+    engine: dfa
+    sensitive: true
+  - name: JSON Web Token
+    loaded: true
+    f_regex: (eyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9._-]{10,}|eyJ[A-Za-z0-9_\/+-]{10,}\.[A-Za-z0-9._\/+-]{10,})
+    s_regex: ''
+    format: '{0}'
+    color: green
+    scope: any
+    engine: nfa
+    sensitive: true
+  - name: Swagger UI
+    loaded: true
+    f_regex: ((swagger-ui.html)|(\"swagger\":)|(Swagger UI)|(swaggerUi)|(swaggerVersion))
+    s_regex: ''
+    format: '{0}'
+    color: red
+    scope: response body
+    engine: dfa
+    sensitive: false
+  - name: Ueditor
+    loaded: true
+    f_regex: (ueditor\.(config|all)\.js)
+    s_regex: ''
+    format: '{0}'
+    color: green
+    scope: response body
+    engine: dfa
+    sensitive: false
+  - name: Druid
+    loaded: true
+    f_regex: (Druid Stat Index)
+    s_regex: ''
+    format: '{0}'
+    color: orange
+    scope: response body
+    engine: dfa
+    sensitive: false
+- group: Maybe Vulnerability
+  rule:
+  - name: Java Deserialization
+    loaded: true
+    f_regex: (javax\.faces\.ViewState)
+    s_regex: ''
+    format: '{0}'
+    color: yellow
+    scope: response body
+    engine: dfa
+    sensitive: false
+  - name: Debug Logic Parameters
+    loaded: true
+    f_regex: ((access=)|(adm=)|(admin=)|(alter=)|(cfg=)|(clone=)|(config=)|(create=)|(dbg=)|(debug=)|(delete=)|(disable=)|(edit=)|(enable=)|(exec=)|(execute=)|(grant=)|(load=)|(make=)|(modify=)|(rename=)|(reset=)|(root=)|(shell=)|(test=)|(toggl=))
+    s_regex: ''
+    format: '{0}'
+    color: cyan
+    scope: request
+    engine: dfa
+    sensitive: false
+  - name: URL As A Value
+    loaded: true
+    f_regex: (=(https?)(://|%3a%2f%2f))
+    s_regex: ''
+    format: '{0}'
+    color: cyan
+    scope: any
+    engine: nfa
+    sensitive: false
+  - name: Upload Form
+    loaded: true
+    f_regex: (type\=\"file\")
+    s_regex: ''
+    format: '{0}'
+    color: yellow
+    scope: response body
+    engine: dfa
+    sensitive: false
+  - name: DoS Paramters
+    loaded: true
+    f_regex: ((size=)|(page=)|(num=)|(limit=)|(start=)|(end=)|(count=))
+    s_regex: ''
+    format: '{0}'
+    color: cyan
+    scope: request
+    engine: dfa
+    sensitive: false
+- group: Basic Information
+  rule:
+  - name: Email
+    loaded: true
+    f_regex: (([a-z0-9]+[_|\.])*[a-z0-9]+@([a-z0-9]+[-|_|\.])*[a-z0-9]+\.((?!js|css|jpg|jpeg|png|ico)[a-z]{2,5}))
+    s_regex: ''
+    format: '{0}'
+    color: yellow
+    scope: response
+    engine: nfa
+    sensitive: false
+  - name: Chinese IDCard
+    loaded: true
+    f_regex: '[^0-9]((\d{8}(0\d|10|11|12)([0-2]\d|30|31)\d{3}$)|(\d{6}(18|19|20)\d{2}(0[1-9]|10|11|12)([0-2]\d|30|31)\d{3}(\d|X|x)))[^0-9]'
+    s_regex: ''
+    format: '{0}'
+    color: orange
+    scope: response body
+    engine: nfa
+    sensitive: true
+  - name: Chinese Mobile Number
+    loaded: true
+    f_regex: '[^\w]((?:(?:\+|00)86)?1(?:(?:3[\d])|(?:4[5-79])|(?:5[0-35-9])|(?:6[5-7])|(?:7[0-8])|(?:8[\d])|(?:9[189]))\d{8})[^\w]'
+    s_regex: ''
+    format: '{0}'
+    color: orange
+    scope: response body
+    engine: nfa
+    sensitive: false
+  - name: Internal IP Address
+    loaded: true
+    f_regex: '[^0-9]((127\.0\.0\.1)|(10\.\d{1,3}\.\d{1,3}\.\d{1,3})|(172\.((1[6-9])|(2\d)|(3[01]))\.\d{1,3}\.\d{1,3})|(192\.168\.\d{1,3}\.\d{1,3}))'
+    s_regex: ''
+    format: '{0}'
+    color: cyan
+    scope: response
+    engine: nfa
+    sensitive: true
+  - name: MAC Address
+    loaded: true
+    f_regex: (^([a-fA-F0-9]{2}(:[a-fA-F0-9]{2}){5})|[^a-zA-Z0-9]([a-fA-F0-9]{2}(:[a-fA-F0-9]{2}){5}))
+    s_regex: ''
+    format: '{0}'
+    color: green
+    scope: response
+    engine: nfa
+    sensitive: true
+- group: Sensitive Information
+  rule:
+  - name: Cloud Key
+    loaded: true
+    f_regex: (((access)(|-|_)(key)(|-|_)(id|secret))|(LTAI[a-z0-9]{12,20}))
+    s_regex: ''
+    format: '{0}'
+    color: yellow
+    scope: any
+    engine: nfa
+    sensitive: false
+  - name: Windows File/Dir Path
+    loaded: true
+    f_regex: '[^\w](([a-zA-Z]:\\(?:\w+\\?)*)|([a-zA-Z]:\\(?:\w+\\)*\w+\.\w+))'
+    s_regex: ''
+    format: '{0}'
+    color: green
+    scope: response
+    engine: nfa
+    sensitive: true
+  - name: Password Field
+    loaded: true
+    f_regex: ((|'|")(|[\w]{1,10})([p](ass|wd|asswd|assword))(|[\w]{1,10})(|'|")(:|=)(
+      |)('|")(.*?)('|")(|,))
+    s_regex: ''
+    format: '{0}'
+    color: yellow
+    scope: response body
+    engine: nfa
+    sensitive: false
+  - name: Username Field
+    loaded: true
+    f_regex: ((|'|")(|[\w]{1,10})(([u](ser|name|sername))|(account)|((((create|update)((d|r)|(by|on|at)))|(creator))))(|[\w]{1,10})(|'|")(:|=)(
+      |)('|")(.*?)('|")(|,))
+    s_regex: ''
+    format: '{0}'
+    color: green
+    scope: response body
+    engine: nfa
+    sensitive: false
+  - name: WeCom Key
+    loaded: true
+    f_regex: ((corp)(id|secret))
+    s_regex: ''
+    format: '{0}'
+    color: green
+    scope: response body
+    engine: dfa
+    sensitive: false
+  - name: JDBC Connection
+    loaded: true
+    f_regex: (jdbc:[a-z:]+://[a-z0-9\.\-_:;=/@?,&]+)
+    s_regex: ''
+    format: '{0}'
+    color: yellow
+    scope: any
+    engine: nfa
+    sensitive: false
+  - name: Authorization Header
+    loaded: true
+    f_regex: ((basic [a-z0-9=:_\+\/-]{5,100})|(bearer [a-z0-9_.=:_\+\/-]{5,100}))
+    s_regex: ''
+    format: '{0}'
+    color: yellow
+    scope: response body
+    engine: nfa
+    sensitive: false
+  - name: Sensitive Field
+    loaded: true
+    f_regex: ((\[)?('|")?([\w]{0,10})((key)|(secret)|(token)|(config)|(auth)|(access)|(admin))([\w]{0,10})('|")?(\])?(
+      |)(:|=)( |)('|")(.*?)('|")(|,))
+    s_regex: ''
+    format: '{0}'
+    color: yellow
+    scope: response
+    engine: nfa
+    sensitive: false
+- group: Other
+  rule:
+  - name: Linkfinder
+    loaded: true
+    f_regex: (?:"|')(((?:[a-zA-Z]{1,10}://|//)[^"'/]{1,}\.[a-zA-Z]{2,}[^"']{0,})|((?:/|\.\./|\./)[^"'><,;|*()(%%$^/\\\[\]][^"'><,;|()]{1,})|([a-zA-Z0-9_\-/]{1,}/[a-zA-Z0-9_\-/]{1,}\.(?:[a-zA-Z]{1,4}|action)(?:[\?|#][^"|']{0,}|))|([a-zA-Z0-9_\-/]{1,}/[a-zA-Z0-9_\-/]{3,}(?:[\?|#][^"|']{0,}|))|([a-zA-Z0-9_\-]{1,}\.(?:\w)(?:[\?|#][^"|']{0,}|)))(?:"|')
+    s_regex: ''
+    format: '{0}'
+    color: gray
+    scope: response body
+    engine: nfa
+    sensitive: true
+  - name: Source Map
+    loaded: true
+    f_regex: (\.js\.map)
+    s_regex: ''
+    format: '{0}'
+    color: pink
+    scope: response body
+    engine: dfa
+    sensitive: false
+  - name: HTML Notes
+    loaded: true
+    f_regex: (<!--.*?-->)
+    s_regex: ''
+    format: '{0}'
+    color: magenta
+    scope: response body
+    engine: nfa
+    sensitive: false
+  - name: Create Script
+    loaded: true
+    f_regex: (\+\{.*?\}\[[a-zA-Z]\]\+".*?\.js")
+    s_regex: '"?([\w].*?)"?:"(.*?)"'
+    format: '{0}.{1}'
+    color: green
+    scope: response body
+    engine: nfa
+    sensitive: false
+  - name: URL Schemes
+    loaded: true
+    f_regex: ((?![http]|[https])(([-A-Za-z0-9]{1,20})://[-A-Za-z0-9+&@#/%?=~_|!:,.;]+[-A-Za-z0-9+&@#/%=~_|]))
+    s_regex: ''
+    format: '{0}'
+    color: yellow
+    scope: response body
+    engine: nfa
+    sensitive: false
+  - name: Router Push
+    loaded: true
+    f_regex: (\$router\.push)
+    s_regex: ''
+    format: '{0}'
+    color: magenta
+    scope: response body
+    engine: dfa
+    sensitive: false
+  - name: All URL
+    loaded: true
+    f_regex: (https?://[-A-Za-z0-9+&@#/%?=~_|!:,.;\u4E00-\u9FFF]+[-A-Za-z0-9+&@#/%=~_|])
+    s_regex: ''
+    format: '{0}'
+    color: gray
+    scope: response body
+    engine: nfa
+    sensitive: true