Version: 2.5 Update

Update
Update README.md
2023-10-12 21:38:27 +08:00 · 2023-10-09 14:26:03 +08:00 · 2023-10-09 14:25:14 +08:00 · 2023-09-28 01:48:51 +08:00 · 2023-09-28 01:42:09 +08:00 · 2023-09-28 01:23:36 +08:00
52 changed files with 2647 additions and 1477 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,137 @@
+# User-specific stuff
+.idea/**/workspace.xml
+.idea/**/tasks.xml
+.idea/**/usage.statistics.xml
+.idea/**/dictionaries
+.idea/**/shelf
+
+# AWS User-specific
+.idea/**/aws.xml
+
+# Generated files
+.idea/**/contentModel.xml
+
+# Sensitive or high-churn files
+.idea/**/dataSources/
+.idea/**/dataSources.ids
+.idea/**/dataSources.local.xml
+.idea/**/sqlDataSources.xml
+.idea/**/dynamic.xml
+.idea/**/uiDesigner.xml
+.idea/**/dbnavigator.xml
+
+# Gradle
+.idea/**/gradle.xml
+.idea/**/libraries
+
+# Gradle and Maven with auto-import
+# When using Gradle or Maven with auto-import, you should exclude module files,
+# since they will be recreated, and may cause churn.  Uncomment if using
+# auto-import.
+# .idea/artifacts
+# .idea/compiler.xml
+# .idea/jarRepositories.xml
+# .idea/modules.xml
+# .idea/*.iml
+# .idea/modules
+# *.iml
+# *.ipr
+
+# CMake
+cmake-build-*/
+
+# Mongo Explorer plugin
+.idea/**/mongoSettings.xml
+
+# File-based project format
+*.iws
+
+# IntelliJ
+out/
+
+# mpeltonen/sbt-idea plugin
+.idea_modules/
+
+# JIRA plugin
+atlassian-ide-plugin.xml
+
+# Cursive Clojure plugin
+.idea/replstate.xml
+
+# SonarLint plugin
+.idea/sonarlint/
+
+# Crashlytics plugin (for Android Studio and IntelliJ)
+com_crashlytics_export_strings.xml
+crashlytics.properties
+crashlytics-build.properties
+fabric.properties
+
+# Editor-based Rest Client
+.idea/httpRequests
+
+# Android studio 3.1+ serialized cache file
+.idea/caches/build_file_checksums.ser
+
+### JetBrains+all Patch ###
+# Ignore everything but code style settings and run configurations
+# that are supposed to be shared within teams.
+
+.idea/*
+
+!.idea/codeStyles
+!.idea/runConfigurations
+
+### macOS ###
+# General
 .DS_Store
-.idea
-.gradle
+.AppleDouble
+.LSOverride
+
+# Icon must end with two \r
+Icon
+
+
+# Thumbnails
+._*
+
+# Files that might appear in the root of a volume
+.DocumentRevisions-V100
+.fseventsd
+.Spotlight-V100
+.TemporaryItems
+.Trashes
+.VolumeIcon.icns
+.com.apple.timemachine.donotpresent
+
+# Directories potentially created on remote AFP share
+.AppleDB
+.AppleDesktop
+Network Trash Folder
+Temporary Items
+.apdisk
+
+### Gradle ###
+.gradle
+**/build/
+!src/**/build/
+
+# Ignore Gradle GUI config
+gradle-app.setting
+
+# Avoid ignoring Gradle wrapper jar file (.jar files are usually ignored)
+!gradle-wrapper.jar
+
+# Avoid ignore Gradle wrappper properties
+!gradle-wrapper.properties
+
+# Cache of project
+.gradletasknamecache
+
+# Eclipse Gradle plugin generated files
+# Eclipse Core
+.project
+# JDT-specific (Eclipse Java Development Tools)
+.classpath
+
+# End of https://www.toptal.com/developers/gitignore/api/macos,gradle,jetbrains+all
--- a/201
+++ b/201
@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
--- a/README.md
+++ b/README.md
@@ -1,87 +1,67 @@
-# HaE - Highlighter and Extractor
+<div align="center">
+<img src="images/logo.png" style="width: 20%" />
+<h4><a href="https://gh0st.cn/HaE/">赋能白帽，高效作战！</a></h4>
+<h5>第一作者： <a href="https://github.com/gh0stkey">EvilChen</a>（中孚信息元亨实验室）, 第二作者： <a href="https://github.com/0chencc">0chencc</a>（米斯特安全团队）</h5>
+</div>

-HaE相关作者 (来自米斯特安全团队 www.acmesec.cn) ：
+## 项目介绍

-架构作者: [@0chencc](https://github.com/0Chencc)
-核心功能作者: [@EvilChen](https://github.com/gh0stkey)
+**HaE**是一个基于`BurpSuite Java插件API`开发的辅助型框架式插件，旨在实现对HTTP消息的高亮标记和信息提取。该插件通过自定义正则表达式匹配响应报文或请求报文，并对匹配成功的报文进行标记和提取。

-## 公共规则网站
+随着现代化Web应用采用前后端分离的开发模式，日常漏洞挖掘的过程中，捕获的HTTP请求流量也相应增加。若想全面评估一个Web应用，会花费大量时间在无用的报文上。**HaE的出现旨在解决这类情况**，借助HaE，您能够**有效减少**测试时间，将更多精力集中在**有价值且有意义**的报文上，从而**提高漏洞挖掘效率**。

-https://gh0st.cn/HaE/
-
-## 介绍
-
-**HaE**是基于 `BurpSuite` 插件 `JavaAPI` 开发的请求高亮标记与信息提取的辅助型插件。
-
-![-w1070](images/16000706401522.jpg)
-
-该插件可以通过自定义正则的方式匹配**响应报文或请求报文**，可以自行决定符合该自定义正则匹配的相应请求是否需要高亮标记、信息提取。
-
-**注**: `HaE`的使用，对测试人员来说需要基本的正则表达式基础，由于`Java`正则表达式的库并没有`Python`的优雅或方便，在使用正则的，HaE要求使用者必须使用`()`将所需提取的表达式内容包含；例如你要匹配一个**Shiro应用**的响应报文，正常匹配规则为`rememberMe=delete`，如果你要提取这段内容的话就需要变成`(rememberMe=delete)`。
+**注**: 要想灵活的使用`HaE`，你需要掌握正则表达式阅读、编写、修改能力；由于`Java`正则表达式的库并没有`Python`的优雅或方便，所以HaE要求使用者必须用`()`将所需提取的表达式内容包含；例如你要匹配一个**Shiro应用**的响应报文，正常匹配规则为`rememberMe=delete`，如果你要提取这段内容的话就需要变成`(rememberMe=delete)`。

 ## 使用方法

 插件装载: `Extender - Extensions - Add - Select File - Next`

-初次装载`HaE`会初始化配置文件，默认配置文件内置一个正则: `Email`，初始化的配置文件会放在与`BurpSuite Jar`包同级目录下。
+初次装载`HaE`会自动获取官方规则库`https://raw.githubusercontent.com/gh0stkey/HaE/gh-pages/Rules.yml`，配置文件（`Config.yml`）和规则文件（`Rules.yml`）会放在固定目录下：

-除了初始化的配置文件外，还有`Setting.yml`，该文件用于存储配置文件路径；`HaE`支持自定义配置文件路径，你可以通过点击`Select File`按钮进行选择自定义配置文件。
+1. Linux/Mac用户的配置文件目录：`~/.config/HaE/`
+2. Windows用户的配置文件目录：`%USERPROFILE%/.config/HaE/`

-![-w477](images/16000710069404.jpg)
+## 优势特点

-## 插件优点
+1. 精细配置：高度自由的配置选项，以满足各类精细化场景需求。
+2. 分类标签：使用标签对规则进行分类，便于管理和组织规则。
+3. 高亮标记：在HTTP History页面，通过颜色高亮和注释判断请求的价值。
+4. 易读配置：使用易读的YAML格式存储配置文件，方便阅读和修改。
+5. 数据集合：将匹配到的数据、请求和响应集中在数据面板中，提高测试和梳理效率。
+6. 简洁可视：清晰可视的界面设计，更轻松地了解和配置HaE，操作简单、使用便捷。
+7. 颜色升级：内置颜色升级算法，避免“屠龙者终成恶龙”场景，突出最具价值的请求。
+8. 实战规则：官方规则库是基于实战化场景总结输出，提升数据发现的有效性、精准性。

-1. 多选项自定义控制适配需求
-2. 多颜色高亮分类，将BurpSuite的所有高亮颜色集成: `red, orange, yellow, green, cyan, blue, pink, magenta, gray`
-3. **颜色升级算法**: 利用下标的方式进行优先级排序，当满足2个同颜色条件则以优先级顺序上升颜色（例如: **两个正则，颜色为橘黄色，该请求两个正则都匹配到了，那么将升级为红色**）
-4. 配置文件采用YAML格式存储，更加便于阅读和修改
-5. 内置简单缓存，在“多正则、大数据”的场景下减少卡顿现象
-6. **支持标签分页**，点击`...`即可添加新的标签页，对着标签页右键即可删除
-
-![-w477](images/16000720732851.jpg)
+| 界面名称                  | 界面展示                                              |
+| ------------------------ | ---------------------------------------------------- |
+| 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)
+![-w467](images/rgperson.jpg)

-访问该地址，在`Proxy - HTTP History`中可以看见高亮请求，响应标签页中含有`MarkINFO`标签，其中将匹配到的信息提取了出来。
+访问该地址，在`Proxy - HTTP History`中可以看见高亮请求，响应标签页中含有`MarkInfo`标签，其中将匹配到的信息提取了出来。

-![-w1047](images/16000720732854.jpg)
+![-w1047](images/markinfo.png)

+## 文末随笔

-## 正则优化
+正义感是一个不可丢失的东西。

-有些正则在实战应用场景中并不理想
+如果你觉得HaE好用，可以打赏一下作者，给作者持续更新下去的动力！

-在正则匹配手机号、身份证号码的时候（纯数字类）会存在一些误报（这里匹配身份证号码无法进行校验，误报率很高），但手机号处理这一块可以解决: 
+<div align=center>
+<img src="images/reward.jpeg" style="width: 30%" />
+</div>

-原正则: 
+## 404StarLink 2.0 - Galaxy

-```
-1[3-9]\d{9}
-```
+![404StarLink Logo](https://github.com/knownsec/404StarLink-Project/raw/master/logo.png)

-误报场景: `12315188888888123`，这时候会匹配到`15188888888`，而实际上这一段并不是手机号，所以修改正则为: 
+`HaE` 是 404Team [星链计划2.0](https://github.com/knownsec/404StarLink2.0-Galaxy) 中的一环，如果对 `HaE` 有任何疑问又或是想要找小伙伴交流，可以参考星链计划的加群方式。

-```
-[^0-9]+(1[3-9]\d{9})[^0-9]+
-```
-
-也就是要求匹配的手机号前后不能为0-9的数字。
-
-## 实战用法
-
-1. CMS指纹识别，Discuz正则: `(Powered by Discuz!)`
-2. OSS对象存储信息泄露，正则: `([A|a]ccess[K|k]ey[I|i]d|[A|a]ccess[K|k]ey[S|s]ecret)`
-3. 内网地址信息提取，正则: `(?:10\.\d{1,3}\.\d{1,3}\.\d{1,3})|(?:172\.(?:(?:1[6-9])|(?:2\d)|(?:3[01]))\.\d{1,3}\.\d{1,3})|(?:192\.168\.\d{1,3}\.\d{1,3})`
-4. 实战插件关联搭配，漏洞挖掘案例: https://mp.weixin.qq.com/s/5vNn7dMRZBtv0ojPBAHV7Q
-
-...还有诸多使用方法等待大家去发掘。
-
-## 文末
-
-随笔: 正义感是一个不可丢失的东西。
-
-Github项目地址（BUG、需求、正则欢迎提交）: https://github.com/gh0stkey/HaE
+- [https://github.com/knownsec/404StarLink2.0-Galaxy#community](https://github.com/knownsec/404StarLink2.0-Galaxy#community)
--- a/build.gradle
+++ b/build.gradle
@@ -30,4 +30,5 @@ 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'
 }
--- a/images/16000706401522.jpg
+++ b/images/16000706401522.jpg
--- a/images/16000710069404.jpg
+++ b/images/16000710069404.jpg
--- a/images/16000720732851.jpg
+++ b/images/16000720732851.jpg
--- a/images/16000720732854.jpg
+++ b/images/16000720732854.jpg
--- a/images/config.png
+++ b/images/config.png
--- a/images/databoard.png
+++ b/images/databoard.png
--- a/images/logo.png
+++ b/images/logo.png
--- a/images/markinfo.png
+++ b/images/markinfo.png
--- a/images/reward.jpeg
+++ b/images/reward.jpeg
--- a/images/16000719723284.jpg
+++ b/images/16000719723284.jpg
--- a/images/rules.png
+++ b/images/rules.png
--- a/src/main/java/burp/BurpExtender.java
+++ b/src/main/java/burp/BurpExtender.java
@@ -1,31 +1,34 @@
 package burp;

-import burp.action.*;
+import burp.core.processor.ColorProcessor;
+import burp.core.processor.MessageProcessor;
 import burp.ui.MainUI;
-
+import burp.ui.board.MessagePanel;
+import java.security.NoSuchAlgorithmException;
+import java.util.Map;
+import java.util.Objects;
 import javax.swing.*;
 import java.awt.*;
-import java.io.UnsupportedEncodingException;
-import java.util.Arrays;
-import java.util.List;
+import java.nio.charset.StandardCharsets;
 import java.io.PrintWriter;
-import java.util.Map;
+import java.util.ArrayList;
+import java.util.List;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;

-/*
- * @author EvilChen
+/**
+ * @author EvilChen & 0chencc
 */

 public class BurpExtender implements IBurpExtender, IHttpListener, IMessageEditorTabFactory, ITab {
-    private MainUI main = new MainUI();
-    private static PrintWriter stdout;
+    private MainUI main;
+    // stdout变成公开属性，便于其他类调用输出调试信息
+    public static PrintWriter stdout;
    private IBurpExtenderCallbacks callbacks;
    private static IExtensionHelpers helpers;
-    private static IMessageEditorTab HaETab;
-    MatchHTTP mh = new MatchHTTP();
-    ExtractContent ec = new ExtractContent();
-    DoAction da = new DoAction();
-    GetColorKey gck = new GetColorKey();
-    UpgradeColor uc = new UpgradeColor();
+    ColorProcessor colorProcessor = new ColorProcessor();
+    MessageProcessor messageProcessor = new MessageProcessor();
+    private MessagePanel messagePanel;

    @Override
    public void registerExtenderCallbacks(final IBurpExtenderCallbacks callbacks)
@@ -33,13 +36,15 @@ public class BurpExtender implements IBurpExtender, IHttpListener, IMessageEdito
        this.callbacks = callbacks;
        BurpExtender.helpers = callbacks.getHelpers();

-        String version = "2.0.1";
+        String version = "2.5";
        callbacks.setExtensionName(String.format("HaE (%s) - Highlighter and Extractor", version));
+
        // 定义输出
        stdout = new PrintWriter(callbacks.getStdout(), true);
-        stdout.println("@UI Author: 0chencc");
-        stdout.println("@Core Author: EvilChen");
-        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(new Runnable() {
            @Override
@@ -50,11 +55,16 @@ public class BurpExtender implements IBurpExtender, IHttpListener, IMessageEdito

        callbacks.registerHttpListener(BurpExtender.this);
        callbacks.registerMessageEditorTabFactory(BurpExtender.this);
+
    }
+
    private void initialize(){
+        messagePanel = new MessagePanel(callbacks, helpers);
+        main = new MainUI(messagePanel);
        callbacks.customizeUiComponent(main);
        callbacks.addSuiteTab(BurpExtender.this);
    }
+
    @Override
    public String getTabCaption(){
        return "HaE";
@@ -65,60 +75,79 @@ public class BurpExtender implements IBurpExtender, IHttpListener, IMessageEdito
        return main;
    }

-    /*
+    /**
     * 使用processHttpMessage用来做Highlighter
     */
    @Override
    public void processHttpMessage(int toolFlag, boolean messageIsRequest, IHttpRequestResponse messageInfo) {
        // 判断是否是响应，且该代码作用域为：REPEATER、INTRUDER、PROXY（分别对应toolFlag 64、32、4）
        if (toolFlag == 64 || toolFlag == 32 || toolFlag == 4) {
-            Map<String, Map<String, Object>> obj;
-            byte[] content = messageInfo.getRequest();
-            // 获取报文头
-            List<String> tmpHeaders = helpers.analyzeRequest(messageInfo.getHttpService(), content).getHeaders();
-            String headers = String.join("\n", tmpHeaders);
-
-            // 获取报文主体
-            int bodyOffset = helpers.analyzeRequest(messageInfo.getHttpService(), content).getBodyOffset();
-            byte[] byteRequest = messageInfo.getRequest();
-            byte[] body = Arrays.copyOfRange(byteRequest, bodyOffset, byteRequest.length);
-
-            // 流量清洗
-            String urlString = helpers.analyzeRequest(messageInfo.getHttpService(), content).getUrl().toString();
-            urlString = urlString.indexOf("?") > 0 ? urlString.substring(0, urlString.indexOf("?")) : urlString;
-
-            // 正则判断
-            if (mh.matchSuffix(urlString)) {
-                return;
-            }
+            byte[] content;

            if (messageIsRequest) {
-                obj = ec.matchRegex(content, headers, body, "request");
+                content = messageInfo.getRequest();
            } else {
                content = messageInfo.getResponse();
-                obj = ec.matchRegex(content, headers, body, "response");
            }

-            List<String> colorList = da.highlightList(obj);
-            if (colorList.size() != 0) {
-                String color = uc.getEndColor(gck.getColorKeys(colorList, Config.colorArray), Config.colorArray);
-                messageInfo.setHighlight(color);
+            IHttpService iHttpService = null;
+
+            try {
+                iHttpService = messageInfo.getHttpService();
+            } catch (Exception ignored) {
+            }
+
+            // 获取请求主机信息
+            assert iHttpService != null;
+            String host = iHttpService.getHost();
+
+            String c = new String(content, StandardCharsets.UTF_8).intern();
+
+            List<Map<String, String>> result = null;
+            try {
+                result = messageProcessor.processMessage(helpers, content, messageIsRequest, true, host);
+            } catch (NoSuchAlgorithmException e) {
+                throw new RuntimeException(e);
+            }
+            String resComment = "";
+            String resColor = "";
+            String originalColor = messageInfo.getHighlight();
+            String originalComment = messageInfo.getComment();
+            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"));
+                resColor = colorProcessor.retrieveFinalColor(colorProcessor.retrieveColorIndices(colorList));
+                messageInfo.setHighlight(resColor);
+
+                String addComment = String.join(", ", result.get(1).get("comment"));
+                resComment = !Objects.equals(originalComment, "") ? String.format("%s, %s", originalComment, addComment) : addComment;
+                messageInfo.setComment(resComment);
+            }
+
+            String endComment = resComment.isEmpty() ? originalComment : resComment;
+            String endColor = resColor.isEmpty() ? originalColor : resColor;
+
+            if (!messageIsRequest && !endComment.isEmpty() && !endColor.isEmpty()) {
+                messagePanel.add(messageInfo, endComment, String.valueOf(content.length), endColor);
            }
        }
-
    }

    class MarkInfoTab implements IMessageEditorTab {
-        private ITextEditor markInfoText;
-        private byte[] currentMessage;
+        private final JTabbedPane jTabbedPane = new JTabbedPane();
+        private JTable jTable = new JTable();
        private final IMessageEditorController controller;
-        private byte[] extractRequestContent;
-        private byte[] extractResponseContent;
+        private Map<String, String> extractRequestMap;
+        private Map<String, String> extractResponseMap;
+        private ArrayList<String> titleList = new ArrayList<>();

        public MarkInfoTab(IMessageEditorController controller, boolean editable) {
            this.controller = controller;
-            markInfoText = callbacks.createTextEditor();
-            markInfoText.setEditable(editable);
        }

        @Override
@@ -128,99 +157,114 @@ public class BurpExtender implements IBurpExtender, IHttpListener, IMessageEdito

        @Override
        public Component getUiComponent() {
-            return markInfoText.getComponent();
+            jTabbedPane.addChangeListener(new ChangeListener() {
+                @Override
+                public void stateChanged(ChangeEvent arg0) {
+                    jTable = (JTable) ((JScrollPane)jTabbedPane.getSelectedComponent()).getViewport().getView();
+                }
+            });
+            return this.jTabbedPane;
        }

        @Override
        public boolean isEnabled(byte[] content, boolean isRequest) {
-            Map<String, Map<String, Object>> obj;
+            String c = new String(content, StandardCharsets.UTF_8).intern();
+            List<Map<String, String>> result = null;
+            try {
+                result = messageProcessor.processMessage(helpers, content, isRequest, false, "");
+            } catch (NoSuchAlgorithmException e) {
+                throw new RuntimeException(e);
+            }

-            if (isRequest) {
-                try {
-                    // 流量清洗
-                    String urlString = helpers.analyzeRequest(controller.getHttpService(), controller.getRequest()).getUrl().toString();
-                    urlString = urlString.indexOf("?") > 0 ? urlString.substring(0, urlString.indexOf("?")) : urlString;
-                    // 正则判断
-                    if (mh.matchSuffix(urlString)) {
-                        return false;
-                    }
-                } catch (Exception e) {
-                    return false;
-                }
-
-                // 获取报文头
-                List<String> tmpHeaders = helpers.analyzeRequest(controller.getHttpService(), content).getHeaders();
-                String headers = String.join("\n", tmpHeaders);
-                // 获取报文主体
-                int bodyOffset = helpers.analyzeRequest(controller.getHttpService(), content).getBodyOffset();
-                byte[] byteRequest = controller.getRequest();
-                byte[] body = Arrays.copyOfRange(byteRequest, bodyOffset, byteRequest.length);
-
-                obj = ec.matchRegex(content, headers, body, "request");
-                if (obj.size() > 0) {
-                    String result = da.extractString(obj);
-                    extractRequestContent = result.getBytes();
-                    return true;
-                }
-            } else {
-
-                // 获取报文头
-                List<String> tmpHeaders1 = helpers.analyzeResponse(content).getHeaders();
-                String headers1 = String.join("\n", tmpHeaders1);
-                // 获取报文主体
-                int bodyOffset1 = helpers.analyzeResponse(content).getBodyOffset();
-                byte[] byteRequest1 = controller.getResponse();
-                byte[] body = Arrays.copyOfRange(byteRequest1, bodyOffset1, byteRequest1.length);
-
-                obj = ec.matchRegex(content, headers1, body, "response");
-                if (obj.size() > 0) {
-                    String result = da.extractString(obj);
-                    extractResponseContent = result.getBytes();
-                    return true;
+            if (result != null && !result.isEmpty()) {
+                Map<String, String> dataMap = result.get(0);
+                if (isRequest) {
+                    extractRequestMap = dataMap;
+                } else {
+                    extractResponseMap = dataMap;
                }
+                return true;
            }
            return false;
        }

        @Override
        public byte[] getMessage() {
-            return currentMessage;
+            return null;
        }

        @Override
        public boolean isModified() {
-            return markInfoText.isTextModified();
+            return false;
        }

+        /**
+         * 快捷键复制功能
+         */
        @Override
        public byte[] getSelectedData() {
-            return markInfoText.getSelectedText();
+            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());
        }

-        /*
+        /**
         * 使用setMessage用来做Extractor
         */
        @Override
        public void setMessage(byte[] content, boolean isRequest) {
-            try {
-                String c = new String(content, "UTF-8").intern();
-            } catch (UnsupportedEncodingException e) {
-                stdout.println(e);
-            }
+            String c = new String(content, StandardCharsets.UTF_8).intern();
            if (content.length > 0) {
                if (isRequest) {
-                    markInfoText.setText(extractRequestContent);
+                    makeTable(extractRequestMap);
                } else {
-                    markInfoText.setText(extractResponseContent);
+                    makeTable(extractResponseMap);
                }
            }
-            currentMessage = content;
+        }
+
+        /**
+         * 创建MarkInfo表单
+         */
+        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];
+                }
+                JTable infoTable = new JTable(data, new Object[]{"Information"});
+                infoTable.setAutoCreateRowSorter(true);
+                JScrollPane jScrollPane = new JScrollPane(infoTable);
+
+                lTitleList.add(i);
+                this.jTabbedPane.addTab(i, jScrollPane);
+            });
+
+            /*
+             * 使用removeAll会导致MarkInfo UI出现空白的情况，为了改善用户侧体验，采用remove的方式进行删除；
+             * 采用全局ArrayList的方式遍历删除Tab，以此应对BurpSuite缓存机制导致的MarkInfo UI错误展示。
+             */
+            titleList.forEach(t->{
+                int indexOfTab = this.jTabbedPane.indexOfTab(t);
+                if (indexOfTab != -1) {
+                    this.jTabbedPane.removeTabAt(indexOfTab);
+                }
+            });
+
+            titleList = lTitleList;
        }
    }

    @Override
    public IMessageEditorTab createNewInstance(IMessageEditorController controller, boolean editable) {
-        HaETab = new MarkInfoTab(controller, editable);
-        return HaETab;
+        return new MarkInfoTab(controller, editable);
    }
 }
--- a/src/main/java/burp/Config.java
+++ b/src/main/java/burp/Config.java
@@ -1,38 +0,0 @@
-package burp;
-
-/*
- * @author EvilChen
- */
-
-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 static String[] scopeArray = new String[] {
-            "any",
-            "response",
-            "response header",
-            "response body",
-            "request",
-            "request header",
-            "request body"
-    };
-
-    public static String[] engineArray = new String[] {
-            "nfa",
-            "dfa"
-    };
-
-    public static String outputTplString = "[%s]\n%s\n\n";
-
-    public static String[] colorArray = new String[] {
-            "red",
-            "orange",
-            "yellow",
-            "green",
-            "cyan",
-            "blue",
-            "pink",
-            "magenta",
-            "gray"
-    };
-}
--- a/src/main/java/burp/action/DoAction.java
+++ b/src/main/java/burp/action/DoAction.java
@@ -1,33 +0,0 @@
-package burp.action;
-
-import java.util.Map;
-import burp.Config;
-import java.util.ArrayList;
-import java.util.List;
-
-/*
- * @author EvilChen
- */
-
-public class DoAction {
-    public String extractString(Map<String, Map<String, Object>> obj) {
-        String[] result = {""};
-        obj.keySet().forEach(i->{
-            Map<String, Object> tmpMap = obj.get(i);
-            String data = tmpMap.get("data").toString();
-            String tmpStr = String.format(Config.outputTplString, i, data).intern();
-            result[0] += tmpStr;
-        });
-        return result[0];
-    }
-
-    public List<String> highlightList(Map<String, Map<String, Object>> obj) {
-        List<String> colorList = new ArrayList<String>();
-        obj.keySet().forEach(i->{
-            Map<String, Object> tmpMap = obj.get(i);
-            String color = tmpMap.get("color").toString();
-            colorList.add(color);
-        });
-        return colorList;
-    }
-}
--- a/src/main/java/burp/action/ExtractContent.java
+++ b/src/main/java/burp/action/ExtractContent.java
@@ -1,103 +0,0 @@
-package burp.action;
-
-import java.io.UnsupportedEncodingException;
-import java.util.*;
-
-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;
-
-import burp.yaml.LoadRule;
-import burp.yaml.LoadConfigFile;
-
-/*
- * @author EvilChen
- */
-
-public class ExtractContent {
-    private LoadConfigFile lcf = new LoadConfigFile();
-    private LoadRule lr = new LoadRule(lcf.getConfigPath());
-
-    public Map<String, Map<String, Object>> matchRegex(byte[] content, String headers, byte[] body, String scopeString) {
-        Map<String, Map<String, Object>> map = new HashMap<>(); // 最终返回的结果
-        Map<String,Object[][]> rules = lr.getConfig();
-        rules.keySet().forEach(i -> {
-            String matchContent = "";
-            for (Object[] objects : rules.get(i)) {
-                // 遍历获取规则
-                List<String> result = new ArrayList<String>();
-                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();
-                // 判断规则是否开启与作用域
-                if (loaded && (scopeString.contains(scope) || scope.equals("any"))) {
-                    switch (scope) {
-                        case "any":
-                        case "request":
-                        case "response":
-                            try {
-                                matchContent = new String(content, "UTF-8").intern();
-                            } catch (UnsupportedEncodingException e) {
-                                e.printStackTrace();
-                            }
-                            break;
-                        case "request header":
-                        case "response header":
-                            matchContent = headers;
-                            break;
-                        case "request body":
-                        case "response body":
-                            try {
-                                matchContent = new String(body, "UTF-8").intern();
-                            } catch (UnsupportedEncodingException e) {
-                                e.printStackTrace();
-                            }
-                            break;
-                    }
-
-                    if (engine.equals("nfa")) {
-                        Pattern pattern = new Pattern(regex);
-                        Matcher matcher = pattern.matcher(matchContent);
-                        while (matcher.find()) {
-                            // 添加匹配数据至list
-                            // 强制用户使用()包裹正则
-                            result.add(matcher.group(1));
-                        }
-                    } else {
-                        RegExp regexpr = new RegExp(regex);
-                        Automaton auto = regexpr.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);
-                    }
-                }
-            }
-        });
-
-        return map;
-    }
-}
--- a/src/main/java/burp/action/GetColorKey.java
+++ b/src/main/java/burp/action/GetColorKey.java
@@ -1,27 +0,0 @@
-package burp.action;
-
-import java.util.ArrayList;
-import java.util.List;
-
-/*
- * @author EvilChen
- */
-
-public class GetColorKey {
-    /*
-     * 颜色下标获取
-     */
-    public List<Integer> getColorKeys(List<String> keys, String[] colorArray){
-        List<Integer> result = new ArrayList<Integer>();
-        int size = colorArray.length;
-        // 根据颜色获取下标
-        for (int x = 0; x < keys.size(); x++) {
-            for (int v = 0; v < size; v++) {
-                if (colorArray[v].equals(keys.get(x))) {
-                    result.add(v);
-                }
-            }
-        }
-        return result;
-    }
-}
--- a/src/main/java/burp/action/MatchHTTP.java
+++ b/src/main/java/burp/action/MatchHTTP.java
@@ -1,24 +0,0 @@
-package burp.action;
-
-import jregex.Matcher;
-import jregex.Pattern;
-import jregex.REFlags;
-import burp.yaml.LoadConfigFile;
-
-/*
- * @author EvilChen
- */
-
-public class MatchHTTP {
-    // 匹配后缀
-    LoadConfigFile lc = new LoadConfigFile();
-    public boolean matchSuffix(String str) {
-        Pattern pattern = new Pattern(String.format("[\\w]+[\\.](%s)", lc.getExcludeSuffix()), REFlags.IGNORE_CASE);
-        Matcher matcher = pattern.matcher(str);
-        if(matcher.find()){
-            return true;
-        }else{
-            return false;
-        }
-    }
-}
--- a/src/main/java/burp/action/UpgradeColor.java
+++ b/src/main/java/burp/action/UpgradeColor.java
@@ -1,56 +0,0 @@
-package burp.action;
-
-import java.util.ArrayList;
-import java.util.Comparator;
-import java.util.HashSet;
-import java.util.List;
-
-/*
- * @author EvilChen
- */
-
-public class UpgradeColor {
-    private String endColor = "";
-    /*
-     * 颜色升级递归算法
-     */
-    private String colorUpgrade(List<Integer> colorList, String[] colorArray) {
-        int colorSize = colorList.size();
-        colorList.sort(Comparator.comparingInt(Integer::intValue));
-        int i = 0;
-        List<Integer> stack = new ArrayList<Integer>();
-        while (i < colorSize) {
-            if (stack.isEmpty()) {
-                stack.add(colorList.get(i));
-                i++;
-            } else {
-                if (colorList.get(i) != stack.stream().reduce((first, second) -> second).orElse(99999999)) {
-                    stack.add(colorList.get(i));
-                    i++;
-                } else {
-                    stack.set(stack.size() - 1, stack.get(stack.size() - 1) - 1);
-                    i++;
-                }
-            }
-
-        }
-        // 利用HashSet删除重复元素
-        HashSet tmpList = new HashSet(stack);
-        if (stack.size() == tmpList.size()) {
-            stack.sort(Comparator.comparingInt(Integer::intValue));
-            if(stack.get(0).equals(-1)) {
-                this.endColor = colorArray[0];
-            } else {
-                this.endColor = colorArray[stack.get(0)];
-            }
-        } else {
-            this.colorUpgrade(stack, colorArray);
-        }
-        return "";
-    }
-
-    public String getEndColor(List<Integer> colorList, String[] colorArray) {
-        colorUpgrade(colorList, colorArray);
-        return endColor;
-    }
-}
--- a/src/main/java/burp/config/ConfigEntry.java
+++ b/src/main/java/burp/config/ConfigEntry.java
@@ -0,0 +1,42 @@
+package burp.config;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+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",
+            "any header",
+            "any body",
+            "response",
+            "response header",
+            "response body",
+            "request",
+            "request header",
+            "request body"
+    };
+
+    public static String[] engineArray = new String[] {
+            "nfa",
+            "dfa"
+    };
+
+    public static String[] colorArray = new String[] {
+            "red",
+            "orange",
+            "yellow",
+            "green",
+            "cyan",
+            "blue",
+            "pink",
+            "magenta",
+            "gray"
+    };
+
+    public static Map<String,Object[][]> globalRules = null;
+
+    public static Map<String, Map<String, List<String>>> globalDataMap = new HashMap<>();
+}
--- a/src/main/java/burp/config/ConfigLoader.java
+++ b/src/main/java/burp/config/ConfigLoader.java
@@ -0,0 +1,131 @@
+package burp.config;
+
+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 = String.format("%s/.config/HaE", System.getProperty("user.home"));
+    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();
+            initRules();
+        }
+        ConfigEntry.globalRules = ConfigLoader.getRules();
+    }
+
+    public void initConfig() {
+        Map<String, Object> r = new LinkedHashMap<>();
+        r.put("rulesPath", RulesFilePath);
+        r.put("excludeSuffix", getExcludeSuffix());
+        try {
+            Writer ws = new OutputStreamWriter(Files.newOutputStream(Paths.get(ConfigFilePath)), StandardCharsets.UTF_8);
+            yaml.dump(r, ws);
+        } catch (Exception ex) {
+            ex.printStackTrace();
+        }
+    }
+
+    public void initRules() {
+        RuleTool rt = new RuleTool(RulesFilePath);
+        rt.getRulesFromSite();
+    }
+
+    public static String getRulesFilePath() {
+        try {
+            Map<String, Object> r = YamlTool.loadYaml(ConfigFilePath);
+            return r.get("rulesPath").toString();
+        } catch (Exception e) {
+            e.printStackTrace();
+            return RulesFilePath;
+        }
+    }
+
+    public 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", "regex", "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 void setExcludeSuffix(String excludeSuffix){
+        Map<String,Object> r = new LinkedHashMap<>();
+        r.put("rulesPath", getRulesFilePath());
+        r.put("excludeSuffix", excludeSuffix);
+        try{
+            Writer ws = new OutputStreamWriter(Files.newOutputStream(Paths.get(RulesFilePath)), StandardCharsets.UTF_8);
+            yaml.dump(r, ws);
+        }catch (Exception ex){
+            ex.printStackTrace();
+        }
+    }
+
+}
--- a/src/main/java/burp/core/GlobalCachePool.java
+++ b/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);
+    }
+
+}
--- a/src/main/java/burp/core/processor/ColorProcessor.java
+++ b/src/main/java/burp/core/processor/ColorProcessor.java
@@ -0,0 +1,68 @@
+package burp.core.processor;
+
+import burp.config.ConfigEntry;
+
+import java.util.*;
+
+/**
+ * @author EvilChen
+ */
+
+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 upgradeColors(List<Integer> colorList) {
+        int colorSize = colorList.size();
+        String[] colorArray = ConfigEntry.colorArray;
+        colorList.sort(Comparator.comparingInt(Integer::intValue));
+        int i = 0;
+        List<Integer> stack = new ArrayList<>();
+        while (i < colorSize) {
+            if (stack.isEmpty()) {
+                stack.add(colorList.get(i));
+            } else {
+                if (!Objects.equals(colorList.get(i), stack.stream().reduce((first, second) -> second).orElse(99999999))) {
+                    stack.add(colorList.get(i));
+                } else {
+                    stack.set(stack.size() - 1, stack.get(stack.size() - 1) - 1);
+                }
+            }
+            i++;
+        }
+        // 利用HashSet删除重复元素
+        HashSet tmpList = new HashSet(stack);
+        if (stack.size() == tmpList.size()) {
+            stack.sort(Comparator.comparingInt(Integer::intValue));
+            if(stack.get(0) < 0) {
+                this.finalColor = colorArray[0];
+            } else {
+                this.finalColor = colorArray[stack.get(0)];
+            }
+        } else {
+            this.upgradeColors(stack);
+        }
+    }
+
+    public String retrieveFinalColor(List<Integer> colorList) {
+        upgradeColors(colorList);
+        return finalColor;
+    }
+}
--- a/src/main/java/burp/core/processor/DataProcessingUnit.java
+++ b/src/main/java/burp/core/processor/DataProcessingUnit.java
@@ -0,0 +1,201 @@
+package burp.core.processor;
+
+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.util.Arrays;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.ArrayList;
+import java.util.List;
+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().forEach(i -> {
+                for (Object[] objects : ConfigEntry.globalRules.get(i)) {
+                    // 多线程执行，一定程度上减少阻塞现象
+                    Thread t = new Thread(() -> {
+                        String matchContent = "";
+                        // 遍历获取规则
+                        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:
+                                    break;
+                            }
+
+                            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);
+
+                            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 (!host.isEmpty()) {
+                                    List<String> dataList = Arrays.asList(dataStr.split("\n"));
+                                    if (ConfigEntry.globalDataMap.containsKey(host)) {
+                                        Map<String, List<String>> gRuleMap = new HashMap<>(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<>());
+                                    }
+                                }
+                            }
+                        }
+                    });
+                    t.start();
+                    try {
+                        t.join();
+                    } catch (Exception e) {
+                        e.printStackTrace();
+                    }
+
+                }
+            });
+            GlobalCachePool.addToCache(messageIndex, finalMap);
+            return finalMap;
+        }
+
+    }
+}
--- a/src/main/java/burp/core/processor/MessageProcessor.java
+++ b/src/main/java/burp/core/processor/MessageProcessor.java
@@ -0,0 +1,78 @@
+package burp.core.processor;
+
+import burp.IExtensionHelpers;
+import burp.core.utils.MatchTool;
+import java.security.NoSuchAlgorithmException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class MessageProcessor {
+    MatchTool matcher = new MatchTool();
+    DataProcessingUnit dataProcessingUnit = new DataProcessingUnit();
+    ColorProcessor colorProcessor = new ColorProcessor();
+
+    public List<Map<String, String>> processMessage(IExtensionHelpers helpers, byte[] content, boolean isRequest, boolean messageInfo, String host)
+            throws NoSuchAlgorithmException {
+        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 (matcher.matchUrlSuffix(urlString)) {
+                    return result;
+                }
+            } catch (Exception e) {
+                return result;
+            }
+
+            int requestBodyOffset = helpers.analyzeRequest(content).getBodyOffset();
+            byte[] requestBody = Arrays.copyOfRange(content, requestBodyOffset, content.length);
+            obj = dataProcessingUnit.matchContentByRegex(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 (matcher.matchUrlSuffix(statedMimeType) || matcher.matchUrlSuffix(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 = dataProcessingUnit.matchContentByRegex(content, responseHeaders, responseBody, "response", host);
+        }
+
+        if (obj.size() > 0) {
+            if (messageInfo) {
+                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));
+                    }};
+                    result.add(colorMap);
+                    result.add(commentMap);
+                }
+            } else {
+                result.add(dataProcessingUnit.extractDataFromMap(obj));
+            }
+        }
+        return result;
+    }
+}
--- a/src/main/java/burp/core/utils/HashCalculator.java
+++ b/src/main/java/burp/core/utils/HashCalculator.java
@@ -0,0 +1,28 @@
+package burp.core.utils;
+
+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();
+    }
+}
--- a/src/main/java/burp/core/utils/MatchTool.java
+++ b/src/main/java/burp/core/utils/MatchTool.java
@@ -0,0 +1,24 @@
+package burp.core.utils;
+
+import jregex.Pattern;
+import jregex.REFlags;
+import burp.config.ConfigLoader;
+
+/**
+ * @author EvilChen
+ */
+
+public class MatchTool {
+    // 匹配后缀
+    ConfigLoader configLoader = new ConfigLoader();
+
+    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");
+    }
+}
--- a/src/main/java/burp/core/utils/StringHelper.java
+++ b/src/main/java/burp/core/utils/StringHelper.java
@@ -0,0 +1,30 @@
+package burp.core.utils;
+
+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;
+    }
+}
--- a/src/main/java/burp/rule/RuleProcessor.java
+++ b/src/main/java/burp/rule/RuleProcessor.java
@@ -0,0 +1,98 @@
+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],
+                            (boolean) objects[6]))
+                    .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", "(New Regex)", "gray", "any", "nfa", false
+                }
+        };
+        while (ConfigEntry.globalRules.containsKey(name + i)) {
+            i++;
+        }
+        ConfigEntry.globalRules.put(name + i, data);
+        this.rulesFormatAndSave();
+        return name + i;
+    }
+}
--- a/src/main/java/burp/rule/model/Rule.java
+++ b/src/main/java/burp/rule/model/Rule.java
@@ -0,0 +1,35 @@
+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 regex, String color, String scope, String engine, boolean sensitive) {
+        fields = new LinkedHashMap<>();
+        fields.put("name", name);
+        fields.put("loaded", loaded);
+        fields.put("regex", regex);
+        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;
+    }
+}
--- a/src/main/java/burp/rule/model/RuleGroup.java
+++ b/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;
+    }
+}
--- a/src/main/java/burp/rule/utils/RuleTool.java
+++ b/src/main/java/burp/rule/utils/RuleTool.java
@@ -0,0 +1,35 @@
+package burp.rule.utils;
+
+import com.squareup.okhttp.OkHttpClient;
+import com.squareup.okhttp.Request;
+import com.squareup.okhttp.Response;
+import java.io.FileOutputStream;
+import javax.swing.JOptionPane;
+
+/**
+ * @author EvilChen
+ */
+public class RuleTool {
+    private String rulesFilePath;
+
+    public RuleTool(String rulesFilePath) {
+        this.rulesFilePath = rulesFilePath;
+    }
+
+    public void getRulesFromSite() {
+        String url = "https://cdn.jsdelivr.net/gh/gh0stkey/HaE@gh-pages/Rules.yml";
+        OkHttpClient httpClient = new OkHttpClient();
+        Request httpRequest = new Request.Builder().url(url).get().build();
+        try {
+            Response httpResponse = httpClient.newCall(httpRequest).execute();
+            // 获取官方规则文件，在线更新写入
+            FileOutputStream fileOutputStream = new FileOutputStream(this.rulesFilePath);
+            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);
+        }
+    }
+}
--- a/src/main/java/burp/rule/utils/YamlTool.java
+++ b/src/main/java/burp/rule/utils/YamlTool.java
@@ -0,0 +1,35 @@
+package burp.rule.utils;
+
+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 = new FileInputStream(filePath);
+            Yaml yaml = newStandardYaml();
+            return yaml.load(inputStream);
+        } catch (FileNotFoundException e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+}
+
--- a/src/main/java/burp/ui/JTabbedPaneCloseButton.java
+++ b/src/main/java/burp/ui/JTabbedPaneCloseButton.java
@@ -1,117 +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 {
-        private Component tab;
-
-        public CloseButtonTab(final Component tab, String title, Icon icon) {
-            this.tab = tab;
-            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 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();
-            }
-        }
-    }
-}
--- a/src/main/java/burp/ui/MainUI.java
+++ b/src/main/java/burp/ui/MainUI.java
@@ -1,291 +1,254 @@
 package burp.ui;

-import org.jetbrains.annotations.NotNull;
-import burp.yaml.LoadConfigFile;
-import burp.yaml.LoadRule;
-import burp.yaml.SetRuleConfig;
-
+import burp.config.ConfigEntry;
+import burp.config.ConfigLoader;
+import burp.rule.RuleProcessor;
+import burp.rule.utils.RuleTool;
+import burp.ui.board.Databoard;
+import burp.ui.board.MessagePanel;
+import burp.ui.rule.RulePane;
 import javax.swing.*;
 import javax.swing.event.ChangeEvent;
 import javax.swing.event.ChangeListener;
 import javax.swing.event.DocumentEvent;
 import javax.swing.event.DocumentListener;
-import javax.swing.filechooser.FileNameExtensionFilter;
 import java.awt.*;
 import java.awt.event.*;
 import java.util.Map;

-/*
- * @author LinChen
+/**
+ * @author LinChen && EvilChen
 */

-public class MainUI extends JPanel{
-    public MainUI() {
+public class MainUI extends JPanel {
+    private final ConfigLoader loadConn = new ConfigLoader();
+    private MessagePanel messagePanel;
+
+    public MainUI(MessagePanel messagePanel) {
+        this.messagePanel = messagePanel;
+        databoardPanel = new Databoard(this.messagePanel);
        initComponents();
    }
-    public void closeTabActionPerformed(ActionEvent e){
-        if (tabbedPane1.getTabCount()>2){
-            if (tabbedPane1.getSelectedIndex()!=0){
-                SetRuleConfig setruleconfig = new SetRuleConfig();
-                setruleconfig.deleteRules(tabbedPane1.getTitleAt(tabbedPane1.getSelectedIndex()));
-                tabbedPane1.remove(tabbedPane1.getSelectedIndex());
-                tabbedPane1.setSelectedIndex(tabbedPane1.getSelectedIndex()-1);
-            }else{
-                SetRuleConfig setruleconfig = new SetRuleConfig();
-                setruleconfig.deleteRules(tabbedPane1.getTitleAt(tabbedPane1.getSelectedIndex()));
-                tabbedPane1.remove(tabbedPane1.getSelectedIndex());
-                tabbedPane1.setSelectedIndex(tabbedPane1.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 SelectFileMouseClicked(MouseEvent e) {
-        JFileChooser chooseconfig = new JFileChooser();
-        chooseconfig.setFileSelectionMode(JFileChooser.FILES_ONLY);
-        FileNameExtensionFilter filter = new FileNameExtensionFilter("Yaml File (.yml/.yaml)","yaml", "yml");
-        chooseconfig.setFileFilter(filter);
-        int selectframe = chooseconfig.showDialog(new JLabel(),"Select");
-        if (selectframe == JFileChooser.APPROVE_OPTION){
-            String configpath = chooseconfig.getSelectedFile().toString();
-            reloadRule(configpath);
-            loadfile.setConfigPath(configpath);
+    private void onlineUpdateActionPerformed(ActionEvent e) {
+        // 添加提示框防止用户误触导致配置更新
+        int retCode = JOptionPane.showConfirmDialog(null, "Do you want to update config?", "Info",
+                JOptionPane.YES_NO_CANCEL_OPTION);
+        if (retCode == JOptionPane.YES_OPTION) {
+            String rulesFilePath = rulesPathTextField.getText();
+            RuleTool rt = new RuleTool(rulesFilePath);
+            rt.getRulesFromSite();
+            new ConfigLoader();
+            reloadRule();
        }
-        configfilepathtext.setText(loadfile.getConfigPath());
-    }
-    private void reloadRule(String configfile){
-        tabbedPane1.removeAll();
-        LoadRule loadrule = new LoadRule(configfile);
-        Map<String,Object[][]> config = loadrule.getConfig();
-        ruleSwitch.setListen(false);
-        config.keySet().forEach(i->tabbedPane1.addTab(i,new RulePane(config.get(i),tabbedPane1)));
-        tabbedPane1.addTab("...",new JLabel());
-        ruleSwitch.setListen(true);
    }
+
    private void reloadRule(){
-        tabbedPane1.removeAll();
-        LoadRule loadrule = new LoadRule(loadfile.getConfigPath());
-        Map<String,Object[][]> config = loadrule.getConfig();
+        ruleTabbedPane.removeAll();
        ruleSwitch.setListen(false);
-        config.keySet().forEach(i->tabbedPane1.addTab(i,new RulePane(config.get(i),tabbedPane1))
+        Map<String,Object[][]> rules = ConfigLoader.getRules();
+        rules.keySet().forEach(
+                i -> ruleTabbedPane.addTab(
+                        i,
+                        new RulePane(rules.get(i), ruleTabbedPane)
+                )
+
        );
-        tabbedPane1.addTab("...",new JLabel());
+        ruleTabbedPane.addTab("...", new JLabel());
        ruleSwitch.setListen(true);
    }

-    private void reloadMouseClicked(MouseEvent e) {
+    private void reloadActionPerformed(ActionEvent e) {
        reloadRule();
    }
-    private void ESSaveMouseClicked(MouseEvent e) {
-        // TODO add your code here
-        LoadConfigFile lcf = new LoadConfigFile();
-        lcf.setExcludeSuffix(EStext.getText());
+
+    private void excludeSuffixSaveActionPerformed(ActionEvent e) {
+        ConfigLoader loadCon = new ConfigLoader();
+        loadCon.setExcludeSuffix(excludeSuffixTextField.getText());
    }
    private void initComponents() {
-        tabbedPane2 = new JTabbedPane();
-        tabbedPane1 = new JTabbedPane();
-        panel3 = new JPanel();
-        configfilepathtext = new JTextField();
-        label1 = new JLabel();
-        SelectFile = new JButton();
-        reload = new JButton();
-        label2 = new JLabel();
-        EStext = new JTextField();
-        ESSave = new JButton();
+        JTabbedPane mainTabbedPane = new JTabbedPane();
+        ruleTabbedPane = new JTabbedPane();
+        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();
+        JButton excludeSuffixSaveButton = new JButton();

-        //======== this ========
        setLayout(new GridBagLayout());
        ((GridBagLayout)getLayout()).columnWidths = new int[] {0, 0};
        ((GridBagLayout)getLayout()).rowHeights = new int[] {0, 0};
        ((GridBagLayout)getLayout()).columnWeights = new double[] {1.0, 1.0E-4};
        ((GridBagLayout)getLayout()).rowWeights = new double[] {1.0, 1.0E-4};

-        //======== tabbedPane2 ========
        {
-            tabbedPane2.addTab("Rules", tabbedPane1);
+            mainTabbedPane.addTab("Rules", ruleTabbedPane);

-            //======== panel3 ========
            {
-                panel3.setLayout(new GridBagLayout());
-                ((GridBagLayout)panel3.getLayout()).columnWidths = new int[] {0, 0, 0, 0, 0};
-                ((GridBagLayout)panel3.getLayout()).rowHeights = new int[] {0, 0, 0};
-                ((GridBagLayout)panel3.getLayout()).columnWeights = new double[] {0.0, 1.0, 0.0, 0.0, 1.0E-4};
-                ((GridBagLayout)panel3.getLayout()).rowWeights = new double[] {0.0, 0.0, 1.0E-4};
+                rulePanel.setLayout(new GridBagLayout());
+                ((GridBagLayout) rulePanel.getLayout()).columnWidths = new int[] {0, 0, 0, 0, 0};
+                ((GridBagLayout) rulePanel.getLayout()).rowHeights = new int[] {0, 0, 0};
+                ((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};

-                //---- configfilepathtext ----
-                configfilepathtext.setEditable(false);
-                panel3.add(configfilepathtext, 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));

-                //---- label1 ----
-                label1.setText("Config File Path:");
-                panel3.add(label1, 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));

-                //---- SelectFile ----
-                SelectFile.setText("Select File ...");
-                SelectFile.addMouseListener(new MouseAdapter() {
-                    @Override
-                    public void mouseClicked(MouseEvent e) {
-                        SelectFileMouseClicked(e);
-                    }
-                });
-                panel3.add(SelectFile, new GridBagConstraints(2, 0, 1, 1, 0.0, 0.0,
+                onlineUpdateButton.setText("Online Update");
+                onlineUpdateButton.addActionListener(this::onlineUpdateActionPerformed);
+                rulePanel.add(onlineUpdateButton, new GridBagConstraints(2, 0, 1, 1, 0.0, 0.0,
                        GridBagConstraints.CENTER, GridBagConstraints.BOTH,
                        new Insets(5, 0, 5, 5), 0, 0));

-                //---- reload ----
-                reload.setText("Reload");
-                reload.addMouseListener(new MouseAdapter() {
-                    @Override
-                    public void mouseClicked(MouseEvent e) {
-                        reloadMouseClicked(e);
-                    }
-                });
-                panel3.add(reload, new GridBagConstraints(3, 0, 1, 1, 0.0, 0.0,
+                reloadButton.setText("Reload");
+                reloadButton.addActionListener(this::reloadActionPerformed);
+                rulePanel.add(reloadButton, new GridBagConstraints(3, 0, 1, 1, 0.0, 0.0,

                        GridBagConstraints.CENTER, GridBagConstraints.BOTH,
                        new Insets(5, 0, 5, 5), 0, 0));
-//---- label2 ----
-                label2.setText("ExcludeSuffix:");
-                panel3.add(label2, new GridBagConstraints(0, 1, 1, 1, 0.0, 0.0,
+
+                excludeSuffixLabel.setText("Exclude Suffix:");
+                rulePanel.add(excludeSuffixLabel, new GridBagConstraints(0, 1, 1, 1, 0.0, 0.0,
                        GridBagConstraints.SOUTHWEST, GridBagConstraints.NONE,
                        new Insets(0, 5, 5, 5), 0, 0));
-                panel3.add(EStext, new GridBagConstraints(1, 1, 1, 1, 0.0, 0.0,
+                rulePanel.add(excludeSuffixTextField, new GridBagConstraints(1, 1, 1, 1, 0.0, 0.0,
                        GridBagConstraints.SOUTH, GridBagConstraints.HORIZONTAL,
                        new Insets(0, 0, 0, 5), 0, 0));

-                //---- ESSave ----
-                ESSave.setText("Save");
-                ESSave.addMouseListener(new MouseAdapter() {
-                    @Override
-                    public void mouseClicked(MouseEvent e) {
-                        ESSaveMouseClicked(e);
-                    }
-                });
-                panel3.add(ESSave, new GridBagConstraints(2, 1, 1, 1, 0.0, 0.0,
+                excludeSuffixSaveButton.setText("Save");
+                excludeSuffixSaveButton.addActionListener(this::excludeSuffixSaveActionPerformed);
+                rulePanel.add(excludeSuffixSaveButton, new GridBagConstraints(2, 1, 1, 1, 0.0, 0.0,
                        GridBagConstraints.SOUTH, GridBagConstraints.HORIZONTAL,
                        new Insets(0, 0, 0, 5), 0, 0));
            }
-            tabbedPane2.addTab("Config", panel3);
+            mainTabbedPane.addTab("Config", rulePanel);
+            mainTabbedPane.addTab("Databoard", this.databoardPanel);
        }
-        add(tabbedPane2, new GridBagConstraints(0, 0, 1, 1, 0.0, 0.0,
+        add(mainTabbedPane, new GridBagConstraints(0, 0, 1, 1, 0.0, 0.0,
                GridBagConstraints.CENTER, GridBagConstraints.BOTH,
                new Insets(0, 0, 0, 0), 0, 0));
-        // JFormDesigner - End of component initialization  //GEN-END:initComponents

-        LoadRule loadRule = new LoadRule(loadfile.getConfigPath());
-        Map<String,Object[][]> config = loadRule.getConfig();
-        config.keySet().forEach(i->tabbedPane1.addTab(i,new RulePane(config.get(i),tabbedPane1)));
+        ConfigEntry.globalRules.keySet().forEach(i-> ruleTabbedPane.addTab(i, new RulePane(
+                ConfigEntry.globalRules.get(i),
+                ruleTabbedPane)));

-        tabbedPane1.addTab("...",new JLabel());
+        ruleTabbedPane.addTab("...",new JLabel());

-        //TabTitleEditListener ruleSwitch = new TabTitleEditListener(tabbedPane1);
-        configfilepathtext.setText(loadfile.getConfigPath());
-        LoadConfigFile lcf =new LoadConfigFile();
-        EStext.setText(lcf.getExcludeSuffix());
-        ruleSwitch = new TabTitleEditListener(tabbedPane1);
-        tabbedPane1.addChangeListener(ruleSwitch);
-        tabbedPane1.addMouseListener(ruleSwitch);
-        closeTab.addActionListener(e -> closeTabActionPerformed(e));
-        tabMenu.add(closeTab);
+        rulesPathTextField.setText(ConfigLoader.getRulesFilePath());
+        excludeSuffixTextField.setText(loadConn.getExcludeSuffix());
+        ruleSwitch = new TabTitleEditListener(ruleTabbedPane);
+        ruleTabbedPane.addChangeListener(ruleSwitch);
+        ruleTabbedPane.addMouseListener(ruleSwitch);
+        deleteMenuItem.addActionListener(this::closeTabActionPerformed);
+        tabMenu.add(deleteMenuItem);
    }

-    // JFormDesigner - Variables declaration - DO NOT MODIFY  //GEN-BEGIN:variables
-    private JTabbedPane tabbedPane2;
-    private JTabbedPane tabbedPane1;
-    private JPanel panel3;
-    private JTextField configfilepathtext;
-    private JLabel label1;
-    private JButton SelectFile;
-    private JButton reload;
-    private JLabel label2;
-    private JTextField EStext;
-    private JButton ESSave;
-    // JFormDesigner - End of variables declaration  //GEN-END:variables
+    private JTabbedPane ruleTabbedPane;
+    private JTextField rulesPathTextField;
+    private JTextField excludeSuffixTextField;
+    private Databoard databoardPanel;
    protected static JPopupMenu tabMenu = new JPopupMenu();
-    private JMenuItem closeTab = new JMenuItem("Delete");
+    private final JMenuItem deleteMenuItem = new JMenuItem("Delete");
    private TabTitleEditListener ruleSwitch;
-    private LoadConfigFile loadfile = new LoadConfigFile();
 }

 class TabTitleEditListener extends MouseAdapter implements ChangeListener, DocumentListener {
-    protected final JTextField editor = new JTextField();
-    protected final JTabbedPane tabbedPane;
-    protected int editingIdx = -1;
+    protected final JTextField ruleEditTextField = new JTextField();
+    protected final JTabbedPane ruleEditTabbedPane;
+    protected int editingIndex = -1;
    protected int len = -1;
    protected Boolean listen = true;
    protected Dimension dim;
    protected Component tabComponent;
-    protected Boolean isRenamesucc = false;
-    protected LoadConfigFile loadfile = new LoadConfigFile();
-    protected LoadRule lr = new LoadRule(loadfile.getConfigPath());
-    protected SetRuleConfig setRuleConfig = new SetRuleConfig();
+    protected Boolean isRenameOk = false;
+    protected RuleProcessor ruleProcessor = new RuleProcessor();
+
    protected final Action startEditing = new AbstractAction() {
        @Override public void actionPerformed(ActionEvent e) {
-            editingIdx = tabbedPane.getSelectedIndex();
-            tabComponent = tabbedPane.getTabComponentAt(editingIdx);
-            tabbedPane.setTabComponentAt(editingIdx, editor);
-            isRenamesucc = true;
-            editor.setVisible(true);
-            editor.setText(tabbedPane.getTitleAt(editingIdx));
-            editor.selectAll();
-            editor.requestFocusInWindow();
-            len = editor.getText().length();
-            dim = editor.getPreferredSize();
-            editor.setMinimumSize(dim);
+            editingIndex = ruleEditTabbedPane.getSelectedIndex();
+            tabComponent = ruleEditTabbedPane.getTabComponentAt(editingIndex);
+            ruleEditTabbedPane.setTabComponentAt(editingIndex, ruleEditTextField);
+            isRenameOk = true;
+            ruleEditTextField.setVisible(true);
+            ruleEditTextField.setText(ruleEditTabbedPane.getTitleAt(editingIndex));
+            ruleEditTextField.selectAll();
+            ruleEditTextField.requestFocusInWindow();
+            len = ruleEditTextField.getText().length();
+            dim = ruleEditTextField.getPreferredSize();
+            ruleEditTextField.setMinimumSize(dim);
        }
    };
+
    protected final Action renameTabTitle = new AbstractAction() {
        @Override public void actionPerformed(ActionEvent e) {
-            String title = editor.getText().trim();
-            if (editingIdx >= 0 && !title.isEmpty()) {
-                String oldname = tabbedPane.getTitleAt(editingIdx);
-                tabbedPane.setTitleAt(editingIdx, title);
-                setRuleConfig.rename(oldname,title);
+            String title = ruleEditTextField.getText().trim();
+            if (editingIndex >= 0 && !title.isEmpty()) {
+                String oldName = ruleEditTabbedPane.getTitleAt(editingIndex);
+                ruleEditTabbedPane.setTitleAt(editingIndex, title);
+                ruleProcessor.renameRuleGroup(oldName,title);
            }
            cancelEditing.actionPerformed(null);
        }
    };
+
    protected final Action cancelEditing = new AbstractAction() {
        @Override public void actionPerformed(ActionEvent e) {
-            if (editingIdx >= 0) {
-                tabbedPane.setTabComponentAt(editingIdx, tabComponent);
-                editor.setVisible(false);
-                editingIdx = -1;
+            if (editingIndex >= 0) {
+                ruleEditTabbedPane.setTabComponentAt(editingIndex, tabComponent);
+                ruleEditTextField.setVisible(false);
+                editingIndex = -1;
                len = -1;
                tabComponent = null;
-                editor.setPreferredSize(null);
-                tabbedPane.requestFocusInWindow();
+                ruleEditTextField.setPreferredSize(null);
+                ruleEditTabbedPane.requestFocusInWindow();
            }
        }
    };

    protected TabTitleEditListener(JTabbedPane tabbedPane) {
        super();
-        this.tabbedPane = tabbedPane;
-        editor.setBorder(BorderFactory.createEmptyBorder());
-        editor.addFocusListener(new FocusAdapter() {
+        this.ruleEditTabbedPane = tabbedPane;
+        ruleEditTextField.setBorder(BorderFactory.createEmptyBorder());
+        ruleEditTextField.addFocusListener(new FocusAdapter() {
            @Override public void focusLost(FocusEvent e) {
                renameTabTitle.actionPerformed(null);
            }
        });
-        InputMap im = editor.getInputMap(JComponent.WHEN_FOCUSED);
-        ActionMap am = editor.getActionMap();
+        InputMap im = ruleEditTextField.getInputMap(JComponent.WHEN_FOCUSED);
+        ActionMap am = ruleEditTextField.getActionMap();
        im.put(KeyStroke.getKeyStroke(KeyEvent.VK_ESCAPE, 0), "cancel-editing");
        am.put("cancel-editing", cancelEditing);
        im.put(KeyStroke.getKeyStroke(KeyEvent.VK_ENTER, 0), "rename-tab-title");
        am.put("rename-tab-title", renameTabTitle);
-        editor.getDocument().addDocumentListener(this);
+        ruleEditTextField.getDocument().addDocumentListener(this);
        tabbedPane.getInputMap(JComponent.WHEN_FOCUSED).put(KeyStroke.getKeyStroke(KeyEvent.VK_ENTER, 0), "start-editing");
        tabbedPane.getActionMap().put("start-editing", startEditing);
-            }
-            @Override public void stateChanged(ChangeEvent e) {
-                if (e.getSource() instanceof JTabbedPane && listen) {
-                    JTabbedPane pane = (JTabbedPane) e.getSource();
-                    if (!isRenamesucc){
-                        if (pane.getSelectedIndex() == pane.getComponentCount()-1){
+    }
+
+    @Override public void stateChanged(ChangeEvent e) {
+        if (e.getSource() instanceof JTabbedPane && listen) {
+            JTabbedPane pane = (JTabbedPane) e.getSource();
+            if (!isRenameOk){
+                if (pane.getSelectedIndex() == pane.getComponentCount()-1){
                    newTab();
                }
            }else{
@@ -296,18 +259,22 @@ class TabTitleEditListener extends MouseAdapter implements ChangeListener, Docum
        }
        renameTabTitle.actionPerformed(null);
    }
+
    public void newTab(){
-        Object[][] data = new Object[][]{{false, "New Name", "(New Regex)", "gray", "any", "nfa"}};
-        insertTab(tabbedPane,setRuleConfig.newRules(),data);
+        Object[][] data = new Object[][]{{false, "New Name", "(New Regex)", "gray", "any", "nfa", false}};
+        insertTab(ruleEditTabbedPane, ruleProcessor.newRule(),data);
    }
-    public void insertTab(@NotNull JTabbedPane pane,String title,Object[][] data){
+
+    public void insertTab(JTabbedPane pane,String title,Object[][] data){
        pane.addTab(title,new RulePane(data,pane));
        pane.remove(pane.getSelectedIndex());
        pane.addTab("...",new JLabel());
    }
+
    public void setListen(Boolean listen){
        this.listen = listen;
    }
+
    @Override public void insertUpdate(DocumentEvent e) {
        updateTabSize();
    }
@@ -322,7 +289,7 @@ class TabTitleEditListener extends MouseAdapter implements ChangeListener, Docum
        switch (e.getButton()){
            case 1:
            {
-                Rectangle r = tabbedPane.getBoundsAt(tabbedPane.getSelectedIndex());
+                Rectangle r = ruleEditTabbedPane.getBoundsAt(ruleEditTabbedPane.getSelectedIndex());
                boolean isDoubleClick = e.getClickCount() >= 2;
                if (isDoubleClick && r.contains(e.getPoint())) {
                    startEditing.actionPerformed(null);
@@ -341,7 +308,7 @@ class TabTitleEditListener extends MouseAdapter implements ChangeListener, Docum
    }

    protected void updateTabSize() {
-        editor.setPreferredSize(editor.getText().length() > len ? null : dim);
-        tabbedPane.revalidate();
+        ruleEditTextField.setPreferredSize(ruleEditTextField.getText().length() > len ? null : dim);
+        ruleEditTabbedPane.revalidate();
    }
 }
--- a/src/main/java/burp/ui/RulePane.java
+++ b/src/main/java/burp/ui/RulePane.java
@@ -1,197 +0,0 @@
-package burp.ui;
-
-import burp.yaml.SetRuleConfig;
-
-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.awt.event.MouseAdapter;
-import java.awt.event.MouseEvent;
-import java.util.Vector;
-
-/*
- * @author LinChen
- */
-
-public class RulePane extends JPanel {
-    public RulePane(Object[][] data,JTabbedPane pane) {
-        initComponents(data,pane);
-    }
-    private SetRuleConfig setruleconfig = new SetRuleConfig();
-    private Boolean isEdit = false;
-    private void RuleAddMouseClicked(MouseEvent e, JTabbedPane pane) {
-        // TODO add your code here
-        RuleSetting add = new RuleSetting();
-        int isOk = JOptionPane.showConfirmDialog(null,add,"RuleSetting - Add Rule",JOptionPane.OK_OPTION);
-        if(isOk == 0){
-            Vector data = new Vector();
-            data.add(false);
-            data.add(add.Name.getText());
-            data.add(add.Regex.getText());
-            data.add(add.ColorSelect.getSelectedItem().toString());
-            data.add(add.ScopeSelect.getSelectedItem().toString());
-            data.add(add.EngineSelect.getSelectedItem().toString());
-            model.insertRow(model.getRowCount(),data);
-            model = (DefaultTableModel) table.getModel();
-            setruleconfig.add(data,pane.getTitleAt(pane.getSelectedIndex()));
-        }
-    }
-
-    private void RuleEditMouseClicked(MouseEvent e,JTabbedPane pane){
-        if (table.getSelectedRowCount()>=1){
-            RuleSetting edit = new RuleSetting();
-            edit.Name.setText(table.getValueAt(table.getSelectedRow(),1).toString());
-            edit.Regex.setText(table.getValueAt(table.getSelectedRow(),2).toString());
-            edit.ColorSelect.setSelectedItem(table.getValueAt(table.getSelectedRow(),3).toString());
-            edit.ScopeSelect.setSelectedItem(table.getValueAt(table.getSelectedRow(),4).toString());
-            edit.EngineSelect.setSelectedItem(table.getValueAt(table.getSelectedRow(),5).toString());
-            int isOk = JOptionPane.showConfirmDialog(null,edit,"RuleSetting - Edit Rule",JOptionPane.OK_OPTION);
-            if (isOk ==0){
-                int select = table.convertRowIndexToModel(table.getSelectedRow());
-                model.setValueAt(edit.Name.getText(),select,1);
-                model.setValueAt(edit.Regex.getText(),select,2);
-                model.setValueAt(edit.ColorSelect.getSelectedItem().toString(),select,3);
-                model.setValueAt(edit.ScopeSelect.getSelectedItem().toString(),select,4);
-                model.setValueAt(edit.EngineSelect.getSelectedItem().toString(),select,5);
-                model = (DefaultTableModel) table.getModel();
-                setruleconfig.edit((Vector) model.getDataVector().get(select),select,pane.getTitleAt(pane.getSelectedIndex()));
-            }
-        }
-    }
-
-    private void RuleRemoveMouseClicked(MouseEvent e,JTabbedPane pane){
-        if (table.getSelectedRowCount()>=1){
-            int isOk = JOptionPane.showConfirmDialog(null,"Are your sure?","RuleSetting - Delete Rule",JOptionPane.OK_OPTION);
-            if (isOk==0){
-                int select = table.convertRowIndexToModel(table.getSelectedRow());
-                model.removeRow(select);
-                model = (DefaultTableModel) table.getModel();
-                setruleconfig.remove(select,pane.getTitleAt(pane.getSelectedIndex()));
-            }
-        }
-    }
-
-    private void RuleTableChange(TableModelEvent e,JTabbedPane pane) {
-        if (e.getColumn()==0&&table.getSelectedRow()!=-1&&!isEdit){
-            model = (DefaultTableModel) table.getModel();
-            int select = table.convertRowIndexToModel(table.getSelectedRow());
-            setruleconfig.edit((Vector) model.getDataVector().get(select),select,pane.getTitleAt(pane.getSelectedIndex()));
-        }
-    }
-
-    private void initComponents(Object[][] data,JTabbedPane pane) {
-        // JFormDesigner - Component initialization - DO NOT MODIFY  //GEN-BEGIN:initComponents
-        RuleAdd = new JButton();
-        RuleEdit = new JButton();
-        scrollPane = new JScrollPane();
-        table = new JTable();
-        Remove = new JButton();
-
-        //======== this ========
-        setLayout(new GridBagLayout());
-        ((GridBagLayout)getLayout()).columnWidths = new int[] {0, 0, 0};
-        ((GridBagLayout)getLayout()).rowHeights = new int[] {0, 0, 0, 0, 0};
-        ((GridBagLayout)getLayout()).columnWeights = new double[] {0.0, 1.0, 1.0E-4};
-        ((GridBagLayout)getLayout()).rowWeights = new double[] {0.0, 0.0, 0.0, 1.0, 1.0E-4};
-
-        //---- RuleAdd ----
-        RuleAdd.setText("Add");
-        RuleAdd.addMouseListener(new MouseAdapter() {
-            @Override
-            public void mouseClicked(MouseEvent e) {
-                isEdit = true;
-                RuleAddMouseClicked(e,pane);
-                model = (DefaultTableModel) table.getModel();
-                isEdit = false;
-            }
-        });
-        add(RuleAdd, new GridBagConstraints(0, 0, 1, 1, 0.0, 0.0,
-            GridBagConstraints.CENTER, GridBagConstraints.BOTH,
-            new Insets(15, 5, 3, 2), 0, 0));
-
-        //---- RuleEdit ----
-        RuleEdit.setText("Edit");
-        RuleEdit.addMouseListener(new MouseAdapter() {
-            @Override
-            public void mouseClicked(MouseEvent e) {
-                isEdit = true;
-                RuleEditMouseClicked(e,pane);
-                model = (DefaultTableModel) table.getModel();
-                isEdit = false;
-            }
-        });
-        add(RuleEdit, new GridBagConstraints(0, 1, 1, 1, 0.0, 0.0,
-            GridBagConstraints.CENTER, GridBagConstraints.BOTH,
-            new Insets(0, 5, 3, 2), 0, 0));
-
-        //======== scrollPane ========
-        {
-
-            //---- table ----
-            table.setShowVerticalLines(false);
-            table.setVerifyInputWhenFocusTarget(false);
-            table.setUpdateSelectionOnSort(false);
-            table.setShowHorizontalLines(false);
-            table.setModel(new DefaultTableModel());
-            table.setSurrendersFocusOnKeystroke(true);
-            scrollPane.setViewportView(table);
-        }
-        add(scrollPane, new GridBagConstraints(1, 0, 1, 4, 0.0, 0.0,
-            GridBagConstraints.CENTER, GridBagConstraints.BOTH,
-            new Insets(15, 5, 5, 5), 0, 0));
-
-        //---- Remove ----
-        Remove.setText("Remove");
-        Remove.addMouseListener(new MouseAdapter() {
-            @Override
-            public void mouseClicked(MouseEvent e) {
-                isEdit = true;
-                RuleRemoveMouseClicked(e,pane);
-                model = (DefaultTableModel) table.getModel();
-                isEdit = false;
-            }
-        });
-        add(Remove, new GridBagConstraints(0, 2, 1, 1, 0.0, 0.0,
-            GridBagConstraints.CENTER, GridBagConstraints.BOTH,
-            new Insets(0, 5, 3, 2), 0, 0));
-        // JFormDesigner - End of component initialization  //GEN-END:initComponents
-        table.setModel(model);
-        model.setDataVector(data,title);
-        model.addTableModelListener(new TableModelListener() {
-            @Override
-            public void tableChanged(TableModelEvent e) {
-                RuleTableChange(e,pane);
-            }
-        });
-        table.setRowSorter(new TableRowSorter(model));
-    }
-
-    // JFormDesigner - Variables declaration - DO NOT MODIFY  //GEN-BEGIN:variables
-    public JButton RuleAdd;
-    public JButton RuleEdit;
-    public JScrollPane scrollPane;
-    public JTable table;
-    public JButton Remove;
-    // JFormDesigner - End of variables declaration  //GEN-END:variables
-    private final String[] title = new String[]{"Loaded", "Name", "Regex", "Color", "Scope", "Engine"};
-    private DefaultTableModel model = new DefaultTableModel() {
-        public Class<?> getColumnClass ( int column){
-            if (column == 0) {
-                return Boolean.class;
-            }else{
-                return String.class;
-            }
-        }
-        public boolean isCellEditable(int row,int column){
-            if (column ==0){
-                return true;
-            }else {
-                return false;
-            }
-        }
-    };
-}
-
--- a/src/main/java/burp/ui/RuleSetting.java
+++ b/src/main/java/burp/ui/RuleSetting.java
@@ -1,105 +0,0 @@
-package burp.ui;
-
-import javax.swing.*;
-import java.awt.*;
-import burp.Config;
-
-/*
- * @author LinChen
- */
-
-public class RuleSetting extends JPanel {
-    public RuleSetting() {
-        initComponents();
-    }
-
-    public void initComponents() {
-        // JFormDesigner - Component initialization - DO NOT MODIFY  //GEN-BEGIN:initComponents
-        label5 = new JLabel();
-        label4 = new JLabel();
-        Regex = new JTextField();
-        label3 = new JLabel();
-        label2 = new JLabel();
-        Name = new JTextField();
-        ScopeSelect = new JComboBox<>();
-        EngineSelect = new JComboBox<>();
-        label7 = new JLabel();
-        ColorSelect = new JComboBox<>();
-
-        //======== this ========
-        setLayout(null);
-
-        //---- label5 ----
-        label5.setText("Engine:");
-        add(label5);
-        label5.setBounds(10, 175, 50, 17);
-
-        //---- label4 ----
-        label4.setText("Scope:");
-        add(label4);
-        label4.setBounds(10, 135, 50, 17);
-        add(Regex);
-        Regex.setBounds(70, 50, 265, 30);
-
-        //---- label3 ----
-        label3.setText("Regex:");
-        add(label3);
-        label3.setBounds(10, 55, 50, 17);
-
-        //---- label2 ----
-        label2.setText("Name:");
-        add(label2);
-        label2.setBounds(10, 15, 50, 17);
-        add(Name);
-        Name.setBounds(70, 10, 265, 30);
-
-        //---- ScopeSelect ----
-        ScopeSelect.setModel(new DefaultComboBoxModel<>(Config.scopeArray));
-        add(ScopeSelect);
-        ScopeSelect.setBounds(70, 130, 265, ScopeSelect.getPreferredSize().height);
-
-        //---- EngineSelect ----
-        EngineSelect.setModel(new DefaultComboBoxModel<>(Config.engineArray));
-        add(EngineSelect);
-        EngineSelect.setBounds(70, 170, 265, EngineSelect.getPreferredSize().height);
-
-        //---- label7 ----
-        label7.setText("Color:");
-        add(label7);
-        label7.setBounds(new Rectangle(new Point(10, 95), label7.getPreferredSize()));
-
-        //---- ColorSelect ----
-        ColorSelect.setModel(new DefaultComboBoxModel<>(Config.colorArray));
-        add(ColorSelect);
-        ColorSelect.setBounds(70, 90, 265, ColorSelect.getPreferredSize().height);
-
-        {
-            // compute preferred size
-            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);
-        }
-        // JFormDesigner - End of component initialization  //GEN-END:initComponents
-    }
-
-    // JFormDesigner - Variables declaration - DO NOT MODIFY  //GEN-BEGIN:variables
-    private JLabel label5;
-    private JLabel label4;
-    public JTextField Regex;
-    private JLabel label3;
-    private JLabel label2;
-    public JTextField Name;
-    public JComboBox<String> ScopeSelect;
-    public JComboBox<String> EngineSelect;
-    private JLabel label7;
-    public JComboBox<String> ColorSelect;
-    // JFormDesigner - End of variables declaration  //GEN-END:variables
-}
--- a/src/main/java/burp/ui/board/CustomTableCellRenderer.java
+++ b/src/main/java/burp/ui/board/CustomTableCellRenderer.java
@@ -0,0 +1,64 @@
+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 CustomTableCellRenderer extends DefaultTableCellRenderer {
+
+    private List<LogEntry> log;
+    private Map<String, Color> colorMap = new HashMap<>();
+    private JTable table; // 保存对表格的引用
+
+    public CustomTableCellRenderer(List<LogEntry> log, JTable table) {
+        this.log = log;
+        this.colorMap.put("red", Color.RED);
+        this.colorMap.put("orange", Color.ORANGE);
+        this.colorMap.put("yellow", Color.YELLOW);
+        this.colorMap.put("green", Color.GREEN);
+        this.colorMap.put("cyan", Color.CYAN);
+        this.colorMap.put("blue", Color.BLUE);
+        this.colorMap.put("pink", Color.PINK);
+        this.colorMap.put("magenta", Color.MAGENTA);
+        this.colorMap.put("gray", Color.GRAY);
+        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) {
+            // 如果行被选中，设置阴影颜色
+            component.setBackground(new Color(173, 216, 230)); // Light Blue
+        } else {
+            // 否则使用原始颜色
+            component.setBackground(color);
+        }
+
+        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));
+            }
+        }
+    }
+}
--- a/src/main/java/burp/ui/board/Databoard.java
+++ b/src/main/java/burp/ui/board/Databoard.java
@@ -0,0 +1,358 @@
+package burp.ui.board;
+
+import burp.config.ConfigEntry;
+import burp.core.utils.StringHelper;
+import burp.ui.board.MessagePanel.Table;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+import javax.swing.table.DefaultTableModel;
+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.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 {
+    private static Boolean isMatchHost = false;
+    private JLabel hostLabel;
+    private JTextField hostTextField;
+    private JTabbedPane dataTabbedPaneA;
+    private JTabbedPane dataTabbedPaneB;
+    private JButton clearButton;
+    private JSplitPane splitPane;
+    private MessagePanel messagePanel;
+    private Table table;
+
+    public Databoard(MessagePanel messagePanel) {
+        this.messagePanel = messagePanel;
+        initComponents();
+    }
+
+    private void cleanUI() {
+        dataTabbedPaneA.removeAll();
+        dataTabbedPaneB.removeAll();
+        splitPane.setVisible(false);
+    }
+
+    private void clearActionPerformed(ActionEvent e) {
+        cleanUI();
+
+        String host = hostTextField.getText();
+        String cleanedHost = StringHelper.replaceFirstOccurrence(host, "*.", "");
+
+        if (host.contains("*")) {
+            ConfigEntry.globalDataMap.keySet().removeIf(i -> i.contains(cleanedHost) || cleanedHost.equals("**"));
+        } else {
+            ConfigEntry.globalDataMap.remove(host);
+        }
+
+        messagePanel.deleteByHost(cleanedHost);
+    }
+
+
+    private void initComponents() {
+        // JFormDesigner - Component initialization - DO NOT MODIFY  //GEN-BEGIN:initComponents
+        hostLabel = new JLabel();
+        hostTextField = new JTextField();
+        dataTabbedPaneA = new JTabbedPane(JTabbedPane.TOP);
+        dataTabbedPaneB = 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));
+
+        splitPane = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT);
+        splitPane.setVisible(false);
+
+        add(splitPane, new GridBagConstraints(1, 1, 3, 2, 0.0, 0.0,
+                GridBagConstraints.CENTER, GridBagConstraints.BOTH,
+                new Insets(8, 0, 5, 5), 0, 0));
+
+        setAutoMatch();
+    }
+
+    private static List<String> getHostByList() {
+        return new ArrayList<>(ConfigEntry.globalDataMap.keySet());
+    }
+
+    /**
+     * 设置输入自动匹配
+     */
+    private void setAutoMatch() {
+        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) {
+                    hostTextField.setText(hostComboBox.getSelectedItem().toString());
+                    populateTabbedPaneByHost(hostComboBox);
+                }
+            }
+        });
+
+        // 事件监听
+        hostTextField.addKeyListener(new KeyAdapter() {
+            @Override
+            public void keyPressed(KeyEvent e) {
+                isMatchHost = true;
+                int keyCode = e.getKeyCode();
+
+                if (keyCode == KeyEvent.VK_SPACE && hostComboBox.isPopupVisible()) {
+                    e.setKeyCode(KeyEvent.VK_ENTER);
+                }
+
+                if (keyCode == KeyEvent.VK_ENTER || keyCode == KeyEvent.VK_UP || keyCode == KeyEvent.VK_DOWN) {
+                    e.setSource(hostComboBox);
+                    hostComboBox.dispatchEvent(e);
+
+                    if (keyCode == KeyEvent.VK_ENTER) {
+                        String selectedItem = hostComboBox.getSelectedItem().toString();
+                        hostTextField.setText(selectedItem);
+                        populateTabbedPaneByHost(hostComboBox);
+                        hostComboBox.setPopupVisible(false);
+                        return;
+                    }
+                }
+
+                if (keyCode == KeyEvent.VK_ESCAPE) {
+                    hostComboBox.setPopupVisible(false);
+                }
+
+                isMatchHost = false;
+            }
+        });
+
+        hostTextField.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 = hostTextField.getText().toLowerCase();
+                if (!input.isEmpty()){
+                    for (String host : getHostByList()) {
+                        String lowerCaseHost = host.toLowerCase();
+                        if (lowerCaseHost.contains(input)) {
+                            if (host.length() == input.length()){
+                                comboBoxModel.insertElementAt(host,0);
+                                comboBoxModel.setSelectedItem(host);
+                            } else {
+                                comboBoxModel.addElement(host);
+                            }
+                        }
+                    }
+                }
+                hostComboBox.setPopupVisible(comboBoxModel.getSize() > 0);
+                isMatchHost = false;
+            }
+        });
+
+        hostTextField.setLayout(new BorderLayout());
+        hostTextField.add(hostComboBox, BorderLayout.SOUTH);
+    }
+
+    private void applyHostFilter(String filterText) {
+        TableRowSorter<TableModel> sorter = (TableRowSorter<TableModel>) table.getRowSorter();
+        if (filterText.contains("*.")) {
+            filterText = StringHelper.replaceFirstOccurrence(filterText, "*.", "");
+        } else if (filterText.contains("*")) {
+            filterText = "";
+        }
+        RowFilter<TableModel, Integer> filter = RowFilter.regexFilter(filterText, 1);
+        sorter.setRowFilter(filter);
+        filterText = filterText.isEmpty() ? "*" : filterText;
+
+        messagePanel.applyHostFilter(filterText);
+    }
+
+    private void populateTabbedPaneByHost(JComboBox<String> hostComboBox) {
+        if (hostComboBox.getSelectedItem() != null) {
+            String selectedHost = hostComboBox.getSelectedItem().toString();
+            Map<String, Map<String, List<String>>> dataMap = ConfigEntry.globalDataMap;
+            Map<String, List<String>> selectedDataMap;
+
+            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);
+            }
+
+            // 由于removeChangeListener不知什么原因不生效，因此建立两个tabbedPane
+            dataTabbedPaneA.removeAll();
+            dataTabbedPaneB.removeAll();
+
+            ChangeListener changeListenerInstance = new ChangeListener() {
+                @Override
+                public void stateChanged(ChangeEvent e) {
+                    int selectedIndex = dataTabbedPaneA.getSelectedIndex();
+                    String selectedTitle = "";
+                    if (selectedIndex != -1) {
+                        selectedTitle = dataTabbedPaneA.getTitleAt(selectedIndex);
+                    }
+                    applyHostFilter(selectedTitle);
+                }
+            };
+
+            if (selectedHost.equals("**")) {
+                dataTabbedPaneA.setPreferredSize(new Dimension(500,0));
+                dataTabbedPaneA.setTabLayoutPolicy(JTabbedPane.SCROLL_TAB_LAYOUT);
+                splitPane.setLeftComponent(dataTabbedPaneA);
+                for (Map.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()) {
+                        Thread t = new Thread(() -> {
+                            String tabTitle = String.format("%s (%s)", entrySet.getKey(), entrySet.getValue().size());
+                            newTabbedPane.addTab(tabTitle, new JScrollPane(new DataTable(entrySet.getKey(), entrySet.getValue())));
+                            dataTabbedPaneA.addTab(entry.getKey(), newTabbedPane);
+                        });
+                        t.start();
+                        try {
+                            t.join();
+                        } catch (Exception e) {
+                            e.printStackTrace();
+                        }
+                    }
+                }
+                dataTabbedPaneA.addChangeListener(changeListenerInstance);
+            } else {
+                dataTabbedPaneB.setPreferredSize(new Dimension(500,0));
+                dataTabbedPaneB.setTabLayoutPolicy(JTabbedPane.SCROLL_TAB_LAYOUT);
+                splitPane.setLeftComponent(dataTabbedPaneB);
+                for (Map.Entry<String, List<String>> entry : selectedDataMap.entrySet()) {
+                    String tabTitle = String.format("%s (%s)", entry.getKey(), entry.getValue().size());
+                    dataTabbedPaneB.addTab(tabTitle, new JScrollPane(new DataTable(entry.getKey(), entry.getValue())));
+                }
+            }
+
+            // 展示请求消息表单
+            JSplitPane messageSplitPane = this.messagePanel.getPanel();
+            this.splitPane.setRightComponent(messageSplitPane);
+            // 获取字段
+            table = this.messagePanel.getTable();
+
+            // 设置对应字段宽度
+            TableColumnModel columnModel = table.getColumnModel();
+            TableColumn column = columnModel.getColumn(1);
+            column.setPreferredWidth(300);
+            column = columnModel.getColumn(2);
+            column.setPreferredWidth(300);
+
+            splitPane.setVisible(true);
+            applyHostFilter(selectedHost);
+
+            // 主动调用一次stateChanged，使得dataTabbedPane可以精准展示内容
+            if (selectedHost.equals("**")) {
+                changeListenerInstance.stateChanged(null);
+            }
+
+            hostTextField.setText(selectedHost);
+        }
+    }
+
+
+    class DataTable extends JTable {
+        public DataTable(String tableName, 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"});
+            setAutoCreateRowSorter(true);
+            setModel(model);
+            setDefaultEditor(Object.class, null);
+
+            addMouseListener(new MouseAdapter() {
+                @Override
+                public void mouseClicked(MouseEvent e) {
+                    if (e.getClickCount() == 2) {
+                        int selectedRow = getSelectedRow();
+                        if (selectedRow != -1) {
+                            String rowData = getValueAt(selectedRow, 0).toString();
+                            messagePanel.applyMessageFilter(tableName, rowData);
+                        }
+                    }
+                }
+            });
+        }
+    }
+}
--- a/src/main/java/burp/ui/board/LogEntry.java
+++ b/src/main/java/burp/ui/board/LogEntry.java
@@ -0,0 +1,47 @@
+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 color;
+    private final String method;
+
+    LogEntry(IHttpRequestResponsePersisted requestResponse, String method, URL url, String comment, String length, String color) {
+        this.requestResponse = requestResponse;
+        this.method = method;
+        this.url = url;
+        this.comment = comment;
+        this.length = length;
+        this.color = color;
+    }
+
+    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 IHttpRequestResponsePersisted getRequestResponse() {
+        return this.requestResponse;
+    }
+}
--- a/src/main/java/burp/ui/board/MessagePanel.java
+++ b/src/main/java/burp/ui/board/MessagePanel.java
@@ -0,0 +1,345 @@
+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.config.ConfigEntry;
+import burp.core.utils.StringHelper;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.List;
+import javax.swing.JScrollPane;
+import javax.swing.JSplitPane;
+import javax.swing.JTabbedPane;
+import javax.swing.JTable;
+import javax.swing.SwingUtilities;
+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 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 CustomTableCellRenderer(filteredLog, logTable));
+        logTable.setAutoCreateRowSorter(true);
+
+        // Length字段根据大小进行排序
+        TableRowSorter<DefaultTableModel> sorter = (TableRowSorter<DefaultTableModel>) logTable.getRowSorter();
+        sorter.setComparator(3, 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(4, 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 5;
+    }
+
+    @Override
+    public String getColumnName(int columnIndex)
+    {
+        switch (columnIndex)
+        {
+            case 0:
+                return "Method";
+            case 1:
+                return "URL";
+            case 2:
+                return "Comment";
+            case 3:
+                return "Length";
+            case 4:
+                return "Color";
+            default:
+                return "";
+        }
+    }
+
+    @Override
+    public Class<?> getColumnClass(int columnIndex)
+    {
+        return String.class;
+    }
+
+    @Override
+    public Object getValueAt(int rowIndex, int columnIndex)
+    {
+        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.getLength();
+            case 4:
+                return logEntry.getColor();
+            default:
+                return "";
+        }
+    }
+
+    public void applyHostFilter(String filterText) {
+        filteredLog.clear();
+        fireTableDataChanged();
+        for (LogEntry entry : log) {
+            String host = entry.getUrl().getHost();
+            if (StringHelper.matchFromEnd(host, 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();
+
+            List<String> requestTmpHeaders = helpers.analyzeRequest(requestByte).getHeaders();
+            byte[] requestHeaders = helpers.stringToBytes(String.join("\n", requestTmpHeaders));
+            int requestBodyOffset = helpers.analyzeRequest(requestByte).getBodyOffset();
+            byte[] requestBody = Arrays.copyOfRange(requestByte, requestBodyOffset, requestByte.length);
+
+            List<String> responseTmpHeaders = helpers.analyzeResponse(responseByte).getHeaders();
+            byte[] responseHeaders = helpers.stringToBytes(String.join("\n", responseTmpHeaders));
+            int responseBodyOffset = helpers.analyzeResponse(responseByte).getBodyOffset();
+            byte[] responseBody = Arrays.copyOfRange(responseByte, responseBodyOffset, responseByte.length);
+
+            final boolean[] isMatched = {false}; // 标志变量，表示是否满足过滤条件
+
+            ConfigEntry.globalRules.keySet().forEach(i -> {
+                for (Object[] objects : ConfigEntry.globalRules.get(i)) {
+                    String name = objects[1].toString();
+                    String scope = objects[4].toString();
+                    if (name.contains(tableName)) {
+                        boolean match = false; // 标志变量，表示当前规则是否匹配
+
+                        switch (scope) {
+                            case "any":
+                                match = helpers.indexOf(requestByte, helpers.stringToBytes(filterText), true, 0, requestByte.length) != -1 || helpers.indexOf(responseByte, helpers.stringToBytes(filterText), true, 0, responseByte.length) != -1;
+                                break;
+                            case "request":
+                                match = helpers.indexOf(requestByte, helpers.stringToBytes(filterText), true, 0, requestByte.length) != -1;
+                                break;
+                            case "response":
+                                match = helpers.indexOf(responseByte, helpers.stringToBytes(filterText), true, 0, responseByte.length) != -1;
+                                break;
+                            case "any header":
+                                match = helpers.indexOf(requestHeaders, helpers.stringToBytes(filterText), true, 0, requestHeaders.length) != -1 || helpers.indexOf(responseHeaders, helpers.stringToBytes(filterText), true, 0, responseHeaders.length) != -1;
+                                break;
+                            case "request header":
+                                match = helpers.indexOf(requestHeaders, helpers.stringToBytes(filterText), true, 0, requestHeaders.length) != -1;
+                                break;
+                            case "response header":
+                                match = helpers.indexOf(responseHeaders, helpers.stringToBytes(filterText), true, 0, responseHeaders.length) != -1;
+                                break;
+                            case "any body":
+                                match = helpers.indexOf(requestBody, helpers.stringToBytes(filterText), true, 0, requestBody.length) != -1 || helpers.indexOf(responseBody, helpers.stringToBytes(filterText), true, 0, responseBody.length) != -1;
+                                break;
+                            case "request body":
+                                match = helpers.indexOf(requestBody, helpers.stringToBytes(filterText), true, 0, requestBody.length) != -1;
+                                break;
+                            case "response body":
+                                match = helpers.indexOf(responseBody, helpers.stringToBytes(filterText), true, 0, responseBody.length) != -1;
+                                break;
+                            default:
+                                break;
+                        }
+
+                        if (match) {
+                            isMatched[0] = true;
+                            break;
+                        }
+                    }
+                }
+            });
+
+            if (isMatched[0]) {
+                filteredLog.add(entry);
+            }
+        }
+        fireTableDataChanged();
+    }
+
+    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 length, String color) {
+        synchronized(log)
+        {
+            LogEntry logEntry = new LogEntry(callbacks.saveBuffersToTempFiles(messageInfo), helpers.analyzeRequest(messageInfo).getMethod(),
+                    helpers.analyzeRequest(messageInfo).getUrl(), comment, length, color);
+            log.add(logEntry);
+        }
+    }
+
+    public class Table extends JTable {
+        LogEntry logEntry;
+        private SwingWorker<Void, Void> currentWorker;
+
+        public Table(TableModel tableModel) {
+            super(tableModel);
+        }
+
+        @Override
+        public void changeSelection(int row, int col, boolean toggle, boolean extend) {
+            logEntry = filteredLog.get(convertRowIndexToModel(row));
+            requestViewer.setMessage("Loading...".getBytes(), true);
+            responseViewer.setMessage("Loading...".getBytes(), false);
+            currentlyDisplayedItem = logEntry.getRequestResponse();
+
+            // 取消之前的后台任务
+            if (currentWorker != null && !currentWorker.isDone()) {
+                currentWorker.cancel(true);
+            }
+            // 在后台线程中执行耗时操作
+            SwingWorker<Void, Void> worker = new SwingWorker<Void, Void>() {
+                @Override
+                protected Void doInBackground() throws Exception {
+                    refreshMessage();
+                    return null;
+                }
+            };
+            // 设置当前后台任务
+            currentWorker = worker;
+            // 启动后台线程
+            worker.execute();
+            super.changeSelection(row, col, toggle, extend);
+        }
+
+        private void refreshMessage() {
+            SwingUtilities.invokeLater(() -> {
+                requestViewer.setMessage(logEntry.getRequestResponse().getRequest(), true);
+                responseViewer.setMessage(logEntry.getRequestResponse().getResponse(), false);
+            });
+        }
+    }
+
+}
+
--- a/src/main/java/burp/ui/rule/RulePane.java
+++ b/src/main/java/burp/ui/rule/RulePane.java
@@ -0,0 +1,209 @@
+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.table.DefaultTableModel;
+import javax.swing.table.TableRowSorter;
+import java.awt.*;
+import java.util.Vector;
+
+/**
+ * @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", "Regex", "Color", "Scope", "Engine", "Sensitive"
+    };
+
+    public RulePane(Object[][] data, JTabbedPane pane) {
+        initComponents(data, pane);
+    }
+
+    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, "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.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);
+            updateModel();
+            ruleProcessor.addRule(ruleData, pane.getTitleAt(pane.getSelectedIndex()));
+        }
+    }
+
+    private void ruleEditActionPerformed(ActionEvent e, JTabbedPane pane){
+        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.sensitiveComboBox.setEnabled(
+                ruleSettingPanel.engineComboBox.getSelectedItem().toString().equals("nfa")
+            );
+
+            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 = (DefaultTableModel) ruleTable.getModel();
+                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?", "Delete Rule", JOptionPane.OK_OPTION);
+            if (isOk == 0){
+                int select = ruleTable.convertRowIndexToModel(ruleTable.getSelectedRow());
+                model.removeRow(select);
+                model = (DefaultTableModel) ruleTable.getModel();
+                ruleProcessor.removeRule(select, pane.getTitleAt(pane.getSelectedIndex()));
+            }
+        }
+    }
+
+    private void ruleTableChange(TableModelEvent e, JTabbedPane pane) {
+        if (e.getColumn() == 0 && ruleTable.getSelectedRow() != -1 && !isEdit){
+            model = (DefaultTableModel) ruleTable.getModel();
+            int select = ruleTable.convertRowIndexToModel(ruleTable.getSelectedRow());
+            ruleProcessor.changeRule((Vector) model.getDataVector().get(select), select, pane.getTitleAt(pane.getSelectedIndex()));
+        }
+    }
+
+    private void initComponents(Object[][] data, JTabbedPane pane) {
+        // JFormDesigner - Component initialization - DO NOT MODIFY  //GEN-BEGIN:initComponents
+        addButton = new JButton();
+        editButton = new JButton();
+        scrollPane = new JScrollPane();
+        ruleTable = new JTable();
+        removeButton = new JButton();
+
+        //======== this ========
+        setLayout(new GridBagLayout());
+        ((GridBagLayout)getLayout()).columnWidths = new int[] {0, 0, 0};
+        ((GridBagLayout)getLayout()).rowHeights = new int[] {0, 0, 0, 0, 0};
+        ((GridBagLayout)getLayout()).columnWeights = new double[] {0.0, 1.0, 1.0E-4};
+        ((GridBagLayout)getLayout()).rowWeights = new double[] {0.0, 0.0, 0.0, 1.0, 1.0E-4};
+
+        //---- addButton ----
+        addButton.setText("Add");
+
+        addButton.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                isEdit = true;
+                ruleAddActionPerformed(e, pane);
+                model = (DefaultTableModel) ruleTable.getModel();
+                isEdit = false;
+            }
+        });
+
+        add(addButton, new GridBagConstraints(0, 0, 1, 1, 0.0, 0.0,
+                GridBagConstraints.CENTER, GridBagConstraints.BOTH,
+                new Insets(15, 5, 3, 2), 0, 0));
+
+        //---- editButton ----
+        editButton.setText("Edit");
+        editButton.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                isEdit = true;
+                ruleEditActionPerformed(e, pane);
+                model = (DefaultTableModel) ruleTable.getModel();
+                isEdit = false;
+            }
+        });
+
+        add(editButton, new GridBagConstraints(0, 1, 1, 1, 0.0, 0.0,
+                GridBagConstraints.CENTER, GridBagConstraints.BOTH,
+                new Insets(0, 5, 3, 2), 0, 0));
+
+        //======== scrollPane ========
+        {
+            //---- table ----
+            ruleTable.setShowVerticalLines(false);
+            ruleTable.setVerifyInputWhenFocusTarget(false);
+            ruleTable.setUpdateSelectionOnSort(false);
+            ruleTable.setShowHorizontalLines(false);
+            ruleTable.setModel(new DefaultTableModel());
+            ruleTable.setSurrendersFocusOnKeystroke(true);
+            scrollPane.setViewportView(ruleTable);
+        }
+
+        add(scrollPane, new GridBagConstraints(1, 0, 1, 4, 0.0, 0.0,
+                GridBagConstraints.CENTER, GridBagConstraints.BOTH,
+                new Insets(15, 5, 5, 5), 0, 0));
+
+        //---- removeButton ----
+        removeButton.setText("Remove");
+
+        removeButton.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                isEdit = true;
+                ruleRemoveActionPerformed(e, pane);
+                model = (DefaultTableModel) ruleTable.getModel();
+                isEdit = false;
+            }
+        });
+
+        add(removeButton, new GridBagConstraints(0, 2, 1, 1, 0.0, 0.0,
+                GridBagConstraints.CENTER, GridBagConstraints.BOTH,
+                new Insets(0, 5, 3, 2), 0, 0));
+
+        ruleTable.setModel(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
+    public JButton addButton;
+    public JButton editButton;
+    public JScrollPane scrollPane;
+    public JTable ruleTable;
+    public JButton removeButton;
+    // JFormDesigner - End of variables declaration  //GEN-END:variables
+}
+
--- a/src/main/java/burp/ui/rule/RuleSetting.java
+++ b/src/main/java/burp/ui/rule/RuleSetting.java
@@ -0,0 +1,71 @@
+package burp.ui.rule;
+
+import java.awt.*;
+import javax.swing.*;
+import burp.config.ConfigEntry;
+
+/**
+ * @author LinChen & EvilChen
+ */
+
+public class RuleSetting extends JPanel {
+
+    public JTextField regexTextField;
+    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("Regex:", 1, c);
+        regexTextField = addTextField(1, c);
+
+        addLabel("Scope:", 2, c);
+        scopeComboBox = addComboBox(ConfigEntry.scopeArray, 2, c);
+
+        addLabel("Engine:", 3, c);
+        engineComboBox = addComboBox(ConfigEntry.engineArray, 3, c);
+        engineComboBox.addActionListener(e -> sensitiveComboBox.setEnabled("nfa".equals(engineComboBox.getSelectedItem().toString())));
+
+        addLabel("Color:", 4, c);
+        colorComboBox = addComboBox(ConfigEntry.colorArray, 4, c);
+
+        addLabel("Sensitive:", 5, c);
+        sensitiveComboBox = addComboBox(new Boolean[]{true, false}, 5, 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;
+    }
+}
--- a/src/main/java/burp/yaml/Config.java
+++ b/src/main/java/burp/yaml/Config.java
@@ -1,19 +0,0 @@
-package burp.yaml;
-
-import java.util.List;
-
-/*
- * @author LinChen
- */
-
-public class Config {
-    public List<Rules> rules;
-
-    public List<Rules> getRules() {
-        return rules;
-    }
-
-    public void setRules(List<Rules> rules) {
-        this.rules = rules;
-    }
-}
--- a/src/main/java/burp/yaml/LoadConfigFile.java
+++ b/src/main/java/burp/yaml/LoadConfigFile.java
@@ -1,86 +0,0 @@
-package burp.yaml;
-
-import org.jetbrains.annotations.NotNull;
-import org.yaml.snakeyaml.Yaml;
-
-import java.io.*;
-import java.util.HashMap;
-import java.util.Map;
-
-/*
- * @author LinChen
- */
-
-public class LoadConfigFile {
-    private static Yaml yaml = new Yaml();
-    private static final String SettingPath = "Setting.yml";
-    private static final String ConfigPath = "Config.yml";
-
-    public LoadConfigFile(){
-        init();
-    }
-
-    // 初始化配置
-    public void init(){
-        File yamlSetting = new File(SettingPath);
-        if (!(yamlSetting.exists() && yamlSetting.isFile())) {
-            Map<String,Object> r = new HashMap<>();
-            r.put("configPath", ConfigPath);
-            r.put("excludeSuffix", getExcludeSuffix());
-            try{
-                Writer ws = new OutputStreamWriter(new FileOutputStream(SettingPath),"UTF-8");
-                yaml.dump(r, ws);
-            }catch (Exception ex){
-                ex.printStackTrace();
-            }
-        }
-    }
-
-    public String getExcludeSuffix(){
-        try {
-            InputStream inorder = new FileInputStream(SettingPath);
-            Map<String,Object> r;
-            r = yaml.load(inorder);
-            return r.get("excludeSuffix").toString();
-        } catch (FileNotFoundException e) {
-            e.printStackTrace();
-            return "css|jpeg|gif|jpg|png|pdf|rar|zip|docx|doc|svg|jpeg|ico|woff|woff2|ttf|otf";
-        }
-    }
-
-    public String getConfigPath(){
-        try {
-            InputStream inorder = new FileInputStream(SettingPath);
-            Map<String,Object> r;
-            r = yaml.load(inorder);
-            return r.get("configPath").toString();
-        } catch (FileNotFoundException e) {
-            e.printStackTrace();
-            return ConfigPath;
-        }
-    }
-
-    public void setExcludeSuffix(@NotNull String excludeSuffix){
-        Map<String,Object> r = new HashMap<>();
-        r.put("excludeSuffix", excludeSuffix);
-        r.put("configPath", getConfigPath());
-        try{
-            Writer ws = new OutputStreamWriter(new FileOutputStream(SettingPath),"UTF-8");
-            yaml.dump(r, ws);
-        }catch (Exception ex){
-            ex.printStackTrace();
-        }
-    }
-
-    public void setConfigPath(@NotNull String filePath){
-        Map<String,Object> r = new HashMap<>();
-        r.put("configPath", filePath);
-        r.put("excludeSuffix", getExcludeSuffix());
-        try{
-            Writer ws = new OutputStreamWriter(new FileOutputStream(SettingPath),"UTF-8");
-            yaml.dump(r, ws);
-        }catch (Exception ex){
-            ex.printStackTrace();
-        }
-    }
-}
--- a/src/main/java/burp/yaml/LoadRule.java
+++ b/src/main/java/burp/yaml/LoadRule.java
@@ -1,89 +0,0 @@
-package burp.yaml;
-
-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;
-
-import java.io.*;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.Map;
-
-/*
- * @author LinChen
- */
-
-public class LoadRule {
-    private static String filePath = "Config.yml";
-    public LoadRule(String configfile){
-        init();
-        filePath = configfile;
-    }
-
-    // 初始化配置
-    public void init(){
-        File settingyaml = new File(filePath);
-        if (!(settingyaml.exists() && settingyaml.isFile())){
-            Map<String,Object[][]> r = new HashMap<>();
-            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,}))");
-            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);
-            Config config = new Config();
-            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);
-            LoadConfigFile loadfile = new LoadConfigFile();
-            File f = new File(loadfile.getConfigPath());
-            try{
-                Writer ws = new OutputStreamWriter(new FileOutputStream(f),"UTF-8");
-                yaml.dump(config,ws);
-            }catch (Exception ex){
-                ex.printStackTrace();
-            }
-        }
-    }
-
-    public static Map<String,Object[][]> getConfig(){
-        InputStream inorder = null;
-        {
-            try {
-                inorder = new FileInputStream(new File(filePath));
-            } catch (FileNotFoundException e) {
-                e.printStackTrace();
-            }
-        }
-        Yaml yaml = new Yaml(new Constructor(Config.class));
-        Config plugin = yaml.loadAs(inorder, Config.class);
-        Map<String,Object[][]> config = new HashMap<>();
-        plugin.rules.forEach(i->{
-            ArrayList<Object[]> data = new ArrayList<>();
-            i.rule.forEach(j->{
-                try {
-                    data.add(j.getRuleObject());
-                }catch (Exception e){
-                    e.printStackTrace();
-                }
-            });
-            config.put(i.getType(), data.toArray(new Object[data.size()][]));
-        });
-        return config;
-    }
-}
--- a/src/main/java/burp/yaml/Rule.java
+++ b/src/main/java/burp/yaml/Rule.java
@@ -1,81 +0,0 @@
-package burp.yaml;
-
-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;
-
-    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 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 Object[] getRuleObject(){
-        return new Object[]{Loaded, Name, Regex, Color, Scope, Engine};
-    }
-    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);
-        return r;
-    }
-    public String toString(){
-        return "{ \nLoaded: "+Loaded+"\nName: "+Name+"\nRegex: "+Regex+"\nColor: "+Color+"\nScope: "+Scope+"\nEngine: "+Engine+"\n}";
-    }
-}
--- a/src/main/java/burp/yaml/Rules.java
+++ b/src/main/java/burp/yaml/Rules.java
@@ -1,35 +0,0 @@
-package burp.yaml;
-
-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(){
-
-    }
-    public String toString(){
-        return "{ type: "+type+"\n config: "+ rule +"}\n";
-    }
-}
--- a/src/main/java/burp/yaml/SetRuleConfig.java
+++ b/src/main/java/burp/yaml/SetRuleConfig.java
@@ -1,109 +0,0 @@
-package burp.yaml;
-
-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.util.*;
-
-public class SetRuleConfig {
-    private static Yaml yaml;
-    private static LoadConfigFile loadfile;
-    private static LoadRule lr;
-    private Map<String,Object[][]> config = lr.getConfig();
-    public void format(){
-        DumperOptions dop = new DumperOptions();
-        dop.setDefaultFlowStyle(DumperOptions.FlowStyle.BLOCK);
-        Representer representer = new Representer();
-        representer.addClassTag(Config.class, Tag.MAP);
-        yaml = new Yaml(new Constructor(),representer,dop);
-        Config con = new Config();
-        List<Rules> rls = new ArrayList<>();
-
-        config.keySet().forEach(i->
-        {
-            Rules rlstmp = new Rules();
-            rlstmp.setType(i);
-            List<Rule> rl = new ArrayList<>();
-            for (Object[] objects : config.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]);
-                rl.add(rltmp);
-            }
-            rlstmp.setRule(rl);
-            rls.add(rlstmp);
-        });
-        con.setRules(rls);
-        File f = new File(loadfile.getConfigPath());
-        try{
-            Writer ws = new OutputStreamWriter(new FileOutputStream(f),"UTF-8");
-            yaml.dump(con,ws);
-        }catch (Exception ex){
-            ex.printStackTrace();
-        }
-    }
-    public void edit(Vector data,int select, String type){
-        loadfile = new LoadConfigFile();
-        lr = new LoadRule(loadfile.getConfigPath());
-        config = lr.getConfig();
-        config.get(type)[select] = data.toArray();
-        this.format();
-    }
-    public void add(Vector data,String type){
-        loadfile = new LoadConfigFile();
-        lr = new LoadRule(loadfile.getConfigPath());
-        config = lr.getConfig();
-        ArrayList<Object[]> x = new ArrayList<Object[]>(Arrays.asList(config.get(type)));
-        x.add(data.toArray());
-        config.put(type,x.toArray(new Object[x.size()][]));
-        this.format();
-    }
-    public void remove(int select,String type){
-        loadfile = new LoadConfigFile();
-        lr = new LoadRule(loadfile.getConfigPath());
-        config = lr.getConfig();
-        ArrayList<Object[]> x = new ArrayList<Object[]>(Arrays.asList(config.get(type)));
-        x.remove(select);
-        config.put(type,x.toArray(new Object[x.size()][]));
-        this.format();
-    }
-    public void rename(String oldname,String newname){
-        loadfile = new LoadConfigFile();
-        lr = new LoadRule(loadfile.getConfigPath());
-        config = lr.getConfig();
-        config.put(newname,config.remove(oldname));
-        this.format();
-    }
-    public void deleteRules(String Rules){
-        loadfile = new LoadConfigFile();
-        lr = new LoadRule(loadfile.getConfigPath());
-        config = lr.getConfig();
-        config.remove(Rules);
-        this.format();
-    }
-    public String newRules(){
-        int i = 0;
-        loadfile = new LoadConfigFile();
-        lr = new LoadRule(loadfile.getConfigPath());
-        config = lr.getConfig();
-        String name = "New ";
-        Object[][] data = new Object[][]{{false, "New Name", "(New Regex)", "gray", "any", "nfa"}};
-        while (config.containsKey(name+i)){
-            i++;
-        }
-        config.put(name+i,data);
-        this.format();
-        return name+i;
-    }
-}
Author	SHA1	Message	Date
gh0stkey	e68619d1c2	Version: 2.5 Update	2023-10-12 21:38:27 +08:00
gh0stkey	dd08ffaaa2	Update	2023-10-09 14:26:03 +08:00
gh0stkey	d9aeda4cc3	Update README.md	2023-10-09 14:25:14 +08:00
gh0stkey	e1c05ba10d	Version: 2.4.7 Update	2023-09-28 01:48:51 +08:00
gh0stkey	6a17064b3a	Version: 2.4.7 Update	2023-09-28 01:42:09 +08:00
gh0stkey	e698bb1caa	Version: 2.4.7 Update	2023-09-28 01:23:36 +08:00
gh0stkey	a69503ca3d	Version: 2.4.7 Update	2023-09-27 23:55:02 +08:00
AnonymousUser	d590d4a70e	Version: 2.4.6 Update	2023-02-22 17:36:50 +08:00
AnonymousUser	548339fa58	Version: 2.4.6 Update	2023-02-22 17:25:55 +08:00
AnonymousUser	df4496d4fd	Version: 2.4.5 Update	2022-12-18 16:12:16 +08:00
AnonymousUser	48e355ac54	Update	2022-12-18 15:09:28 +08:00
AnonymousUser	b784aa1425	Version: 2.4.4 Update	2022-09-26 18:49:35 +08:00
AnonymousUser	440b3b1504	Version: 2.4.3 Update	2022-09-20 10:33:00 +08:00
ᴋᴇʏ	a8f1798c7b	Update README.md	2022-07-25 10:56:33 +08:00
AnonymousUser	225ee471ec	Version: 2.4.2 Update	2022-07-15 10:12:34 +08:00
AnonymousUser	5097124867	Version: 2.4.1 Update	2022-06-29 16:05:51 +08:00
AnonymousUser	7e0e3054be	Version: 2.4.1 Update	2022-06-29 15:17:42 +08:00
ᴋᴇʏ	17a84fc19e	Update README.md	2022-06-24 11:11:27 +08:00
ᴋᴇʏ	1573d563eb	Update README.md	2022-06-23 22:31:39 +08:00
ᴋᴇʏ	515f7b33f0	Update README.md	2022-06-23 22:26:51 +08:00
AnonymousUser	1dc510d576	Version: 2.4 Update	2022-06-23 15:48:22 +08:00
AnonymousUser	f401214524	Version: 2.4 Update	2022-06-23 15:34:22 +08:00
ᴋᴇʏ	7ebba02200	Update README.md	2022-06-22 10:26:36 +08:00
AnonymousUser	93f5c73aac	Update	2022-06-22 10:20:44 +08:00
AnonymousUser	60b261d6ef	Update	2022-06-21 17:06:45 +08:00
AnonymousUser	c84ebf3a9d	Version: 2.3 Update	2022-05-27 13:29:32 +08:00
AnonymousUser	15f84028bb	Version: 2.2.3 Update	2022-05-12 11:00:55 +08:00
AnonymousUser	1238e536d1	Version: 2.2.2 Update	2022-05-04 23:17:24 +08:00
AnonymousUser	5d23a68c0e	Version: 2.2.2 Update	2022-05-04 22:51:58 +08:00
AnonymousUser	d7f04526b4	Version: 2.2.2 Update	2022-05-04 22:48:44 +08:00
AnonymousUser	acff96ed7b	Version: 2.2.2 Update	2022-05-04 22:47:28 +08:00
AnonymousUser	350c093162	Update	2022-05-04 20:50:53 +08:00
AnonymousUser	0d3d4f88e9	Version: 2.2.1 Update	2022-04-21 10:50:10 +08:00
AnonymousUser	37ca315aba	Version: 2.2 Update	2022-04-08 17:25:35 +08:00
AnonymousUser	241247a4a0	Version: 2.2 Update	2022-04-08 17:21:40 +08:00
AnonymousUser	08bfb69fce	Version: 2.1.6 Update	2022-03-31 13:54:12 +08:00
AnonymousUser	a6d5f3a204	Version: 2.1.5 Update	2022-02-25 13:22:14 +08:00
AnonymousUser	c4d8743fe3	Version: 2.1.4 Update	2022-02-21 09:31:03 +08:00
AnonymousUser	903077c830	Version: 2.1.3 Update	2022-01-11 14:46:25 +08:00
AnonymousUser	daddf15af2	Version: 2.1.2 Update	2021-10-23 00:06:48 +08:00
AnonymousUser	e747011ec0	Version: 2.1.2 Update	2021-10-23 00:00:20 +08:00
AnonymousUser	f7b2e99eb2	Version: 2.1.2 Update	2021-10-22 22:46:42 +08:00
AnonymousUser	59cd0a88b9	Update	2021-10-22 21:58:45 +08:00
AnonymousUser	b16cbf5b60	Update	2021-10-22 21:57:11 +08:00
AnonymousUser	4ef766dd82	Version: 2.1.1 Update	2021-10-21 23:42:15 +08:00
AnonymousUser	5d9f590977	Version: 2.1 Update	2021-09-12 15:23:54 +08:00
AnonymousUser	5c326d3ca6	Version: 2.0.7 Update	2021-09-07 22:09:42 +08:00
ᴋᴇʏ	62edae0ab4	Merge pull request #28 from gh0stkey/add-license-1 Create LICENSE	2021-08-16 11:01:05 +08:00
ᴋᴇʏ	562378873c	Create LICENSE	2021-08-16 11:00:53 +08:00
AnonymousUser	5f62e9653f	update	2021-08-01 15:00:12 +08:00
AnonymousUser	3fc1869a7b	Version: 2.0.6 Update	2021-07-13 15:10:25 +08:00
AnonymousUser	43fbc46b65	Version: 2.0.5 Fixed Bug	2021-07-06 18:33:11 +08:00
AnonymousUser	00a4a835b2	Update	2021-06-25 12:41:25 +08:00
AnonymousUser	f872dadf46	Version: 2.0.4 Fixed Bug	2021-06-14 23:06:03 +08:00
0chen	15bbb9f1a0	修复一处bug close #18 感谢#18 问题已经修复	2021-06-14 15:33:22 +08:00
AnonymousUser	89f3f6cf09	Version 2.0.3 Fixed Match Scope Bug	2021-06-12 15:24:19 +08:00
AnonymousUser	cf9f434ff8	Version 2.0.3 Fixed Match Scope Bug	2021-06-12 15:19:39 +08:00
AnonymousUser	37a907d6df	Version: 2.0.2 Fixed UI BUG	2021-06-11 18:27:14 +08:00
AnonymousUser	83e5da2f7e	Version: 2.0.2 Fixed UI BUG	2021-06-11 18:25:36 +08:00