Version: 2.6 Update

.github/ISSUE_TEMPLATE/问题反馈.md

@@ -0,0 +1,36 @@
+---
+name: 问题反馈
+about: 尽可能详细的描述问题并反馈
+title: "[BUG] "
+labels: bug
+assignees: ''
+
+---
+
+## 使用环境
+
+```
+HaE版本：
+是否有自定义的HaE规则：
+BurpSuite版本：
+JDK版本：
+操作系统版本：
+```
+
+## 问题详情
+
+问题描述：
+
+出现的场景：
+
+## 解决建议
+
+无。
+
+## 赞助
+
+如果你觉得HaE好用，可以打赏一下作者，给作者持续更新下去的动力！
+
+<div align=center>
+<img src="https://raw.githubusercontent.com/gh0stkey/HaE/master/images/reward.jpeg" style="width: 30%" />
+</div>

README.md

@@ -4,12 +4,11 @@
 <h5>第一作者： <a href="https://github.com/gh0stkey">EvilChen</a>（中孚信息元亨实验室）, 第二作者： <a href="https://github.com/0chencc">0chencc</a>（米斯特安全团队）</h5>
 </div>
 
-
 ## 项目介绍
 
-**HaE**是基于 `BurpSuite Java插件API` 开发的请求高亮标记与信息提取的辅助型框架式插件，该插件可以通过自定义正则的方式匹配响应报文或请求报文，并对满足正则匹配的报文进行信息高亮与提取。
+**HaE**是一个基于`BurpSuite Java插件API`开发的辅助型框架式插件，旨在实现对HTTP消息的高亮标记和信息提取。该插件通过自定义正则表达式匹配响应报文或请求报文，并对匹配成功的报文进行标记和提取。
 
-现代化Web应用走上前后端分离开发模式，这就导致在日常测试时候会有许多的流量，如果你想要尽可能全面的对一个Web应用进行测试评估，将花费大量精力浪费在无用的报文上；**HaE的出现正是为了解决这一类似场景**，借助HaE你可以**有效的减少**测试的时间，将更多的精力放在**有价值、有意义**的报文上，**提高漏洞挖掘效率**。
+随着现代化Web应用采用前后端分离的开发模式，日常漏洞挖掘的过程中，捕获的HTTP请求流量也相应增加。若想全面评估一个Web应用，会花费大量时间在无用的报文上。**HaE的出现旨在解决这类情况**，借助HaE，您能够**有效减少**测试时间，将更多精力集中在**有价值且有意义**的报文上，从而**提高漏洞挖掘效率**。
 
 **注**: 要想灵活的使用`HaE`，你需要掌握正则表达式阅读、编写、修改能力；由于`Java`正则表达式的库并没有`Python`的优雅或方便，所以HaE要求使用者必须用`()`将所需提取的表达式内容包含；例如你要匹配一个**Shiro应用**的响应报文，正常匹配规则为`rememberMe=delete`，如果你要提取这段内容的话就需要变成`(rememberMe=delete)`。
 
@@ -17,41 +16,48 @@
 
 插件装载: `Extender - Extensions - Add - Select File - Next`
 
-初次装载`HaE`会初始化配置文件，默认配置文件内置一个正则: `Email`，初始化的配置文件会放在的`/用户根目录/.config/HaE/`目录下。
+初次装载`HaE`会自动获取官方规则库`https://raw.githubusercontent.com/gh0stkey/HaE/gh-pages/Rules.yml`，配置文件（`Config.yml`）和规则文件（`Rules.yml`）会放在固定目录下：
 
-![-w477](images/show_config.png)
+1. Linux/Mac用户的配置文件目录：`~/.config/HaE/`
+2. Windows用户的配置文件目录：`%USERPROFILE%/.config/HaE/`
+
+除此之外，您也可以选择将配置文件存放在`HaE Jar包`的同级目录下的`/.config/HaE/`中，**以便于离线携带**。
+
+### 规则释义
+
+HaE目前的规则一共有8个字段，分别是规则名称、规则正则、规则作用域、正则引擎、规则匹配颜色、规则敏感性。
+
+详细的含义如下所示：
+
+| 字段      | 含义                                                                                                                                                                                                   |
+|-----------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| Name      | 规则名称，主要用于简短概括当前规则的作用。                                                                                                                                                               |
+| F-Regex     | 规则正则，主要用于填写正则表达式。在HaE中所需提取匹配的内容需要用`(`、`)`将正则表达式进行包裹。|
+| S-Regex     | 规则正则，作用及使用同F-Regex。S-Regex为二次正则，可以用于对F-Regex匹配的数据结果进行二次的匹配提取，如不需要的情况下可以留空。|
+| Format     | 格式化输出，在NFA引擎的正则表达式中，我们可以通过`{0}`、`{1}`、`{2}`…的方式进行取分组格式化输出。默认情况下使用`{0}`即可。          |
+| Scope     | 规则作用域，主要用于表示当前规则作用于HTTP报文的哪个部分。                                                                                                                                               |
+| Engine    | 正则引擎，主要用于表示当前规则的正则表达式所使用的引擎。**DFA引擎**：对于文本串里的每一个字符只需扫描一次，速度快、特性少；**NFA引擎**：要翻来覆去标注字符、取消标注字符，速度慢，但是特性（如:分组、替换、分割）丰富。 |
+| Color     | 规则匹配颜色，主要用于表示当前规则匹配到对应HTTP报文时所需标记的高亮颜色。在HaE中具备颜色升级算法，当出现相同颜色时会自动向上升级一个颜色进行标记。                                                                                                                               |
+| Sensitive | 规则敏感性，主要用于表示当前规则对于大小写字母是否敏感，敏感（`True`）则严格按照大小写要求匹配，不敏感（`False`）则反之。                                                                                      |
 
-除了初始化的配置文件外，还有`Setting.yml`，该文件用于存储配置文件路径与排除后缀名；`HaE`支持在线更新配置文件，你可以通过点击`Online Update`按钮进行更新（部分网络需要挂代理）。
 
 ## 优势特点
 
-1. **精细化配置项**：高自由度配置更适配精细化场景需求；
-2. **简洁可视界面**：简洁的可视化界面让你更加清晰了解HaE的各项配置，操作更轻松，使用更简单；
-3. **颜色升级算法**：内置颜色升级算法，避免“屠龙者终成恶龙”场景，突出最具价值的请求；
-4. **标签化规则项**：标签化你的正则规则，让规则可分类，让管理更轻松；
-5. **数据集合面板**：将所有匹配数据集合到Databoard中，使得测试、梳理更高效；
-6. **高亮标记一体**：在Proxy - History页面你可以通过颜色高亮与Comment判断请求价值；
-7. **实战化官方库**：基于实战化场景、案例进行输出的官方规则库，提升测试实战性；
-8. **配置文件易读**：配置文件使用YAML格式存储，更加便于阅读与修改。
+1. 精细配置：高度自由的配置选项，以满足各类精细化场景需求。
+2. 分类标签：使用标签对规则进行分类，便于管理和组织规则。
+3. 高亮标记：在HTTP History页面，通过颜色高亮和注释判断请求的价值。
+4. 易读配置：使用易读的YAML格式存储配置文件，方便阅读和修改。
+5. 数据集合：将匹配到的数据、请求和响应集中在数据面板中，提高测试和梳理效率。
+6. 简洁可视：清晰可视的界面设计，更轻松地了解和配置HaE，操作简单、使用便捷。
+7. 颜色升级：内置颜色升级算法，避免“屠龙者终成恶龙”场景，突出最具价值的请求。
+8. 实战规则：官方规则库是基于实战化场景总结输出，提升数据发现的有效性、精准性。
 
 | 界面名称                  | 界面展示                                              |
-| ------------------------- | ----------------------------------------------------- |
+| ------------------------ | ---------------------------------------------------- |
 | Rules（规则信息管理）     | <img src="images/rules.png" style="width: 80%" />     |
 | Config（配置信息管理）    | <img src="images/config.png" style="width: 80%" />    |
 | Databoard（数据集合面板） | <img src="images/databoard.png" style="width: 80%" /> |
 
-
-
-## 实际使用
-
-使用 RGPerson 生成测试数据，放入网站根目录文件中: 
-
-![-w467](images/16000719723284.jpg)
-
-访问该地址，在`Proxy - HTTP History`中可以看见高亮请求，响应标签页中含有`MarkINFO`标签，其中将匹配到的信息提取了出来。
-
-![-w1047](images/16000720732854.png)
-
 ## 文末随笔
 
 正义感是一个不可丢失的东西。

build.gradle

@@ -30,5 +30,4 @@ dependencies {
     compile group: 'org.yaml', name: 'snakeyaml', version: '1.28'
     compile 'net.sourceforge.jregex:jregex:1.2_01'
     compile 'dk.brics.automaton:automaton:1.11-8'
-    compile 'com.squareup.okhttp:okhttp:2.7.5'
-}
+}

src/main/java/burp/BurpExtender.java

@@ -1,15 +1,16 @@
 package burp;
 
-import burp.action.*;
+import burp.config.ConfigLoader;
+import burp.core.processor.ColorProcessor;
+import burp.core.processor.MessageProcessor;
+import burp.core.utils.StringHelper;
 import burp.ui.MainUI;
-
-import java.util.Map;
-import java.util.Objects;
+import burp.ui.board.DatatablePanel;
+import burp.ui.board.MessagePanel;
+import java.util.*;
 import javax.swing.*;
 import java.awt.*;
-import java.nio.charset.StandardCharsets;
 import java.io.PrintWriter;
-import java.util.ArrayList;
 import java.util.List;
 import javax.swing.event.ChangeEvent;
 import javax.swing.event.ChangeListener;
@@ -19,42 +20,53 @@ import javax.swing.event.ChangeListener;
  */
 
 public class BurpExtender implements IBurpExtender, IHttpListener, IMessageEditorTabFactory, ITab {
-    private final MainUI main = new MainUI();
-    // stdout变成公开属性，便于其他类调用输出调试信息
+    private MainUI main;
     public static PrintWriter stdout;
-    private IBurpExtenderCallbacks callbacks;
-    private static IExtensionHelpers helpers;
-    GetColorKey gck = new GetColorKey();
-    UpgradeColor uc = new UpgradeColor();
-    ProcessMessage pm = new ProcessMessage();
+    public static IBurpExtenderCallbacks callbacks;
+    public static IExtensionHelpers helpers;
+    ColorProcessor colorProcessor = new ColorProcessor();
+    MessageProcessor messageProcessor = new MessageProcessor();
+    private MessagePanel messagePanel;
 
     @Override
     public void registerExtenderCallbacks(final IBurpExtenderCallbacks callbacks)
     {
-        this.callbacks = callbacks;
+        BurpExtender.callbacks = callbacks;
         BurpExtender.helpers = callbacks.getHelpers();
 
-        String version = "2.4.5";
+        new ConfigLoader();
+
+        String version = "2.6";
         callbacks.setExtensionName(String.format("HaE (%s) - Highlighter and Extractor", version));
+
         // 定义输出
         stdout = new PrintWriter(callbacks.getStdout(), true);
-        stdout.println("@First Author: EvilChen");
-        stdout.println("@Second Author: 0chencc");
-        stdout.println("@Github: https://github.com/gh0stkey/HaE");
+        stdout.println("[ HACK THE WORLD - TO DO IT ]");
+        stdout.println("[#] Author: EvilChen & 0chencc");
+        stdout.println("[#] Github: https://github.com/gh0stkey/HaE");
+
         // UI
-        SwingUtilities.invokeLater(this::initialize);
+        SwingUtilities.invokeLater(new Runnable() {
+            @Override
+            public void run() {
+                initialize();
+            }
+        });
 
         callbacks.registerHttpListener(BurpExtender.this);
         callbacks.registerMessageEditorTabFactory(BurpExtender.this);
+
     }
 
-    private void initialize(){
+    private void initialize() {
+        messagePanel = new MessagePanel(callbacks, helpers);
+        main = new MainUI(messagePanel);
         callbacks.customizeUiComponent(main);
         callbacks.addSuiteTab(BurpExtender.this);
     }
 
     @Override
-    public String getTabCaption(){
+    public String getTabCaption() {
         return "HaE";
     }
 
@@ -70,54 +82,53 @@ public class BurpExtender implements IBurpExtender, IHttpListener, IMessageEdito
     public void processHttpMessage(int toolFlag, boolean messageIsRequest, IHttpRequestResponse messageInfo) {
         // 判断是否是响应，且该代码作用域为：REPEATER、INTRUDER、PROXY（分别对应toolFlag 64、32、4）
         if (toolFlag == 64 || toolFlag == 32 || toolFlag == 4) {
-            byte[] content;
-            if (messageIsRequest) {
-                content = messageInfo.getRequest();
-            } else {
-                content = messageInfo.getResponse();
-            }
+            if (!messageIsRequest) {
+                IHttpService iHttpService = messageInfo.getHttpService();
+                String host = iHttpService.getHost();
 
-            IHttpService iHttpService = null;
-            try {
-                iHttpService = messageInfo.getHttpService();
-            } catch (Exception ignored) {
-            }
-            // 获取请求主机信息
-            assert iHttpService != null;
-            String host = iHttpService.getHost();
+                List<Map<String, String>> result = null;
 
-            String c = new String(content, StandardCharsets.UTF_8).intern();
-
-            List<Map<String, String>> result = pm.processMessageByContent(helpers, content, messageIsRequest, true, host);
-            if (result != null && !result.isEmpty() && result.size() > 0) {
                 String originalColor = messageInfo.getHighlight();
                 String originalComment = messageInfo.getComment();
-                List<String> colorList = new ArrayList<>();
 
-                if (originalColor != null) {
-                    colorList.add(originalColor);
+                try {
+                    result = messageProcessor.processMessage(helpers, messageInfo, host, true);
+
+                    if (result != null && !result.isEmpty() && result.size() > 0) {
+                        List<String> colorList = new ArrayList<>();
+
+                        if (originalColor != null) {
+                            colorList.add(originalColor);
+                        }
+
+                        colorList.add(result.get(0).get("color"));
+                        String resColor = colorProcessor.retrieveFinalColor(colorProcessor.retrieveColorIndices(colorList));
+                        messageInfo.setHighlight(resColor);
+
+                        String addComment = String.join(", ", result.get(1).get("comment"));
+                        String allComment = !Objects.equals(originalComment, "") ? String.format("%s, %s", originalComment, addComment) : addComment;
+                        String resComment = StringHelper.mergeComment(allComment);
+                        messageInfo.setComment(resComment);
+
+                        messagePanel.add(messageInfo, resComment, resColor);
+                    }
+                } catch (Exception e) {
+                    e.printStackTrace();
                 }
-
-                colorList.add(result.get(0).get("color"));
-                String color = uc.getEndColor(gck.getColorKeys(colorList));
-
-                messageInfo.setHighlight(color);
-
-                String addComment = String.join(", ", result.get(1).get("comment"));
-                String resComment = !Objects.equals(originalComment, "") ? String.format("%s, %s", originalComment, addComment) : addComment;
-
-                messageInfo.setComment(resComment);
             }
+
         }
     }
 
     class MarkInfoTab implements IMessageEditorTab {
         private final JTabbedPane jTabbedPane = new JTabbedPane();
-        private JTable jTable = new JTable();
+        private DatatablePanel dataPanel;
+        private JTable dataTable;
         private final IMessageEditorController controller;
         private Map<String, String> extractRequestMap;
         private Map<String, String> extractResponseMap;
         private ArrayList<String> titleList = new ArrayList<>();
+        private byte[] message;
 
         public MarkInfoTab(IMessageEditorController controller, boolean editable) {
             this.controller = controller;
@@ -133,32 +144,43 @@ public class BurpExtender implements IBurpExtender, IHttpListener, IMessageEdito
             jTabbedPane.addChangeListener(new ChangeListener() {
                 @Override
                 public void stateChanged(ChangeEvent arg0) {
-                    jTable = (JTable) ((JScrollPane)jTabbedPane.getSelectedComponent()).getViewport().getView();
+                    dataTable = ((DatatablePanel)jTabbedPane.getSelectedComponent()).getTable();
                 }
             });
-            return this.jTabbedPane;
+            return jTabbedPane;
         }
 
         @Override
         public boolean isEnabled(byte[] content, boolean isRequest) {
-            String c = new String(content, StandardCharsets.UTF_8).intern();
-            List<Map<String, String>> result = pm.processMessageByContent(helpers, content, isRequest, false, "");
-
-            if (result != null && !result.isEmpty()) {
-                Map<String, String> dataMap = result.get(0);
-                if (isRequest) {
-                    extractRequestMap = dataMap;
-                } else {
-                    extractResponseMap = dataMap;
+            this.message = content;
+            List<Map<String, String>> result = null;
+            if (content.length != 0 && !helpers.bytesToString(content).equals("Loading...")) {
+                try {
+                    if (isRequest) {
+                        result = messageProcessor.processRequestMessage(helpers, content, "", false);
+                    } else {
+                        result = messageProcessor.processResponseMessage(helpers, content, "", false);
+                    }
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+
+                if (result != null && !result.isEmpty()) {
+                    Map<String, String> dataMap = result.get(0);
+                    if (isRequest) {
+                        extractRequestMap = dataMap;
+                    } else {
+                        extractResponseMap = dataMap;
+                    }
+                    return true;
                 }
-                return true;
             }
             return false;
         }
 
         @Override
         public byte[] getMessage() {
-            return null;
+            return message;
         }
 
         @Override
@@ -171,15 +193,7 @@ public class BurpExtender implements IBurpExtender, IHttpListener, IMessageEdito
          */
         @Override
         public byte[] getSelectedData() {
-            int[] selectRows = jTable.getSelectedRows();
-            StringBuilder selectData = new StringBuilder();
-            for (int row : selectRows) {
-                selectData.append(jTable.getValueAt(row, 0).toString()).append("\n");
-            }
-            // 便于单行复制，去除最后一个换行符
-            String revData = selectData.reverse().toString().replaceFirst("\n", "");
-            StringBuilder retData = new StringBuilder(revData).reverse();
-            return helpers.stringToBytes(retData.toString());
+            return helpers.stringToBytes(dataPanel.getSelectedData(dataTable));
         }
 
         /**
@@ -187,7 +201,6 @@ public class BurpExtender implements IBurpExtender, IHttpListener, IMessageEdito
          */
         @Override
         public void setMessage(byte[] content, boolean isRequest) {
-            String c = new String(content, StandardCharsets.UTF_8).intern();
             if (content.length > 0) {
                 if (isRequest) {
                     makeTable(extractRequestMap);
@@ -202,16 +215,12 @@ public class BurpExtender implements IBurpExtender, IHttpListener, IMessageEdito
          */
         public void makeTable(Map<String, String> dataMap) {
             ArrayList<String> lTitleList = new ArrayList<>();
+
             dataMap.keySet().forEach(i->{
                 String[] extractData = dataMap.get(i).split("\n");
-                Object[][] data = new Object[extractData.length][1];
-                for (int x = 0; x < extractData.length; x++) {
-                    data[x][0] = extractData[x];
-                    // stdout.println(extractData[x]);
-                }
-                JScrollPane jScrollPane = new JScrollPane(new JTable(data, new Object[]{"Information"}));
                 lTitleList.add(i);
-                this.jTabbedPane.addTab(i, jScrollPane);
+                dataPanel = new DatatablePanel(i, Arrays.asList(extractData));
+                jTabbedPane.addTab(i, dataPanel);
             });
 
             /*
@@ -219,9 +228,9 @@ public class BurpExtender implements IBurpExtender, IHttpListener, IMessageEdito
              * 采用全局ArrayList的方式遍历删除Tab，以此应对BurpSuite缓存机制导致的MarkInfo UI错误展示。
              */
             titleList.forEach(t->{
-                int indexOfTab = this.jTabbedPane.indexOfTab(t);
+                int indexOfTab = jTabbedPane.indexOfTab(t);
                 if (indexOfTab != -1) {
-                    this.jTabbedPane.removeTabAt(indexOfTab);
+                    jTabbedPane.removeTabAt(indexOfTab);
                 }
             });
 
@@ -233,4 +242,4 @@ public class BurpExtender implements IBurpExtender, IHttpListener, IMessageEdito
     public IMessageEditorTab createNewInstance(IMessageEditorController controller, boolean editable) {
         return new MarkInfoTab(controller, editable);
     }
-}
+}

src/main/java/burp/action/DoAction.java

@@ -1,38 +0,0 @@
-package burp.action;
-
-import burp.BurpExtender;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.ArrayList;
-import java.util.List;
-
-/**
- * @author EvilChen
- */
-
-public class DoAction {
-    public Map<String, String> extractString(Map<String, Map<String, Object>> obj) {
-        Map<String, String> resultMap = new HashMap<>();
-        obj.keySet().forEach(i->{
-            Map<String, Object> tmpMap = obj.get(i);
-            String data = tmpMap.get("data").toString();
-            resultMap.put(i, data);
-        });
-        return resultMap;
-    }
-
-    public List<List<String>> highlightAndComment(Map<String, Map<String, Object>> obj) {
-        List<String> colorList = new ArrayList<>();
-        List<String> commentList = new ArrayList<>();
-        List<List<String>> result = new ArrayList<>();
-        obj.keySet().forEach(i->{
-            Map<String, Object> tmpMap = obj.get(i);
-            String color = tmpMap.get("color").toString();
-            colorList.add(color);
-            commentList.add(i);
-        });
-        result.add(colorList);
-        result.add(commentList);
-        return result;
-    }
-}

src/main/java/burp/action/ExtractContent.java

@@ -1,139 +0,0 @@
-package burp.action;
-
-import java.nio.charset.StandardCharsets;
-import java.util.*;
-import burp.Config;
-import dk.brics.automaton.Automaton;
-import dk.brics.automaton.AutomatonMatcher;
-import dk.brics.automaton.RegExp;
-import dk.brics.automaton.RunAutomaton;
-import jregex.Matcher;
-import jregex.Pattern;
-
-/**
- * @author EvilChen
- */
-
-public class ExtractContent {
-
-    public Map<String, Map<String, Object>> matchRegex(byte[] content, String headers, byte[] body, String scopeString, String host) {
-        Map<String, Map<String, Object>> map = new HashMap<>(); // 最终返回的结果
-        Config.ruleConfig.keySet().forEach(i -> {
-            String matchContent = "";
-            for (Object[] objects : Config.ruleConfig.get(i)) {
-                // 遍历获取规则
-                List<String> result = new ArrayList<>();
-                Map<String, Object> tmpMap = new HashMap<>();
-
-                String name = objects[1].toString();
-                boolean loaded = (Boolean) objects[0];
-                String regex = objects[2].toString();
-                String color = objects[3].toString();
-                String scope = objects[4].toString();
-                String engine = objects[5].toString();
-                boolean sensitive = (Boolean) objects[6];
-                // 判断规则是否开启与作用域
-                if (loaded && (scope.contains(scopeString) || scope.contains("any"))) {
-                    switch (scope) {
-                        case "any":
-                        case "request":
-                        case "response":
-                            matchContent = new String(content, StandardCharsets.UTF_8).intern();
-                            break;
-                        case "any header":
-                        case "request header":
-                        case "response header":
-                            matchContent = headers;
-                            break;
-                        case "any body":
-                        case "request body":
-                        case "response body":
-                            matchContent = new String(body, StandardCharsets.UTF_8).intern();
-                            break;
-                        default:
-                            return;
-                    }
-
-                    if ("nfa".equals(engine)) {
-                        Pattern pattern;
-                        // 判断规则是否大小写敏感
-                        if (sensitive) {
-                            pattern = new Pattern(regex);
-                        } else {
-                            pattern = new Pattern(regex, Pattern.IGNORE_CASE);
-                        }
-
-                        Matcher matcher = pattern.matcher(matchContent);
-                        while (matcher.find()) {
-                            // 添加匹配数据至list
-                            // 强制用户使用()包裹正则
-                            result.add(matcher.group(1));
-                        }
-                    } else {
-                        RegExp regexp = new RegExp(regex);
-                        Automaton auto = regexp.toAutomaton();
-                        RunAutomaton runAuto = new RunAutomaton(auto, true);
-                        AutomatonMatcher autoMatcher = runAuto.newMatcher(matchContent);
-                        while (autoMatcher.find()) {
-                            // 添加匹配数据至list
-                            // 强制用户使用()包裹正则
-                            result.add(autoMatcher.group());
-                        }
-                    }
-
-                    // 去除重复内容
-                    HashSet tmpList = new HashSet(result);
-                    result.clear();
-                    result.addAll(tmpList);
-
-                    if (!result.isEmpty()) {
-                        tmpMap.put("color", color);
-                        tmpMap.put("data", String.join("\n", result));
-                        // 初始化格式
-                        map.put(name, tmpMap);
-                    }
-                }
-            }
-        });
-
-        // 将提取的数据存放到全局变量中
-        if (!host.isEmpty()) {
-            map.keySet().forEach(i -> {
-                Map<String, Object> tmpMap = map.get(i);
-                List<String> dataList = Arrays.asList(tmpMap.get("data").toString().split("\n"));
-                // 组合通配符Host
-                String anyHost = host.replace(host.split("\\.")[0], "*");
-                // 判断Host是否存在，如存在则进行数据更新，反之则新增数据
-                if (Config.globalDataMap.containsKey(host)) {
-                    Map<String, List<String>> gRuleMap = Config.globalDataMap.get(host);
-                    // 判断匹配规则是否存在（逻辑同Host判断）
-                    if (gRuleMap.containsKey(i)) {
-                        List<String> gDataList = gRuleMap.get(i);
-                        List<String> mergeDataList = new ArrayList<>(gDataList);
-                        // 合并两个List
-                        mergeDataList.addAll(dataList);
-                        // 去重操作
-                        HashSet tmpList = new HashSet(mergeDataList);
-                        mergeDataList.clear();
-                        mergeDataList.addAll(tmpList);
-                        // 替换操作
-                        gRuleMap.replace(i, gDataList, mergeDataList);
-                    } else {
-                        gRuleMap.put(i, dataList);
-                    }
-                } else if (!Config.globalDataMap.containsKey(anyHost)) {
-                    // 添加通配符Host
-                    Config.globalDataMap.put(anyHost, new HashMap<>());
-                }
-                else {
-                    Map<String, List<String>> ruleMap = new HashMap<>();
-                    ruleMap.put(i, dataList);
-                    // 添加单一Host
-                    Config.globalDataMap.put(host, ruleMap);
-                }
-            });
-        }
-
-        return map;
-    }
-}

src/main/java/burp/action/GetColorKey.java

@@ -1,29 +0,0 @@
-package burp.action;
-
-import burp.Config;
-import java.util.ArrayList;
-import java.util.List;
-
-/**
- * @author EvilChen
- */
-
-public class GetColorKey {
-    /**
-     * 颜色下标获取
-     */
-    public List<Integer> getColorKeys(List<String> keys){
-        List<Integer> result = new ArrayList<>();
-        String[] colorArray = Config.colorArray;
-        int size = colorArray.length;
-        // 根据颜色获取下标
-        for (String key : keys) {
-            for (int v = 0; v < size; v++) {
-                if (colorArray[v].equals(key)) {
-                    result.add(v);
-                }
-            }
-        }
-        return result;
-    }
-}

src/main/java/burp/action/MatchHTTP.java

@@ -1,20 +0,0 @@
-package burp.action;
-
-import jregex.Matcher;
-import jregex.Pattern;
-import jregex.REFlags;
-import burp.yaml.LoadConfig;
-
-/**
- * @author EvilChen
- */
-
-public class MatchHTTP {
-    // 匹配后缀
-    LoadConfig lc = new LoadConfig();
-    public boolean matchSuffix(String str) {
-        Pattern pattern = new Pattern(String.format("[\\w]+[\\.](%s)", lc.getExcludeSuffix()), REFlags.IGNORE_CASE);
-        Matcher matcher = pattern.matcher(str);
-        return matcher.find();
-    }
-}

src/main/java/burp/action/ProcessMessage.java

@@ -1,94 +0,0 @@
-package burp.action;
-
-import burp.BurpExtender;
-import burp.IExtensionHelpers;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-public class ProcessMessage {
-    MatchHTTP mh = new MatchHTTP();
-    ExtractContent ec = new ExtractContent();
-    DoAction da = new DoAction();
-    GetColorKey gck = new GetColorKey();
-    UpgradeColor uc = new UpgradeColor();
-
-    public List<Map<String, String>> processMessageByContent(IExtensionHelpers helpers, byte[] content, boolean isRequest, boolean messageInfo, String host) {
-        List<Map<String, String>> result = new ArrayList<>();;
-        Map<String, Map<String, Object>> obj;
-
-        if (isRequest) {
-
-            // 获取报文头
-            List<String> requestTmpHeaders = helpers.analyzeRequest(content).getHeaders();
-            String requestHeaders = String.join("\n", requestTmpHeaders);
-
-            try {
-                // 流量清洗
-                String urlString = requestTmpHeaders.get(0).split(" ")[1];
-                urlString = urlString.indexOf("?") > 0 ? urlString.substring(0, urlString.indexOf("?")) : urlString;
-
-                // 正则判断
-                if (mh.matchSuffix(urlString)) {
-                    return result;
-                }
-            } catch (Exception e) {
-                return result;
-            }
-
-
-            // 获取报文主体
-            int requestBodyOffset = helpers.analyzeRequest(content).getBodyOffset();
-            byte[] requestBody = Arrays.copyOfRange(content, requestBodyOffset, content.length);
-
-            obj = ec.matchRegex(content, requestHeaders, requestBody, "request", host);
-        } else {
-            try {
-                // 流量清洗
-                String inferredMimeType = String.format("hae.%s", helpers.analyzeResponse(content).getInferredMimeType().toLowerCase());
-                String statedMimeType = String.format("hae.%s", helpers.analyzeResponse(content).getStatedMimeType().toLowerCase());
-                // 正则判断
-                if (mh.matchSuffix(statedMimeType) || mh.matchSuffix(inferredMimeType)) {
-                    return result;
-                }
-            } catch (Exception e) {
-                return result;
-            }
-            // 获取报文头
-            List<String> responseTmpHeaders = helpers.analyzeResponse(content).getHeaders();
-            String responseHeaders = String.join("\n", responseTmpHeaders);
-
-            // 获取报文主体
-            int responseBodyOffset = helpers.analyzeResponse(content).getBodyOffset();
-            byte[] responseBody = Arrays.copyOfRange(content, responseBodyOffset, content.length);
-
-            obj = ec.matchRegex(content, responseHeaders, responseBody, "response", host);
-        }
-
-        if (obj.size() > 0) {
-            if (messageInfo) {
-                List<List<String>> resultList = da.highlightAndComment(obj);
-                List<String> colorList = resultList.get(0);
-                List<String> commentList = resultList.get(1);
-                if (colorList.size() != 0 && commentList.size() != 0) {
-                    String color = uc.getEndColor(gck.getColorKeys(colorList));
-                    Map<String, String> colorMap = new HashMap<String, String>(){{
-                        put("color", color);
-                    }};
-                    Map<String, String> commentMap = new HashMap<String, String>(){{
-                        put("comment", String.join(", ", commentList));
-                    }};
-                    result.add(colorMap);
-                    result.add(commentMap);
-                }
-            } else {
-                result.add(da.extractString(obj));
-            }
-        }
-
-        return result;
-
-    }
-}

src/main/java/burp/config/ConfigEntry.java

@@ -1,15 +1,12 @@
-package burp;
-
-/**
- * @author EvilChen
- */
+package burp.config;
 
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
 
-public class Config {
-    public static String excludeSuffix = "3g2|3gp|7z|aac|abw|aif|aifc|aiff|arc|au|avi|azw|bin|bmp|bz|bz2|cmx|cod|csh|css|csv|doc|docx|eot|epub|gif|gz|ico|ics|ief|jar|jfif|jpe|jpeg|jpg|m3u|mid|midi|mjs|mp2|mp3|mpa|mpe|mpeg|mpg|mpkg|mpp|mpv2|odp|ods|odt|oga|ogv|ogx|otf|pbm|pdf|pgm|png|pnm|ppm|ppt|pptx|ra|ram|rar|ras|rgb|rmi|rtf|snd|svg|swf|tar|tif|tiff|ttf|vsd|wav|weba|webm|webp|woff|woff2|xbm|xls|xlsx|xpm|xul|xwd|zip|zip";
+public class ConfigEntry {
+    public static String excludeSuffix = "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[] scopeArray = new String[] {
             "any",
@@ -40,7 +37,7 @@ public class Config {
             "gray"
     };
 
-    public static Map<String,Object[][]> ruleConfig = null;
+    public static Map<String,Object[][]> globalRules = null;
 
-    public static Map<String, Map<String, List<String>>> globalDataMap = new HashMap<>();
+    public static ConcurrentHashMap<String, Map<String, List<String>>> globalDataMap = new ConcurrentHashMap<>();
 }

src/main/java/burp/config/ConfigLoader.java

@@ -0,0 +1,153 @@
+package burp.config;
+
+import burp.BurpExtender;
+import burp.rule.utils.RuleTool;
+import burp.rule.utils.YamlTool;
+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;
+import org.yaml.snakeyaml.Yaml;
+
+/**
+ * @author EvilChen
+ */
+
+public class ConfigLoader {
+    private static final Yaml yaml = YamlTool.newStandardYaml();
+    private static final String HaEConfigPath = determineConfigPath();
+    private static final String RulesFilePath = String.format("%s/%s", HaEConfigPath, "Rules.yml");
+    private static final String ConfigFilePath =  String.format("%s/%s", HaEConfigPath, "Config.yml");
+
+    public ConfigLoader() {
+        // 构造函数，初始化配置
+        File HaEConfigPathFile = new File(HaEConfigPath);
+        if (!(HaEConfigPathFile.exists() && HaEConfigPathFile.isDirectory())) {
+            HaEConfigPathFile.mkdirs();
+        }
+
+        File configFilePath = new File(ConfigFilePath);
+        if (!(configFilePath.exists() && configFilePath.isFile())) {
+            initConfig();
+        }
+
+        File rulesFilePath = new File(RulesFilePath);
+        if (!(rulesFilePath.exists() && rulesFilePath.isFile())) {
+            initRules();
+        }
+
+        ConfigEntry.globalRules = getRules();
+    }
+
+    private static String determineConfigPath() {
+        // 优先级1：用户根目录
+        String userConfigPath = String.format("%s/.config/HaE", System.getProperty("user.home"));
+        if (isValidConfigPath(userConfigPath)) {
+            return userConfigPath;
+        }
+
+        // 优先级2：Jar包所在目录
+        String jarPath = BurpExtender.callbacks.getExtensionFilename();
+        String jarDirectory = new File(jarPath).getParent();
+        String jarConfigPath = String.format("%s/.config/HaE", jarDirectory);
+        if (isValidConfigPath(jarConfigPath)) {
+            return jarConfigPath;
+        }
+        
+        return userConfigPath;
+    }
+
+    private static boolean isValidConfigPath(String configPath) {
+        File configPathFile = new File(configPath);
+        return configPathFile.exists() && configPathFile.isDirectory();
+    }
+
+    public static void initConfig() {
+        Map<String, Object> r = new LinkedHashMap<>();
+        r.put("excludeSuffix", getExcludeSuffix());
+        try {
+            Writer ws = new OutputStreamWriter(Files.newOutputStream(Paths.get(ConfigFilePath)), StandardCharsets.UTF_8);
+            yaml.dump(r, ws);
+            ws.close();
+        } catch (Exception ex) {
+            ex.printStackTrace();
+        }
+    }
+
+    public static void initRules() {
+        RuleTool rt = new RuleTool(RulesFilePath);
+        rt.getRulesFromSite();
+    }
+
+    public static String getRulesFilePath() {
+        return RulesFilePath;
+    }
+
+    public static String getExcludeSuffix(){
+        String excludeSuffix = "";
+        File yamlSetting = new File(ConfigFilePath);
+        
+        if (yamlSetting.exists() && yamlSetting.isFile()) {
+            try {
+                InputStream inorder = Files.newInputStream(Paths.get(ConfigFilePath));
+                Map<String,Object> r = yaml.load(inorder);
+                excludeSuffix = r.get("excludeSuffix").toString();
+            } catch (Exception e) {
+                // e.printStackTrace();
+                excludeSuffix = ConfigEntry.excludeSuffix;
+            }
+        } else {
+            excludeSuffix = ConfigEntry.excludeSuffix;
+        }
+        
+        return excludeSuffix;
+    }
+
+    // 获取规则配置
+    public static Map<String, Object[][]> getRules() {
+        Map<String, Object> rulesMap = YamlTool.loadYaml(getRulesFilePath());
+        Map<String, Object[][]> resRule = new HashMap<>();
+        String[] fieldKeys = {"loaded", "name", "f_regex", "s_regex", "format", "color", "scope", "engine", "sensitive"};
+
+        Object rulesObj = rulesMap.get("rules");
+        if (rulesObj instanceof List) {
+            List<Map<String, Object>> groupData = (List<Map<String, Object>>) rulesObj;
+            for (Map<String, Object> groupFields : groupData) {
+                ArrayList<Object[]> data = new ArrayList<>();
+
+                Object ruleObj = groupFields.get("rule");
+                if (ruleObj instanceof List) {
+                    List<Map<String, Object>> ruleData = (List<Map<String, Object>>) ruleObj;
+                    for (Map<String, Object> ruleFields : ruleData) {
+                        Object[] valuesArray = new Object[fieldKeys.length];
+                        for (int i = 0; i < fieldKeys.length; i++) {
+                            valuesArray[i] = ruleFields.get(fieldKeys[i]);
+                        }
+                        data.add(valuesArray);
+                    }
+                }
+
+                Object[][] dataArray = data.toArray(new Object[data.size()][]);
+                resRule.put(groupFields.get("group").toString(), dataArray);
+            }
+        }
+        return resRule;
+    }
+
+    public static 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();
+        }catch (Exception ex){
+            ex.printStackTrace();
+        }
+    }
+}

src/main/java/burp/core/GlobalCachePool.java

@@ -0,0 +1,26 @@
+package burp.core;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * @author EvilChen
+ */
+
+public class GlobalCachePool {
+    // 用于缓存匹配结果，以请求/响应的MD5 Hash作为索引
+    private static final Map<String, Map<String, Map<String, Object>>> cache = new HashMap<>();
+
+    public static void addToCache(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 void removeFromCache(String key) {
+        cache.remove(key);
+    }
+
+}

src/main/java/burp/core/processor/ColorProcessor.java

@@ -1,6 +1,6 @@
-package burp.action;
+package burp.core.processor;
 
-import burp.Config;
+import burp.config.ConfigEntry;
 
 import java.util.*;
 
@@ -8,14 +8,30 @@ import java.util.*;
  * @author EvilChen
  */
 
-public class UpgradeColor {
-    private String endColor = "";
+public class ColorProcessor {
+    private String finalColor = "";
+
+    public List<Integer> retrieveColorIndices(List<String> colors){
+        List<Integer> indices = new ArrayList<>();
+        String[] colorArray = ConfigEntry.colorArray;
+        int size = colorArray.length;
+
+        for (String color : colors) {
+            for (int i = 0; i < size; i++) {
+                if (colorArray[i].equals(color)) {
+                    indices.add(i);
+                }
+            }
+        }
+        return indices;
+    }
+
     /**
      * 颜色升级递归算法
      */
-    private void colorUpgrade(List<Integer> colorList) {
+    private void upgradeColors(List<Integer> colorList) {
         int colorSize = colorList.size();
-        String[] colorArray = Config.colorArray;
+        String[] colorArray = ConfigEntry.colorArray;
         colorList.sort(Comparator.comparingInt(Integer::intValue));
         int i = 0;
         List<Integer> stack = new ArrayList<>();
@@ -36,17 +52,17 @@ public class UpgradeColor {
         if (stack.size() == tmpList.size()) {
             stack.sort(Comparator.comparingInt(Integer::intValue));
             if(stack.get(0) < 0) {
-                this.endColor = colorArray[0];
+                this.finalColor = colorArray[0];
             } else {
-                this.endColor = colorArray[stack.get(0)];
+                this.finalColor = colorArray[stack.get(0)];
             }
         } else {
-            this.colorUpgrade(stack);
+            this.upgradeColors(stack);
         }
     }
 
-    public String getEndColor(List<Integer> colorList) {
-        colorUpgrade(colorList);
-        return endColor;
+    public String retrieveFinalColor(List<Integer> colorList) {
+        upgradeColors(colorList);
+        return finalColor;
     }
 }

src/main/java/burp/core/processor/DataProcessingUnit.java

@@ -0,0 +1,290 @@
+package burp.core.processor;
+
+import burp.BurpExtender;
+import burp.core.GlobalCachePool;
+import burp.core.utils.HashCalculator;
+import burp.core.utils.MatchTool;
+import burp.config.ConfigEntry;
+import burp.core.utils.StringHelper;
+import dk.brics.automaton.Automaton;
+import dk.brics.automaton.AutomatonMatcher;
+import dk.brics.automaton.RegExp;
+import dk.brics.automaton.RunAutomaton;
+import java.nio.charset.StandardCharsets;
+import java.security.NoSuchAlgorithmException;
+import java.text.MessageFormat;
+import java.util.*;
+
+import java.util.concurrent.ConcurrentHashMap;
+import jregex.Matcher;
+import jregex.Pattern;
+
+/**
+ * @author EvilChen
+ */
+
+public class DataProcessingUnit {
+    public Map<String, String> extractDataFromMap(Map<String, Map<String, Object>> inputData) {
+        Map<String, String> extractedData = new HashMap<>();
+        inputData.keySet().forEach(key -> {
+            Map<String, Object> tempMap = inputData.get(key);
+            String data = tempMap.get("data").toString();
+            extractedData.put(key, data);
+        });
+        return extractedData;
+    }
+
+    public List<List<String>> extractColorsAndComments(Map<String, Map<String, Object>> inputData) {
+        List<String> colorList = new ArrayList<>();
+        List<String> commentList = new ArrayList<>();
+        inputData.keySet().forEach(key -> {
+            Map<String, Object> tempMap = inputData.get(key);
+            String color = tempMap.get("color").toString();
+            colorList.add(color);
+            commentList.add(key);
+        });
+        List<List<String>> result = new ArrayList<>();
+        result.add(colorList);
+        result.add(commentList);
+        return result;
+    }
+
+    public Map<String, Map<String, Object>> matchContentByRegex(byte[] content, String headers, byte[] body, String scopeString, String host)
+            throws NoSuchAlgorithmException {
+        // 先从缓存池里判断是否有已经匹配好的结果
+        String messageIndex = HashCalculator.calculateHash(content);
+        Map<String, Map<String, Object>> map = GlobalCachePool.getFromCache(messageIndex);
+        if (map != null) {
+            return map;
+        } else {
+            // 最终返回的结果
+            Map<String, Map<String, Object>> finalMap = new HashMap<>();
+            ConfigEntry.globalRules.keySet().parallelStream().forEach(i -> {
+                for (Object[] objects : ConfigEntry.globalRules.get(i)) {
+                    // 多线程执行，一定程度上减少阻塞现象
+                    String matchContent = "";
+                    // 遍历获取规则
+                    List<String> result = new ArrayList<>();
+                    Map<String, Object> tmpMap = new HashMap<>();
+
+                    boolean loaded = (Boolean) objects[0];
+                    String name = objects[1].toString();
+                    String f_regex = objects[2].toString();
+                    String s_regex = objects[3].toString();
+                    String format = objects[4].toString();
+                    String color = objects[5].toString();
+                    String scope = objects[6].toString();
+                    String engine = objects[7].toString();
+                    boolean sensitive = (Boolean) objects[8];
+
+                    // 判断规则是否开启与作用域
+                    if (loaded && (scope.contains(scopeString) || scope.contains("any"))) {
+                        switch (scope) {
+                            case "any":
+                            case "request":
+                            case "response":
+                                matchContent = new String(content, StandardCharsets.UTF_8);
+                                break;
+                            case "any header":
+                            case "request header":
+                            case "response header":
+                                matchContent = headers;
+                                break;
+                            case "any body":
+                            case "request body":
+                            case "response body":
+                                matchContent = new String(body, StandardCharsets.UTF_8);
+                                break;
+                            default:
+                                break;
+                        }
+
+                        try {
+                            result.addAll(matchByRegex(f_regex, s_regex, matchContent, format, engine, sensitive));
+                        } catch (Exception e) {
+                            BurpExtender.stdout.println(String.format("[x] Error Info:\nName: %s\nRegex: %s", name, f_regex));
+                            e.printStackTrace();
+                            continue;
+                        }
+
+                        // 去除重复内容
+                        HashSet tmpList = new HashSet(result);
+                        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);
+                            finalMap.put(nameAndSize, tmpMap);
+                            // 添加到全局变量中，便于Databoard检索
+                            if (!Objects.equals(host, "") && host != null) {
+                                List<String> dataList = Arrays.asList(dataStr.split("\n"));
+                                if (ConfigEntry.globalDataMap.containsKey(host)) {
+                                    ConcurrentHashMap<String, List<String>> gRuleMap = new ConcurrentHashMap<>(ConfigEntry.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);
+                                    }
+                                    ConfigEntry.globalDataMap.remove(host);
+                                    ConfigEntry.globalDataMap.put(host, gRuleMap);
+                                } else {
+                                    Map<String, List<String>> ruleMap = new HashMap<>();
+                                    ruleMap.put(name, dataList);
+                                    // 添加单一Host
+                                    ConfigEntry.globalDataMap.put(host, ruleMap);
+                                }
+
+                                String[] splitHost = host.split("\\.");
+
+                                String anyHost = (splitHost.length > 2 && !MatchTool.matchIP(host)) ? StringHelper.replaceFirstOccurrence(host, splitHost[0], "*") : "";
+
+                                if (!ConfigEntry.globalDataMap.containsKey(anyHost) && anyHost.length() > 0) {
+                                    // 添加通配符Host，实际数据从查询哪里将所有数据提取
+                                    ConfigEntry.globalDataMap.put(anyHost, new HashMap<>());
+                                }
+
+                                if (!ConfigEntry.globalDataMap.containsKey("*")) {
+                                    // 添加通配符全匹配，同上
+                                    ConfigEntry.globalDataMap.put("*", new HashMap<>());
+                                }
+
+                                if (!ConfigEntry.globalDataMap.containsKey("**")) {
+                                    // 添加通配符全匹配，同上
+                                    ConfigEntry.globalDataMap.put("**", new HashMap<>());
+                                }
+                            }
+                        }
+                    }
+                }
+            });
+            GlobalCachePool.addToCache(messageIndex, finalMap);
+            return finalMap;
+        }
+    }
+
+    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)) {
+            Matcher matcher = createPatternMatcher(f_regex, content, sensitive);
+            retList.addAll(extractMatches(s_regex, format, sensitive, matcher));
+        } else {
+            String newContent = content;
+            String newFirstRegex = f_regex;
+            if (!sensitive) {
+                newContent = content.toLowerCase();
+                newFirstRegex = f_regex.toLowerCase();
+            }
+            AutomatonMatcher autoMatcher = createAutomatonMatcher(newFirstRegex, newContent);
+            retList.addAll(extractMatches(s_regex, format, autoMatcher, content));
+        }
+        return retList;
+    }
+
+    private List<String> extractMatches(String s_regex, String format, boolean sensitive, Matcher matcher) {
+        List<String> matches = new ArrayList<>();
+        if (s_regex.isEmpty()) {
+            matches.addAll(getFormatString(matcher, format));
+        } else {
+            while (matcher.find()) {
+                matcher = createPatternMatcher(s_regex, matcher.group(1), sensitive);
+                matches.addAll(getFormatString(matcher, format));
+            }
+        }
+        return matches;
+    }
+
+    private List<String> extractMatches(String s_regex, String format, AutomatonMatcher autoMatcher, String content) {
+        List<String> matches = new ArrayList<>();
+        if (s_regex.isEmpty()) {
+            matches.addAll(getFormatString(autoMatcher, format, content));
+        } else {
+            while (autoMatcher.find()) {
+                autoMatcher = createAutomatonMatcher(s_regex, getSubString(content, autoMatcher.group()));
+                matches.addAll(getFormatString(autoMatcher, format, content));
+            }
+        }
+        return matches;
+    }
+
+    public List<String> getFormatString(Matcher matcher, String format) {
+        List<Integer> indexList = parseIndexesFromString(format);
+        List<String> stringList = new ArrayList<>();
+
+        while (matcher.find()) {
+            Object[] params = indexList.stream().map(i -> {
+                if (matcher.group(i+1) != null) {
+                    return matcher.group(i+1);
+                }
+                return "";
+            }).toArray();
+            stringList.add(MessageFormat.format(reorderIndex(format), params));
+        }
+
+        return stringList;
+    }
+
+    public List<String> getFormatString(AutomatonMatcher matcher, String format, String content) {
+        List<Integer> indexList = parseIndexesFromString(format);
+        List<String> stringList = new ArrayList<>();
+
+        while (matcher.find()) {
+            Object[] params = indexList.stream().map(i -> getSubString(content, matcher.group(i))).toArray();
+            stringList.add(MessageFormat.format(reorderIndex(format), params));
+        }
+
+        return stringList;
+    }
+
+    private Matcher createPatternMatcher(String regex, String content, boolean sensitive) {
+        Pattern pattern = (sensitive) ? new Pattern(regex) : new Pattern(regex, Pattern.IGNORE_CASE);
+        return pattern.matcher(content);
+    }
+
+    private AutomatonMatcher createAutomatonMatcher(String regex, String content) {
+        RegExp regexp = new RegExp(regex);
+        Automaton auto = regexp.toAutomaton();
+        RunAutomaton runAuto = new RunAutomaton(auto, true);
+        return runAuto.newMatcher(content);
+    }
+
+    private LinkedList<Integer> parseIndexesFromString(String input) {
+        LinkedList<Integer> indexes = new LinkedList<>();
+        Pattern pattern = new Pattern("\\{(\\d+)}");
+        Matcher matcher = pattern.matcher(input);
+
+        while (matcher.find()) {
+            indexes.add(Integer.valueOf(matcher.group(1)));
+        }
+
+        return indexes;
+    }
+
+    private String getSubString(String content, String s) {
+        int startIndex = content.toLowerCase().indexOf(s);
+        int endIndex = startIndex + s.length();
+        return content.substring(startIndex, endIndex);
+    }
+
+    private String reorderIndex(String format) {
+        Pattern pattern = new Pattern("\\{(\\d+)}");
+        Matcher matcher = pattern.matcher(format);
+        int count = 0;
+        while (matcher.find()) {
+            String newStr = String.format("{%s}", count);
+            String matchStr = matcher.group(0);
+            format = format.replace(matchStr, newStr);
+            count++;
+        }
+        return format;
+    }
+}
+

src/main/java/burp/core/processor/MessageProcessor.java

@@ -0,0 +1,128 @@
+package burp.core.processor;
+
+import burp.IExtensionHelpers;
+import burp.IHttpRequestResponse;
+import burp.IRequestInfo;
+import burp.IResponseInfo;
+import burp.core.utils.MatchTool;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class MessageProcessor {
+    private MatchTool matcher = new MatchTool();
+    private DataProcessingUnit dataProcessingUnit = new DataProcessingUnit();
+    private ColorProcessor colorProcessor = new ColorProcessor();
+
+    public List<Map<String, String>> processMessage(IExtensionHelpers helpers, IHttpRequestResponse messageInfo, String host, boolean actionFlag) throws Exception {
+
+        byte[] requestByte = messageInfo.getRequest();
+        byte[] responseByte = messageInfo.getResponse();
+
+        List<Map<String, String>> reqObj = processRequestMessage(helpers, requestByte, host, actionFlag);
+        List<Map<String, String>> resObj = processResponseMessage(helpers, responseByte, host, actionFlag);
+        List<Map<String, String>> mergedList = new ArrayList<>();
+
+        if (reqObj != null && !reqObj.isEmpty()) {
+            if (resObj != null && !resObj.isEmpty()) {
+                List<String> colorList = new ArrayList<>();
+
+                colorList.add(reqObj.get(0).get("color"));
+                colorList.add(resObj.get(0).get("color"));
+                Map<String, String> colorMap = new HashMap<>();
+                colorMap.put("color", colorProcessor.retrieveFinalColor(colorProcessor.retrieveColorIndices(colorList)));
+
+                Map<String, String> commentMap = new HashMap<>();
+                String commentList = String.format("%s, %s", reqObj.get(1).get("comment"), resObj.get(1).get("comment"));
+                commentMap.put("comment", commentList);
+
+                mergedList.add(0, colorMap);
+                mergedList.add(1, commentMap);
+            } else {
+                mergedList = new ArrayList<>(reqObj);
+            }
+        } else if (resObj != null && !resObj.isEmpty()){
+            mergedList = new ArrayList<>(resObj);
+        }
+
+        return mergedList;
+    }
+
+    public List<Map<String, String>> processRequestMessage(IExtensionHelpers helpers, byte[] content, String host, boolean actionFlag) throws Exception {
+        Map<String, Map<String, Object>> obj;
+
+        IRequestInfo requestInfo = helpers.analyzeRequest(content);
+        List<String> requestTmpHeaders = requestInfo.getHeaders();
+        String requestHeaders = String.join("\n", requestTmpHeaders);
+
+        try {
+            String urlString = requestTmpHeaders.get(0).split(" ")[1];
+            urlString = urlString.indexOf("?") > 0 ? urlString.substring(0, urlString.indexOf("?")) : urlString;
+            if (matcher.matchUrlSuffix(urlString)) {
+                return null;
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+            return null;
+        }
+
+        int requestBodyOffset = requestInfo.getBodyOffset();
+        byte[] requestBody = Arrays.copyOfRange(content, requestBodyOffset, content.length);
+        obj = dataProcessingUnit.matchContentByRegex(content, requestHeaders, requestBody, "request", host);
+
+        return getDataList(obj, actionFlag);
+    }
+
+    public List<Map<String, String>> processResponseMessage(IExtensionHelpers helpers, byte[] content, String host, boolean actionFlag) throws Exception {
+        Map<String, Map<String, Object>> obj;
+
+        IResponseInfo responseInfo = helpers.analyzeResponse(content);
+        try {
+            String inferredMimeType = String.format("hae.%s", responseInfo.getInferredMimeType().toLowerCase());
+            String statedMimeType = String.format("hae.%s", responseInfo.getStatedMimeType().toLowerCase());
+            if (matcher.matchUrlSuffix(statedMimeType) || matcher.matchUrlSuffix(inferredMimeType)) {
+                return null;
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+            return null;
+        }
+        List<String> responseTmpHeaders = responseInfo.getHeaders();
+        String responseHeaders = String.join("\n", responseTmpHeaders);
+        int responseBodyOffset = responseInfo.getBodyOffset();
+        byte[] responseBody = Arrays.copyOfRange(content, responseBodyOffset, content.length);
+        obj = dataProcessingUnit.matchContentByRegex(content, responseHeaders, responseBody, "response", host);
+
+        return getDataList(obj, actionFlag);
+    }
+
+    private List<Map<String, String>> getDataList(Map<String, Map<String, Object>> obj, boolean actionFlag) {
+        List<Map<String, String>> highlightList = new ArrayList<>();
+        List<Map<String, String>> extractList = new ArrayList<>();
+
+        if (obj.size() > 0) {
+            if (actionFlag) {
+                List<List<String>> resultList = dataProcessingUnit.extractColorsAndComments(obj);
+                List<String> colorList = resultList.get(0);
+                List<String> commentList = resultList.get(1);
+                if (!colorList.isEmpty() && !commentList.isEmpty()) {
+                    String color = colorProcessor.retrieveFinalColor(colorProcessor.retrieveColorIndices(colorList));
+                    Map<String, String> colorMap = new HashMap<String, String>() {{
+                        put("color", color);
+                    }};
+                    Map<String, String> commentMap = new HashMap<String, String>() {{
+                        put("comment", String.join(", ", commentList));
+                    }};
+                    highlightList.add(colorMap);
+                    highlightList.add(commentMap);
+                }
+            } else {
+                extractList.add(dataProcessingUnit.extractDataFromMap(obj));
+            }
+        }
+
+        return actionFlag ? highlightList : extractList;
+    }
+}

src/main/java/burp/core/utils/HashCalculator.java

@@ -0,0 +1,30 @@
+package burp.core.utils;
+
+import burp.BurpExtender;
+
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+
+/**
+ * @author EvilChen
+ */
+
+public class HashCalculator {
+    public static String calculateHash(byte[] bytes) throws NoSuchAlgorithmException {
+        MessageDigest digest = MessageDigest.getInstance("MD5");
+        byte[] hashBytes = digest.digest(bytes);
+        return bytesToHex(hashBytes);
+    }
+
+    private static String bytesToHex(byte[] bytes) {
+        StringBuilder hexString = new StringBuilder();
+        for (byte b : bytes) {
+            String hex = Integer.toHexString(0xff & b);
+            if (hex.length() == 1) {
+                hexString.append('0');
+            }
+            hexString.append(hex);
+        }
+        return hexString.toString();
+    }
+}

src/main/java/burp/core/utils/MatchTool.java

@@ -0,0 +1,21 @@
+package burp.core.utils;
+
+import jregex.Pattern;
+import jregex.REFlags;
+import burp.config.ConfigLoader;
+
+/**
+ * @author EvilChen
+ */
+
+public class MatchTool {
+    public boolean matchUrlSuffix(String str) {
+        Pattern pattern = new Pattern(String.format("[\\w]+[\\.](%s)", ConfigLoader.getExcludeSuffix()), REFlags.IGNORE_CASE);
+        jregex.Matcher matcher = pattern.matcher(str);
+        return matcher.find();
+    }
+
+    public static boolean matchIP(String str) {
+        return str.matches("\\b(?:\\d{1,3}\\.){3}\\d{1,3}\\b");
+    }
+}

src/main/java/burp/core/utils/StringHelper.java

@@ -0,0 +1,66 @@
+package burp.core.utils;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class StringHelper {
+    public static String replaceFirstOccurrence(String original, String find, String replace) {
+        int index = original.indexOf(find);
+        if (index != -1) {
+            return original.substring(0, index) + replace + original.substring(index + find.length());
+        }
+        return original;
+    }
+
+    public static boolean matchFromEnd(String input, String pattern) {
+        int inputLength = input.length();
+        int patternLength = pattern.length();
+
+        int inputIndex = inputLength - 1;
+        int patternIndex = patternLength - 1;
+
+        while (inputIndex >= 0 && patternIndex >= 0) {
+            if (input.charAt(inputIndex) != pattern.charAt(patternIndex)) {
+                return false;
+            }
+            inputIndex--;
+            patternIndex--;
+        }
+
+        // 如果patternIndex为-1，表示pattern字符串已经完全匹配
+        return patternIndex == -1;
+    }
+
+    public static String mergeComment(String comment) {
+        if (!comment.contains(",")) {
+            return comment;
+        }
+
+        Map<String, Integer> itemCounts = new HashMap<>();
+        String[] items = comment.split(", ");
+
+        for (String item : items) {
+            if (item.contains("(") && item.contains(")")) {
+                int openParenIndex = item.lastIndexOf("(");
+                int closeParenIndex = item.lastIndexOf(")");
+                String itemName = item.substring(0, openParenIndex).trim();
+                int count = Integer.parseInt(item.substring(openParenIndex + 1, closeParenIndex).trim());
+                itemCounts.put(itemName, itemCounts.getOrDefault(itemName, 0) + count);
+            } else {
+                itemCounts.put(item, 0);
+            }
+        }
+
+        StringBuilder mergedItems = new StringBuilder();
+
+        for (Map.Entry<String, Integer> entry : itemCounts.entrySet()) {
+            String itemName = entry.getKey();
+            int count = entry.getValue();
+            if (count != 0) {
+                mergedItems.append(itemName).append(" (").append(count).append("), ");
+            }
+        }
+
+        return mergedItems.substring(0, mergedItems.length() - 2);
+    }
+}

src/main/java/burp/rule/RuleProcessor.java

@@ -0,0 +1,103 @@
+package burp.rule;
+
+import burp.config.ConfigEntry;
+import burp.config.ConfigLoader;
+import burp.rule.model.Rule;
+import burp.rule.model.RuleGroup;
+import burp.rule.utils.YamlTool;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.util.stream.Collectors;
+import org.yaml.snakeyaml.Yaml;
+import java.io.File;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+import java.nio.charset.StandardCharsets;
+import java.util.*;
+
+/**
+ * @author EvilChen
+ */
+
+public class RuleProcessor {
+    public void rulesFormatAndSave() {
+        Yaml yaml = YamlTool.newStandardYaml();
+        List<RuleGroup> ruleGroupList = new ArrayList<>();
+
+        ConfigEntry.globalRules.forEach((k, v) -> {
+            List<Rule> ruleList = Arrays.stream(v)
+                    .map(objects -> new Rule(
+                            (boolean) objects[0],
+                            (String) objects[1],
+                            (String) objects[2],
+                            (String) objects[3],
+                            (String) objects[4],
+                            (String) objects[5],
+                            (String) objects[6],
+                            (String) objects[7],
+                            (boolean) objects[8]))
+                    .collect(Collectors.toList());
+            ruleGroupList.add(new RuleGroup(k, ruleList));
+        });
+
+        List<Map<String, Object>> outputGroupsMap = ruleGroupList.stream()
+                .map(RuleGroup::getFields)
+                .collect(Collectors.toList());
+
+        Map<String, Object> outputMap = new LinkedHashMap<>();
+        outputMap.put("rules", outputGroupsMap);
+
+        File f = new File(ConfigLoader.getRulesFilePath());
+        try (Writer ws = new OutputStreamWriter(Files.newOutputStream(f.toPath()), StandardCharsets.UTF_8)) {
+            yaml.dump(outputMap, ws);
+        } catch (IOException ex) {
+            ex.printStackTrace();
+        }
+    }
+
+    public void changeRule(Vector data, int select, String type) {
+        ConfigEntry.globalRules.get(type)[select] = data.toArray();
+        this.rulesFormatAndSave();
+    }
+
+    public void addRule(Vector data, String type) {
+        ArrayList<Object[]> x = new ArrayList<>(Arrays.asList(ConfigEntry.globalRules.get(type)));
+        x.add(data.toArray());
+        ConfigEntry.globalRules.put(type,x.toArray(new Object[x.size()][]));
+        this.rulesFormatAndSave();
+    }
+    public void removeRule(int select,String type) {
+        ArrayList<Object[]> x = new ArrayList<>(Arrays.asList(ConfigEntry.globalRules.get(type)));
+        x.remove(select);
+        ConfigEntry.globalRules.put(type,x.toArray(new Object[x.size()][]));
+        this.rulesFormatAndSave();
+    }
+
+    public void renameRuleGroup(String oldName, String newName) {
+        ConfigEntry.globalRules.put(newName, ConfigEntry.globalRules.remove(oldName));
+        this.rulesFormatAndSave();
+    }
+
+    public void deleteRuleGroup(String Rules) {
+        ConfigEntry.globalRules.remove(Rules);
+        this.rulesFormatAndSave();
+    }
+
+    public String newRule() {
+        int i = 0;
+        String name = "New ";
+        Object[][] data = new Object[][] {
+                {
+                    false, "New Name", "(First Regex)", "(Second Regex)", "{0}", "gray", "any", "nfa", false
+                }
+        };
+
+        while (ConfigEntry.globalRules.containsKey(name + i)) {
+            i++;
+        }
+
+        ConfigEntry.globalRules.put(name + i, data);
+        this.rulesFormatAndSave();
+        return name + i;
+    }
+}

src/main/java/burp/rule/model/Rule.java

@@ -0,0 +1,37 @@
+package burp.rule.model;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+/**
+ * @author EvilChen
+ */
+
+public class Rule {
+    private Map<String, Object> fields;
+
+    public Rule(boolean loaded, String name, String f_regex, String s_regex, String format, String color, String scope, String engine, boolean sensitive) {
+        fields = new LinkedHashMap<>();
+        fields.put("name", name);
+        fields.put("loaded", loaded);
+        fields.put("f_regex", f_regex);
+        fields.put("s_regex", s_regex);
+        fields.put("format", format);
+        fields.put("color", color);
+        fields.put("scope", scope);
+        fields.put("engine", engine);
+        fields.put("sensitive", sensitive);
+    }
+
+    public Rule() {
+
+    }
+
+    public Map<String, Object> getFields() {
+        return fields;
+    }
+
+    public void loadFields(Map<String, Object> fields) {
+        this.fields = fields;
+    }
+}

src/main/java/burp/rule/model/RuleGroup.java

@@ -0,0 +1,37 @@
+package burp.rule.model;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @author EvilChen
+ */
+
+public class RuleGroup {
+    private Map<String, Object> fields;
+
+    public RuleGroup(String groupName, List<Rule> rules) {
+        List<Map<String, Object>> ruleList = new ArrayList<>();
+        for (Rule rule : rules) {
+            ruleList.add(rule.getFields());
+        }
+
+        fields = new LinkedHashMap<>();
+        fields.put("group", groupName);
+        fields.put("rule", ruleList);
+    }
+
+    public RuleGroup() {
+
+    }
+
+    public Map<String, Object> getFields() {
+        return fields;
+    }
+
+    public void loadFields(Map<String, Object> fields) {
+        this.fields = fields;
+    }
+}

src/main/java/burp/rule/utils/RuleTool.java

@@ -0,0 +1,52 @@
+package burp.rule.utils;
+
+import burp.*;
+import java.io.FileOutputStream;
+import java.net.URL;
+import java.util.Arrays;
+import javax.swing.JOptionPane;
+
+/**
+ * @author EvilChen
+ */
+public class RuleTool {
+    private String rulesFilePath;
+    private boolean isSuccess;
+
+    public RuleTool(String rulesFilePath) {
+        this.rulesFilePath = rulesFilePath;
+    }
+
+    public void getRulesFromSite() {
+        // 以独立线程使用BurpSuite官方请求接口获取规则
+        Thread t = new Thread(()->{
+            try {
+                URL url = new URL("https://cdn.jsdelivr.net/gh/gh0stkey/HaE@gh-pages/Rules.yml");
+                IHttpService iHttpService = BurpExtender.helpers.buildHttpService(url.getHost(), 443, true);
+                IHttpRequestResponse iHttpRequestResponse = BurpExtender.callbacks.makeHttpRequest(iHttpService, BurpExtender.helpers.buildHttpRequest(url));
+                byte[] responseByte = iHttpRequestResponse.getResponse();
+                IResponseInfo iResponseInfo = BurpExtender.helpers.analyzeResponse(responseByte);
+                int bodyOffset = iResponseInfo.getBodyOffset();
+                byte[] responseBodyByte = Arrays.copyOfRange(responseByte, bodyOffset, responseByte.length);
+                FileOutputStream fileOutputStream = new FileOutputStream(this.rulesFilePath);
+                fileOutputStream.write(responseBodyByte);
+                fileOutputStream.close();
+                isSuccess = true;
+            } catch (Exception e) {
+                isSuccess = false;
+            }
+        });
+        t.start();
+        try {
+            t.join(10000);
+        } catch (Exception e) {
+            isSuccess = false;
+        }
+
+        if (isSuccess) {
+            JOptionPane.showMessageDialog(null, "Rules update successfully!", "Info", JOptionPane.INFORMATION_MESSAGE);
+        } else {
+            JOptionPane.showMessageDialog(null, "Rule update failed, please check the network!", "Error", JOptionPane.ERROR_MESSAGE);
+        }
+    }
+}

src/main/java/burp/rule/utils/YamlTool.java

@@ -0,0 +1,36 @@
+package burp.rule.utils;
+
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.Map;
+
+import org.yaml.snakeyaml.DumperOptions;
+import org.yaml.snakeyaml.Yaml;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.InputStream;
+import org.yaml.snakeyaml.representer.Representer;
+
+/**
+ * @author EvilChen
+ */
+
+public class YamlTool {
+
+    public static Yaml newStandardYaml() {
+        DumperOptions dop = new DumperOptions();
+        dop.setDefaultFlowStyle(DumperOptions.FlowStyle.BLOCK);
+        Representer representer = new Representer();
+        return new Yaml(representer, dop);
+    }
+
+    public static Map<String, Object> loadYaml(String filePath) {
+        try {
+            InputStream inputStream = Files.newInputStream(Paths.get(filePath));
+            return newStandardYaml().load(inputStream);
+        } catch (Exception e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+}

src/main/java/burp/ui/Databoard.java

@@ -1,249 +0,0 @@
-package burp.ui;
-
-import burp.Config;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import javax.swing.table.DefaultTableModel;
-import org.jetbrains.annotations.NotNull;
-
-import java.awt.*;
-import java.awt.event.*;
-import java.util.ArrayList;
-import java.util.Map;
-import javax.swing.*;
-import javax.swing.event.DocumentEvent;
-import javax.swing.event.DocumentListener;
-
-/**
- * @author LinChen && EvilChen
- */
-
-public class Databoard extends JPanel {
-    public Databoard() {
-        initComponents();
-    }
-
-    /**
-     * 清空数据
-     */
-    private void clearActionPerformed(ActionEvent e) {
-        // 清空页面
-        dataTabbedPane.removeAll();
-        // 判断通配符Host/单一Host
-        String host = hostTextField.getText();
-        if(host.contains("*")){
-            Map<String, Map<String, List<String>>> ruleMap = Config.globalDataMap;
-            Map<String, List<String>> selectHost = new HashMap<>();
-            ruleMap.keySet().forEach(i -> {
-                if (i.contains(host.replace("*.", ""))) {
-                    Config.globalDataMap.remove(i);
-                }
-            });
-        } else {
-            Config.globalDataMap.remove(host);
-        }
-    }
-
-    private void initComponents() {
-        // JFormDesigner - Component initialization - DO NOT MODIFY  //GEN-BEGIN:initComponents
-        hostLabel = new JLabel();
-        hostTextField = new JTextField();
-        dataTabbedPane = new JTabbedPane();
-        clearButton = new JButton();
-
-        //======== this ========
-        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};
-
-        //---- hostLabel ----
-        hostLabel.setText("Host:");
-        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));
-        clearButton.setText("Clear");
-        clearButton.addActionListener(this::clearActionPerformed);
-        add(clearButton,  new GridBagConstraints(3, 0, 1, 1, 0.0, 0.0,
-                GridBagConstraints.CENTER, GridBagConstraints.BOTH,
-                new Insets(8, 0, 5, 5), 0, 0));
-        add(dataTabbedPane, new GridBagConstraints(1, 1, 3, 2, 0.0, 0.0,
-                GridBagConstraints.CENTER, GridBagConstraints.BOTH,
-                new Insets(8, 0, 0, 5), 0, 0));
-
-        setAutoMatch(hostTextField, dataTabbedPane);
-    }
-
-    /**
-     * 获取Host列表
-     */
-    private static List<String> getHostByList(){
-        List<String> hostList = new ArrayList<>();
-        hostList.addAll(Config.globalDataMap.keySet());
-        return hostList;
-    }
-
-    /**
-     * 设置输入自动匹配
-     */
-    public static void setAutoMatch(JTextField textField, JTabbedPane tabbedPane) {
-        final DefaultComboBoxModel comboBoxModel = new DefaultComboBoxModel();
-
-        final JComboBox hostComboBox = new JComboBox(comboBoxModel) {
-            @Override
-            public Dimension getPreferredSize() {
-                return new Dimension(super.getPreferredSize().width, 0);
-            }
-        };
-
-        isMatchHost = false;
-
-        for (String host : getHostByList()) {
-            comboBoxModel.addElement(host);
-        }
-
-        hostComboBox.setSelectedItem(null);
-
-        hostComboBox.addActionListener(e -> {
-            if (!isMatchHost) {
-                if (hostComboBox.getSelectedItem() != null) {
-                    textField.setText(hostComboBox.getSelectedItem().toString());
-                    getInfoByHost(hostComboBox, tabbedPane, textField);
-                }
-            }
-        });
-
-        // 事件监听
-        textField.addKeyListener(new KeyAdapter() {
-            @Override
-            public void keyPressed(KeyEvent e) {
-                isMatchHost = true;
-                if (e.getKeyCode() == KeyEvent.VK_SPACE) {
-                    if (hostComboBox.isPopupVisible()) {
-                        e.setKeyCode(KeyEvent.VK_ENTER);
-                    }
-                }
-                if (e.getKeyCode() == KeyEvent.VK_ENTER
-                        || e.getKeyCode() == KeyEvent.VK_UP
-                        || e.getKeyCode() == KeyEvent.VK_DOWN) {
-                    e.setSource(hostComboBox);
-                    hostComboBox.dispatchEvent(e);
-                    if (e.getKeyCode() == KeyEvent.VK_ENTER) {
-                        textField.setText(hostComboBox.getSelectedItem().toString());
-                        getInfoByHost(hostComboBox, tabbedPane, textField);
-                        hostComboBox.setPopupVisible(false);
-                    }
-                }
-                if (e.getKeyCode() == KeyEvent.VK_ESCAPE) {
-                    hostComboBox.setPopupVisible(false);
-                }
-                isMatchHost = false;
-            }
-        });
-
-        textField.getDocument().addDocumentListener(new DocumentListener() {
-            @Override
-            public void insertUpdate(DocumentEvent e) {
-                updateList();
-            }
-
-            @Override
-            public void removeUpdate(DocumentEvent e) {
-                updateList();
-            }
-
-            @Override
-            public void changedUpdate(DocumentEvent e) {
-                updateList();
-            }
-
-            private void updateList() {
-                isMatchHost = true;
-                comboBoxModel.removeAllElements();
-                String input = textField.getText();
-                if (!input.isEmpty()){
-                    for (String host : getHostByList()) {
-                        if (host.toLowerCase().contains(input.toLowerCase())) {
-                            if (host.length() == input.length()){
-                                comboBoxModel.insertElementAt(host,0);
-                                comboBoxModel.setSelectedItem(host);
-                            }else{
-                                comboBoxModel.addElement(host);
-                            }
-                        }
-                    }
-                }
-                hostComboBox.setPopupVisible(comboBoxModel.getSize() > 0);
-                isMatchHost = false;
-            }
-        });
-
-        textField.setLayout(new BorderLayout());
-        textField.add(hostComboBox, BorderLayout.SOUTH);
-    }
-
-    private static void getInfoByHost(@NotNull JComboBox hostComboBox, JTabbedPane tabbedPane, JTextField textField) {
-        if (hostComboBox.getSelectedItem() != null) {
-            Map<String, Map<String, List<String>>> ruleMap = Config.globalDataMap;
-            Map<String, List<String>> selectHost = new HashMap<>();
-            String host = hostComboBox.getSelectedItem().toString();
-            if (host.contains("*")) {
-                // 通配符数据
-                Map<String, List<String>> finalSelectHost = selectHost;
-                ruleMap.keySet().forEach(i -> {
-                    if (i.contains(host.replace("*.", ""))) {
-                        ruleMap.get(i).keySet().forEach(e -> {
-                            if (finalSelectHost.containsKey(e)) {
-                                // 合并操作
-                                List<String> newList = new ArrayList<>(finalSelectHost.get(e));
-                                newList.addAll(ruleMap.get(i).get(e));
-                                // 去重操作
-                                HashSet tmpList = new HashSet(newList);
-                                newList.clear();
-                                newList.addAll(tmpList);
-                                // 添加操作
-                                finalSelectHost.put(e, newList);
-                            } else {
-                                finalSelectHost.put(e, ruleMap.get(i).get(e));
-                            }
-                        });
-                    }
-                });
-            } else {
-                selectHost = ruleMap.get(host);
-            }
-
-            tabbedPane.removeAll();
-            for(Map.Entry<String, List<String>> entry: selectHost.entrySet()){
-                tabbedPane.addTab(entry.getKey(), new JScrollPane(new HitRuleDataList(entry.getValue())));
-            }
-            textField.setText(hostComboBox.getSelectedItem().toString());
-        }
-    }
-
-    // JFormDesigner - Variables declaration - DO NOT MODIFY  //GEN-BEGIN:variables
-    private JLabel hostLabel;
-    private JTextField hostTextField;
-    private JTabbedPane dataTabbedPane;
-    private JButton clearButton;
-    // JFormDesigner - End of variables declaration  //GEN-END:variables
-
-    // 是否自动匹配Host
-    private static Boolean isMatchHost = false;
-}
-class HitRuleDataList extends JTable {
-    public HitRuleDataList(List<String> list){
-        DefaultTableModel model = new DefaultTableModel();
-        Object[][] data = new Object[list.size()][1];
-        for (int x = 0; x < list.size(); x++) {
-            data[x][0] = list.get(x);
-        }
-        model.setDataVector(data, new Object[]{"Information"});
-        this.setModel(model);
-    }
-}

src/main/java/burp/ui/JTabbedPaneCloseButton.java

@@ -1,114 +0,0 @@
-package burp.ui;
-
-import javax.swing.*;
-import javax.swing.plaf.metal.MetalIconFactory;
-import java.awt.*;
-import java.awt.event.MouseEvent;
-import java.awt.event.MouseListener;
-
-/**
- * @author 6dc
- *
- * A class which creates a JTabbedPane and auto sets a close button when you add a tab
- */
-
-public class JTabbedPaneCloseButton extends JTabbedPane {
-
-    public JTabbedPaneCloseButton() {
-        super();
-    }
-
-    /** Override Addtab in order to add the close Button everytime */
-    @Override
-    public void addTab(String title, Icon icon, Component component, String tip) {
-        super.addTab(title, icon, component, tip);
-        int count = this.getTabCount() - 1;
-        setTabComponentAt(count, new CloseButtonTab(component, title, icon));
-    }
-
-    @Override
-    public void addTab(String title, Icon icon, Component component) {
-        addTab(title, icon, component, null);
-    }
-
-    @Override
-    public void addTab(String title, Component component) {
-        addTab(title, null, component);
-    }
-
-
-    public void addTab(String title,Component component,Boolean closewith){
-        if (closewith){
-            addTab(title,component);
-        }else{
-            super.addTab(title,null,component,null);
-        }
-    }
-
-    /** addTabNoExit */
-    public void addTabNoExit(String title, Icon icon, Component component, String tip) {
-        super.addTab(title, icon, component, tip);
-    }
-
-    public void addTabNoExit(String title, Icon icon, Component component) {
-        addTabNoExit(title, icon, component, null);
-    }
-
-    public void addTabNoExit(String title, Component component) {
-        addTabNoExit(title, null, component);
-    }
-
-    /** Button */
-    public class CloseButtonTab extends JPanel {
-        public CloseButtonTab(final Component tab, String title, Icon icon) {
-            setOpaque(false);
-            FlowLayout flowLayout = new FlowLayout(FlowLayout.CENTER, 3, 3);
-            setLayout(flowLayout);
-            JLabel jLabel = new JLabel(title);
-            jLabel.setIcon(icon);
-            add(jLabel);
-            JButton button = new JButton(MetalIconFactory.getInternalFrameCloseIcon(2));
-            button.setMargin(new Insets(0, 0, 0, 0));
-            button.addMouseListener(new CloseListener(tab));
-            add(button);
-        }
-    }
-    /** ClickListener */
-    public class CloseListener implements MouseListener
-    {
-        private final Component tab;
-
-        public CloseListener(Component tab){
-            this.tab=tab;
-        }
-
-        @Override
-        public void mouseClicked(MouseEvent e) {
-            if(e.getSource() instanceof JButton){
-                JButton clickedButton = (JButton) e.getSource();
-                JTabbedPane tabbedPane = (JTabbedPane) clickedButton.getParent().getParent().getParent();
-                tabbedPane.remove(tab);
-            }
-        }
-
-        @Override
-        public void mousePressed(MouseEvent e) {}
-
-        @Override
-        public void mouseReleased(MouseEvent e) {}
-
-        @Override
-        public void mouseEntered(MouseEvent e) {
-            if(e.getSource() instanceof JButton){
-                JButton clickedButton = (JButton) e.getSource();
-            }
-        }
-
-        @Override
-        public void mouseExited(MouseEvent e) {
-            if(e.getSource() instanceof JButton){
-                JButton clickedButton = (JButton) e.getSource();
-            }
-        }
-    }
-}

src/main/java/burp/ui/MainUI.java

@@ -1,13 +1,14 @@
 package burp.ui;
 
-import burp.Config;
-import burp.yaml.LoadConfig;
-import burp.yaml.SetConfig;
-
-import com.squareup.okhttp.OkHttpClient;
-import com.squareup.okhttp.Request;
-import com.squareup.okhttp.Response;
-import java.io.FileOutputStream;
+import burp.config.ConfigEntry;
+import burp.config.ConfigLoader;
+import burp.rule.RuleProcessor;
+import burp.ui.board.Databoard;
+import burp.ui.board.MessagePanel;
+import burp.ui.rule.RulePane;
+import java.beans.PropertyChangeEvent;
+import java.beans.PropertyChangeListener;
+import java.net.URL;
 import javax.swing.*;
 import javax.swing.event.ChangeEvent;
 import javax.swing.event.ChangeListener;
@@ -21,51 +22,27 @@ import java.util.Map;
  * @author LinChen && EvilChen
  */
 
-public class MainUI extends JPanel{
-    private final LoadConfig loadConn = new LoadConfig();
+public class MainUI extends JPanel {
 
-    public MainUI() {
+    public MainUI(MessagePanel messagePanel) {
+        databoardPanel = new Databoard(messagePanel);
         initComponents();
     }
 
-    public void closeTabActionPerformed(ActionEvent e){
-        if (ruleTabbedPane.getTabCount()>2){
-            if (ruleTabbedPane.getSelectedIndex()!=0){
-                SetConfig setConn = new SetConfig();
-                setConn.deleteRules(ruleTabbedPane.getTitleAt(ruleTabbedPane.getSelectedIndex()));
-                ruleTabbedPane.remove(ruleTabbedPane.getSelectedIndex());
-                ruleTabbedPane.setSelectedIndex(ruleTabbedPane.getSelectedIndex()-1);
-            } else {
-                SetConfig setConn = new SetConfig();
-                setConn.deleteRules(ruleTabbedPane.getTitleAt(ruleTabbedPane.getSelectedIndex()));
-                ruleTabbedPane.remove(ruleTabbedPane.getSelectedIndex());
-                ruleTabbedPane.setSelectedIndex(ruleTabbedPane.getSelectedIndex());
-            }
+    public void closeTabActionPerformed(ActionEvent e) {
+        if (ruleTabbedPane.getTabCount() > 2 && ruleTabbedPane.getSelectedIndex() != 0) {
+            String title = ruleTabbedPane.getTitleAt(ruleTabbedPane.getSelectedIndex());
+            new RuleProcessor().deleteRuleGroup(title);
+            ruleTabbedPane.remove(ruleTabbedPane.getSelectedIndex());
+            ruleTabbedPane.setSelectedIndex(ruleTabbedPane.getSelectedIndex() - 1);
         }
     }
 
     private void onlineUpdateActionPerformed(ActionEvent e) {
         // 添加提示框防止用户误触导致配置更新
-        int retCode = JOptionPane.showConfirmDialog(null, "Do you want to update config?", "Info",
-                JOptionPane.YES_NO_CANCEL_OPTION);
+        int retCode = JOptionPane.showConfirmDialog(null, "Do you want to update rules?", "Info", JOptionPane.YES_NO_OPTION);
         if (retCode == JOptionPane.YES_OPTION) {
-            String url = "https://raw.githubusercontent.com/gh0stkey/HaE/gh-pages/Config.yml";
-            OkHttpClient httpClient = new OkHttpClient();
-            Request httpRequest = new Request.Builder().url(url).get().build();
-            try {
-                Response httpResponse = httpClient.newCall(httpRequest).execute();
-                // 获取官方规则文件，在线更新写入
-                String configFile = configTextField.getText();
-                FileOutputStream fileOutputStream = new FileOutputStream(configFile);
-                fileOutputStream.write(httpResponse.body().bytes());
-                JOptionPane.showMessageDialog(null, "Config file updated successfully!", "Error",
-                        JOptionPane.INFORMATION_MESSAGE);
-            } catch (Exception ignored) {
-                JOptionPane.showMessageDialog(null, "Please check your network!", "Error",
-                        JOptionPane.ERROR_MESSAGE);
-            }
-
-            new LoadConfig();
+            ConfigLoader.initRules();
             reloadRule();
         }
     }
@@ -73,9 +50,9 @@ public class MainUI extends JPanel{
     private void reloadRule(){
         ruleTabbedPane.removeAll();
         ruleSwitch.setListen(false);
-        Map<String,Object[][]> rules = LoadConfig.getRules();
+        Map<String,Object[][]> rules = ConfigLoader.getRules();
         rules.keySet().forEach(
-                i-> ruleTabbedPane.addTab(
+                i -> ruleTabbedPane.addTab(
                         i,
                         new RulePane(rules.get(i), ruleTabbedPane)
                 )
@@ -89,20 +66,20 @@ public class MainUI extends JPanel{
     }
 
     private void excludeSuffixSaveActionPerformed(ActionEvent e) {
-        LoadConfig loadCon = new LoadConfig();
-        loadCon.setExcludeSuffix(excludeSuffixTextField.getText());
+        ConfigLoader.setExcludeSuffix(excludeSuffixTextField.getText());
     }
+
     private void initComponents() {
-        mainTabbedPane = new JTabbedPane();
+        JTabbedPane mainTabbedPane = new JTabbedPane();
         ruleTabbedPane = new JTabbedPane();
-        rulePanel = new JPanel();
-        configTextField = new JTextField();
-        configLabel = new JLabel();
-        onlineUpdateButton = new JButton();
-        reloadButton = new JButton();
-        excludeSuffixLabel = new JLabel();
+        JPanel rulePanel = new JPanel();
+        rulesPathTextField = new JTextField();
+        JLabel rulesPathLabel = new JLabel();
+        JButton onlineUpdateButton = new JButton();
+        JButton reloadButton = new JButton();
+        JLabel excludeSuffixLabel = new JLabel();
         excludeSuffixTextField = new JTextField();
-        excludeSuffixSaveButton = new JButton();
+        JButton excludeSuffixSaveButton = new JButton();
 
         setLayout(new GridBagLayout());
         ((GridBagLayout)getLayout()).columnWidths = new int[] {0, 0};
@@ -120,13 +97,13 @@ public class MainUI extends JPanel{
                 ((GridBagLayout) rulePanel.getLayout()).columnWeights = new double[] {0.0, 1.0, 0.0, 0.0, 1.0E-4};
                 ((GridBagLayout) rulePanel.getLayout()).rowWeights = new double[] {0.0, 0.0, 1.0E-4};
 
-                configTextField.setEditable(false);
-                rulePanel.add(configTextField, new GridBagConstraints(1, 0, 1, 1, 0.0, 0.0,
+                rulesPathTextField.setEditable(false);
+                rulePanel.add(rulesPathTextField, new GridBagConstraints(1, 0, 1, 1, 0.0, 0.0,
                         GridBagConstraints.CENTER, GridBagConstraints.BOTH,
                         new Insets(5, 0, 5, 5), 0, 0));
 
-                configLabel.setText("Config Path:");
-                rulePanel.add(configLabel, new GridBagConstraints(0, 0, 1, 1, 0.0, 0.0,
+                rulesPathLabel.setText("Rules Path:");
+                rulePanel.add(rulesPathLabel, new GridBagConstraints(0, 0, 1, 1, 0.0, 0.0,
                         GridBagConstraints.WEST, GridBagConstraints.VERTICAL,
                         new Insets(5, 5, 5, 5), 0, 0));
 
@@ -158,39 +135,72 @@ public class MainUI extends JPanel{
                         new Insets(0, 0, 0, 5), 0, 0));
             }
             mainTabbedPane.addTab("Config", rulePanel);
-            mainTabbedPane.addTab("Databoard", databoardPanel);
+            mainTabbedPane.addTab("Databoard", this.databoardPanel);
         }
-        add(mainTabbedPane, new GridBagConstraints(0, 0, 1, 1, 0.0, 0.0,
+
+        // 新增Logo
+        JTabbedPane HaETabbedPane = new JTabbedPane();
+        HaETabbedPane.addTab("", getImageIcon(false), mainTabbedPane);
+        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();
+                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,
                 GridBagConstraints.CENTER, GridBagConstraints.BOTH,
                 new Insets(0, 0, 0, 0), 0, 0));
 
-        Config.ruleConfig.keySet().forEach(i-> ruleTabbedPane.addTab(i,new RulePane(Config.ruleConfig.get(i),
+        ConfigEntry.globalRules.keySet().forEach(i-> ruleTabbedPane.addTab(i, new RulePane(
+                ConfigEntry.globalRules.get(i),
                 ruleTabbedPane)));
 
-        ruleTabbedPane.addTab("...",new JLabel());
+        ruleTabbedPane.addTab("...", new JLabel());
 
-        configTextField.setText(LoadConfig.getConfigPath());
-        excludeSuffixTextField.setText(loadConn.getExcludeSuffix());
+        rulesPathTextField.setText(ConfigLoader.getRulesFilePath());
+        excludeSuffixTextField.setText(ConfigLoader.getExcludeSuffix());
         ruleSwitch = new TabTitleEditListener(ruleTabbedPane);
         ruleTabbedPane.addChangeListener(ruleSwitch);
         ruleTabbedPane.addMouseListener(ruleSwitch);
-        closeTabMenuItem.addActionListener(this::closeTabActionPerformed);
-        tabMenu.add(closeTabMenuItem);
+        deleteMenuItem.addActionListener(this::closeTabActionPerformed);
+        tabMenu.add(deleteMenuItem);
+    }
+
+    private ImageIcon getImageIcon(boolean isDark) {
+        ClassLoader classLoader = getClass().getClassLoader();
+        URL imageURL;
+        if (isDark) {
+            imageURL = classLoader.getResource("logo.png");
+        } else {
+            imageURL = classLoader.getResource("logo_black.png");
+        }
+        ImageIcon originalIcon = new ImageIcon(imageURL);
+        Image originalImage = originalIcon.getImage();
+        Image scaledImage = originalImage.getScaledInstance(30, 20, Image.SCALE_FAST);
+        ImageIcon scaledIcon = new ImageIcon(scaledImage);
+        return scaledIcon;
     }
 
-    private JTabbedPane mainTabbedPane;
     private JTabbedPane ruleTabbedPane;
-    private JPanel rulePanel;
-    private JTextField configTextField;
-    private JLabel configLabel;
-    private JButton onlineUpdateButton;
-    private JButton reloadButton;
-    private JLabel excludeSuffixLabel;
+    private JTextField rulesPathTextField;
     private JTextField excludeSuffixTextField;
-    private JButton excludeSuffixSaveButton;
-    private Databoard databoardPanel = new Databoard();
+    private Databoard databoardPanel;
     protected static JPopupMenu tabMenu = new JPopupMenu();
-    private JMenuItem closeTabMenuItem = new JMenuItem("Delete");
+    private final JMenuItem deleteMenuItem = new JMenuItem("Delete");
     private TabTitleEditListener ruleSwitch;
 }
 
@@ -203,7 +213,7 @@ class TabTitleEditListener extends MouseAdapter implements ChangeListener, Docum
     protected Dimension dim;
     protected Component tabComponent;
     protected Boolean isRenameOk = false;
-    protected SetConfig setConfig = new SetConfig();
+    protected RuleProcessor ruleProcessor = new RuleProcessor();
 
     protected final Action startEditing = new AbstractAction() {
         @Override public void actionPerformed(ActionEvent e) {
@@ -227,7 +237,7 @@ class TabTitleEditListener extends MouseAdapter implements ChangeListener, Docum
             if (editingIndex >= 0 && !title.isEmpty()) {
                 String oldName = ruleEditTabbedPane.getTitleAt(editingIndex);
                 ruleEditTabbedPane.setTitleAt(editingIndex, title);
-                setConfig.rename(oldName,title);
+                ruleProcessor.renameRuleGroup(oldName,title);
             }
             cancelEditing.actionPerformed(null);
         }
@@ -284,8 +294,8 @@ class TabTitleEditListener extends MouseAdapter implements ChangeListener, Docum
     }
 
     public void newTab(){
-        Object[][] data = new Object[][]{{false, "New Name", "(New Regex)", "gray", "any", "nfa", false}};
-        insertTab(ruleEditTabbedPane, setConfig.newRules(),data);
+        Object[][] data = new Object[][]{{false, "New Name", "(New Regex)", "", "{0}", "gray", "any", "nfa", false}};
+        insertTab(ruleEditTabbedPane, ruleProcessor.newRule(),data);
     }
 
     public void insertTab(JTabbedPane pane,String title,Object[][] data){
@@ -334,4 +344,4 @@ class TabTitleEditListener extends MouseAdapter implements ChangeListener, Docum
         ruleEditTextField.setPreferredSize(ruleEditTextField.getText().length() > len ? null : dim);
         ruleEditTabbedPane.revalidate();
     }
-}
+}

src/main/java/burp/ui/RuleSetting.java

@@ -1,118 +0,0 @@
-package burp.ui;
-
-import java.awt.event.ActionEvent;
-import java.awt.event.ActionListener;
-import java.awt.event.ItemEvent;
-import java.awt.event.ItemListener;
-import javax.swing.*;
-import java.awt.*;
-import burp.Config;
-
-/**
- * @author LinChen
- */
-
-public class RuleSetting extends JPanel {
-    public RuleSetting() {
-        initComponents();
-    }
-
-    public void initComponents() {
-        sensitiveLabel = new JLabel();
-        engineLabel = new JLabel();
-        scopeLabel = new JLabel();
-        regexTextField = new JTextField();
-        regexLabel = new JLabel();
-        nameLabel = new JLabel();
-        ruleNameTextField = new JTextField();
-        scopeComboBox = new JComboBox<>();
-        engineComboBox = new JComboBox<>();
-        colorLabel = new JLabel();
-        colorComboBox = new JComboBox<>();
-        sensitiveComboBox = new JComboBox<>();
-
-        setLayout(null);
-
-        engineLabel.setText("Engine:");
-        add(engineLabel);
-        engineLabel.setBounds(new Rectangle(new Point(10, 175), engineLabel.getPreferredSize()));
-
-        sensitiveLabel.setText("Sensitive:");
-        add(sensitiveLabel);
-        sensitiveLabel.setBounds(new Rectangle(new Point(10,215), sensitiveLabel.getPreferredSize()));
-
-        scopeLabel.setText("Scope:");
-        add(scopeLabel);
-        scopeLabel.setBounds(new Rectangle(new Point(10, 135), scopeLabel.getPreferredSize()));
-        add(regexTextField);
-        regexTextField.setBounds(70, 50, 265, 30);
-
-        regexLabel.setText("Regex:");
-        add(regexLabel);
-        regexLabel.setBounds(new Rectangle(new Point(10, 55), regexLabel.getPreferredSize()));
-
-        nameLabel.setText("Name:");
-        add(nameLabel);
-        nameLabel.setBounds(new Rectangle(new Point(10, 15), nameLabel.getPreferredSize()));
-        add(ruleNameTextField);
-        ruleNameTextField.setBounds(70, 10, 265, 30);
-
-        scopeComboBox.setModel(new DefaultComboBoxModel<>(Config.scopeArray));
-        add(scopeComboBox);
-        scopeComboBox.setBounds(70, 130, 265, scopeComboBox.getPreferredSize().height);
-
-        engineComboBox.setModel(new DefaultComboBoxModel<>(Config.engineArray));
-        engineComboBox.addActionListener(new ActionListener() {
-            @Override
-            public void actionPerformed(ActionEvent e) {
-                String engineValue = engineComboBox.getSelectedItem().toString();
-                if (engineValue.equals("nfa")) {
-                    sensitiveComboBox.setEnabled(true);
-                } else {
-                    sensitiveComboBox.setEnabled(false);
-                }
-            }
-        });
-        add(engineComboBox);
-        engineComboBox.setBounds(70, 170, 265, engineComboBox.getPreferredSize().height);
-
-        colorLabel.setText("Color:");
-        add(colorLabel);
-        colorLabel.setBounds(new Rectangle(new Point(10, 95), colorLabel.getPreferredSize()));
-
-        colorComboBox.setModel(new DefaultComboBoxModel<>(Config.colorArray));
-        add(colorComboBox);
-        colorComboBox.setBounds(70, 90, 265, colorComboBox.getPreferredSize().height);
-
-        sensitiveComboBox.setModel(new DefaultComboBoxModel<>(new Boolean[]{true, false}));
-        add(sensitiveComboBox);
-        sensitiveComboBox.setBounds(70,210,265,sensitiveComboBox.getPreferredSize().height);
-
-        {
-            Dimension preferredSize = new Dimension();
-            for(int i = 0; i < getComponentCount(); i++) {
-                Rectangle bounds = getComponent(i).getBounds();
-                preferredSize.width = Math.max(bounds.x + bounds.width, preferredSize.width);
-                preferredSize.height = Math.max(bounds.y + bounds.height, preferredSize.height);
-            }
-            Insets insets = getInsets();
-            preferredSize.width += insets.right;
-            preferredSize.height += insets.bottom;
-            setMinimumSize(preferredSize);
-            setPreferredSize(preferredSize);
-        }
-    }
-
-    private JLabel engineLabel;
-    private JLabel sensitiveLabel;
-    private JLabel scopeLabel;
-    public JTextField regexTextField;
-    private JLabel regexLabel;
-    private JLabel nameLabel;
-    public JTextField ruleNameTextField;
-    public JComboBox<String> scopeComboBox;
-    public JComboBox<String> engineComboBox;
-    private JLabel colorLabel;
-    public JComboBox<String> colorComboBox;
-    public JComboBox<Boolean> sensitiveComboBox;
-}

src/main/java/burp/ui/board/ColorRenderer.java

@@ -0,0 +1,67 @@
+package burp.ui.board;
+
+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.table.DefaultTableCellRenderer;
+
+public class ColorRenderer extends DefaultTableCellRenderer {
+
+    private List<LogEntry> log;
+    private Map<String, Color> colorMap = new HashMap<>();
+    private JTable table; // 保存对表格的引用
+
+    public ColorRenderer(List<LogEntry> log, JTable table) {
+        this.log = log;
+        // 与BurpSuite的颜色保持一致
+        this.colorMap.put("red", new Color(0xFF, 0x64, 0x64));
+        this.colorMap.put("orange", new Color(0xFF, 0xC8, 0x64));
+        this.colorMap.put("yellow", new Color(0xFF, 0xFF, 0x64));
+        this.colorMap.put("green", new Color(0x64, 0xFF, 0x64));
+        this.colorMap.put("cyan", new Color(0x64, 0xFF, 0xFF));
+        this.colorMap.put("blue", new Color(0x64, 0x64, 0xFF));
+        this.colorMap.put("pink", new Color(0xFF, 0xC8, 0xC8));
+        this.colorMap.put("magenta", new Color(0xFF, 0x64, 0xFF));
+        this.colorMap.put("gray", new Color(0xB4, 0xB4, 0xB4));
+        this.table = table;
+    }
+
+    @Override
+    public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected,
+            boolean hasFocus, int row, int column) {
+        Component component = super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
+
+        LogEntry logEntry = log.get(table.convertRowIndexToModel(row)); // 使用convertRowIndexToModel方法转换行索引
+
+        // 设置颜色
+        String colorByLog = logEntry.getColor();
+        Color color = colorMap.get(colorByLog);
+
+        if (isSelected) {
+            // 通过更改RGB颜色来达成阴影效果
+            component.setBackground(new Color(color.getRed()-0x20, color.getGreen()-0x20, color.getBlue()-0x20));
+        } else {
+            // 否则使用原始颜色
+            component.setBackground(color);
+        }
+
+        component.setForeground(Color.BLACK);
+
+        return component;
+    }
+
+    @Override
+    public void firePropertyChange(String propertyName, Object oldValue, Object newValue) {
+        super.firePropertyChange(propertyName, oldValue, newValue);
+        // 监听表格排序的属性变化
+        if ("tableCellRenderer".equals(propertyName)) {
+            // 更新每一行数据的颜色
+            for (int i = 0; i < table.getRowCount(); i++) {
+                table.repaint(table.getCellRect(i, 0, true));
+            }
+        }
+    }
+}

src/main/java/burp/ui/board/Databoard.java

@@ -0,0 +1,352 @@
+package burp.ui.board;
+
+import burp.config.ConfigEntry;
+import burp.core.utils.StringHelper;
+import burp.ui.board.MessagePanel.Table;
+
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+import javax.swing.event.*;
+import javax.swing.table.TableColumn;
+import javax.swing.table.TableColumnModel;
+import javax.swing.table.TableModel;
+import javax.swing.table.TableRowSorter;
+import java.awt.*;
+import java.awt.event.*;
+import java.util.List;
+import javax.swing.*;
+
+/**
+ * @author LinChen && EvilChen
+ */
+
+public class Databoard extends JPanel {
+    private static Boolean isMatchHost = false;
+    private JLabel hostLabel;
+    private JTextField hostTextField;
+    private JTabbedPane dataTabbedPane;
+    private JButton clearButton;
+    private JSplitPane splitPane;
+    private MessagePanel messagePanel;
+    private Table table;
+    private SwingWorker<Object, Void> currentWorker;
+    private DefaultComboBoxModel comboBoxModel = new DefaultComboBoxModel();
+    private JComboBox hostComboBox = new JComboBox(comboBoxModel);
+    private ChangeListener changeListenerInstance = new ChangeListener() {
+        @Override
+        public void stateChanged(ChangeEvent e) {
+            int selectedIndex = dataTabbedPane.getSelectedIndex();
+            String selectedTitle = "";
+
+            if (selectedIndex != -1) {
+                selectedTitle = dataTabbedPane.getTitleAt(selectedIndex);
+            }
+
+            applyHostFilter(selectedTitle);
+        }
+    };
+
+    public Databoard(MessagePanel messagePanel) {
+        this.messagePanel = messagePanel;
+        initComponents();
+    }
+
+    private void cleanUI() {
+        dataTabbedPane.removeAll();
+        splitPane.setVisible(false);
+    }
+
+    private void clearActionPerformed(ActionEvent e) {
+        int retCode = JOptionPane.showConfirmDialog(null, "Do you want to clear data?", "Info",
+                JOptionPane.YES_NO_OPTION);
+        if (retCode == JOptionPane.YES_OPTION) {
+            cleanUI();
+
+            String host = hostTextField.getText();
+            String cleanedHost = StringHelper.replaceFirstOccurrence(host, "*.", "");
+
+            if (host.contains("*")) {
+                ConfigEntry.globalDataMap.keySet().removeIf(i -> i.contains(cleanedHost) || cleanedHost.contains("*"));
+            } else {
+                ConfigEntry.globalDataMap.remove(host);
+            }
+
+            messagePanel.deleteByHost(cleanedHost);
+        }
+    }
+
+    private void initComponents() {
+        hostLabel = new JLabel();
+        hostTextField = new JTextField();
+        dataTabbedPane = new JTabbedPane(JTabbedPane.TOP);
+        clearButton = new JButton();
+
+        //======== this ========
+        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};
+
+        //---- hostLabel ----
+        hostLabel.setText("Host:");
+        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));
+        clearButton.setText("Clear");
+        clearButton.addActionListener(this::clearActionPerformed);
+        add(clearButton,  new GridBagConstraints(3, 0, 1, 1, 0.0, 0.0, GridBagConstraints.CENTER, GridBagConstraints.BOTH,
+                new Insets(8, 0, 5, 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));
+
+        splitPane = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT);
+        splitPane.setVisible(false);
+        add(splitPane, new GridBagConstraints(1, 1, 3, 3, 0.0, 0.0,
+                GridBagConstraints.CENTER, GridBagConstraints.BOTH,
+                new Insets(8, 0, 5, 5), 0, 0));
+
+        splitPane.addComponentListener(new ComponentAdapter() {
+            @Override
+            public void componentResized(ComponentEvent e) {
+                resizePanel();
+            }
+        });
+
+        setAutoMatch();
+    }
+
+    private void resizePanel() {
+        splitPane.setDividerLocation(0.4);
+        TableColumnModel columnModel = table.getColumnModel();
+        int totalWidth = (int) (getWidth() * 0.6);
+        columnModel.getColumn(0).setPreferredWidth((int) (totalWidth * 0.1));
+        columnModel.getColumn(1).setPreferredWidth((int) (totalWidth * 0.3));
+        columnModel.getColumn(2).setPreferredWidth((int) (totalWidth * 0.3));
+        columnModel.getColumn(3).setPreferredWidth((int) (totalWidth * 0.1));
+        columnModel.getColumn(4).setPreferredWidth((int) (totalWidth * 0.1));
+        columnModel.getColumn(5).setPreferredWidth((int) (totalWidth * 0.1));
+    }
+
+    private static List<String> getHostByList() {
+        return new ArrayList<>(ConfigEntry.globalDataMap.keySet());
+    }
+
+    /**
+     * 设置输入自动匹配
+     */
+    private void setAutoMatch() {
+        populateComboBoxModel();
+
+        hostComboBox.setSelectedItem(null);
+        hostComboBox.addActionListener(this::handleComboBoxAction);
+
+        hostTextField.addKeyListener(new KeyAdapter() {
+            @Override
+            public void keyPressed(KeyEvent e) {
+                handleKeyEvents(e);
+            }
+        });
+
+        hostTextField.getDocument().addDocumentListener(new DocumentListener() {
+            @Override
+            public void insertUpdate(DocumentEvent e) {
+                filterComboBoxList();
+            }
+
+            @Override
+            public void removeUpdate(DocumentEvent e) {
+                filterComboBoxList();
+            }
+
+            @Override
+            public void changedUpdate(DocumentEvent e) {
+                filterComboBoxList();
+            }
+
+        });
+    }
+
+    private void populateComboBoxModel() {
+        for (String host : getHostByList()) {
+            comboBoxModel.addElement(host);
+        }
+    }
+
+    private void handleComboBoxAction(ActionEvent e) {
+        if (!isMatchHost && hostComboBox.getSelectedItem() != null) {
+            String selectedHost = hostComboBox.getSelectedItem().toString();
+            hostTextField.setText(selectedHost);
+            populateTabbedPaneByHost(selectedHost);
+        }
+    }
+    
+    private void handleKeyEvents(KeyEvent e) {
+        isMatchHost = true;
+        int keyCode = e.getKeyCode();
+
+        if (keyCode == KeyEvent.VK_SPACE && hostComboBox.isPopupVisible()) {
+            e.setKeyCode(KeyEvent.VK_ENTER);
+        }
+
+        if (Arrays.asList(KeyEvent.VK_DOWN, KeyEvent.VK_UP).contains(keyCode)) {
+            hostComboBox.dispatchEvent(e);
+        }
+
+        if (keyCode == KeyEvent.VK_ENTER) {
+            isMatchHost = false;
+            handleComboBoxAction(null);
+            hostComboBox.setPopupVisible(false);
+        }
+
+        if (keyCode == KeyEvent.VK_ESCAPE) {
+            hostComboBox.setPopupVisible(false);
+        }
+
+        isMatchHost = false;
+    }
+
+    private void filterComboBoxList() {
+        isMatchHost = true;
+        comboBoxModel.removeAllElements();
+        String input = hostTextField.getText().toLowerCase();
+
+        if (!input.isEmpty()) {
+            for (String host : getHostByList()) {
+                String lowerCaseHost = host.toLowerCase();
+                if (lowerCaseHost.contains(input)) {
+                    if (lowerCaseHost.equals(input)) {
+                        comboBoxModel.insertElementAt(lowerCaseHost, 0);
+                        comboBoxModel.setSelectedItem(lowerCaseHost);
+                    } else {
+                        comboBoxModel.addElement(host);
+                    }
+                }
+            }
+        }
+
+        hostComboBox.setPopupVisible(comboBoxModel.getSize() > 0);
+        isMatchHost = false;
+    }
+
+    private void applyHostFilter(String filterText) {
+        TableRowSorter<TableModel> sorter = (TableRowSorter<TableModel>) table.getRowSorter();
+
+        String cleanedText = StringHelper.replaceFirstOccurrence(filterText, "*.", "");
+
+        if (cleanedText.contains("*")) {
+            cleanedText = "";
+        }
+
+        RowFilter<TableModel, Integer> filter = RowFilter.regexFilter(cleanedText, 1);
+        sorter.setRowFilter(filter);
+
+        messagePanel.applyHostFilter(filterText);
+    }
+
+    private void populateTabbedPaneByHost(String selectedHost) {
+        if (!Objects.equals(selectedHost, "")) {
+            ConcurrentHashMap<String, Map<String, List<String>>> dataMap = ConfigEntry.globalDataMap;
+            Map<String, List<String>> selectedDataMap;
+
+            dataTabbedPane.removeAll();
+            dataTabbedPane.setPreferredSize(new Dimension(500,0));
+            dataTabbedPane.setTabLayoutPolicy(JTabbedPane.SCROLL_TAB_LAYOUT);
+            dataTabbedPane.removeChangeListener(changeListenerInstance);
+            splitPane.setLeftComponent(dataTabbedPane);
+
+            if (selectedHost.contains("*")) {
+                // 通配符数据
+                selectedDataMap = new HashMap<>();
+                String hostPattern = StringHelper.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);
+            }
+
+            if (selectedHost.equals("**")) {
+                if (currentWorker != null && !currentWorker.isDone()) {
+                    currentWorker.cancel(true);
+                }
+                for (ConcurrentHashMap.Entry<String, Map<String, List<String>>> entry : dataMap.entrySet()) {
+                    JTabbedPane newTabbedPane = new JTabbedPane();
+                    newTabbedPane.setTabLayoutPolicy(JTabbedPane.SCROLL_TAB_LAYOUT);
+                    for (Map.Entry<String, List<String>> entrySet : entry.getValue().entrySet()) {
+                        currentWorker = new SwingWorker<Object, Void>() {
+                            @Override
+                            protected Object[] doInBackground() throws Exception {
+                                String tabTitle = String.format("%s (%s)", entrySet.getKey(),
+                                        entrySet.getValue().size());
+                                DatatablePanel datatablePanel = new DatatablePanel(entrySet.getKey(),
+                                        entrySet.getValue());
+                                datatablePanel.setTableListener(messagePanel);
+                                return new Object[] {tabTitle, datatablePanel};
+                            }
+
+                            @Override
+                            protected void done() {
+                                if (!isCancelled()) {
+                                    try {
+                                        Object[] result = (Object[]) get();
+                                        SwingUtilities.invokeLater(() -> {
+                                            newTabbedPane.addTab(result[0].toString(), (DatatablePanel) result[1]);
+                                            dataTabbedPane.addTab(entry.getKey(), newTabbedPane);
+                                        });
+                                    } catch (Exception e) {
+                                        e.printStackTrace();
+                                    }
+                                }
+                            }
+                        };
+                        currentWorker.execute();
+                    }
+                }
+
+                dataTabbedPane.addChangeListener(changeListenerInstance);
+            } else {
+                for (Map.Entry<String, List<String>> entry : selectedDataMap.entrySet()) {
+                    String tabTitle = String.format("%s (%s)", entry.getKey(), entry.getValue().size());
+                    DatatablePanel datatablePanel = new DatatablePanel(entry.getKey(), entry.getValue());
+                    datatablePanel.setTableListener(messagePanel);
+                    dataTabbedPane.addTab(tabTitle, datatablePanel);
+                }
+            }
+
+            // 展示请求消息表单
+            JSplitPane messageSplitPane = this.messagePanel.getPanel();
+            this.splitPane.setRightComponent(messageSplitPane);
+            table = this.messagePanel.getTable();
+
+            resizePanel();
+            splitPane.setVisible(true);
+
+            applyHostFilter(selectedHost);
+
+            // 主动调用一次stateChanged，使得dataTabbedPane可以精准展示内容
+            if (selectedHost.equals("**")) {
+                changeListenerInstance.stateChanged(null);
+            }
+
+            hostTextField.setText(selectedHost);
+
+        }
+    }
+}

src/main/java/burp/ui/board/DatatablePanel.java

@@ -0,0 +1,240 @@
+package burp.ui.board;
+
+import java.awt.BorderLayout;
+import java.awt.Color;
+import java.awt.GridLayout;
+import java.awt.datatransfer.Clipboard;
+import java.awt.datatransfer.StringSelection;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.event.FocusEvent;
+import java.awt.event.FocusListener;
+import jregex.Pattern;
+import jregex.REFlags;
+import java.awt.event.ItemEvent;
+import java.awt.event.ItemListener;
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+import java.util.Comparator;
+import java.util.List;
+import javax.swing.BorderFactory;
+import javax.swing.Box;
+import javax.swing.BoxLayout;
+import javax.swing.JButton;
+import javax.swing.JCheckBox;
+import javax.swing.JComponent;
+import javax.swing.JPanel;
+import javax.swing.JPopupMenu;
+import javax.swing.JScrollPane;
+import javax.swing.JTable;
+import javax.swing.JTextField;
+import javax.swing.RowFilter;
+import javax.swing.ScrollPaneConstants;
+import javax.swing.TransferHandler;
+import javax.swing.event.DocumentEvent;
+import javax.swing.event.DocumentListener;
+import javax.swing.table.DefaultTableModel;
+import javax.swing.table.TableColumn;
+import javax.swing.table.TableRowSorter;
+
+public class DatatablePanel extends JPanel {
+    private final JTable table;
+    private final DefaultTableModel model;
+    private final JTextField searchField;
+    private TableRowSorter<DefaultTableModel> sorter;
+    private JScrollPane scrollPane;
+    private String tableName;
+    private JCheckBox searchMode = new JCheckBox("Reverse search");
+
+    public DatatablePanel(String tableName, List<String> list) {
+        this.tableName = tableName;
+
+        String[] columnNames = {"#", "Information"};
+        model = new DefaultTableModel(columnNames, 0);
+        table = new JTable(model);
+        sorter = new TableRowSorter<>(model);
+        // 设置ID排序
+        sorter.setComparator(0, new Comparator<Integer>() {
+            @Override
+            public int compare(Integer s1, Integer s2) {
+                return s1.compareTo(s2);
+            }
+        });
+
+        table.setRowSorter(sorter);
+        TableColumn idColumn = table.getColumnModel().getColumn(0);
+        idColumn.setMaxWidth(50);
+
+        for (String item : list) {
+            if (!item.isEmpty()) {
+                addRowToTable(model, new Object[]{item});
+            }
+        }
+
+        String defaultText = "Search";
+        searchField = new JTextField(defaultText);
+
+        // 设置灰色默认文本Search
+        searchField.setForeground(Color.GRAY);
+        searchField.addFocusListener(new FocusListener() {
+            @Override
+            public void focusGained(FocusEvent e) {
+                if (searchField.getText().equals(defaultText)) {
+                    searchField.setText("");
+                    searchField.setForeground(Color.BLACK);
+                }
+            }
+
+            @Override
+            public void focusLost(FocusEvent e) {
+                if (searchField.getText().isEmpty()) {
+                    searchField.setForeground(Color.GRAY);
+                    searchField.setText(defaultText);
+                }
+            }
+        });
+
+        // 监听输入框内容输入、更新、删除
+        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();
+            }
+
+        });
+
+        // 设置布局
+        scrollPane = new JScrollPane(table);
+        scrollPane.setVerticalScrollBarPolicy(ScrollPaneConstants.VERTICAL_SCROLLBAR_ALWAYS);
+
+        searchMode.addItemListener(new ItemListener() {
+            public void itemStateChanged(ItemEvent 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(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent 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);
+
+        add(scrollPane, BorderLayout.CENTER);
+        add(optionsPanel, BorderLayout.SOUTH);
+    }
+
+    private static void addRowToTable(DefaultTableModel model, Object[] data) {
+        // 获取当前ID
+        int rowCount = model.getRowCount();
+        int id = rowCount > 0 ? (Integer) model.getValueAt(rowCount - 1, 0) + 1 : 1;
+        Object[] rowData = new Object[data.length + 1];
+        rowData[0] = id; // 设置ID列的值
+        System.arraycopy(data, 0, rowData, 1, data.length); // 拷贝其余数据
+        model.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 void setTableListener(MessagePanel messagePanel) {
+        table.setDefaultEditor(Object.class, null);
+
+        // 表格内容双击事件
+        table.addMouseListener(new MouseAdapter() {
+            @Override
+            public void mouseClicked(MouseEvent e) {
+                if (e.getClickCount() == 2) {
+                    int selectedRow = table.getSelectedRow();
+                    if (selectedRow != -1) {
+                        String rowData = table.getValueAt(selectedRow, 1).toString();
+                        messagePanel.applyMessageFilter(tableName, rowData);
+                    }
+                }
+            }
+        });
+
+        table.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);
+                }
+            }
+        });
+    }
+
+    public 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.length() > 0){
+            selectData.deleteCharAt(selectData.length() - 1);
+        }
+
+        return selectData.toString();
+    }
+
+    public JTable getTable() {
+        return this.table;
+    }
+}

src/main/java/burp/ui/board/LogEntry.java

@@ -0,0 +1,53 @@
+package burp.ui.board;
+
+import burp.IHttpRequestResponsePersisted;
+import java.net.URL;
+
+public class LogEntry {
+
+    private final String comment;
+    private final IHttpRequestResponsePersisted requestResponse;
+    private final URL url;
+    private final String length;
+    private final String status;
+    private final String color;
+    private final String method;
+
+    LogEntry(IHttpRequestResponsePersisted requestResponse, String method, URL url, String comment, String length, String color, String status) {
+        this.requestResponse = requestResponse;
+        this.method = method;
+        this.url = url;
+        this.comment = comment;
+        this.length = length;
+        this.color = color;
+        this.status = status;
+    }
+
+    public String getColor() {
+        return this.color;
+    }
+
+    public URL getUrl() {
+        return this.url;
+    }
+
+    public String getLength() {
+        return this.length;
+    }
+
+    public String getComment() {
+        return this.comment;
+    }
+
+    public String getMethod() {
+        return this.method;
+    }
+
+    public String getStatus() {
+        return this.status;
+    }
+
+    public IHttpRequestResponsePersisted getRequestResponse() {
+        return this.requestResponse;
+    }
+}

src/main/java/burp/ui/board/MessagePanel.java

@@ -0,0 +1,497 @@
+package burp.ui.board;
+
+import burp.IBurpExtenderCallbacks;
+import burp.IExtensionHelpers;
+import burp.IHttpRequestResponse;
+import burp.IHttpRequestResponsePersisted;
+import burp.IHttpService;
+import burp.IMessageEditor;
+import burp.IMessageEditorController;
+import burp.IRequestInfo;
+import burp.config.ConfigEntry;
+import burp.core.GlobalCachePool;
+import burp.core.utils.HashCalculator;
+import burp.core.utils.StringHelper;
+
+import java.net.URL;
+import java.nio.charset.StandardCharsets;
+import java.security.NoSuchAlgorithmException;
+import java.text.MessageFormat;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicBoolean;
+import javax.swing.JScrollPane;
+import javax.swing.JSplitPane;
+import javax.swing.JTabbedPane;
+import javax.swing.JTable;
+import javax.swing.SwingWorker;
+import javax.swing.table.AbstractTableModel;
+import javax.swing.table.DefaultTableModel;
+import javax.swing.table.TableModel;
+import javax.swing.table.TableRowSorter;
+
+/**
+ * @author EvilChen
+ */
+
+public class MessagePanel extends AbstractTableModel implements IMessageEditorController {
+    private JSplitPane splitPane;
+    private IMessageEditor requestViewer;
+    private IMessageEditor responseViewer;
+    private final IBurpExtenderCallbacks callbacks;
+    private final List<LogEntry> log = new ArrayList<LogEntry>();
+    private final List<LogEntry> filteredLog = new ArrayList<LogEntry>();
+    private IHttpRequestResponse currentlyDisplayedItem;
+    private final IExtensionHelpers helpers;
+    private final Table logTable;
+
+    public MessagePanel(IBurpExtenderCallbacks callbacks, IExtensionHelpers helpers) {
+        this.callbacks = callbacks;
+        this.helpers = helpers;
+
+        splitPane = new JSplitPane(JSplitPane.VERTICAL_SPLIT);
+
+        logTable = new Table(MessagePanel.this);
+        logTable.setDefaultRenderer(Object.class, new ColorRenderer(filteredLog, logTable));
+        logTable.setAutoCreateRowSorter(true);
+
+        // Length字段根据大小进行排序
+        TableRowSorter<DefaultTableModel> sorter = (TableRowSorter<DefaultTableModel>) logTable.getRowSorter();
+        sorter.setComparator(4, new Comparator<String>() {
+            @Override
+            public int compare(String s1, String s2) {
+                Integer age1 = Integer.parseInt(s1);
+                Integer age2 = Integer.parseInt(s2);
+                return age1.compareTo(age2);
+            }
+        });
+
+        // Color字段根据颜色顺序进行排序
+        sorter.setComparator(5, new Comparator<String>() {
+            @Override
+            public int compare(String s1, String s2) {
+                int index1 = getIndex(s1);
+                int index2 = getIndex(s2);
+                return Integer.compare(index1, index2);
+            }
+            private int getIndex(String color) {
+                for (int i = 0; i < ConfigEntry.colorArray.length; i++) {
+                    if (ConfigEntry.colorArray[i].equals(color)) {
+                        return i;
+                    }
+                }
+                return -1;
+            }
+        });
+
+        logTable.setRowSorter(sorter);
+        logTable.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
+
+        JScrollPane scrollPane = new JScrollPane(logTable);
+        scrollPane.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS);
+        scrollPane.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);
+        splitPane.setLeftComponent(scrollPane);
+
+        JTabbedPane tabs = new JTabbedPane();
+        requestViewer = callbacks.createMessageEditor(MessagePanel.this, false);
+
+        responseViewer = callbacks.createMessageEditor(MessagePanel.this, false);
+        tabs.addTab("Request", requestViewer.getComponent());
+        tabs.addTab("Response", responseViewer.getComponent());
+        splitPane.setRightComponent(tabs);
+    }
+
+    public JSplitPane getPanel() {
+        return splitPane;
+    }
+
+    public Table getTable() {
+        return logTable;
+    }
+
+    public List<LogEntry> getLogs() {
+        return log;
+    }
+
+    @Override
+    public int getRowCount()
+    {
+        return filteredLog.size();
+    }
+
+    @Override
+    public int getColumnCount()
+    {
+        return 6;
+    }
+
+    @Override
+    public String getColumnName(int columnIndex)
+    {
+        switch (columnIndex)
+        {
+            case 0:
+                return "Method";
+            case 1:
+                return "URL";
+            case 2:
+                return "Comment";
+            case 3:
+                return "Status";
+            case 4:
+                return "Length";
+            case 5:
+                return "Color";
+            default:
+                return "";
+        }
+    }
+
+    @Override
+    public Class<?> getColumnClass(int columnIndex)
+    {
+        return String.class;
+    }
+
+    @Override
+    public Object getValueAt(int rowIndex, int columnIndex)
+    {
+        if (filteredLog.isEmpty()) {
+            return "";
+        }
+        LogEntry logEntry = filteredLog.get(rowIndex);
+        switch (columnIndex)
+        {
+            case 0:
+                return logEntry.getMethod();
+            case 1:
+                return logEntry.getUrl().toString();
+            case 2:
+                return logEntry.getComment();
+            case 3:
+                return logEntry.getStatus();
+            case 4:
+                return logEntry.getLength();
+            case 5:
+                return logEntry.getColor();
+            default:
+                return "";
+        }
+    }
+
+    public void applyHostFilter(String filterText) {
+        filteredLog.clear();
+        fireTableDataChanged();
+        String cleanedText = StringHelper.replaceFirstOccurrence(filterText, "*.", "");
+
+        for (LogEntry entry : log) {
+            String host = entry.getUrl().getHost();
+            if (filterText.contains("*.") && StringHelper.matchFromEnd(host, cleanedText)) {
+                filteredLog.add(entry);
+            } else if (host.equals(filterText) || filterText.contains("*")) {
+                filteredLog.add(entry);
+            }
+        }
+        fireTableDataChanged();
+    }
+
+    public void applyMessageFilter(String tableName, String filterText) {
+        filteredLog.clear();
+        for (LogEntry entry : log) {
+            IHttpRequestResponsePersisted requestResponse = entry.getRequestResponse();
+            byte[] requestByte = requestResponse.getRequest();
+            byte[] responseByte = requestResponse.getResponse();
+
+            String requestString = new String(requestResponse.getRequest(), StandardCharsets.UTF_8);
+            String responseString = new String(requestResponse.getResponse(), StandardCharsets.UTF_8);
+
+            List<String> requestTmpHeaders = helpers.analyzeRequest(requestByte).getHeaders();
+            String requestHeaders = new String(String.join("\n", requestTmpHeaders).getBytes(StandardCharsets.UTF_8), StandardCharsets.UTF_8);
+            int requestBodyOffset = helpers.analyzeRequest(requestByte).getBodyOffset();
+            String requestBody = new String(Arrays.copyOfRange(requestByte, requestBodyOffset, requestByte.length), StandardCharsets.UTF_8);
+
+            List<String> responseTmpHeaders = helpers.analyzeResponse(responseByte).getHeaders();
+            String responseHeaders = new String(String.join("\n", responseTmpHeaders).getBytes(StandardCharsets.UTF_8), StandardCharsets.UTF_8);
+            int responseBodyOffset = helpers.analyzeResponse(responseByte).getBodyOffset();
+            String responseBody = new String(Arrays.copyOfRange(responseByte, responseBodyOffset, responseByte.length), StandardCharsets.UTF_8);
+
+            // 标志变量，表示是否满足过滤条件
+            AtomicBoolean isMatched = new AtomicBoolean(false);
+
+            ConfigEntry.globalRules.keySet().forEach(i -> {
+                for (Object[] objects : ConfigEntry.globalRules.get(i)) {
+                    String name = objects[1].toString();
+                    String format = objects[4].toString();
+                    String scope = objects[6].toString();
+
+                    // 从注释中查看是否包含当前规则名，包含的再进行查询，有效减少无意义的检索时间
+                    if (entry.getComment().contains(name)) {
+                        if (name.equals(tableName)) {
+                            // 标志变量，表示当前规则是否匹配
+                            boolean isMatch = false;
+
+                            switch (scope) {
+                                case "any":
+                                    isMatch = matchingString(format, filterText, requestString) || matchingString(format, filterText, responseString);
+                                    break;
+                                case "request":
+                                    isMatch = matchingString(format, filterText, requestString);
+                                    break;
+                                case "response":
+                                    isMatch = matchingString(format, filterText, responseString);
+                                    break;
+                                case "any header":
+                                    isMatch = matchingString(format, filterText, requestHeaders) || matchingString(format, filterText, responseHeaders);
+                                    break;
+                                case "request header":
+                                    isMatch = matchingString(format, filterText, requestHeaders);
+                                    break;
+                                case "response header":
+                                    isMatch = matchingString(format, filterText, responseHeaders);
+                                    break;
+                                case "any body":
+                                    isMatch = matchingString(format, filterText, requestBody) || matchingString(format, filterText, responseBody);
+                                    break;
+                                case "request body":
+                                    isMatch = matchingString(format, filterText, requestBody);
+                                    break;
+                                case "response body":
+                                    isMatch = matchingString(format, filterText, responseBody);
+                                    break;
+                                default:
+                                    break;
+                            }
+
+                            isMatched.set(isMatch);
+                            break;
+                        }
+                    }
+                }
+            });
+
+            if (isMatched.get()) {
+                filteredLog.add(entry);
+            }
+        }
+        fireTableDataChanged();
+        logTable.lastSelectedIndex = -1;
+    }
+
+    private boolean matchingString(String format, String filterText, String target) {
+        boolean isMatch = true;
+
+        try {
+            MessageFormat mf = new MessageFormat(format);
+            Object[] parsedObjects = mf.parse(filterText);
+
+            for (Object parsedObject : parsedObjects) {
+                if (!target.contains(parsedObject.toString())) {
+                    isMatch = false;
+                    break;
+                }
+            }
+        } catch (Exception e) {
+            isMatch = false;
+        }
+
+        return isMatch;
+    }
+
+    public void deleteByHost(String filterText) {
+        filteredLog.clear();
+        List<Integer> rowsToRemove = new ArrayList<>();
+        for (int i = 0; i < log.size(); i++) {
+            LogEntry entry = log.get(i);
+            String host = entry.getUrl().getHost();
+            if (StringHelper.matchFromEnd(host, filterText) || filterText.contains("*")) {
+                rowsToRemove.add(i);
+            }
+        }
+
+        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]);
+        }
+    }
+
+    @Override
+    public byte[] getRequest()
+    {
+        return currentlyDisplayedItem.getRequest();
+    }
+
+    @Override
+    public byte[] getResponse()
+    {
+        return currentlyDisplayedItem.getResponse();
+    }
+
+    @Override
+    public IHttpService getHttpService()
+    {
+        return currentlyDisplayedItem.getHttpService();
+    }
+
+    public void add(IHttpRequestResponse messageInfo, String comment, String color) {
+        synchronized(log) {
+            IRequestInfo iRequestInfo = helpers.analyzeRequest(messageInfo);
+            URL url = iRequestInfo.getUrl();
+            String method = iRequestInfo.getMethod();
+            String status = String.valueOf(helpers.analyzeResponse(messageInfo.getResponse()).getStatusCode());
+            String length = String.valueOf(messageInfo.getResponse().length);
+            LogEntry logEntry = new LogEntry(callbacks.saveBuffersToTempFiles(messageInfo), method, url, comment, length, color, status);
+
+            try {
+                // 比较Hash，如若存在重复的请求或响应，则不放入消息内容里
+                byte[] reqByteA = messageInfo.getRequest();
+                byte[] resByteA = messageInfo.getResponse();
+                boolean isDuplicate = false;
+
+                if (log.size() > 0) {
+                    for (LogEntry entry : log) {
+                        IHttpRequestResponsePersisted reqResMessage = entry.getRequestResponse();
+                        byte[] reqByteB = reqResMessage.getRequest();
+                        byte[] resByteB = reqResMessage.getResponse();
+                        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)))) {
+                                isDuplicate = true;
+                                break;
+                            }
+                        } catch (Exception e) {
+                            e.printStackTrace();
+                        }
+                    }
+                }
+
+                if (!isDuplicate) {
+                    log.add(logEntry);
+                }
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+
+    }
+
+    private Map<String, Map<String, Object>> getCacheData(byte[] content)
+            throws NoSuchAlgorithmException {
+        String hashIndex = HashCalculator.calculateHash(content);
+        return GlobalCachePool.getFromCache(hashIndex);
+    }
+
+    private boolean areMapsEqual(Map<String, Map<String, Object>> map1, Map<String, Map<String, Object>> map2) {
+        if (map1 == null || map2 == null) {
+            return false;
+        }
+        if (map1.size() != map2.size()) {
+            return false;
+        }
+
+        for (String key : map1.keySet()) {
+            if (!map2.containsKey(key)) {
+                return false;
+            }
+            if (!areInnerMapsEqual(map1.get(key), map2.get(key))) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    private boolean areInnerMapsEqual(Map<String, Object> innerMap1, Map<String, Object> innerMap2) {
+        if (innerMap1.size() != innerMap2.size()) {
+            return false;
+        }
+
+        for (String key : innerMap1.keySet()) {
+            if (!innerMap2.containsKey(key)) {
+                return false;
+            }
+            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;
+                }
+            } else if (!value1.equals(value2)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    public class Table extends JTable {
+        LogEntry logEntry;
+        private SwingWorker<Object, Void> currentWorker;
+        // 设置响应报文返回的最大长度为3MB
+        private final int MAX_LENGTH = 3145728;
+        private int lastSelectedIndex = -1;
+
+        public Table(TableModel tableModel) {
+            super(tableModel);
+        }
+
+        @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;
+                logEntry = filteredLog.get(selectedIndex);
+
+                requestViewer.setMessage("Loading...".getBytes(), true);
+                responseViewer.setMessage("Loading...".getBytes(), false);
+                currentlyDisplayedItem = logEntry.getRequestResponse();
+
+                if (currentWorker != null && !currentWorker.isDone()) {
+                    currentWorker.cancel(true);
+                }
+
+                currentWorker = new SwingWorker<Object, Void>() {
+                    @Override
+                    protected byte[][] doInBackground() throws Exception {
+                        byte[] requestByte = logEntry.getRequestResponse().getRequest();
+                        byte[] responseByte = logEntry.getRequestResponse().getResponse();
+
+                        if (responseByte.length > MAX_LENGTH) {
+                            String ellipsis = "\r\n......";
+                            responseByte = Arrays.copyOf(responseByte, MAX_LENGTH + ellipsis.length());
+                            byte[] ellipsisBytes = ellipsis.getBytes();
+                            System.arraycopy(ellipsisBytes, 0, responseByte, MAX_LENGTH, ellipsisBytes.length);
+                        }
+
+                        return new byte[][] {requestByte, responseByte};
+                    }
+
+                    @Override
+                    protected void done() {
+                        if (!isCancelled()) {
+                            try {
+                                byte[][] result = (byte[][]) get();
+                                requestViewer.setMessage(result[0], true);
+                                responseViewer.setMessage(result[1], false);
+                            } catch (Exception e) {
+                                e.printStackTrace();
+                            }
+                        }
+                    }
+                };
+                currentWorker.execute();
+            }
+        }
+    }
+
+}

src/main/java/burp/ui/rule/RulePane.java

@@ -1,43 +1,69 @@
-package burp.ui;
-
-import burp.yaml.SetConfig;
+package burp.ui.rule;
 
+import burp.rule.RuleProcessor;
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
 import javax.swing.*;
 import javax.swing.event.TableModelEvent;
-import javax.swing.event.TableModelListener;
 import javax.swing.table.DefaultTableModel;
 import javax.swing.table.TableRowSorter;
 import java.awt.*;
 import java.util.Vector;
 
 /**
- * @author LinChen
+ * @author LinChen & EvilChen
  */
 
 public class RulePane extends JPanel {
+    private RuleProcessor ruleProcessor = new RuleProcessor();
+    private Boolean isEdit = false;
+    private DefaultTableModel model = createModel();
+    private static final int YES_OPTION = JOptionPane.YES_OPTION;
+    private static final String[] TITLE = {
+            "Loaded", "Name", "F-Regex", "S-Regex", "Format", "Color", "Scope", "Engine", "Sensitive"
+    };
+
     public RulePane(Object[][] data, JTabbedPane pane) {
         initComponents(data, pane);
     }
-    private SetConfig setConfig = new SetConfig();
-    private Boolean isEdit = false;
+
+    private DefaultTableModel createModel() {
+        return new DefaultTableModel() {
+            @Override
+            public Class<?> getColumnClass(int column) {
+                return (column == 0) ? Boolean.class : String.class;
+            }
+
+            @Override
+            public boolean isCellEditable(int row, int column) {
+                return column == 0;
+            }
+        };
+    }
+
+    private void updateModel() {
+        model = (DefaultTableModel) ruleTable.getModel();
+    }
 
     private void ruleAddActionPerformed(ActionEvent e, JTabbedPane pane) {
         RuleSetting ruleSettingPanel = new RuleSetting();
-        int showState = JOptionPane.showConfirmDialog(null, ruleSettingPanel, "RuleSetting - Add Rule", JOptionPane.OK_OPTION);
-        if(showState == 0){
-            Vector ruleData = new Vector();
+        ruleSettingPanel.formatTextField.setText("{0}");
+
+        int showState = JOptionPane.showConfirmDialog(null, ruleSettingPanel, "Add Rule", JOptionPane.OK_OPTION);
+        if (showState == YES_OPTION) {
+            Vector<Object> ruleData = new Vector<>();
             ruleData.add(false);
             ruleData.add(ruleSettingPanel.ruleNameTextField.getText());
-            ruleData.add(ruleSettingPanel.regexTextField.getText());
+            ruleData.add(ruleSettingPanel.firstRegexTextField.getText());
+            ruleData.add(ruleSettingPanel.secondRegexTextField.getText());
+            ruleData.add(ruleSettingPanel.formatTextField.getText());
             ruleData.add(ruleSettingPanel.colorComboBox.getSelectedItem().toString());
             ruleData.add(ruleSettingPanel.scopeComboBox.getSelectedItem().toString());
             ruleData.add(ruleSettingPanel.engineComboBox.getSelectedItem().toString());
             ruleData.add(ruleSettingPanel.sensitiveComboBox.getSelectedItem());
             model.insertRow(model.getRowCount(), ruleData);
-            model = (DefaultTableModel) ruleTable.getModel();
-            setConfig.add(ruleData, pane.getTitleAt(pane.getSelectedIndex()));
+            updateModel();
+            ruleProcessor.addRule(ruleData, pane.getTitleAt(pane.getSelectedIndex()));
         }
     }
 
@@ -45,39 +71,43 @@ public class RulePane extends JPanel {
         if (ruleTable.getSelectedRowCount() >= 1){
             RuleSetting ruleSettingPanel = new RuleSetting();
             ruleSettingPanel.ruleNameTextField.setText(ruleTable.getValueAt(ruleTable.getSelectedRow(), 1).toString());
-            ruleSettingPanel.regexTextField.setText(ruleTable.getValueAt(ruleTable.getSelectedRow(), 2).toString());
-            ruleSettingPanel.colorComboBox.setSelectedItem(ruleTable.getValueAt(ruleTable.getSelectedRow(), 3).toString());
-            ruleSettingPanel.scopeComboBox.setSelectedItem(ruleTable.getValueAt(ruleTable.getSelectedRow(), 4).toString());
-            ruleSettingPanel.engineComboBox.setSelectedItem(ruleTable.getValueAt(ruleTable.getSelectedRow(), 5).toString());
-            ruleSettingPanel.sensitiveComboBox.setSelectedItem(ruleTable.getValueAt(ruleTable.getSelectedRow(),6));
+            ruleSettingPanel.firstRegexTextField.setText(ruleTable.getValueAt(ruleTable.getSelectedRow(), 2).toString());
+            ruleSettingPanel.secondRegexTextField.setText(ruleTable.getValueAt(ruleTable.getSelectedRow(), 3).toString());
+            ruleSettingPanel.formatTextField.setText(ruleTable.getValueAt(ruleTable.getSelectedRow(), 4).toString());
+            ruleSettingPanel.colorComboBox.setSelectedItem(ruleTable.getValueAt(ruleTable.getSelectedRow(), 5).toString());
+            ruleSettingPanel.scopeComboBox.setSelectedItem(ruleTable.getValueAt(ruleTable.getSelectedRow(), 6).toString());
+            ruleSettingPanel.engineComboBox.setSelectedItem(ruleTable.getValueAt(ruleTable.getSelectedRow(), 7).toString());
+            ruleSettingPanel.sensitiveComboBox.setSelectedItem(ruleTable.getValueAt(ruleTable.getSelectedRow(),8));
 
-            ruleSettingPanel.sensitiveComboBox.setEnabled(
+            ruleSettingPanel.formatTextField.setEnabled(
                 ruleSettingPanel.engineComboBox.getSelectedItem().toString().equals("nfa")
             );
 
-            int showState = JOptionPane.showConfirmDialog(null, ruleSettingPanel, "RuleSetting - Edit Rule", JOptionPane.OK_OPTION);
+            int showState = JOptionPane.showConfirmDialog(null, ruleSettingPanel, "Edit Rule", JOptionPane.OK_OPTION);
             if (showState == 0){
                 int select = ruleTable.convertRowIndexToModel(ruleTable.getSelectedRow());
                 model.setValueAt(ruleSettingPanel.ruleNameTextField.getText(), select, 1);
-                model.setValueAt(ruleSettingPanel.regexTextField.getText(), select, 2);
-                model.setValueAt(ruleSettingPanel.colorComboBox.getSelectedItem().toString(), select, 3);
-                model.setValueAt(ruleSettingPanel.scopeComboBox.getSelectedItem().toString(), select, 4);
-                model.setValueAt(ruleSettingPanel.engineComboBox.getSelectedItem().toString(), select, 5);
-                model.setValueAt(ruleSettingPanel.sensitiveComboBox.getSelectedItem(), select, 6);
+                model.setValueAt(ruleSettingPanel.firstRegexTextField.getText(), select, 2);
+                model.setValueAt(ruleSettingPanel.secondRegexTextField.getText(), select, 3);
+                model.setValueAt(ruleSettingPanel.formatTextField.getText(), select, 4);
+                model.setValueAt(ruleSettingPanel.colorComboBox.getSelectedItem().toString(), select, 5);
+                model.setValueAt(ruleSettingPanel.scopeComboBox.getSelectedItem().toString(), select, 6);
+                model.setValueAt(ruleSettingPanel.engineComboBox.getSelectedItem().toString(), select, 7);
+                model.setValueAt(ruleSettingPanel.sensitiveComboBox.getSelectedItem(), select, 8);
                 model = (DefaultTableModel) ruleTable.getModel();
-                setConfig.edit((Vector) model.getDataVector().get(select), select, pane.getTitleAt(pane.getSelectedIndex()));
+                ruleProcessor.changeRule((Vector) model.getDataVector().get(select), select, pane.getTitleAt(pane.getSelectedIndex()));
             }
         }
     }
 
     private void ruleRemoveActionPerformed(ActionEvent e, JTabbedPane pane){
         if (ruleTable.getSelectedRowCount() >= 1){
-            int isOk = JOptionPane.showConfirmDialog(null, "Are your sure?", "RuleSetting - Delete Rule", JOptionPane.OK_OPTION);
+            int isOk = JOptionPane.showConfirmDialog(null, "Are you sure you want to delete this rule?", "Info", JOptionPane.OK_OPTION);
             if (isOk == 0){
                 int select = ruleTable.convertRowIndexToModel(ruleTable.getSelectedRow());
                 model.removeRow(select);
                 model = (DefaultTableModel) ruleTable.getModel();
-                setConfig.remove(select, pane.getTitleAt(pane.getSelectedIndex()));
+                ruleProcessor.removeRule(select, pane.getTitleAt(pane.getSelectedIndex()));
             }
         }
     }
@@ -86,7 +116,7 @@ public class RulePane extends JPanel {
         if (e.getColumn() == 0 && ruleTable.getSelectedRow() != -1 && !isEdit){
             model = (DefaultTableModel) ruleTable.getModel();
             int select = ruleTable.convertRowIndexToModel(ruleTable.getSelectedRow());
-            setConfig.edit((Vector) model.getDataVector().get(select), select, pane.getTitleAt(pane.getSelectedIndex()));
+            ruleProcessor.changeRule((Vector) model.getDataVector().get(select), select, pane.getTitleAt(pane.getSelectedIndex()));
         }
     }
 
@@ -171,17 +201,10 @@ public class RulePane extends JPanel {
                 GridBagConstraints.CENTER, GridBagConstraints.BOTH,
                 new Insets(0, 5, 3, 2), 0, 0));
 
-        // JFormDesigner - End of component initialization  //GEN-END:initComponents
         ruleTable.setModel(model);
-        model.setDataVector(data, title);
-        model.addTableModelListener(new TableModelListener() {
-            @Override
-            public void tableChanged(TableModelEvent e) {
-                ruleTableChange(e, pane);
-            }
-        });
-
-        ruleTable.setRowSorter(new TableRowSorter(model));
+        model.setDataVector(data, TITLE);
+        model.addTableModelListener(e -> ruleTableChange(e, pane));
+        ruleTable.setRowSorter(new TableRowSorter<>(model));
     }
 
     // JFormDesigner - Variables declaration - DO NOT MODIFY  //GEN-BEGIN:variables
@@ -191,21 +214,5 @@ public class RulePane extends JPanel {
     public JTable ruleTable;
     public JButton removeButton;
     // JFormDesigner - End of variables declaration  //GEN-END:variables
-    private final String[] title = new String[]{"Loaded", "Name", "Regex", "Color", "Scope", "Engine", "Sensitive"};
-    private DefaultTableModel model = new DefaultTableModel() {
-        @Override
-        public Class<?> getColumnClass (int column){
-            if (column == 0) {
-                return Boolean.class;
-            }else{
-                return String.class;
-            }
-        }
-
-        @Override
-        public boolean isCellEditable(int row, int column){
-            return column == 0;
-        }
-    };
 }
 

src/main/java/burp/ui/rule/RuleSetting.java

@@ -0,0 +1,82 @@
+package burp.ui.rule;
+
+import java.awt.*;
+import javax.swing.*;
+import burp.config.ConfigEntry;
+
+/**
+ * @author LinChen & EvilChen
+ */
+
+public class RuleSetting extends JPanel {
+    public JTextField firstRegexTextField;
+    public JTextField secondRegexTextField;
+    public JTextField formatTextField;
+    public JTextField ruleNameTextField;
+    public JComboBox<String> scopeComboBox;
+    public JComboBox<String> engineComboBox;
+    public JComboBox<String> colorComboBox;
+    public JComboBox<Boolean> sensitiveComboBox;
+
+    public RuleSetting() {
+        initComponents();
+    }
+
+    private void initComponents() {
+        setLayout(new GridBagLayout());
+        GridBagConstraints c = new GridBagConstraints();
+        c.fill = GridBagConstraints.BOTH;
+
+        addLabel("Name:", 0, c);
+        ruleNameTextField = addTextField(0, c);
+
+        addLabel("F-Regex:", 1, c);
+        firstRegexTextField = addTextField(1, c);
+
+        addLabel("S-Regex:", 2, c);
+        secondRegexTextField = addTextField(2, c);
+
+        addLabel("Format:", 3, c);
+        formatTextField = addTextField(3, c);
+
+        addLabel("Scope:", 4, c);
+        scopeComboBox = addComboBox(ConfigEntry.scopeArray, 4, c);
+
+        addLabel("Engine:", 5, c);
+        engineComboBox = addComboBox(ConfigEntry.engineArray, 5, c);
+        engineComboBox.addActionListener(e -> {
+            boolean isNfa = "nfa".equals(engineComboBox.getSelectedItem().toString());
+            formatTextField.setEnabled(isNfa);
+            formatTextField.setText(isNfa ? formatTextField.getText() : "{0}");
+        });
+
+        addLabel("Color:", 6, c);
+        colorComboBox = addComboBox(ConfigEntry.colorArray, 6, c);
+
+        addLabel("Sensitive:", 7, c);
+        sensitiveComboBox = addComboBox(new Boolean[]{true, false}, 7, c);
+    }
+
+    private void addLabel(String text, int y, GridBagConstraints c) {
+        JLabel label = new JLabel(text);
+        c.gridx = 0;
+        c.gridy = y;
+        add(label, c);
+    }
+
+    private JTextField addTextField(int y, GridBagConstraints c) {
+        JTextField textField = new JTextField(35);
+        c.gridx = 1;
+        c.gridy = y;
+        add(textField, c);
+        return textField;
+    }
+
+    private <T> JComboBox<T> addComboBox(T[] items, int y, GridBagConstraints c) {
+        JComboBox<T> comboBox = new JComboBox<>(items);
+        c.gridx = 1;
+        c.gridy = y;
+        add(comboBox, c);
+        return comboBox;
+    }
+}

src/main/java/burp/yaml/LoadConfig.java

@@ -1,162 +0,0 @@
-package burp.yaml;
-
-import burp.Config;
-import burp.yaml.template.*;
-
-import java.io.*;
-import java.nio.charset.StandardCharsets;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.ArrayList;
-
-import org.yaml.snakeyaml.Yaml;
-import org.yaml.snakeyaml.constructor.Constructor;
-import org.yaml.snakeyaml.DumperOptions;
-import org.yaml.snakeyaml.representer.Representer;
-import org.yaml.snakeyaml.nodes.Tag;
-
-public class LoadConfig {
-    private static final Yaml yaml = new Yaml();
-    private static String HaEConfigPath = String.format("%s/.config/HaE", System.getProperty("user.home"));
-    private static String SettingPath = String.format("%s/%s", HaEConfigPath, "Setting.yml");
-    private static String ConfigPath =  String.format("%s/%s", HaEConfigPath, "Config.yml");
-
-    public LoadConfig() {
-        // 构造函数，初始化配置
-        File HaEConfigPathFile = new File(HaEConfigPath);
-        if (!(HaEConfigPathFile.exists() && HaEConfigPathFile.isDirectory())) {
-            HaEConfigPathFile.mkdirs();
-        }
-
-        File settingPathFile = new File(SettingPath);
-        if (!(settingPathFile.exists() && settingPathFile.isFile())) {
-            initSetting();
-            initRules();
-        }
-        Config.ruleConfig = LoadConfig.getRules();
-    }
-
-
-    // 初始化设置信息
-    public void initSetting() {
-        Map<String, Object> r = new HashMap<>();
-        r.put("configPath", ConfigPath);
-        r.put("excludeSuffix", getExcludeSuffix());
-        try {
-            Writer ws = new OutputStreamWriter(new FileOutputStream(SettingPath), StandardCharsets.UTF_8);
-            yaml.dump(r, ws);
-        } catch (Exception ex) {
-            ex.printStackTrace();
-        }
-    }
-
-    // 初始化规则配置
-    public void initRules() {
-        Rule rule = new Rule();
-        rule.setLoaded(true);
-        rule.setName("Email");
-        rule.setColor("yellow");
-        rule.setEngine("nfa");
-        rule.setScope("response");
-        rule.setRegex("(([a-zA-Z0-9][_|\\.])*[a-zA-Z0-9]+@([a-zA-Z0-9][-|_|\\.])*[a-zA-Z0-9]+\\.((?!js|css|jpg|jpeg|png|ico)[a-zA-Z]{2,}))");
-        rule.setSensitive(false);
-
-        Rules rules = new Rules();
-        rules.setType("Basic Information");
-        ArrayList<Rule> rl = new ArrayList<>();
-        rl.add(rule);
-        rules.setRule(rl);
-        ArrayList<Rules> rls = new ArrayList<>();
-        rls.add(rules);
-        RulesConfig config = new RulesConfig();
-        config.setRules(rls);
-
-        DumperOptions dop = new DumperOptions();
-        dop.setDefaultFlowStyle(DumperOptions.FlowStyle.BLOCK);
-        Representer representer = new Representer();
-        representer.addClassTag(Config.class, Tag.MAP);
-
-        Yaml yaml = new Yaml(new Constructor(),representer,dop);
-        File f = new File(ConfigPath);
-        try{
-            Writer ws = new OutputStreamWriter(new FileOutputStream(f), StandardCharsets.UTF_8);
-            yaml.dump(config,ws);
-        }catch (Exception ex){
-            ex.printStackTrace();
-        }
-    }
-
-    // 获取配置路径
-    public static String getConfigPath(){
-        try {
-            InputStream inorder = new FileInputStream(SettingPath);
-            Map<String,Object> r = yaml.load(inorder);
-            return r.get("configPath").toString();
-        } catch (FileNotFoundException e) {
-            e.printStackTrace();
-            return ConfigPath;
-        }
-
-    }
-
-    // 获取不包含的后缀名
-    public String getExcludeSuffix(){
-        String excludeSuffix = "";
-        File yamlSetting = new File(SettingPath);
-        if (yamlSetting.exists() && yamlSetting.isFile()) {
-            try {
-                InputStream inorder = new FileInputStream(SettingPath);
-                Map<String,Object> r = yaml.load(inorder);
-                excludeSuffix = r.get("excludeSuffix").toString();
-            } catch (Exception e) {
-                // e.printStackTrace();
-                excludeSuffix = "";
-            }
-        } else {
-            excludeSuffix = Config.excludeSuffix;
-        }
-        return excludeSuffix;
-    }
-
-    // 获取规则配置
-    public static Map<String,Object[][]> getRules(){
-        InputStream inorder = null;
-        {
-            try {
-                inorder = new FileInputStream(getConfigPath());
-            } catch (FileNotFoundException e) {
-                e.printStackTrace();
-            }
-        }
-        Yaml yaml = new Yaml(new Constructor(RulesConfig.class));
-        RulesConfig rulesConfig = yaml.loadAs(inorder, RulesConfig.class);
-        Map<String,Object[][]> resRule = new HashMap<>();
-        rulesConfig.rules.forEach(i->{
-            ArrayList<Object[]> data = new ArrayList<>();
-            i.rule.forEach(j->{
-                try {
-                    data.add(j.getRuleObject());
-                }catch (Exception e){
-                    e.printStackTrace();
-                }
-            });
-            resRule.put(i.getType(), data.toArray(new Object[data.size()][]));
-        });
-        return resRule;
-    }
-
-
-    // 设置不包含的后缀名
-    public void setExcludeSuffix(String excludeSuffix){
-        Map<String,Object> r = new HashMap<>();
-        r.put("configPath", getConfigPath());
-        r.put("excludeSuffix", excludeSuffix);
-        try{
-            Writer ws = new OutputStreamWriter(new FileOutputStream(SettingPath), StandardCharsets.UTF_8);
-            yaml.dump(r, ws);
-        }catch (Exception ex){
-            ex.printStackTrace();
-        }
-    }
-
-}

src/main/java/burp/yaml/RulesConfig.java

@@ -1,12 +0,0 @@
-package burp.yaml;
-
-import java.util.List;
-import burp.yaml.template.Rules;
-
-public class RulesConfig {
-    public List<Rules> rules;
-
-    public void setRules(List<Rules> rules) {
-        this.rules = rules;
-    }
-}

src/main/java/burp/yaml/SetConfig.java

@@ -1,101 +0,0 @@
-package burp.yaml;
-
-import burp.Config;
-import burp.yaml.template.Rule;
-import burp.yaml.template.Rules;
-import org.yaml.snakeyaml.DumperOptions;
-import org.yaml.snakeyaml.Yaml;
-import org.yaml.snakeyaml.constructor.Constructor;
-import org.yaml.snakeyaml.nodes.Tag;
-import org.yaml.snakeyaml.representer.Representer;
-
-import java.io.File;
-import java.io.FileOutputStream;
-import java.io.OutputStreamWriter;
-import java.io.Writer;
-import java.nio.charset.StandardCharsets;
-import java.util.*;
-
-public class SetConfig {
-
-    public void format() {
-        DumperOptions dop = new DumperOptions();
-        dop.setDefaultFlowStyle(DumperOptions.FlowStyle.BLOCK);
-        Representer representer = new Representer();
-        representer.addClassTag(RulesConfig.class, Tag.MAP);
-        Yaml yaml = new Yaml(new Constructor(), representer, dop);
-        RulesConfig con = new RulesConfig();
-        List<Rules> rls = new ArrayList<>();
-
-        Config.ruleConfig.keySet().forEach(i->
-        {
-            Rules rlsTmp = new Rules();
-            rlsTmp.setType(i);
-            List<Rule> rl = new ArrayList<>();
-            for (Object[] objects : Config.ruleConfig.get(i)) {
-                Rule rlTmp = new Rule();
-                rlTmp.setName((String) objects[1]);
-                rlTmp.setLoaded((Boolean) objects[0]);
-                rlTmp.setRegex((String) objects[2]);
-                rlTmp.setColor((String) objects[3]);
-                rlTmp.setScope((String) objects[4]);
-                rlTmp.setEngine((String) objects[5]);
-                rlTmp.setSensitive((Boolean) objects[6]);
-                rl.add(rlTmp);
-            }
-            rlsTmp.setRule(rl);
-            rls.add(rlsTmp);
-        });
-        con.setRules(rls);
-        File f = new File(LoadConfig.getConfigPath());
-        try{
-            Writer ws = new OutputStreamWriter(new FileOutputStream(f), StandardCharsets.UTF_8);
-            yaml.dump(con,ws);
-        }catch (Exception ex){
-            ex.printStackTrace();
-        }
-    }
-
-    public void edit(Vector data, int select, String type) {
-        Config.ruleConfig.get(type)[select] = data.toArray();
-        this.format();
-    }
-
-    public void add(Vector data, String type) {
-        ArrayList<Object[]> x = new ArrayList<>(Arrays.asList(Config.ruleConfig.get(type)));
-        x.add(data.toArray());
-        Config.ruleConfig.put(type,x.toArray(new Object[x.size()][]));
-        this.format();
-    }
-    public void remove(int select,String type) {
-        ArrayList<Object[]> x = new ArrayList<>(Arrays.asList(Config.ruleConfig.get(type)));
-        x.remove(select);
-        Config.ruleConfig.put(type,x.toArray(new Object[x.size()][]));
-        this.format();
-    }
-
-    public void rename(String oldName, String newName) {
-        Config.ruleConfig.put(newName, Config.ruleConfig.remove(oldName));
-        this.format();
-    }
-
-    public void deleteRules(String Rules) {
-        Config.ruleConfig.remove(Rules);
-        this.format();
-    }
-    public String newRules() {
-        int i = 0;
-        String name = "New ";
-        Object[][] data = new Object[][]{
-                {
-                    false, "New Name", "(New Regex)", "gray", "any", "nfa", false
-                }
-        };
-        while (Config.ruleConfig.containsKey(name + i)) {
-            i++;
-        }
-        Config.ruleConfig.put(name + i, data);
-        this.format();
-        return name + i;
-    }
-}

src/main/java/burp/yaml/template/Rule.java

@@ -1,93 +0,0 @@
-package burp.yaml.template;
-
-import java.util.HashMap;
-import java.util.Map;
-
-/**
- * @author LinChen
- */
-
-public class Rule {
-    private String Name;
-    private Boolean Loaded;
-    private String Regex;
-    private String Color;
-    private String Engine;
-    private String Scope;
-    private Boolean Sensitive;
-
-    public Boolean getLoaded() {
-        return Loaded;
-    }
-    public String getColor() {
-        return Color;
-    }
-
-    public String getEngine() {
-        return Engine;
-    }
-
-    public String getName() {
-        return Name;
-    }
-
-    public String getRegex() {
-        return Regex;
-    }
-
-    public String getScope() {
-        return Scope;
-    }
-
-    public Boolean getSensitive(){
-        return Sensitive = Sensitive;
-    }
-    public void setLoaded(Boolean loaded) {
-        this.Loaded = loaded;
-    }
-
-
-    public void setColor(String color) {
-        this.Color = color;
-    }
-
-    public void setEngine(String engine) {
-        this.Engine = engine;
-    }
-
-    public void setName(String name) {
-        this.Name = name;
-    }
-
-    public void setRegex(String regex) {
-        this.Regex = regex;
-    }
-
-    public void setScope(String scope) {
-        this.Scope = scope;
-    }
-    public void setSensitive(Boolean sensitive){
-        this.Sensitive = sensitive;
-    }
-
-    public Object[] getRuleObject() {
-        return new Object[] { Loaded, Name, Regex, Color, Scope, Engine,Sensitive };
-    }
-
-    public Map<String, Object> getRuleObjMap(){
-        Map<String,Object> r = new HashMap<>();
-        r.put("Loaded", Loaded);
-        r.put("Name", Name);
-        r.put("Regex", Regex);
-        r.put("Color", Color);
-        r.put("Scope", Scope);
-        r.put("Engine", Engine);
-        r.put("Sensitive", Sensitive);
-        return r;
-    }
-
-    @Override
-    public String toString() {
-        return "{ \nLoaded: " + Loaded + "\nName: " + Name + "\nRegex: " + Regex + "\nColor: " + Color + "\nScope: " + Scope + "\nEngine: " + Engine + "\nSensitive: " + Sensitive + "\n }";
-    }
-}

src/main/java/burp/yaml/template/Rules.java

@@ -1,37 +0,0 @@
-package burp.yaml.template;
-
-import burp.yaml.template.Rule;
-
-import java.util.List;
-
-/**
- * @author LinChen
- */
-
-public class Rules {
-    private String type;
-    public List<Rule> rule;
-
-    public String getType() {
-        return type;
-    }
-
-    public void setType(String type) {
-        this.type = type;
-    }
-
-    public List<Rule> getRule() {
-        return rule;
-    }
-
-    public void setRule(List<Rule> rule) {
-        this.rule = rule;
-    }
-
-    public void setRuleObj(){}
-
-    @Override
-    public String toString(){
-        return "{ type: "+type+"\n config: "+ rule +"}\n";
-    }
-}