Version: 2.5.11 Update

Version: 2.5.10 Update
2024-01-18 12:07:20 +08:00 · 2023-12-12 14:54:16 +08:00 · 2023-12-12 14:19:50 +08:00 · 2023-12-12 14:19:28 +08:00 · 2023-11-28 15:26:25 +08:00 · 2023-11-28 09:11:56 +08:00
54 changed files with 3485 additions and 999 deletions
--- a/.github/ISSUE_TEMPLATE/问题反馈.md
+++ b/.github/ISSUE_TEMPLATE/问题反馈.md
@@ -0,0 +1,28 @@
+---
+name: 问题反馈
+about: 尽可能详细的描述问题并反馈
+title: "[BUG] "
+labels: bug
+assignees: ''
+
+---
+
+## 使用环境
+
+```
+HaE版本：
+是否有自定义的HaE规则：
+BurpSuite版本：
+JDK版本：
+操作系统版本：
+```
+
+## 问题详情
+
+问题描述：
+
+出现的场景：
+
+## 解决建议
+
+无。
--- a/.gitignore
+++ b/.gitignore
@@ -0,0 +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
+.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,99 +1,75 @@
-# 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>

-Note: My english is not very good, Thanks!
+## 项目介绍

-Read Chinese simplified version ([README_zh](README_zh.md)).
+**HaE**是一个基于`BurpSuite Java插件API`开发的辅助型框架式插件，旨在实现对HTTP消息的高亮标记和信息提取。该插件通过自定义正则表达式匹配响应报文或请求报文，并对匹配成功的报文进行标记和提取。

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

-**HaE** is used to highlight HTTP requests and extract information from HTTP `response messages` or `request messages`.
+**注**: 要想灵活的使用`HaE`，你需要掌握正则表达式阅读、编写、修改能力；由于`Java`正则表达式的库并没有`Python`的优雅或方便，所以HaE要求使用者必须用`()`将所需提取的表达式内容包含；例如你要匹配一个**Shiro应用**的响应报文，正常匹配规则为`rememberMe=delete`，如果你要提取这段内容的话就需要变成`(rememberMe=delete)`。

-![-w1070](images/16000706401522.jpg)
+## 使用方法

-The plugin can custom regular expression to match HTTP response messages. You can decide for yourself whether the corresponding request that meets the custom regular expression match needs to be highlighted and information extracted.
+插件装载: `Extender - Extensions - Add - Select File - Next`

-**Note**: The use of HaE requires a basic regular expression foundation for testers. Since the Java regular expression library is not as elegant or convenient as Python, when using regular expressions, HaE requires users to use `()` to extract what they need The expression content contains; for example, if you want to match a response message of a Shiro application, the normal matching rule is `rememberMe=delete`, if you want to extract this content, you need to become `(rememberMe=delete)`.
+初次装载`HaE`会自动获取官方规则库`https://raw.githubusercontent.com/gh0stkey/HaE/gh-pages/Rules.yml`，配置文件（`Config.yml`）和规则文件（`Rules.yml`）会放在固定目录下：

-## Instructions
+1. Linux/Mac用户的配置文件目录：`~/.config/HaE/`
+2. Windows用户的配置文件目录：`%USERPROFILE%/.config/HaE/`

-Load: `Extender - Extensions - Add - Select File - Next`
+除此之外，您也可以选择将配置文件存放在`HaE Jar包`的同级目录下的`/.config/HaE/`中，**以便于离线携带**。

-The configuration file is initialized when HaE is loaded for the first time. The default configuration file has a built-in regular expression: `Email`. The initialized configuration file will be placed in the same directory as the BurpSuite Jar package.
+### 规则释义

-![-w330](images/16000708493657.jpg)
+HaE目前的规则一共有6个字段，分别是规则名称、规则正则、规则作用域、正则引擎、规则匹配颜色、规则敏感性。

-In addition to the initial configuration file, there is `init.hae`, which is used to store the configuration file path; `HaE` supports custom configuration file paths, and you can select a custom configuration file by clicking the `Select File` button.
+详细的含义如下所示：

-![-w477](images/16000710069404.jpg)
-
-HaE supports three actions:
-
-1. Reload: It can be used when you do not use the HaE UI interface to modify the rules in the configuration file, but directly modify the rules based on the configuration file;
-2. New: Add a new rule will automatically add a row of table data, click or double-click to modify the data to automatically save;
-3. Delete: When you click to select a rule, press this button to delete the rule.
-
-**Note**: `HaE's operations` are based on the form UI, and all operations will be automatically saved.
-
-## Plugin Advantages
-
-1. Multi-option custom adaptation requirements;
-2. Multi-color classification (colors of BurpSuite): `red, orange, yellow, green, cyan, blue, pink, magenta, gray`;
-3. Color upgrade algorithm: **Two regulars expression, the colors are both orange, if the request are matched these, it will be upgraded to red.**
-4. The configuration file format uses JSON format, the format is
-    ```
-    {name: {"loaded": isLoaded,"regex": regexText, "scope": request/response/any, "action": extract/highlight/any, "color": colorText}}
-    ```
-5. Built-in simple cache to reduce the stuttering phenomenon in the `multi-regular, big data scenario`.
-
-## Actual Use
-
-Use RGPerson to generate test data and put it in the root directory file of the website:
-
-![-w467](images/16000719723284.jpg)
-
-Visit the address, you can see the highlighted request in the `Proxy-HTTP History`, and you can see the response tab contains the `MarkINFO` tag, which extracts the matched information.
-
-![-w1047](images/16000720732854.jpg)
+| 字段      | 含义                                                                                                                                                                                                   |
+|-----------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| Name      | 规则名称，主要用于简短概括当前规则的作用。                                                                                                                                                               |
+| Regex     | 规则正则，主要用于填写正则表达式。在HaE中所需提取匹配的内容需要用`(`、`)`将正则表达式进行包裹。                                                                                                            |
+| Scope     | 规则作用域，主要用于表示当前规则作用于HTTP报文的哪个部分。                                                                                                                                               |
+| Engine    | 正则引擎，主要用于表示当前规则的正则表达式所使用的引擎。**DFA引擎**：对于文本串里的每一个字符只需扫描一次，速度快、特性少；**NFA引擎**：要翻来覆去标注字符、取消标注字符，速度慢，但是特性（如:分组、替换、分割）丰富。 |
+| Color     | 规则匹配颜色，主要用于表示当前规则匹配到对应HTTP报文时所需标记的高亮颜色。在HaE中具备颜色升级算法，当出现相同颜色时会自动向上升级一个颜色进行标记。                                                                                                                               |
+| Sensitive | 规则敏感性，主要用于表示当前规则对于大小写字母是否敏感，敏感（`True`）则严格按照大小写要求匹配，不敏感（`False`）则反之。                                                                                      |


-## Regular Expression Optimization
+## 优势特点

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

-There will be some false positives when regular expression matching mobile phone numbers (pure numbers), the mobile phone number processing can be solved:
+| 界面名称                  | 界面展示                                              |
+| ------------------------ | ---------------------------------------------------- |
+| 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%" /> |

-Original regular expression: 
+## 文末随笔

-```
-1[3-9]\d{9}
-```
+正义感是一个不可丢失的东西。

-False positive scenario: `12315188888888123`, it will match `15188888888`, but this paragraph is not a mobile phone number, so the modification rule is:
+如果你觉得HaE好用，可以打赏一下作者，给作者持续更新下去的动力！

-```
-[^0-9]+(1[3-9]\d{9})[^0-9]+
-```
+<div align=center>
+<img src="images/reward.jpeg" style="width: 30%" />
+</div>

-The mobile phone number required to be matched cannot be a number from 0-9.
+## 404StarLink 2.0 - Galaxy

+![404StarLink Logo](https://github.com/knownsec/404StarLink-Project/raw/master/logo.png)

-### Include Regular Expression List
-
-Chinese ID-Number(From: https://github.com/gh0stkey/HaE/issues/3): 
-
-```
-[^0-9]([1-9]\d{5}(18|19|([23]\d))\d{2}((0[1-9])|(10|11|12))(([0-2][1-9])|10|20|30|31)\d{3}[0-9Xx])|([1-9]\d{5}\d{2}((0[1-9])|(10|11|12))(([0-2][1-9])|10|20|30|31)\d{2}[0-9Xx])[^0-9]
-```
-
-Email Address: 
-
-```
-([\w-]+(?:\.[\w-]+)*@(?:[\w](?:[\w-]*[\w])?\.)+[\w](?:[\w-]*[\w])?)
-```
-
-Elasticsearch Unauthorized Access(From: https://github.com/gh0stkey/HaE/issues/7):
-
-```
-("cluster_uuid"\s*:\s*"[A-Za-z0-9_-]{22}")
-```
+`HaE` 是 404Team [星链计划2.0](https://github.com/knownsec/404StarLink2.0-Galaxy) 中的一环，如果对 `HaE` 有任何疑问又或是想要找小伙伴交流，可以参考星链计划的加群方式。

+- [https://github.com/knownsec/404StarLink2.0-Galaxy#community](https://github.com/knownsec/404StarLink2.0-Galaxy#community)
--- a/README_zh.md
+++ b/README_zh.md
@@ -1,108 +0,0 @@
-# HaE - Highlighter and Extractor
-
-## 介绍
-
-**HaE**是基于 `BurpSuite` 插件 `JavaAPI` 开发的请求高亮标记与信息提取的辅助型插件。
-
-![-w1070](images/16000706401522.jpg)
-
-该插件可以通过自定义正则的方式匹配**响应报文或请求报文**，可以自行决定符合该自定义正则匹配的相应请求是否需要高亮标记、信息提取。
-
-**注**: `HaE`的使用，对测试人员来说需要基本的正则表达式基础，由于`Java`正则表达式的库并没有`Python`的优雅或方便，在使用正则的，HaE要求使用者必须使用`()`将所需提取的表达式内容包含；例如你要匹配一个**Shiro应用**的响应报文，正常匹配规则为`rememberMe=delete`，如果你要提取这段内容的话就需要变成`(rememberMe=delete)`。
-
-## 使用方法
-
-插件装载: `Extender - Extensions - Add - Select File - Next`
-
-初次装载`HaE`会初始化配置文件，默认配置文件内置一个正则: `Email`，初始化的配置文件会放在与`BurpSuite Jar`包同级目录下。
-
-![-w330](images/16000708493657.jpg)
-
-除了初始化的配置文件外，还有`init.hae`，该文件用于存储配置文件路径；`HaE`支持自定义配置文件路径，你可以通过点击`Select File`按钮进行选择自定义配置文件。
-
-![-w477](images/16000710069404.jpg)
-
-HaE支持三个动作: 
-
-1. 重载规则（Reload）: 当你不使用HaE UI界面去修改配置文件内的规则时，而是直接基于配置文件进行修改规则时可使用；
-2. 新建规则（New）: 新建规则会自动添加一行表格数据，单击或双击进行修改数据即可自动保存；
-3. 删除规则（Delete）: 单击选中某条规则时，按下该按钮即可删除规则。
-
-**注**: HaE的操作都是基于表单UI的方式，操作即会自动保存。
-
-## 插件优点
-
-1. 多选项自定义控制适配需求；
-2. 多颜色高亮分类，将BurpSuite的所有高亮颜色集成: `red, orange, yellow, green, cyan, blue, pink, magenta, gray`；
-3. 颜色升级算法: 利用下标的方式进行优先级排序，当满足2个同颜色条件则以优先级顺序上升颜色。（例如: **两个正则，颜色为橘黄色，该请求两个正则都匹配到了，那么将升级为红色**）
-4. 简单的配置文件格式选用JSON格式，格式为
-    ```
-    {name: {"loaded": isLoaded,"regex": regexText, "scope": request/response/any, "action": extract/highlight/any, "color": colorText}}
-    ```
-5. 内置简单缓存，在“多正则、大数据”的场景下减少卡顿现象。
-
-## 实际使用
-
-使用 RGPerson 生成测试数据，放入网站根目录文件中: 
-
-![-w467](images/16000719723284.jpg)
-
-访问该地址，在`Proxy - HTTP History`中可以看见高亮请求，响应标签页中含有`MarkINFO`标签，其中将匹配到的信息提取了出来。
-
-![-w1047](images/16000720732854.jpg)
-
-
-## 正则优化
-
-有些正则在实战应用场景中并不理想
-
-在正则匹配手机号、身份证号码的时候（纯数字类）会存在一些误报（这里匹配身份证号码无法进行校验，误报率很高），但手机号处理这一块可以解决: 
-
-原正则: 
-
-```
-1[3-9]\d{9}
-```
-
-误报场景: `12315188888888123`，这时候会匹配到`15188888888`，而实际上这一段并不是手机号，所以修改正则为: 
-
-```
-[^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/gh0stkey/HaE/issues/3): 
-
-```
-[^0-9]([1-9]\d{5}(18|19|([23]\d))\d{2}((0[1-9])|(10|11|12))(([0-2][1-9])|10|20|30|31)\d{3}[0-9Xx])|([1-9]\d{5}\d{2}((0[1-9])|(10|11|12))(([0-2][1-9])|10|20|30|31)\d{2}[0-9Xx])[^0-9]
-```
-
-邮箱地址: 
-
-```
-([\w-]+(?:\.[\w-]+)*@(?:[\w](?:[\w-]*[\w])?\.)+[\w](?:[\w-]*[\w])?)
-```
-
-Elasticsearch未授权访问匹配(来自: https://github.com/gh0stkey/HaE/issues/7):
-
-```
-("cluster_uuid"\s*:\s*"[A-Za-z0-9_-]{22}")
-```
--- a/build.gradle
+++ b/build.gradle
@@ -1,25 +1,33 @@
-apply plugin: 'java'
-
-repositories {
-    mavenCentral()
-}
-
-dependencies {
-    compile 'net.portswigger.burp.extender:burp-extender-api:1.7.13'
-    compile 'net.sourceforge.jregex:jregex:1.2_01'
-    compile 'org.json:json:20200518'
-}
-
-sourceSets {
-    main {
-        java {
-            srcDir '.'
-        }
-    }
-}
-
-task fatJar(type: Jar) {
-    baseName = project.name + '-all'
-    from { configurations.compile.collect { it.isDirectory() ? it : zipTree(it) } }
-    with jar
-}
+plugins {
+    id 'java'
+}
+
+repositories {
+    mavenCentral()
+}
+
+compileJava {
+    options.encoding = "UTF-8"
+}
+
+sourceSets {
+    main {
+        java {
+            srcDir './src/main/java'
+        }
+    }
+}
+
+task fatJar(type: Jar) {
+    baseName = project.name + '-all'
+    from { configurations.compile.collect { it.isDirectory() ? it : zipTree(it) } }
+    with jar
+}
+
+dependencies {
+    compile 'net.portswigger.burp.extender:burp-extender-api:1.7.13'
+    compile 'org.jetbrains:annotations:16.0.2'
+    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'
+}
--- a/burp/BurpExtender.java
+++ b/burp/BurpExtender.java
@@ -1,426 +0,0 @@
-package burp;
-
-import java.awt.BorderLayout;
-import java.awt.Color;
-import java.awt.Component;
-import java.util.*;
-
-import org.json.*;
-
-import burp.action.DoAction;
-import burp.action.ExtractContent;
-import burp.action.MatchHTTP;
-import burp.color.GetColorKey;
-import burp.color.UpgradeColor;
-import burp.file.FileExists;
-import burp.file.ReadFile;
-import burp.file.RemoveContent;
-import burp.file.WriteFile;
-import burp.ui.FillTable;
-
-import javax.swing.JFrame;
-import javax.swing.JOptionPane;
-import javax.swing.DefaultCellEditor;
-import javax.swing.JScrollPane;
-import javax.swing.JTable;
-import javax.swing.JTextField;
-import javax.swing.table.DefaultTableModel;
-import javax.swing.JPanel;
-import javax.swing.JButton;
-import java.awt.event.ActionListener;
-import java.io.File;
-import java.awt.event.ActionEvent;
-import javax.swing.JCheckBox;
-import javax.swing.JComboBox;
-import javax.swing.JFileChooser;
-import javax.swing.border.EtchedBorder;
-import javax.swing.border.TitledBorder;
-import javax.swing.event.TableModelEvent;
-import javax.swing.event.TableModelListener;
-import javax.swing.SwingConstants;
-import javax.swing.SwingUtilities;
-import javax.swing.JLabel;
-
-import java.io.PrintWriter;
-import java.io.UnsupportedEncodingException;
-
-public class BurpExtender implements IBurpExtender, IHttpListener, IMessageEditorTabFactory, ITab {
-	
-	private JFrame frame;
-	private JPanel panel;
-	private JTable table;
-	private JTextField textField;
-	private IBurpExtenderCallbacks callbacks;
-	private static IExtensionHelpers helpers;
-	private static String configFilePath = "config.json";
-	private static String initFilePath = "init.hae";
-	private static IMessageEditorTab HaETab;
-	private static PrintWriter stdout;
-	
-	ReadFile rf = new ReadFile();
-	WriteFile wfc = new WriteFile();
-	FileExists fe = new FileExists();
-	RemoveContent rc = new RemoveContent();
-	GetColorKey gck = new GetColorKey();
-	UpgradeColor uc = new UpgradeColor();
-	ExtractContent ec = new ExtractContent();
-	MatchHTTP mh = new MatchHTTP();
-	FillTable ft = new FillTable();
-	DoAction da = new DoAction();
-	
-    @Override
-    public void registerExtenderCallbacks(final IBurpExtenderCallbacks callbacks)
-    {
-    	this.callbacks = callbacks;
-    this.helpers = callbacks.getHelpers();
-        // 设置插件名字和版本
-    	String version = "1.5";
-
-        callbacks.setExtensionName(String.format("HaE (%s) - Highlighter and Extractor", version));
-        
-        // 定义输出
-        stdout = new PrintWriter(callbacks.getStdout(), true);
-        stdout.println("@Author: EvilChen");
-        stdout.println("@Blog: cn.gh0st.cn");
-
-        // UI
-		SwingUtilities.invokeLater(new Runnable() {
-			@Override
-			public void run() {
-				// 判断"config.json"文件是否具备内容，如若不具备则进行初始化
-				if (configFilePath.equals("config.json")) {
-					if (rf.readFileContent(configFilePath).equals("")) {
-						wfc.writeFileContent(configFilePath, Config.initConfigContent);
-						wfc.writeFileContent(initFilePath, configFilePath);
-					}
-				}
-				// 判断配置文件是否存在
-				if (fe.fileExists(configFilePath)) {
-					configFilePath = rf.readFileContent(initFilePath);
-				} else {
-					JOptionPane.showMessageDialog(null, "Config File Not Found!", "Error", JOptionPane.ERROR_MESSAGE);
-				}
-				
-				initialize();
-				ft.fillTable(configFilePath, table);
-				
-			}
-		});
-		callbacks.registerHttpListener(BurpExtender.this);
-		callbacks.registerMessageEditorTabFactory(BurpExtender.this);
-    }
-    
-	private void initialize() {
-		frame = new JFrame();
-		frame.setBounds(100, 100, 526, 403);
-		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
-		
-		panel = new JPanel();
-		frame.getContentPane().add(panel, BorderLayout.CENTER);
-		panel.setLayout(new BorderLayout(0, 0));
-		
-		JPanel panel_3 = new JPanel();
-		panel.add(panel_3, BorderLayout.NORTH);
-		
-		JLabel lblNewLabel_1 = new JLabel("Config File:");
-		panel_3.add(lblNewLabel_1);
-		
-		textField = new JTextField();
-		textField.setEditable(false);
-		panel_3.add(textField);
-		textField.setColumns(20);
-		
-		textField.setText(configFilePath);
-		
-		JButton btnNewButton = new JButton("Select File ...");
-		btnNewButton.addActionListener(new ActionListener() {
-			public void actionPerformed(ActionEvent e) {
-			    JFileChooser jfc = new JFileChooser();
-			    jfc.setFileSelectionMode(JFileChooser.FILES_ONLY);
-			    jfc.showDialog(new JLabel(), "Choose");
-			    File file = jfc.getSelectedFile();
-			    textField.setText(file.getAbsolutePath());
-			    configFilePath = textField.getText();
-			    wfc.writeFileContent(initFilePath, configFilePath);
-			    ft.fillTable(configFilePath, table);
-			}
-		});
-		panel_3.add(btnNewButton);
-		
-		JPanel panel_2 = new JPanel();
-		panel.add(panel_2, BorderLayout.CENTER);
-		panel_2.setLayout(new BorderLayout(0, 0));
-		
-		JPanel panel_1 = new JPanel();
-		panel_2.add(panel_1, BorderLayout.NORTH);
-		panel_1.setBorder(new TitledBorder(new EtchedBorder(EtchedBorder.LOWERED, null, null), "Actions", TitledBorder.LEADING, TitledBorder.TOP, null, new Color(0, 0, 0)));
-		
-		JButton btnReloadRule = new JButton("Reload");
-		btnReloadRule.addActionListener(new ActionListener() {
-			public void actionPerformed(ActionEvent e) {
-				ft.fillTable(configFilePath, table);
-			}
-		});
-		panel_1.add(btnReloadRule);
-		
-		JButton btnNewRule = new JButton("New");
-		btnNewRule.addActionListener(new ActionListener() {
-			public void actionPerformed(ActionEvent arg0) {
-				DefaultTableModel dtm = (DefaultTableModel) table.getModel();
-				Vector rules = new Vector();
-				rules.add(true);
-				rules.add("New Rule");
-				rules.add("New Regex");
-				rules.add("red");
-				rules.add("response");
-				rules.add("any");
-				dtm.addRow(rules);
-			}
-		});
-		panel_1.add(btnNewRule);
-		
-		JButton btnDeleteRule = new JButton("Delete");
-		btnDeleteRule.addActionListener(new ActionListener() {
-			public void actionPerformed(ActionEvent e) {
-				int selectRows = table.getSelectedRows().length;
-				DefaultTableModel dtm = (DefaultTableModel) table.getModel();
-				if (selectRows == 1) {
-					int selectedRowIndex = table.getSelectedRow();
-					// 在配置文件中删除数据
-					String cellValue = (String) dtm.getValueAt(selectedRowIndex, 1);
-					// System.out.println(cellValue);
-					rc.removeFileContent(cellValue, configFilePath);
-					// 在表格中删除数据
-					dtm.removeRow(selectedRowIndex);
-					
-				}
-			}
-		});
-		panel_1.add(btnDeleteRule);
-		
-		JScrollPane scrollPane = new JScrollPane();
-		panel_2.add(scrollPane, BorderLayout.CENTER);
-		
-		table = new JTable();
-		table.setModel(new DefaultTableModel(
-			new Object[][] {
-			},
-			new String[] {
-				"Loaded", "Name", "Regex", "Color", "Scope", "Action"
-			}
-		));
-		scrollPane.setViewportView(table);
-		
-		table.getColumnModel().getColumn(2).setPreferredWidth(172);
-		table.getColumnModel().getColumn(3).setCellEditor(new DefaultCellEditor(new JComboBox(Config.colorArray)));
-		table.getColumnModel().getColumn(0).setCellEditor(new DefaultCellEditor(new JCheckBox()));
-		table.getColumnModel().getColumn(4).setCellEditor(new DefaultCellEditor(new JComboBox(Config.scopeArray)));
-		table.getColumnModel().getColumn(5).setCellEditor(new DefaultCellEditor(new JComboBox(Config.actionArray)));
-		
-		JLabel lblNewLabel = new JLabel("@EvilChen Love YuChen.");
-		lblNewLabel.setHorizontalAlignment(SwingConstants.CENTER);
-		panel.add(lblNewLabel, BorderLayout.SOUTH);
-		
-		table.getModel().addTableModelListener(
-			new TableModelListener() {
-			    @Override
-			    public void tableChanged(TableModelEvent e) {
-			    	if (e.getType() == TableModelEvent.INSERT || e.getType() == TableModelEvent.UPDATE) {
-			    		DefaultTableModel dtm = (DefaultTableModel) table.getModel();
-			    		int rows = dtm.getRowCount();
-			    		JSONObject jsonObj = new JSONObject();
-			    		
-			    		for (int i = 0; i < rows; i++) {
-			    			JSONObject jsonObj1 = new JSONObject();
-			    			jsonObj1.put("loaded", (boolean) dtm.getValueAt(i, 0));
-			    			jsonObj1.put("regex", (String) dtm.getValueAt(i, 2));
-			    			jsonObj1.put("color", (String) dtm.getValueAt(i, 3));
-			    			jsonObj1.put("scope", (String) dtm.getValueAt(i, 4));
-			    			jsonObj1.put("action", (String) dtm.getValueAt(i, 5));
-			    			// 添加数据
-			    			jsonObj.put((String) dtm.getValueAt(i, 1), jsonObj1);
-						}
-			    		
-			    		wfc.writeFileContent(configFilePath, jsonObj.toString());
-			    		
-			    	}
-						
-			    }
-			}
-		);
-		
-		callbacks.customizeUiComponent(panel);
-		callbacks.customizeUiComponent(panel_1);
-		callbacks.customizeUiComponent(panel_2);
-		callbacks.customizeUiComponent(panel_3);
-		callbacks.customizeUiComponent(scrollPane);
-		callbacks.addSuiteTab(BurpExtender.this);
-	}
-
-	@Override
-	public IMessageEditorTab createNewInstance(IMessageEditorController controller, boolean editable) {
-		HaETab = new MarkInfoTab(controller, editable);
-		return HaETab;
-	}
-    
-	@Override
-	public String getTabCaption() {
-		return "HaE";
-	}
-
-	@Override
-	public Component getUiComponent() {
-		return panel;
-	}
-	
-	/*
-	 * 使用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) {
-			JSONObject jsonObj = new JSONObject();
-			byte[] content = messageInfo.getRequest();
-            // 流量清洗
-            String urlString = helpers.analyzeRequest(messageInfo.getHttpService(), content).getUrl().toString();
-            urlString = urlString.indexOf("?") > 0 ? urlString.substring(0, urlString.indexOf("?")) : urlString;
-            // 正则判断
-            if (mh.matchSuffix(urlString)) {
-				return;
-			}
-	        if (messageIsRequest) {
-	            try {
-					String c = new String(content, "UTF-8").intern();
-				} catch (UnsupportedEncodingException e) {
-					e.printStackTrace();
-				}
-	            jsonObj = ec.matchRegex(content, "request", "highlight", configFilePath); 
-	        } else {
-	            content = messageInfo.getResponse();
-	            // 流量清洗
-	            List<String> mimeList = helpers.analyzeResponse(content).getHeaders();
-	            // 正则判断
-	            if (mh.matchMIME(mimeList)) {
-					return;
-				}
-	            try {
-					String c = new String(content, "UTF-8").intern();
-				} catch (UnsupportedEncodingException e) {
-					e.printStackTrace();
-				}
-	            jsonObj = ec.matchRegex(content, "response", "highlight", configFilePath); 
-	        }
-	        
-            List<String> colorList = da.highlightList(jsonObj);
-            if (colorList.size() != 0) {
-                String color = uc.getEndColor(gck.getColorKeys(colorList, Config.colorArray), Config.colorArray);;
-                messageInfo.setHighlight(color);
-            }
-		}
-
-    }
-	
-	class MarkInfoTab implements IMessageEditorTab {
-		private ITextEditor markInfoText;
-		private byte[] currentMessage;
-		private final IMessageEditorController controller;
-		private byte[] extractRequestContent;
-		private byte[] extractResponseContent;
-		
-		public MarkInfoTab(IMessageEditorController controller, boolean editable) {
-			this.controller = controller;
-			markInfoText = callbacks.createTextEditor();
-			markInfoText.setEditable(editable);
-		}
-	
-		@Override
-		public String getTabCaption() {
-			return "MarkInfo";
-		}
-	
-		@Override
-		public Component getUiComponent() {
-			return markInfoText.getComponent();
-		}
-	
-		@Override
-		public boolean isEnabled(byte[] content, boolean 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;
-			}
-			
-            
-			if (isRequest) {
-				JSONObject jsonObj = ec.matchRegex(content, "request", "extract", configFilePath);
-				if (jsonObj.length() != 0) {
-					String result = da.extractString(jsonObj);
-					extractRequestContent = result.getBytes();
-					return true;
-				}
-			} else {
-				// 流量清洗
-	            List<String> mimeList = helpers.analyzeResponse(controller.getResponse()).getHeaders();
-	            // 正则判断
-	            if (mh.matchMIME(mimeList)) {
-					return false;
-				}
-				JSONObject jsonObj = ec.matchRegex(content, "response", "extract", configFilePath);
-				if (jsonObj.length() != 0) {
-					String result = da.extractString(jsonObj);
-					extractResponseContent = result.getBytes();
-					return true;
-				}
-			}
-			return false;
-		}
-	
-		@Override
-		public byte[] getMessage() {
-			return currentMessage;
-		}
-	
-		@Override
-		public boolean isModified() {
-			return markInfoText.isTextModified();
-		}
-	
-		@Override
-		public byte[] getSelectedData() {
-			return markInfoText.getSelectedText();
-		}
-		
-		/*
-		 * 使用setMessage用来做Extractor
-		 */
-		@Override
-		public void setMessage(byte[] content, boolean isRequest) {
-			try {
-				String c = new String(content, "UTF-8").intern();
-			} catch (UnsupportedEncodingException e) {
-				e.printStackTrace();
-			}
-			if (content.length > 0) {
-				if (isRequest) {
-					markInfoText.setText(extractRequestContent);
-				} else {
-					markInfoText.setText(extractResponseContent);
-				}
-			}
-			currentMessage = content;
-		}
-	}
-	
-	
-	
-	public static void main(String[] args) {
-	}
-}
--- a/burp/Config.java
+++ b/burp/Config.java
@@ -1,11 +0,0 @@
-package burp;
-
-public class Config {
-	public static String initConfigContent = "{\"Email\":{\"loaded\":true,\"scope\":\"response\",\"regex\":\"([\\\\w-]+(?:\\\\.[\\\\w-]+)*@(?:[\\\\w](?:[\\\\w-]*[\\\\w])?\\\\.)+[\\\\w](?:[\\\\w-]*[\\\\w])?)\",\"action\":\"any\",\"color\":\"yellow\"}}";
-	public static String[] colorArray = new String[] {"red", "orange", "yellow", "green", "cyan", "blue", "pink", "magenta", "gray"};
-	public static String[] scopeArray = new String[] {"any", "response", "request"};
-	public static String[] actionArray = new String[] {"any", "extract", "highight"};
-	public static String excludeSuffix = "7z|aif|aifc|aiff|au|bmp|cmx|cod|css|doc|docx|gif|gz|ico|ief|jfif|jpe|jpeg|jpg|m3u|mid|mp2|mp3|mpa|mpe|mpeg|mpg|mpp|mpv2|otf|pbm|pdf|pgm|png|pnm|ppm|ra|ram|rar|ras|rgb|rmi|snd|svg|tar|tif|tiff|ttf|wav|woff|woff2|xbm|xpm|xwd|zip";
-	public static String[] excludeMIME = new String[] {"application/msword", "application/vnd.ms-project", "application/x-gzip", "application/x-tar", "application/zip", "audio/basic", "audio/mid", "audio/mpeg", "audio/x-aiff", "audio/x-mpegurl", "audio/x-pn-realaudio", "audio/x-wav", "image/bmp", "image/cis-cod", "image/gif", "image/ief", "image/jpeg", "image/png", "image/pipeg", "image/svg+xml", "image/tiff", "image/x-cmu-raster", "image/x-cmx", "image/x-icon", "image/x-portable-anymap", "image/x-portable-bitmap", "image/x-portable-graymap", "image/x-portable-pixmap", "image/x-rgb", "image/x-xbitmap", "image/x-xpixmap", "image/x-xwindowdump", "text/css", "video/mpeg", "video/mpeg", "application/font-woff"};
-	public static String outputTplString = "[%s]\n%s\n\n";
-}
--- a/burp/action/DoAction.java
+++ b/burp/action/DoAction.java
@@ -1,34 +0,0 @@
-package burp.action;
-
-import java.util.ArrayList;
-import java.util.Iterator;
-import java.util.List;
-
-import org.json.JSONObject;
-
-import burp.Config;
-
-public class DoAction {
-	public String extractString(JSONObject jsonObj) {
-		String result = "";
-		Iterator<String> k = jsonObj.keys();
-		while (k.hasNext()) {
-			String name = k.next();
-			JSONObject jsonObj1 = new JSONObject(jsonObj.get(name).toString());
-			String tmpStr = String.format(Config.outputTplString, name, jsonObj1.getString("data")).intern();
-			result += tmpStr;
-		}
-		return result;
-	}
-	
-	public List<String> highlightList(JSONObject jsonObj) {
-		List<String> colorList = new ArrayList<String>();
-        Iterator<String> k = jsonObj.keys();
-        while (k.hasNext()) {
-            String name = k.next();
-            JSONObject jsonObj2 = new JSONObject(jsonObj.get(name).toString());
-            colorList.add(jsonObj2.getString("color"));
-        }
-		return colorList;
-	}
-}
--- a/burp/action/ExtractContent.java
+++ b/burp/action/ExtractContent.java
@@ -1,67 +0,0 @@
-package burp.action;
-
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.List;
-
-import org.json.JSONObject;
-
-import burp.file.ReadFile;
-import jregex.Matcher;
-import jregex.Pattern;
-
-public class ExtractContent {
-	ReadFile rf = new ReadFile();
-	public JSONObject matchRegex(byte[] content, String scopeString, String actionString, String configFilePath) {
-		JSONObject tabContent = new JSONObject();
-		// 正则匹配提取内容
-		try {
-			String jsonStr = rf.readFileContent(configFilePath);
-		    JSONObject jsonObj = new JSONObject(jsonStr);
-		    Iterator<String> k = jsonObj.keys();
-		    // 遍历json数组
-		    while (k.hasNext()) {
-		    	String contentString = new String(content, "UTF-8").intern();
-		    	String name = k.next(); 
-		    	JSONObject jsonObj1 = new JSONObject(jsonObj.get(name).toString());
-		    	JSONObject jsonData = new JSONObject();
-				String regex = jsonObj1.getString("regex");
-				boolean isLoaded = jsonObj1.getBoolean("loaded");
-				String scope = jsonObj1.getString("scope");
-				String action = jsonObj1.getString("action");
-				String color = jsonObj1.getString("color");
-				List<String> result = new ArrayList<String>();
-				
-				if(isLoaded && (scope.equals(scopeString) || scope.equals("any")) && (action.equals(actionString) || action.equals("any"))) {
-					Pattern pattern = new Pattern(regex);
-					Matcher matcher = pattern.matcher(contentString);
-					while (matcher.find()) {
-						// 添加匹配数据至list
-						// 强制用户使用()包裹正则
-						result.add(matcher.group(1));
-					}
-					
-					// 去除重复内容
-					HashSet tmpList = new HashSet(result);
-					result.clear();
-					result.addAll(tmpList);
-					
-					if (!result.isEmpty()) {
-						jsonData.put("color", color);
-						jsonData.put("data", String.join("\n", result));
-						jsonData.put("loaded", isLoaded);
-						// 初始化格式
-						tabContent.put(name, jsonData);
-					}
-				}
-
-		    }
-		    
-		    
-		} catch (Exception e) {}
-		
-		return tabContent;
-	}
-}
--- a/burp/action/MatchHTTP.java
+++ b/burp/action/MatchHTTP.java
@@ -1,36 +0,0 @@
-package burp.action;
-
-import java.util.Arrays;
-import java.util.List;
-
-import burp.Config;
-import jregex.Matcher;
-import jregex.Pattern;
-import jregex.REFlags;
-
-public class MatchHTTP {
-	// 匹配后缀
-	public boolean matchSuffix(String str) {
-        Pattern pattern = new Pattern(String.format("[\\w]+[\\.](%s)", Config.excludeSuffix), REFlags.IGNORE_CASE);
-        Matcher matcher = pattern.matcher(str);
-        if(matcher.find()){
-            return true;
-        }else{
-            return false;
-        }
-    }
-	
-	// 匹配MIME
-	public boolean matchMIME(List<String> mimeList) {
-		for (String headerString : mimeList) {
-			if (headerString.toLowerCase().startsWith("content-type")) {
-				for (String mime : Arrays.asList(Config.excludeMIME)) {
-					if (headerString.contains(mime)) {
-						return true;
-					}
-				}
-			}
-		}
-		return false;
-	}
-}
--- a/burp/color/GetColorKey.java
+++ b/burp/color/GetColorKey.java
@@ -1,23 +0,0 @@
-package burp.color;
-
-import java.util.ArrayList;
-import java.util.List;
-
-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/burp/color/UpgradeColor.java
+++ b/burp/color/UpgradeColor.java
@@ -1,53 +0,0 @@
-package burp.color;
-
-import java.util.ArrayList;
-import java.util.Comparator;
-import java.util.HashSet;
-import java.util.List;
-
-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/burp/file/FileExists.java
+++ b/burp/file/FileExists.java
@@ -1,18 +0,0 @@
-package burp.file;
-
-import java.io.File;
-
-public class FileExists {
-	
-	/*
-	 * 判断文件是否存在
-	 */
-	public Boolean fileExists(String fileName) {
-		 File file = new File(fileName);
-		 if(file.exists()){
-			 return true;
-		 }
-		 return false;
-	}
-	
-}
--- a/burp/file/ReadFile.java
+++ b/burp/file/ReadFile.java
@@ -1,36 +0,0 @@
-package burp.file;
-
-import java.io.BufferedReader;
-import java.io.File;
-import java.io.FileReader;
-import java.io.IOException;
-
-public class ReadFile {
-	/*
-	 * 获取文件内容
-	 */
-	public String readFileContent(String fileName) {
-	    File file = new File(fileName);
-	    BufferedReader reader = null;
-	    StringBuffer sbf = new StringBuffer();
-	    try {
-	        reader = new BufferedReader(new FileReader(file));
-	        String tempStr;
-	        while ((tempStr = reader.readLine()) != null) {
-	            sbf.append(tempStr);
-	        }
-	        reader.close();
-	        return sbf.toString();
-	    } catch (IOException e) {
-	    } finally {
-	        if (reader != null) {
-	            try {
-	                reader.close();
-	            } catch (IOException err) {
-	                err.printStackTrace();
-	            }
-	        }
-	    }
-	    return sbf.toString();
-	}
-}
--- a/burp/file/RemoveContent.java
+++ b/burp/file/RemoveContent.java
@@ -1,22 +0,0 @@
-package burp.file;
-
-import javax.swing.JOptionPane;
-
-import org.json.JSONObject;
-
-public class RemoveContent {
-	WriteFile w = new WriteFile();
-	ReadFile r = new ReadFile();
-	/*
-	 * 删除某文件内容
-	 */
-	public void removeFileContent(String key, String configFilePath) {
-		String jsonStr = r.readFileContent(configFilePath);
-		JSONObject jsonObj = new JSONObject(jsonStr);
-		jsonObj.remove(key);
-		
-		if (w.writeFileContent(configFilePath, jsonObj.toString())) {
-			JOptionPane.showMessageDialog(null, "Delete Successfully!", "Info", JOptionPane.INFORMATION_MESSAGE);
-		}
-	}
-}
--- a/burp/file/WriteFile.java
+++ b/burp/file/WriteFile.java
@@ -1,21 +0,0 @@
-package burp.file;
-
-import java.io.BufferedWriter;
-import java.io.FileWriter;
-import java.io.IOException;
-
-public class WriteFile {
-	/*
-	 * 写入文件内容
-	 */
-	public boolean writeFileContent(String fileName, String fileContent) {
-		try {
-			BufferedWriter out = new BufferedWriter(new FileWriter(fileName));
-			out.write(fileContent);
-			out.close();
-			return true;
-		} catch (IOException e) {
-			return false;
-		}
-	}
-}
--- a/burp/ui/FillTable.java
+++ b/burp/ui/FillTable.java
@@ -1,44 +0,0 @@
-package burp.ui;
-
-import java.util.Iterator;
-import java.util.Vector;
-
-import javax.swing.JTable;
-import javax.swing.table.DefaultTableModel;
-
-import org.json.JSONObject;
-
-import burp.file.ReadFile;
-
-public class FillTable {
-	ReadFile rf = new ReadFile();
-	/*
-	 * 初始化表格内容
-	 */
-	public void fillTable(String configFilePath, JTable table) {
-		DefaultTableModel dtm=(DefaultTableModel) table.getModel();
-		dtm.setRowCount(0);
-        String jsonStr = rf.readFileContent(configFilePath);
-        JSONObject jsonObj = new JSONObject(jsonStr);
-        Iterator<String> k = jsonObj.keys();
-        // 遍历json数组
-        while (k.hasNext()) {
-        	String name = k.next(); 
-        	JSONObject jsonObj1 = new JSONObject(jsonObj.get(name).toString());
-			boolean loaded = jsonObj1.getBoolean("loaded");
-			String regex = jsonObj1.getString("regex");
-			String color = jsonObj1.getString("color");
-			String scope = jsonObj1.getString("scope");
-			String action = jsonObj1.getString("action");
-			// 填充数据
-			Vector rules = new Vector();
-			rules.add(loaded);
-			rules.add(name);
-			rules.add(regex);
-			rules.add(color);
-			rules.add(scope);
-			rules.add(action);
-			dtm.addRow(rules);
-		}
-	}
-}
--- a/images/16000706401522.jpg
+++ b/images/16000706401522.jpg
--- a/images/16000708493657.jpg
+++ b/images/16000708493657.jpg
--- a/images/16000710069404.jpg
+++ b/images/16000710069404.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/reward.jpeg
+++ b/images/reward.jpeg
--- a/images/16000719723284.jpg
+++ b/images/16000719723284.jpg
--- a/images/rules.png
+++ b/images/rules.png
--- a/settings.gradle
+++ b/settings.gradle
@@ -1 +1,2 @@
-rootProject.name = 'HaE'
+rootProject.name = 'HaE'
+
--- a/src/main/java/burp/BurpExtender.java
+++ b/src/main/java/burp/BurpExtender.java
@@ -0,0 +1,245 @@
+package burp;
+
+import burp.config.ConfigLoader;
+import burp.core.processor.ColorProcessor;
+import burp.core.processor.MessageProcessor;
+import burp.core.utils.StringHelper;
+import burp.ui.MainUI;
+import burp.ui.board.DatatablePanel;
+import burp.ui.board.MessagePanel;
+import java.util.*;
+import javax.swing.*;
+import java.awt.*;
+import java.io.PrintWriter;
+import java.util.List;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+
+/**
+ * @author EvilChen & 0chencc
+ */
+
+public class BurpExtender implements IBurpExtender, IHttpListener, IMessageEditorTabFactory, ITab {
+    private MainUI main;
+    public static PrintWriter stdout;
+    public static IBurpExtenderCallbacks callbacks;
+    public static IExtensionHelpers helpers;
+    ColorProcessor colorProcessor = new ColorProcessor();
+    MessageProcessor messageProcessor = new MessageProcessor();
+    private MessagePanel messagePanel;
+
+    @Override
+    public void registerExtenderCallbacks(final IBurpExtenderCallbacks callbacks)
+    {
+        BurpExtender.callbacks = callbacks;
+        BurpExtender.helpers = callbacks.getHelpers();
+
+        new ConfigLoader();
+
+        String version = "2.5.11";
+        callbacks.setExtensionName(String.format("HaE (%s) - Highlighter and Extractor", version));
+
+        // 定义输出
+        stdout = new PrintWriter(callbacks.getStdout(), true);
+        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
+            public void run() {
+                initialize();
+            }
+        });
+
+        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";
+    }
+
+    @Override
+    public Component getUiComponent() {
+        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) {
+            if (!messageIsRequest) {
+                IHttpService iHttpService = messageInfo.getHttpService();
+                String host = iHttpService.getHost();
+
+                List<Map<String, String>> result = null;
+
+                String originalColor = messageInfo.getHighlight();
+                String originalComment = messageInfo.getComment();
+
+                try {
+                    result = messageProcessor.processMessage(helpers, messageInfo, host, true);
+
+                    if (result != null && !result.isEmpty() && result.size() > 0) {
+                        List<String> colorList = new ArrayList<>();
+
+                        if (originalColor != null) {
+                            colorList.add(originalColor);
+                        }
+
+                        colorList.add(result.get(0).get("color"));
+                        String resColor = colorProcessor.retrieveFinalColor(colorProcessor.retrieveColorIndices(colorList));
+                        messageInfo.setHighlight(resColor);
+
+                        String addComment = String.join(", ", result.get(1).get("comment"));
+                        String allComment = !Objects.equals(originalComment, "") ? String.format("%s, %s", originalComment, addComment) : addComment;
+                        String resComment = StringHelper.mergeComment(allComment);
+                        messageInfo.setComment(resComment);
+
+                        messagePanel.add(messageInfo, resComment, resColor);
+                    }
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+            }
+
+        }
+    }
+
+    class MarkInfoTab implements IMessageEditorTab {
+        private final JTabbedPane jTabbedPane = new JTabbedPane();
+        private DatatablePanel dataPanel;
+        private JTable dataTable;
+        private final IMessageEditorController controller;
+        private Map<String, String> extractRequestMap;
+        private Map<String, String> extractResponseMap;
+        private ArrayList<String> titleList = new ArrayList<>();
+        private byte[] message;
+
+        public MarkInfoTab(IMessageEditorController controller, boolean editable) {
+            this.controller = controller;
+        }
+
+        @Override
+        public String getTabCaption() {
+            return "MarkInfo";
+        }
+
+        @Override
+        public Component getUiComponent() {
+            jTabbedPane.addChangeListener(new ChangeListener() {
+                @Override
+                public void stateChanged(ChangeEvent arg0) {
+                    dataTable = ((DatatablePanel)jTabbedPane.getSelectedComponent()).getTable();
+                }
+            });
+            return jTabbedPane;
+        }
+
+        @Override
+        public boolean isEnabled(byte[] content, boolean isRequest) {
+            this.message = content;
+            List<Map<String, String>> result = null;
+            if (content.length != 0 && !helpers.bytesToString(content).equals("Loading...")) {
+                try {
+                    if (isRequest) {
+                        result = messageProcessor.processRequestMessage(helpers, content, "", false);
+                    } else {
+                        result = messageProcessor.processResponseMessage(helpers, content, "", false);
+                    }
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+
+                if (result != null && !result.isEmpty()) {
+                    Map<String, String> dataMap = result.get(0);
+                    if (isRequest) {
+                        extractRequestMap = dataMap;
+                    } else {
+                        extractResponseMap = dataMap;
+                    }
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        @Override
+        public byte[] getMessage() {
+            return message;
+        }
+
+        @Override
+        public boolean isModified() {
+            return false;
+        }
+
+        /**
+         * 快捷键复制功能
+         */
+        @Override
+        public byte[] getSelectedData() {
+            return helpers.stringToBytes(dataPanel.getSelectedData(dataTable));
+        }
+
+        /**
+         * 使用setMessage用来做Extractor
+         */
+        @Override
+        public void setMessage(byte[] content, boolean isRequest) {
+            if (content.length > 0) {
+                if (isRequest) {
+                    makeTable(extractRequestMap);
+                } else {
+                    makeTable(extractResponseMap);
+                }
+            }
+        }
+
+        /**
+         * 创建MarkInfo表单
+         */
+        public void makeTable(Map<String, String> dataMap) {
+            ArrayList<String> lTitleList = new ArrayList<>();
+
+            dataMap.keySet().forEach(i->{
+                String[] extractData = dataMap.get(i).split("\n");
+                lTitleList.add(i);
+                dataPanel = new DatatablePanel(i, Arrays.asList(extractData));
+                jTabbedPane.addTab(i, dataPanel);
+            });
+
+            /*
+             * 使用removeAll会导致MarkInfo UI出现空白的情况，为了改善用户侧体验，采用remove的方式进行删除；
+             * 采用全局ArrayList的方式遍历删除Tab，以此应对BurpSuite缓存机制导致的MarkInfo UI错误展示。
+             */
+            titleList.forEach(t->{
+                int indexOfTab = jTabbedPane.indexOfTab(t);
+                if (indexOfTab != -1) {
+                    jTabbedPane.removeTabAt(indexOfTab);
+                }
+            });
+
+            titleList = lTitleList;
+        }
+    }
+
+    @Override
+    public IMessageEditorTab createNewInstance(IMessageEditorController controller, boolean editable) {
+        return new MarkInfoTab(controller, editable);
+    }
+}
--- a/src/main/java/burp/config/ConfigEntry.java
+++ b/src/main/java/burp/config/ConfigEntry.java
@@ -0,0 +1,43 @@
+package burp.config;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+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 ConcurrentHashMap<String, Map<String, List<String>>> globalDataMap = new ConcurrentHashMap<>();
+}
--- a/src/main/java/burp/config/ConfigLoader.java
+++ b/src/main/java/burp/config/ConfigLoader.java
@@ -0,0 +1,153 @@
+package burp.config;
+
+import burp.BurpExtender;
+import burp.rule.utils.RuleTool;
+import burp.rule.utils.YamlTool;
+import java.io.*;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.ArrayList;
+import org.yaml.snakeyaml.Yaml;
+
+/**
+ * @author EvilChen
+ */
+
+public class ConfigLoader {
+    private static final Yaml yaml = YamlTool.newStandardYaml();
+    private static final String HaEConfigPath = determineConfigPath();
+    private static final String RulesFilePath = String.format("%s/%s", HaEConfigPath, "Rules.yml");
+    private static final String ConfigFilePath =  String.format("%s/%s", HaEConfigPath, "Config.yml");
+
+    public ConfigLoader() {
+        // 构造函数，初始化配置
+        File HaEConfigPathFile = new File(HaEConfigPath);
+        if (!(HaEConfigPathFile.exists() && HaEConfigPathFile.isDirectory())) {
+            HaEConfigPathFile.mkdirs();
+        }
+
+        File configFilePath = new File(ConfigFilePath);
+        if (!(configFilePath.exists() && configFilePath.isFile())) {
+            initConfig();
+        }
+
+        File rulesFilePath = new File(RulesFilePath);
+        if (!(rulesFilePath.exists() && rulesFilePath.isFile())) {
+            initRules();
+        }
+
+        ConfigEntry.globalRules = getRules();
+    }
+
+    private static String determineConfigPath() {
+        // 优先级1：用户根目录
+        String userConfigPath = String.format("%s/.config/HaE", System.getProperty("user.home"));
+        if (isValidConfigPath(userConfigPath)) {
+            return userConfigPath;
+        }
+
+        // 优先级2：Jar包所在目录
+        String jarPath = BurpExtender.callbacks.getExtensionFilename();
+        String jarDirectory = new File(jarPath).getParent();
+        String jarConfigPath = String.format("%s/.config/HaE", jarDirectory);
+        if (isValidConfigPath(jarConfigPath)) {
+            return jarConfigPath;
+        }
+        
+        return userConfigPath;
+    }
+
+    private static boolean isValidConfigPath(String configPath) {
+        File configPathFile = new File(configPath);
+        return configPathFile.exists() && configPathFile.isDirectory();
+    }
+
+    public static void initConfig() {
+        Map<String, Object> r = new LinkedHashMap<>();
+        r.put("excludeSuffix", getExcludeSuffix());
+        try {
+            Writer ws = new OutputStreamWriter(Files.newOutputStream(Paths.get(ConfigFilePath)), StandardCharsets.UTF_8);
+            yaml.dump(r, ws);
+            ws.close();
+        } catch (Exception ex) {
+            ex.printStackTrace();
+        }
+    }
+
+    public static void initRules() {
+        RuleTool rt = new RuleTool(RulesFilePath);
+        rt.getRulesFromSite();
+    }
+
+    public static String getRulesFilePath() {
+        return RulesFilePath;
+    }
+
+    public static String getExcludeSuffix(){
+        String excludeSuffix = "";
+        File yamlSetting = new File(ConfigFilePath);
+        
+        if (yamlSetting.exists() && yamlSetting.isFile()) {
+            try {
+                InputStream inorder = Files.newInputStream(Paths.get(ConfigFilePath));
+                Map<String,Object> r = yaml.load(inorder);
+                excludeSuffix = r.get("excludeSuffix").toString();
+            } catch (Exception e) {
+                // e.printStackTrace();
+                excludeSuffix = ConfigEntry.excludeSuffix;
+            }
+        } else {
+            excludeSuffix = ConfigEntry.excludeSuffix;
+        }
+        
+        return excludeSuffix;
+    }
+
+    // 获取规则配置
+    public static Map<String, Object[][]> getRules() {
+        Map<String, Object> rulesMap = YamlTool.loadYaml(getRulesFilePath());
+        Map<String, Object[][]> resRule = new HashMap<>();
+        String[] fieldKeys = {"loaded", "name", "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 static void setExcludeSuffix(String excludeSuffix){
+        Map<String,Object> r = new LinkedHashMap<>();
+        r.put("excludeSuffix", excludeSuffix);
+        try{
+            Writer ws = new OutputStreamWriter(Files.newOutputStream(Paths.get(ConfigFilePath)), StandardCharsets.UTF_8);
+            yaml.dump(r, ws);
+            ws.close();
+        }catch (Exception ex){
+            ex.printStackTrace();
+        }
+    }
+}
--- 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,195 @@
+package burp.core.processor;
+
+import burp.BurpExtender;
+import burp.core.GlobalCachePool;
+import burp.core.utils.HashCalculator;
+import burp.core.utils.MatchTool;
+import burp.config.ConfigEntry;
+import burp.core.utils.StringHelper;
+import dk.brics.automaton.Automaton;
+import dk.brics.automaton.AutomatonMatcher;
+import dk.brics.automaton.RegExp;
+import dk.brics.automaton.RunAutomaton;
+import java.nio.charset.StandardCharsets;
+import java.security.NoSuchAlgorithmException;
+import java.util.*;
+
+import java.util.concurrent.ConcurrentHashMap;
+import jregex.Matcher;
+import jregex.Pattern;
+
+/**
+ * @author EvilChen
+ */
+
+public class DataProcessingUnit {
+    public Map<String, String> extractDataFromMap(Map<String, Map<String, Object>> inputData) {
+        Map<String, String> extractedData = new HashMap<>();
+        inputData.keySet().forEach(key -> {
+            Map<String, Object> tempMap = inputData.get(key);
+            String data = tempMap.get("data").toString();
+            extractedData.put(key, data);
+        });
+        return extractedData;
+    }
+
+    public List<List<String>> extractColorsAndComments(Map<String, Map<String, Object>> inputData) {
+        List<String> colorList = new ArrayList<>();
+        List<String> commentList = new ArrayList<>();
+        inputData.keySet().forEach(key -> {
+            Map<String, Object> tempMap = inputData.get(key);
+            String color = tempMap.get("color").toString();
+            colorList.add(color);
+            commentList.add(key);
+        });
+        List<List<String>> result = new ArrayList<>();
+        result.add(colorList);
+        result.add(commentList);
+        return result;
+    }
+
+    public Map<String, Map<String, Object>> matchContentByRegex(byte[] content, String headers, byte[] body, String scopeString, String host)
+            throws NoSuchAlgorithmException {
+        // 先从缓存池里判断是否有已经匹配好的结果
+        String messageIndex = HashCalculator.calculateHash(content);
+        Map<String, Map<String, Object>> map = GlobalCachePool.getFromCache(messageIndex);
+        if (map != null) {
+            return map;
+        } else {
+            // 最终返回的结果
+            Map<String, Map<String, Object>> finalMap = new HashMap<>();
+            ConfigEntry.globalRules.keySet().parallelStream().forEach(i -> {
+                for (Object[] objects : ConfigEntry.globalRules.get(i)) {
+                    // 多线程执行，一定程度上减少阻塞现象
+                    String matchContent = "";
+                    // 遍历获取规则
+                    List<String> result = new ArrayList<>();
+                    Map<String, Object> tmpMap = new HashMap<>();
+
+                    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);
+                                break;
+                            case "any header":
+                            case "request header":
+                            case "response header":
+                                matchContent = headers;
+                                break;
+                            case "any body":
+                            case "request body":
+                            case "response body":
+                                matchContent = new String(body, StandardCharsets.UTF_8);
+                                break;
+                            default:
+                                break;
+                        }
+
+                        try {
+                            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());
+                                }
+                            }
+                        } catch (Exception e) {
+                            BurpExtender.stdout.println(String.format("[x] Error Info:\nName: %s\nRegex: %s", name, regex));
+                            e.printStackTrace();
+                            continue;
+                        }
+
+                        // 去除重复内容
+                        HashSet tmpList = new HashSet(result);
+                        result.clear();
+                        result.addAll(tmpList);
+
+                        String nameAndSize = String.format("%s (%s)", name, result.size());
+                        if (!result.isEmpty()) {
+                            tmpMap.put("color", color);
+                            String dataStr = String.join("\n", result);
+                            tmpMap.put("data", dataStr);
+                            finalMap.put(nameAndSize, tmpMap);
+                            // 添加到全局变量中，便于Databoard检索
+                            if (!Objects.equals(host, "") && host != null) {
+                                List<String> dataList = Arrays.asList(dataStr.split("\n"));
+                                if (ConfigEntry.globalDataMap.containsKey(host)) {
+                                    ConcurrentHashMap<String, List<String>> gRuleMap = new ConcurrentHashMap<>(ConfigEntry.globalDataMap.get(host));
+                                    if (gRuleMap.containsKey(name)) {
+                                        // gDataList为不可变列表，因此需要重新创建一个列表以便于使用addAll方法
+                                        List<String> gDataList = gRuleMap.get(name);
+                                        List<String> newDataList = new ArrayList<>(gDataList);
+                                        newDataList.addAll(dataList);
+                                        newDataList = new ArrayList<>(new HashSet<>(newDataList));
+                                        gRuleMap.remove(name);
+                                        gRuleMap.put(name, newDataList);
+                                    } else {
+                                        gRuleMap.put(name, dataList);
+                                    }
+                                    ConfigEntry.globalDataMap.remove(host);
+                                    ConfigEntry.globalDataMap.put(host, gRuleMap);
+                                } else {
+                                    Map<String, List<String>> ruleMap = new HashMap<>();
+                                    ruleMap.put(name, dataList);
+                                    // 添加单一Host
+                                    ConfigEntry.globalDataMap.put(host, ruleMap);
+                                }
+
+                                String[] splitHost = host.split("\\.");
+
+                                String anyHost = (splitHost.length > 2 && !MatchTool.matchIP(host)) ? StringHelper.replaceFirstOccurrence(host, splitHost[0], "*") : "";
+
+                                if (!ConfigEntry.globalDataMap.containsKey(anyHost) && anyHost.length() > 0) {
+                                    // 添加通配符Host，实际数据从查询哪里将所有数据提取
+                                    ConfigEntry.globalDataMap.put(anyHost, new HashMap<>());
+                                }
+
+                                if (!ConfigEntry.globalDataMap.containsKey("*")) {
+                                    // 添加通配符全匹配，同上
+                                    ConfigEntry.globalDataMap.put("*", new HashMap<>());
+                                }
+
+                                if (!ConfigEntry.globalDataMap.containsKey("**")) {
+                                    // 添加通配符全匹配，同上
+                                    ConfigEntry.globalDataMap.put("**", new HashMap<>());
+                                }
+                            }
+                        }
+                    }
+                }
+            });
+            GlobalCachePool.addToCache(messageIndex, finalMap);
+            return finalMap;
+        }
+
+    }
+}
--- a/src/main/java/burp/core/processor/MessageProcessor.java
+++ b/src/main/java/burp/core/processor/MessageProcessor.java
@@ -0,0 +1,128 @@
+package burp.core.processor;
+
+import burp.IExtensionHelpers;
+import burp.IHttpRequestResponse;
+import burp.IRequestInfo;
+import burp.IResponseInfo;
+import burp.core.utils.MatchTool;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class MessageProcessor {
+    private MatchTool matcher = new MatchTool();
+    private DataProcessingUnit dataProcessingUnit = new DataProcessingUnit();
+    private ColorProcessor colorProcessor = new ColorProcessor();
+
+    public List<Map<String, String>> processMessage(IExtensionHelpers helpers, IHttpRequestResponse messageInfo, String host, boolean actionFlag) throws Exception {
+
+        byte[] requestByte = messageInfo.getRequest();
+        byte[] responseByte = messageInfo.getResponse();
+
+        List<Map<String, String>> reqObj = processRequestMessage(helpers, requestByte, host, actionFlag);
+        List<Map<String, String>> resObj = processResponseMessage(helpers, responseByte, host, actionFlag);
+        List<Map<String, String>> mergedList = new ArrayList<>();
+
+        if (reqObj != null && !reqObj.isEmpty()) {
+            if (resObj != null && !resObj.isEmpty()) {
+                List<String> colorList = new ArrayList<>();
+
+                colorList.add(reqObj.get(0).get("color"));
+                colorList.add(resObj.get(0).get("color"));
+                Map<String, String> colorMap = new HashMap<>();
+                colorMap.put("color", colorProcessor.retrieveFinalColor(colorProcessor.retrieveColorIndices(colorList)));
+
+                Map<String, String> commentMap = new HashMap<>();
+                String commentList = String.format("%s, %s", reqObj.get(1).get("comment"), resObj.get(1).get("comment"));
+                commentMap.put("comment", commentList);
+
+                mergedList.add(0, colorMap);
+                mergedList.add(1, commentMap);
+            } else {
+                mergedList = new ArrayList<>(reqObj);
+            }
+        } else if (resObj != null && !resObj.isEmpty()){
+            mergedList = new ArrayList<>(resObj);
+        }
+
+        return mergedList;
+    }
+
+    public List<Map<String, String>> processRequestMessage(IExtensionHelpers helpers, byte[] content, String host, boolean actionFlag) throws Exception {
+        Map<String, Map<String, Object>> obj;
+
+        IRequestInfo requestInfo = helpers.analyzeRequest(content);
+        List<String> requestTmpHeaders = requestInfo.getHeaders();
+        String requestHeaders = String.join("\n", requestTmpHeaders);
+
+        try {
+            String urlString = requestTmpHeaders.get(0).split(" ")[1];
+            urlString = urlString.indexOf("?") > 0 ? urlString.substring(0, urlString.indexOf("?")) : urlString;
+            if (matcher.matchUrlSuffix(urlString)) {
+                return null;
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+            return null;
+        }
+
+        int requestBodyOffset = requestInfo.getBodyOffset();
+        byte[] requestBody = Arrays.copyOfRange(content, requestBodyOffset, content.length);
+        obj = dataProcessingUnit.matchContentByRegex(content, requestHeaders, requestBody, "request", host);
+
+        return getDataList(obj, actionFlag);
+    }
+
+    public List<Map<String, String>> processResponseMessage(IExtensionHelpers helpers, byte[] content, String host, boolean actionFlag) throws Exception {
+        Map<String, Map<String, Object>> obj;
+
+        IResponseInfo responseInfo = helpers.analyzeResponse(content);
+        try {
+            String inferredMimeType = String.format("hae.%s", responseInfo.getInferredMimeType().toLowerCase());
+            String statedMimeType = String.format("hae.%s", responseInfo.getStatedMimeType().toLowerCase());
+            if (matcher.matchUrlSuffix(statedMimeType) || matcher.matchUrlSuffix(inferredMimeType)) {
+                return null;
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+            return null;
+        }
+        List<String> responseTmpHeaders = responseInfo.getHeaders();
+        String responseHeaders = String.join("\n", responseTmpHeaders);
+        int responseBodyOffset = responseInfo.getBodyOffset();
+        byte[] responseBody = Arrays.copyOfRange(content, responseBodyOffset, content.length);
+        obj = dataProcessingUnit.matchContentByRegex(content, responseHeaders, responseBody, "response", host);
+
+        return getDataList(obj, actionFlag);
+    }
+
+    private List<Map<String, String>> getDataList(Map<String, Map<String, Object>> obj, boolean actionFlag) {
+        List<Map<String, String>> highlightList = new ArrayList<>();
+        List<Map<String, String>> extractList = new ArrayList<>();
+
+        if (obj.size() > 0) {
+            if (actionFlag) {
+                List<List<String>> resultList = dataProcessingUnit.extractColorsAndComments(obj);
+                List<String> colorList = resultList.get(0);
+                List<String> commentList = resultList.get(1);
+                if (!colorList.isEmpty() && !commentList.isEmpty()) {
+                    String color = colorProcessor.retrieveFinalColor(colorProcessor.retrieveColorIndices(colorList));
+                    Map<String, String> colorMap = new HashMap<String, String>() {{
+                        put("color", color);
+                    }};
+                    Map<String, String> commentMap = new HashMap<String, String>() {{
+                        put("comment", String.join(", ", commentList));
+                    }};
+                    highlightList.add(colorMap);
+                    highlightList.add(commentMap);
+                }
+            } else {
+                extractList.add(dataProcessingUnit.extractDataFromMap(obj));
+            }
+        }
+
+        return actionFlag ? highlightList : extractList;
+    }
+}
--- a/src/main/java/burp/core/utils/HashCalculator.java
+++ b/src/main/java/burp/core/utils/HashCalculator.java
@@ -0,0 +1,30 @@
+package burp.core.utils;
+
+import burp.BurpExtender;
+
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+
+/**
+ * @author EvilChen
+ */
+
+public class HashCalculator {
+    public static String calculateHash(byte[] bytes) throws NoSuchAlgorithmException {
+        MessageDigest digest = MessageDigest.getInstance("MD5");
+        byte[] hashBytes = digest.digest(bytes);
+        return bytesToHex(hashBytes);
+    }
+
+    private static String bytesToHex(byte[] bytes) {
+        StringBuilder hexString = new StringBuilder();
+        for (byte b : bytes) {
+            String hex = Integer.toHexString(0xff & b);
+            if (hex.length() == 1) {
+                hexString.append('0');
+            }
+            hexString.append(hex);
+        }
+        return hexString.toString();
+    }
+}
--- a/src/main/java/burp/core/utils/MatchTool.java
+++ b/src/main/java/burp/core/utils/MatchTool.java
@@ -0,0 +1,21 @@
+package burp.core.utils;
+
+import jregex.Pattern;
+import jregex.REFlags;
+import burp.config.ConfigLoader;
+
+/**
+ * @author EvilChen
+ */
+
+public class MatchTool {
+    public boolean matchUrlSuffix(String str) {
+        Pattern pattern = new Pattern(String.format("[\\w]+[\\.](%s)", ConfigLoader.getExcludeSuffix()), REFlags.IGNORE_CASE);
+        jregex.Matcher matcher = pattern.matcher(str);
+        return matcher.find();
+    }
+
+    public static boolean matchIP(String str) {
+        return str.matches("\\b(?:\\d{1,3}\\.){3}\\d{1,3}\\b");
+    }
+}
--- a/src/main/java/burp/core/utils/StringHelper.java
+++ b/src/main/java/burp/core/utils/StringHelper.java
@@ -0,0 +1,66 @@
+package burp.core.utils;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class StringHelper {
+    public static String replaceFirstOccurrence(String original, String find, String replace) {
+        int index = original.indexOf(find);
+        if (index != -1) {
+            return original.substring(0, index) + replace + original.substring(index + find.length());
+        }
+        return original;
+    }
+
+    public static boolean matchFromEnd(String input, String pattern) {
+        int inputLength = input.length();
+        int patternLength = pattern.length();
+
+        int inputIndex = inputLength - 1;
+        int patternIndex = patternLength - 1;
+
+        while (inputIndex >= 0 && patternIndex >= 0) {
+            if (input.charAt(inputIndex) != pattern.charAt(patternIndex)) {
+                return false;
+            }
+            inputIndex--;
+            patternIndex--;
+        }
+
+        // 如果patternIndex为-1，表示pattern字符串已经完全匹配
+        return patternIndex == -1;
+    }
+
+    public static String mergeComment(String comment) {
+        if (!comment.contains(",")) {
+            return comment;
+        }
+
+        Map<String, Integer> itemCounts = new HashMap<>();
+        String[] items = comment.split(", ");
+
+        for (String item : items) {
+            if (item.contains("(") && item.contains(")")) {
+                int openParenIndex = item.lastIndexOf("(");
+                int closeParenIndex = item.lastIndexOf(")");
+                String itemName = item.substring(0, openParenIndex).trim();
+                int count = Integer.parseInt(item.substring(openParenIndex + 1, closeParenIndex).trim());
+                itemCounts.put(itemName, itemCounts.getOrDefault(itemName, 0) + count);
+            } else {
+                itemCounts.put(item, 0);
+            }
+        }
+
+        StringBuilder mergedItems = new StringBuilder();
+
+        for (Map.Entry<String, Integer> entry : itemCounts.entrySet()) {
+            String itemName = entry.getKey();
+            int count = entry.getValue();
+            if (count != 0) {
+                mergedItems.append(itemName).append(" (").append(count).append("), ");
+            }
+        }
+
+        return mergedItems.substring(0, mergedItems.length() - 2);
+    }
+}
--- 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,52 @@
+package burp.rule.utils;
+
+import burp.*;
+import java.io.FileOutputStream;
+import java.net.URL;
+import java.util.Arrays;
+import javax.swing.JOptionPane;
+
+/**
+ * @author EvilChen
+ */
+public class RuleTool {
+    private String rulesFilePath;
+    private boolean isSuccess;
+
+    public RuleTool(String rulesFilePath) {
+        this.rulesFilePath = rulesFilePath;
+    }
+
+    public void getRulesFromSite() {
+        // 以独立线程使用BurpSuite官方请求接口获取规则
+        Thread t = new Thread(()->{
+            try {
+                URL url = new URL("https://cdn.jsdelivr.net/gh/gh0stkey/HaE@gh-pages/Rules.yml");
+                IHttpService iHttpService = BurpExtender.helpers.buildHttpService(url.getHost(), 443, true);
+                IHttpRequestResponse iHttpRequestResponse = BurpExtender.callbacks.makeHttpRequest(iHttpService, BurpExtender.helpers.buildHttpRequest(url));
+                byte[] responseByte = iHttpRequestResponse.getResponse();
+                IResponseInfo iResponseInfo = BurpExtender.helpers.analyzeResponse(responseByte);
+                int bodyOffset = iResponseInfo.getBodyOffset();
+                byte[] responseBodyByte = Arrays.copyOfRange(responseByte, bodyOffset, responseByte.length);
+                FileOutputStream fileOutputStream = new FileOutputStream(this.rulesFilePath);
+                fileOutputStream.write(responseBodyByte);
+                fileOutputStream.close();
+                isSuccess = true;
+            } catch (Exception e) {
+                isSuccess = false;
+            }
+        });
+        t.start();
+        try {
+            t.join(10000);
+        } catch (Exception e) {
+            isSuccess = false;
+        }
+
+        if (isSuccess) {
+            JOptionPane.showMessageDialog(null, "Rules update successfully!", "Info", JOptionPane.INFORMATION_MESSAGE);
+        } else {
+            JOptionPane.showMessageDialog(null, "Rule update failed, please check the network!", "Error", JOptionPane.ERROR_MESSAGE);
+        }
+    }
+}
--- a/src/main/java/burp/rule/utils/YamlTool.java
+++ b/src/main/java/burp/rule/utils/YamlTool.java
@@ -0,0 +1,36 @@
+package burp.rule.utils;
+
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.Map;
+
+import org.yaml.snakeyaml.DumperOptions;
+import org.yaml.snakeyaml.Yaml;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.InputStream;
+import org.yaml.snakeyaml.representer.Representer;
+
+/**
+ * @author EvilChen
+ */
+
+public class YamlTool {
+
+    public static Yaml newStandardYaml() {
+        DumperOptions dop = new DumperOptions();
+        dop.setDefaultFlowStyle(DumperOptions.FlowStyle.BLOCK);
+        Representer representer = new Representer();
+        return new Yaml(representer, dop);
+    }
+
+    public static Map<String, Object> loadYaml(String filePath) {
+        try {
+            InputStream inputStream = Files.newInputStream(Paths.get(filePath));
+            return newStandardYaml().load(inputStream);
+        } catch (Exception e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+}
--- a/src/main/java/burp/ui/MainUI.java
+++ b/src/main/java/burp/ui/MainUI.java
@@ -0,0 +1,347 @@
+package burp.ui;
+
+import burp.config.ConfigEntry;
+import burp.config.ConfigLoader;
+import burp.rule.RuleProcessor;
+import burp.ui.board.Databoard;
+import burp.ui.board.MessagePanel;
+import burp.ui.rule.RulePane;
+import java.beans.PropertyChangeEvent;
+import java.beans.PropertyChangeListener;
+import java.net.URL;
+import javax.swing.*;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+import javax.swing.event.DocumentEvent;
+import javax.swing.event.DocumentListener;
+import java.awt.*;
+import java.awt.event.*;
+import java.util.Map;
+
+/**
+ * @author LinChen && EvilChen
+ */
+
+public class MainUI extends JPanel {
+
+    public MainUI(MessagePanel messagePanel) {
+        databoardPanel = new Databoard(messagePanel);
+        initComponents();
+    }
+
+    public void closeTabActionPerformed(ActionEvent e) {
+        if (ruleTabbedPane.getTabCount() > 2 && ruleTabbedPane.getSelectedIndex() != 0) {
+            String title = ruleTabbedPane.getTitleAt(ruleTabbedPane.getSelectedIndex());
+            new RuleProcessor().deleteRuleGroup(title);
+            ruleTabbedPane.remove(ruleTabbedPane.getSelectedIndex());
+            ruleTabbedPane.setSelectedIndex(ruleTabbedPane.getSelectedIndex() - 1);
+        }
+    }
+
+    private void onlineUpdateActionPerformed(ActionEvent e) {
+        // 添加提示框防止用户误触导致配置更新
+        int retCode = JOptionPane.showConfirmDialog(null, "Do you want to update rules?", "Info", JOptionPane.YES_NO_OPTION);
+        if (retCode == JOptionPane.YES_OPTION) {
+            ConfigLoader.initRules();
+            reloadRule();
+        }
+    }
+
+    private void reloadRule(){
+        ruleTabbedPane.removeAll();
+        ruleSwitch.setListen(false);
+        Map<String,Object[][]> rules = ConfigLoader.getRules();
+        rules.keySet().forEach(
+                i -> ruleTabbedPane.addTab(
+                        i,
+                        new RulePane(rules.get(i), ruleTabbedPane)
+                )
+        );
+        ruleTabbedPane.addTab("...", new JLabel());
+        ruleSwitch.setListen(true);
+    }
+
+    private void reloadActionPerformed(ActionEvent e) {
+        reloadRule();
+    }
+
+    private void excludeSuffixSaveActionPerformed(ActionEvent e) {
+        ConfigLoader.setExcludeSuffix(excludeSuffixTextField.getText());
+    }
+
+    private void initComponents() {
+        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();
+
+        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};
+
+        {
+            mainTabbedPane.addTab("Rules", ruleTabbedPane);
+
+            {
+                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};
+
+                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));
+
+                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));
+
+                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));
+
+                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));
+
+                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));
+                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));
+
+                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));
+            }
+            mainTabbedPane.addTab("Config", rulePanel);
+            mainTabbedPane.addTab("Databoard", this.databoardPanel);
+        }
+
+        // 新增Logo
+        JTabbedPane HaETabbedPane = new JTabbedPane();
+        HaETabbedPane.addTab("", getImageIcon(false), mainTabbedPane);
+        HaETabbedPane.addTab(" Highlighter and Extractor - Empower ethical hacker for efficient operations ", null);
+        HaETabbedPane.setEnabledAt(1, false);
+        HaETabbedPane.addPropertyChangeListener("background", new PropertyChangeListener() {
+            @Override
+            public void propertyChange(PropertyChangeEvent e) {
+                boolean isDarkBg = isDarkBg();
+                HaETabbedPane.setIconAt(0, getImageIcon(isDarkBg));
+            }
+
+            private boolean isDarkBg() {
+                Color bg = HaETabbedPane.getBackground();
+                int r = bg.getRed();
+                int g = bg.getGreen();
+                int b = bg.getBlue();
+                int avg = (r + g + b) / 3;
+
+                return avg < 128;
+            }
+        });
+
+        add(HaETabbedPane, new GridBagConstraints(0, 0, 1, 1, 0.0, 0.0,
+                GridBagConstraints.CENTER, GridBagConstraints.BOTH,
+                new Insets(0, 0, 0, 0), 0, 0));
+
+        ConfigEntry.globalRules.keySet().forEach(i-> ruleTabbedPane.addTab(i, new RulePane(
+                ConfigEntry.globalRules.get(i),
+                ruleTabbedPane)));
+
+        ruleTabbedPane.addTab("...", new JLabel());
+
+        rulesPathTextField.setText(ConfigLoader.getRulesFilePath());
+        excludeSuffixTextField.setText(ConfigLoader.getExcludeSuffix());
+        ruleSwitch = new TabTitleEditListener(ruleTabbedPane);
+        ruleTabbedPane.addChangeListener(ruleSwitch);
+        ruleTabbedPane.addMouseListener(ruleSwitch);
+        deleteMenuItem.addActionListener(this::closeTabActionPerformed);
+        tabMenu.add(deleteMenuItem);
+    }
+
+    private ImageIcon getImageIcon(boolean isDark) {
+        ClassLoader classLoader = getClass().getClassLoader();
+        URL imageURL;
+        if (isDark) {
+            imageURL = classLoader.getResource("logo.png");
+        } else {
+            imageURL = classLoader.getResource("logo_black.png");
+        }
+        ImageIcon originalIcon = new ImageIcon(imageURL);
+        Image originalImage = originalIcon.getImage();
+        Image scaledImage = originalImage.getScaledInstance(30, 20, Image.SCALE_FAST);
+        ImageIcon scaledIcon = new ImageIcon(scaledImage);
+        return scaledIcon;
+    }
+
+    private JTabbedPane ruleTabbedPane;
+    private JTextField rulesPathTextField;
+    private JTextField excludeSuffixTextField;
+    private Databoard databoardPanel;
+    protected static JPopupMenu tabMenu = new JPopupMenu();
+    private final JMenuItem deleteMenuItem = new JMenuItem("Delete");
+    private TabTitleEditListener ruleSwitch;
+}
+
+class TabTitleEditListener extends MouseAdapter implements ChangeListener, DocumentListener {
+    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 isRenameOk = false;
+    protected RuleProcessor ruleProcessor = new RuleProcessor();
+
+    protected final Action startEditing = new AbstractAction() {
+        @Override public void actionPerformed(ActionEvent e) {
+            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 = 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 (editingIndex >= 0) {
+                ruleEditTabbedPane.setTabComponentAt(editingIndex, tabComponent);
+                ruleEditTextField.setVisible(false);
+                editingIndex = -1;
+                len = -1;
+                tabComponent = null;
+                ruleEditTextField.setPreferredSize(null);
+                ruleEditTabbedPane.requestFocusInWindow();
+            }
+        }
+    };
+
+    protected TabTitleEditListener(JTabbedPane tabbedPane) {
+        super();
+        this.ruleEditTabbedPane = tabbedPane;
+        ruleEditTextField.setBorder(BorderFactory.createEmptyBorder());
+        ruleEditTextField.addFocusListener(new FocusAdapter() {
+            @Override public void focusLost(FocusEvent e) {
+                renameTabTitle.actionPerformed(null);
+            }
+        });
+        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);
+        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 (!isRenameOk){
+                if (pane.getSelectedIndex() == pane.getComponentCount()-1){
+                    newTab();
+                }
+            }else{
+                if (pane.getSelectedIndex() == pane.getComponentCount()-2){
+                    newTab();
+                }
+            }
+        }
+        renameTabTitle.actionPerformed(null);
+    }
+
+    public void newTab(){
+        Object[][] data = new Object[][]{{false, "New Name", "(New Regex)", "gray", "any", "nfa", false}};
+        insertTab(ruleEditTabbedPane, ruleProcessor.newRule(),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();
+    }
+
+    @Override public void removeUpdate(DocumentEvent e) {
+        updateTabSize();
+    }
+
+    @Override public void changedUpdate(DocumentEvent e) {}
+
+    @Override public void mouseClicked(MouseEvent e) {
+        switch (e.getButton()){
+            case 1:
+            {
+                Rectangle r = ruleEditTabbedPane.getBoundsAt(ruleEditTabbedPane.getSelectedIndex());
+                boolean isDoubleClick = e.getClickCount() >= 2;
+                if (isDoubleClick && r.contains(e.getPoint())) {
+                    startEditing.actionPerformed(null);
+                } else {
+                    renameTabTitle.actionPerformed(null);
+                }
+                break;
+            }
+            case 3:{
+                MainUI.tabMenu.show(e.getComponent(),e.getX(),e.getY());
+                break;
+            }
+            default:
+                break;
+        }
+    }
+
+    protected void updateTabSize() {
+        ruleEditTextField.setPreferredSize(ruleEditTextField.getText().length() > len ? null : dim);
+        ruleEditTabbedPane.revalidate();
+    }
+}
--- a/src/main/java/burp/ui/board/ColorRenderer.java
+++ b/src/main/java/burp/ui/board/ColorRenderer.java
@@ -0,0 +1,67 @@
+package burp.ui.board;
+
+import java.awt.Color;
+import java.awt.Component;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import javax.swing.JTable;
+import javax.swing.table.DefaultTableCellRenderer;
+
+public class ColorRenderer extends DefaultTableCellRenderer {
+
+    private List<LogEntry> log;
+    private Map<String, Color> colorMap = new HashMap<>();
+    private JTable table; // 保存对表格的引用
+
+    public ColorRenderer(List<LogEntry> log, JTable table) {
+        this.log = log;
+        // 与BurpSuite的颜色保持一致
+        this.colorMap.put("red", new Color(0xFF, 0x64, 0x64));
+        this.colorMap.put("orange", new Color(0xFF, 0xC8, 0x64));
+        this.colorMap.put("yellow", new Color(0xFF, 0xFF, 0x64));
+        this.colorMap.put("green", new Color(0x64, 0xFF, 0x64));
+        this.colorMap.put("cyan", new Color(0x64, 0xFF, 0xFF));
+        this.colorMap.put("blue", new Color(0x64, 0x64, 0xFF));
+        this.colorMap.put("pink", new Color(0xFF, 0xC8, 0xC8));
+        this.colorMap.put("magenta", new Color(0xFF, 0x64, 0xFF));
+        this.colorMap.put("gray", new Color(0xB4, 0xB4, 0xB4));
+        this.table = table;
+    }
+
+    @Override
+    public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected,
+            boolean hasFocus, int row, int column) {
+        Component component = super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
+
+        LogEntry logEntry = log.get(table.convertRowIndexToModel(row)); // 使用convertRowIndexToModel方法转换行索引
+
+        // 设置颜色
+        String colorByLog = logEntry.getColor();
+        Color color = colorMap.get(colorByLog);
+
+        if (isSelected) {
+            // 通过更改RGB颜色来达成阴影效果
+            component.setBackground(new Color(color.getRed()-0x20, color.getGreen()-0x20, color.getBlue()-0x20));
+        } else {
+            // 否则使用原始颜色
+            component.setBackground(color);
+        }
+
+        component.setForeground(Color.BLACK);
+
+        return component;
+    }
+
+    @Override
+    public void firePropertyChange(String propertyName, Object oldValue, Object newValue) {
+        super.firePropertyChange(propertyName, oldValue, newValue);
+        // 监听表格排序的属性变化
+        if ("tableCellRenderer".equals(propertyName)) {
+            // 更新每一行数据的颜色
+            for (int i = 0; i < table.getRowCount(); i++) {
+                table.repaint(table.getCellRect(i, 0, true));
+            }
+        }
+    }
+}
--- a/src/main/java/burp/ui/board/Databoard.java
+++ b/src/main/java/burp/ui/board/Databoard.java
@@ -0,0 +1,346 @@
+package burp.ui.board;
+
+import burp.config.ConfigEntry;
+import burp.core.utils.StringHelper;
+import burp.ui.board.MessagePanel.Table;
+
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+import javax.swing.event.*;
+import javax.swing.table.TableColumn;
+import javax.swing.table.TableColumnModel;
+import javax.swing.table.TableModel;
+import javax.swing.table.TableRowSorter;
+import java.awt.*;
+import java.awt.event.*;
+import java.util.List;
+import javax.swing.*;
+
+/**
+ * @author LinChen && EvilChen
+ */
+
+public class Databoard extends JPanel {
+    private static Boolean isMatchHost = false;
+    private JLabel hostLabel;
+    private JTextField hostTextField;
+    private JTabbedPane dataTabbedPane;
+    private JButton clearButton;
+    private JSplitPane splitPane;
+    private MessagePanel messagePanel;
+    private Table table;
+    private SwingWorker<Object, Void> currentWorker;
+    private DefaultComboBoxModel comboBoxModel = new DefaultComboBoxModel();
+    private JComboBox hostComboBox = new JComboBox(comboBoxModel);
+    private ChangeListener changeListenerInstance = new ChangeListener() {
+        @Override
+        public void stateChanged(ChangeEvent e) {
+            int selectedIndex = dataTabbedPane.getSelectedIndex();
+            String selectedTitle = "";
+
+            if (selectedIndex != -1) {
+                selectedTitle = dataTabbedPane.getTitleAt(selectedIndex);
+            }
+
+            applyHostFilter(selectedTitle);
+        }
+    };
+
+    public Databoard(MessagePanel messagePanel) {
+        this.messagePanel = messagePanel;
+        initComponents();
+    }
+
+    private void cleanUI() {
+        dataTabbedPane.removeAll();
+        splitPane.setVisible(false);
+    }
+
+    private void clearActionPerformed(ActionEvent e) {
+        int retCode = JOptionPane.showConfirmDialog(null, "Do you want to clear data?", "Info",
+                JOptionPane.YES_NO_OPTION);
+        if (retCode == JOptionPane.YES_OPTION) {
+            cleanUI();
+
+            String host = hostTextField.getText();
+            String cleanedHost = StringHelper.replaceFirstOccurrence(host, "*.", "");
+
+            if (host.contains("*")) {
+                ConfigEntry.globalDataMap.keySet().removeIf(i -> i.contains(cleanedHost) || cleanedHost.contains("*"));
+            } else {
+                ConfigEntry.globalDataMap.remove(host);
+            }
+
+            messagePanel.deleteByHost(cleanedHost);
+        }
+    }
+
+    private void initComponents() {
+        hostLabel = new JLabel();
+        hostTextField = new JTextField();
+        dataTabbedPane = new JTabbedPane(JTabbedPane.TOP);
+        clearButton = new JButton();
+
+        //======== this ========
+        setLayout(new GridBagLayout());
+        ((GridBagLayout)getLayout()).columnWidths = new int[] {25, 0, 0, 0, 20, 0};
+        ((GridBagLayout)getLayout()).rowHeights = new int[] {0, 65, 20, 0};
+        ((GridBagLayout)getLayout()).columnWeights = new double[] {0.0, 0.0, 1.0, 0.0, 0.0, 1.0E-4};
+        ((GridBagLayout)getLayout()).rowWeights = new double[] {0.0, 1.0, 0.0, 1.0E-4};
+
+        //---- hostLabel ----
+        hostLabel.setText("Host:");
+        add(hostLabel, new GridBagConstraints(1, 0, 1, 1, 0.0, 0.0, GridBagConstraints.CENTER, GridBagConstraints.BOTH,
+                new Insets(8, 0, 5, 5), 0, 0));
+        add(hostTextField, new GridBagConstraints(2, 0, 1, 1, 0.0, 0.0, GridBagConstraints.CENTER, GridBagConstraints.BOTH,
+                new Insets(8, 0, 5, 5), 0, 0));
+        clearButton.setText("Clear");
+        clearButton.addActionListener(this::clearActionPerformed);
+        add(clearButton,  new GridBagConstraints(3, 0, 1, 1, 0.0, 0.0, GridBagConstraints.CENTER, GridBagConstraints.BOTH,
+                new Insets(8, 0, 5, 5), 0, 0));
+
+        hostComboBox.setMaximumRowCount(5);
+        add(hostComboBox, new GridBagConstraints(2, 0, 1, 1, 0.0, 0.0, GridBagConstraints.CENTER, GridBagConstraints.BOTH,
+                new Insets(8, 0, 5, 5), 0, 0));
+
+        splitPane = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT);
+        splitPane.setVisible(false);
+        add(splitPane, new GridBagConstraints(1, 1, 3, 3, 0.0, 0.0,
+                GridBagConstraints.CENTER, GridBagConstraints.BOTH,
+                new Insets(8, 0, 5, 5), 0, 0));
+
+        setAutoMatch();
+    }
+
+    private static List<String> getHostByList() {
+        return new ArrayList<>(ConfigEntry.globalDataMap.keySet());
+    }
+
+    /**
+     * 设置输入自动匹配
+     */
+    private void setAutoMatch() {
+        populateComboBoxModel();
+
+        hostComboBox.setSelectedItem(null);
+        hostComboBox.addActionListener(this::handleComboBoxAction);
+
+        hostTextField.addKeyListener(new KeyAdapter() {
+            @Override
+            public void keyPressed(KeyEvent e) {
+                handleKeyEvents(e);
+            }
+        });
+
+        hostTextField.getDocument().addDocumentListener(new DocumentListener() {
+            @Override
+            public void insertUpdate(DocumentEvent e) {
+                filterComboBoxList();
+            }
+
+            @Override
+            public void removeUpdate(DocumentEvent e) {
+                filterComboBoxList();
+            }
+
+            @Override
+            public void changedUpdate(DocumentEvent e) {
+                filterComboBoxList();
+            }
+
+        });
+    }
+
+    private void populateComboBoxModel() {
+        for (String host : getHostByList()) {
+            comboBoxModel.addElement(host);
+        }
+    }
+
+    private void handleComboBoxAction(ActionEvent e) {
+        if (!isMatchHost && hostComboBox.getSelectedItem() != null) {
+            String selectedHost = hostComboBox.getSelectedItem().toString();
+            hostTextField.setText(selectedHost);
+            populateTabbedPaneByHost(selectedHost);
+        }
+    }
+    
+    private void handleKeyEvents(KeyEvent e) {
+        isMatchHost = true;
+        int keyCode = e.getKeyCode();
+
+        if (keyCode == KeyEvent.VK_SPACE && hostComboBox.isPopupVisible()) {
+            e.setKeyCode(KeyEvent.VK_ENTER);
+        }
+
+        if (Arrays.asList(KeyEvent.VK_DOWN, KeyEvent.VK_UP).contains(keyCode)) {
+            hostComboBox.dispatchEvent(e);
+        }
+
+        if (keyCode == KeyEvent.VK_ENTER) {
+            isMatchHost = false;
+            handleComboBoxAction(null);
+            hostComboBox.setPopupVisible(false);
+        }
+
+        if (keyCode == KeyEvent.VK_ESCAPE) {
+            hostComboBox.setPopupVisible(false);
+        }
+
+        isMatchHost = false;
+    }
+
+    private void filterComboBoxList() {
+        isMatchHost = true;
+        comboBoxModel.removeAllElements();
+        String input = hostTextField.getText().toLowerCase();
+
+        if (!input.isEmpty()) {
+            for (String host : getHostByList()) {
+                String lowerCaseHost = host.toLowerCase();
+                if (lowerCaseHost.contains(input)) {
+                    if (lowerCaseHost.equals(input)) {
+                        comboBoxModel.insertElementAt(lowerCaseHost, 0);
+                        comboBoxModel.setSelectedItem(lowerCaseHost);
+                    } else {
+                        comboBoxModel.addElement(host);
+                    }
+                }
+            }
+        }
+
+        hostComboBox.setPopupVisible(comboBoxModel.getSize() > 0);
+        isMatchHost = false;
+    }
+
+    private void applyHostFilter(String filterText) {
+        TableRowSorter<TableModel> sorter = (TableRowSorter<TableModel>) table.getRowSorter();
+
+        String cleanedText = StringHelper.replaceFirstOccurrence(filterText, "*.", "");
+
+        if (cleanedText.contains("*")) {
+            cleanedText = "";
+        }
+
+        RowFilter<TableModel, Integer> filter = RowFilter.regexFilter(cleanedText, 1);
+        sorter.setRowFilter(filter);
+
+        messagePanel.applyHostFilter(filterText);
+    }
+
+    private void populateTabbedPaneByHost(String selectedHost) {
+        if (!Objects.equals(selectedHost, "")) {
+            ConcurrentHashMap<String, Map<String, List<String>>> dataMap = ConfigEntry.globalDataMap;
+            Map<String, List<String>> selectedDataMap;
+
+            dataTabbedPane.removeAll();
+            dataTabbedPane.setPreferredSize(new Dimension(500,0));
+            dataTabbedPane.setTabLayoutPolicy(JTabbedPane.SCROLL_TAB_LAYOUT);
+            splitPane.setLeftComponent(dataTabbedPane);
+
+            if (selectedHost.contains("*")) {
+                // 通配符数据
+                selectedDataMap = new HashMap<>();
+                String hostPattern = StringHelper.replaceFirstOccurrence(selectedHost, "*.", "");
+                for (String key : dataMap.keySet()) {
+                    if (key.contains(hostPattern) || selectedHost.equals("*")) {
+                        Map<String, List<String>> ruleMap = dataMap.get(key);
+                        for (String ruleKey : ruleMap.keySet()) {
+                            List<String> dataList = ruleMap.get(ruleKey);
+                            if (selectedDataMap.containsKey(ruleKey)) {
+                                List<String> mergedList = new ArrayList<>(selectedDataMap.get(ruleKey));
+                                mergedList.addAll(dataList);
+                                HashSet<String> uniqueSet = new HashSet<>(mergedList);
+                                selectedDataMap.put(ruleKey, new ArrayList<>(uniqueSet));
+                            } else {
+                                selectedDataMap.put(ruleKey, dataList);
+                            }
+                        }
+                    }
+                }
+            } else {
+                selectedDataMap = dataMap.get(selectedHost);
+            }
+
+            if (selectedHost.equals("**")) {
+                for (ConcurrentHashMap.Entry<String, Map<String, List<String>>> entry : dataMap.entrySet()) {
+                    JTabbedPane newTabbedPane = new JTabbedPane();
+                    newTabbedPane.setTabLayoutPolicy(JTabbedPane.SCROLL_TAB_LAYOUT);
+
+                    for (Map.Entry<String, List<String>> entrySet : entry.getValue().entrySet()) {
+                        currentWorker = new SwingWorker<Object, Void>() {
+                            @Override
+                            protected Object[] doInBackground() throws Exception {
+                                String tabTitle = String.format("%s (%s)", entrySet.getKey(),
+                                        entrySet.getValue().size());
+                                DatatablePanel datatablePanel = new DatatablePanel(entrySet.getKey(),
+                                        entrySet.getValue());
+                                datatablePanel.setTableListener(messagePanel);
+                                return new Object[] {tabTitle, datatablePanel};
+                            }
+
+                            @Override
+                            protected void done() {
+                                if (!isCancelled()) {
+                                    try {
+                                        Object[] result = (Object[]) get();
+                                        SwingUtilities.invokeLater(() -> {
+                                            newTabbedPane.addTab(result[0].toString(), (DatatablePanel) result[1]);
+                                            dataTabbedPane.addTab(entry.getKey(), newTabbedPane);
+                                        });
+                                    } catch (Exception e) {
+                                        e.printStackTrace();
+                                    }
+                                }
+                            }
+                        };
+                        currentWorker.execute();
+                    }
+                }
+
+                dataTabbedPane.addChangeListener(changeListenerInstance);
+            } else {
+                dataTabbedPane.removeChangeListener(changeListenerInstance);
+
+                for (Map.Entry<String, List<String>> entry : selectedDataMap.entrySet()) {
+                    String tabTitle = String.format("%s (%s)", entry.getKey(), entry.getValue().size());
+                    DatatablePanel datatablePanel = new DatatablePanel(entry.getKey(), entry.getValue());
+                    datatablePanel.setTableListener(messagePanel);
+                    dataTabbedPane.addTab(tabTitle, datatablePanel);
+                }
+            }
+
+            // 展示请求消息表单
+            JSplitPane messageSplitPane = this.messagePanel.getPanel();
+            this.splitPane.setRightComponent(messageSplitPane);
+            table = this.messagePanel.getTable();
+
+            this.splitPane.addComponentListener(new ComponentAdapter() {
+                @Override
+                public void componentResized(ComponentEvent e) {
+                    splitPane.setDividerLocation(0.4);
+                    TableColumnModel columnModel = table.getColumnModel();
+                    int totalWidth = (int) (getWidth() * 0.6);
+                    columnModel.getColumn(0).setPreferredWidth((int) (totalWidth * 0.1));
+                    columnModel.getColumn(1).setPreferredWidth((int) (totalWidth * 0.3));
+                    columnModel.getColumn(2).setPreferredWidth((int) (totalWidth * 0.3));
+                    columnModel.getColumn(3).setPreferredWidth((int) (totalWidth * 0.1));
+                    columnModel.getColumn(4).setPreferredWidth((int) (totalWidth * 0.1));
+                    columnModel.getColumn(5).setPreferredWidth((int) (totalWidth * 0.1));
+                }
+            });
+
+            splitPane.setVisible(true);
+
+            applyHostFilter(selectedHost);
+
+            // 主动调用一次stateChanged，使得dataTabbedPane可以精准展示内容
+            if (selectedHost.equals("**")) {
+                changeListenerInstance.stateChanged(null);
+            }
+
+            hostTextField.setText(selectedHost);
+
+        }
+    }
+}
--- a/src/main/java/burp/ui/board/DatatablePanel.java
+++ b/src/main/java/burp/ui/board/DatatablePanel.java
@@ -0,0 +1,238 @@
+package burp.ui.board;
+
+import java.awt.BorderLayout;
+import java.awt.Color;
+import java.awt.GridLayout;
+import java.awt.datatransfer.Clipboard;
+import java.awt.datatransfer.StringSelection;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.event.FocusEvent;
+import java.awt.event.FocusListener;
+import jregex.Pattern;
+import jregex.REFlags;
+import java.awt.event.ItemEvent;
+import java.awt.event.ItemListener;
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+import java.util.Comparator;
+import java.util.List;
+import javax.swing.BorderFactory;
+import javax.swing.Box;
+import javax.swing.BoxLayout;
+import javax.swing.JButton;
+import javax.swing.JCheckBox;
+import javax.swing.JComponent;
+import javax.swing.JPanel;
+import javax.swing.JPopupMenu;
+import javax.swing.JScrollPane;
+import javax.swing.JTable;
+import javax.swing.JTextField;
+import javax.swing.RowFilter;
+import javax.swing.ScrollPaneConstants;
+import javax.swing.TransferHandler;
+import javax.swing.event.DocumentEvent;
+import javax.swing.event.DocumentListener;
+import javax.swing.table.DefaultTableModel;
+import javax.swing.table.TableColumn;
+import javax.swing.table.TableRowSorter;
+
+public class DatatablePanel extends JPanel {
+    private final JTable table;
+    private final DefaultTableModel model;
+    private final JTextField searchField;
+    private TableRowSorter<DefaultTableModel> sorter;
+    private JScrollPane scrollPane;
+    private String tableName;
+    private JCheckBox searchMode = new JCheckBox("Reverse search");
+
+    public DatatablePanel(String tableName, List<String> list) {
+        this.tableName = tableName;
+
+        String[] columnNames = {"#", "Information"};
+        model = new DefaultTableModel(columnNames, 0);
+        table = new JTable(model);
+        sorter = new TableRowSorter<>(model);
+        // 设置ID排序
+        sorter.setComparator(0, new Comparator<Integer>() {
+            @Override
+            public int compare(Integer s1, Integer s2) {
+                return s1.compareTo(s2);
+            }
+        });
+
+        table.setRowSorter(sorter);
+        TableColumn idColumn = table.getColumnModel().getColumn(0);
+        idColumn.setMaxWidth(50);
+
+        for (String item : list) {
+            addRowToTable(model, new Object[]{item});
+        }
+
+        String defaultText = "Search";
+        searchField = new JTextField(defaultText);
+
+        // 设置灰色默认文本Search
+        searchField.setForeground(Color.GRAY);
+        searchField.addFocusListener(new FocusListener() {
+            @Override
+            public void focusGained(FocusEvent e) {
+                if (searchField.getText().equals(defaultText)) {
+                    searchField.setText("");
+                    searchField.setForeground(Color.BLACK);
+                }
+            }
+
+            @Override
+            public void focusLost(FocusEvent e) {
+                if (searchField.getText().isEmpty()) {
+                    searchField.setForeground(Color.GRAY);
+                    searchField.setText(defaultText);
+                }
+            }
+        });
+
+        // 监听输入框内容输入、更新、删除
+        searchField.getDocument().addDocumentListener(new DocumentListener() {
+            @Override
+            public void insertUpdate(DocumentEvent e) {
+                performSearch();
+            }
+
+            @Override
+            public void removeUpdate(DocumentEvent e) {
+                performSearch();
+            }
+
+            @Override
+            public void changedUpdate(DocumentEvent e) {
+                performSearch();
+            }
+
+        });
+
+        // 设置布局
+        scrollPane = new JScrollPane(table);
+        scrollPane.setVerticalScrollBarPolicy(ScrollPaneConstants.VERTICAL_SCROLLBAR_ALWAYS);
+
+        searchMode.addItemListener(new ItemListener() {
+            public void itemStateChanged(ItemEvent e) {
+                performSearch();
+            }
+        });
+
+        setLayout(new BorderLayout(0, 5));
+
+        JPanel optionsPanel = new JPanel();
+        optionsPanel.setBorder(BorderFactory.createEmptyBorder(2, 3, 5, 5));
+        optionsPanel.setLayout(new BoxLayout(optionsPanel, BoxLayout.X_AXIS));
+
+        // 新增复选框要在这修改rows
+        JPanel menuPanel = new JPanel(new GridLayout(1, 1));
+        menuPanel.setBorder(BorderFactory.createEmptyBorder(3, 3, 3, 3));
+        JPopupMenu menu = new JPopupMenu();
+        menuPanel.add(searchMode);
+        menu.add(menuPanel);
+
+        JButton settingsButton = new JButton("Settings");
+        settingsButton.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                int x = settingsButton.getX();
+                int y = settingsButton.getY() - menu.getPreferredSize().height;
+                menu.show(settingsButton, x, y);
+            }
+        });
+
+        optionsPanel.add(settingsButton);
+        optionsPanel.add(Box.createHorizontalStrut(5));
+        optionsPanel.add(searchField);
+
+        add(scrollPane, BorderLayout.CENTER);
+        add(optionsPanel, BorderLayout.SOUTH);
+    }
+
+    private static void addRowToTable(DefaultTableModel model, Object[] data) {
+        // 获取当前ID
+        int rowCount = model.getRowCount();
+        int id = rowCount > 0 ? (Integer) model.getValueAt(rowCount - 1, 0) + 1 : 1;
+        Object[] rowData = new Object[data.length + 1];
+        rowData[0] = id; // 设置ID列的值
+        System.arraycopy(data, 0, rowData, 1, data.length); // 拷贝其余数据
+        model.addRow(rowData); // 添加行
+    }
+
+    private void performSearch() {
+        if (searchField.getForeground().equals(Color.BLACK)) {
+            RowFilter<Object, Object> rowFilter = new RowFilter<Object, Object>() {
+                public boolean include(Entry<?, ?> entry) {
+                    String searchFieldTextText = searchField.getText();
+                    Pattern pattern = null;
+                    try {
+                        pattern = new Pattern(searchFieldTextText, REFlags.IGNORE_CASE);
+                    } catch (Exception ignored) {
+                    }
+
+                    String entryValue = ((String) entry.getValue(1)).toLowerCase();
+                    searchFieldTextText = searchFieldTextText.toLowerCase();
+                    if (pattern != null) {
+                        return searchFieldTextText.isEmpty() || pattern.matcher(entryValue).find() != searchMode.isSelected();
+                    } else {
+                        return searchFieldTextText.isEmpty() || entryValue.contains(searchFieldTextText) != searchMode.isSelected();
+                    }
+                }
+            };
+            sorter.setRowFilter(rowFilter);
+        }
+    }
+
+    public void setTableListener(MessagePanel messagePanel) {
+        table.setDefaultEditor(Object.class, null);
+
+        // 表格内容双击事件
+        table.addMouseListener(new MouseAdapter() {
+            @Override
+            public void mouseClicked(MouseEvent e) {
+                if (e.getClickCount() == 2) {
+                    int selectedRow = table.getSelectedRow();
+                    if (selectedRow != -1) {
+                        String rowData = table.getValueAt(selectedRow, 1).toString();
+                        messagePanel.applyMessageFilter(tableName, rowData);
+                    }
+                }
+            }
+        });
+
+        table.setTransferHandler(new TransferHandler() {
+            @Override
+            public void exportToClipboard(JComponent comp, Clipboard clip, int action) throws IllegalStateException {
+                if (comp instanceof JTable) {
+                    StringSelection stringSelection = new StringSelection(getSelectedData(
+                            (JTable) comp));
+                    clip.setContents(stringSelection, null);
+                } else {
+                    super.exportToClipboard(comp, clip, action);
+                }
+            }
+        });
+    }
+
+    public String getSelectedData(JTable table) {
+        int[] selectRows = table.getSelectedRows();
+        StringBuilder selectData = new StringBuilder();
+        for (int row : selectRows) {
+            selectData.append(table.getValueAt(row, 1).toString()).append("\n");
+        }
+
+        // 便于单行复制，去除最后一个换行符
+        if (selectData.length() > 0){
+            selectData.deleteCharAt(selectData.length() - 1);
+        }
+
+        return selectData.toString();
+    }
+
+    public JTable getTable() {
+        return this.table;
+    }
+}
--- a/src/main/java/burp/ui/board/LogEntry.java
+++ b/src/main/java/burp/ui/board/LogEntry.java
@@ -0,0 +1,53 @@
+package burp.ui.board;
+
+import burp.IHttpRequestResponsePersisted;
+import java.net.URL;
+
+public class LogEntry {
+
+    private final String comment;
+    private final IHttpRequestResponsePersisted requestResponse;
+    private final URL url;
+    private final String length;
+    private final String status;
+    private final String color;
+    private final String method;
+
+    LogEntry(IHttpRequestResponsePersisted requestResponse, String method, URL url, String comment, String length, String color, String status) {
+        this.requestResponse = requestResponse;
+        this.method = method;
+        this.url = url;
+        this.comment = comment;
+        this.length = length;
+        this.color = color;
+        this.status = status;
+    }
+
+    public String getColor() {
+        return this.color;
+    }
+
+    public URL getUrl() {
+        return this.url;
+    }
+
+    public String getLength() {
+        return this.length;
+    }
+
+    public String getComment() {
+        return this.comment;
+    }
+
+    public String getMethod() {
+        return this.method;
+    }
+
+    public String getStatus() {
+        return this.status;
+    }
+
+    public IHttpRequestResponsePersisted getRequestResponse() {
+        return this.requestResponse;
+    }
+}
--- a/src/main/java/burp/ui/board/MessagePanel.java
+++ b/src/main/java/burp/ui/board/MessagePanel.java
@@ -0,0 +1,470 @@
+package burp.ui.board;
+
+import burp.IBurpExtenderCallbacks;
+import burp.IExtensionHelpers;
+import burp.IHttpRequestResponse;
+import burp.IHttpRequestResponsePersisted;
+import burp.IHttpService;
+import burp.IMessageEditor;
+import burp.IMessageEditorController;
+import burp.IRequestInfo;
+import burp.config.ConfigEntry;
+import burp.core.GlobalCachePool;
+import burp.core.utils.HashCalculator;
+import burp.core.utils.StringHelper;
+
+import java.net.URL;
+import java.nio.charset.StandardCharsets;
+import java.security.NoSuchAlgorithmException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Map;
+import javax.swing.JScrollPane;
+import javax.swing.JSplitPane;
+import javax.swing.JTabbedPane;
+import javax.swing.JTable;
+import javax.swing.SwingWorker;
+import javax.swing.table.AbstractTableModel;
+import javax.swing.table.DefaultTableModel;
+import javax.swing.table.TableModel;
+import javax.swing.table.TableRowSorter;
+
+/**
+ * @author EvilChen
+ */
+
+public class MessagePanel extends AbstractTableModel implements IMessageEditorController {
+    private JSplitPane splitPane;
+    private IMessageEditor requestViewer;
+    private IMessageEditor responseViewer;
+    private final IBurpExtenderCallbacks callbacks;
+    private final List<LogEntry> log = new ArrayList<LogEntry>();
+    private final List<LogEntry> filteredLog = new ArrayList<LogEntry>();
+    private IHttpRequestResponse currentlyDisplayedItem;
+    private final IExtensionHelpers helpers;
+    private final Table logTable;
+
+    public MessagePanel(IBurpExtenderCallbacks callbacks, IExtensionHelpers helpers) {
+        this.callbacks = callbacks;
+        this.helpers = helpers;
+
+        splitPane = new JSplitPane(JSplitPane.VERTICAL_SPLIT);
+
+        logTable = new Table(MessagePanel.this);
+        logTable.setDefaultRenderer(Object.class, new ColorRenderer(filteredLog, logTable));
+        logTable.setAutoCreateRowSorter(true);
+
+        // Length字段根据大小进行排序
+        TableRowSorter<DefaultTableModel> sorter = (TableRowSorter<DefaultTableModel>) logTable.getRowSorter();
+        sorter.setComparator(4, new Comparator<String>() {
+            @Override
+            public int compare(String s1, String s2) {
+                Integer age1 = Integer.parseInt(s1);
+                Integer age2 = Integer.parseInt(s2);
+                return age1.compareTo(age2);
+            }
+        });
+
+        // Color字段根据颜色顺序进行排序
+        sorter.setComparator(5, new Comparator<String>() {
+            @Override
+            public int compare(String s1, String s2) {
+                int index1 = getIndex(s1);
+                int index2 = getIndex(s2);
+                return Integer.compare(index1, index2);
+            }
+            private int getIndex(String color) {
+                for (int i = 0; i < ConfigEntry.colorArray.length; i++) {
+                    if (ConfigEntry.colorArray[i].equals(color)) {
+                        return i;
+                    }
+                }
+                return -1;
+            }
+        });
+
+        logTable.setRowSorter(sorter);
+        logTable.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
+
+        JScrollPane scrollPane = new JScrollPane(logTable);
+        scrollPane.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS);
+        scrollPane.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);
+        splitPane.setLeftComponent(scrollPane);
+
+        JTabbedPane tabs = new JTabbedPane();
+        requestViewer = callbacks.createMessageEditor(MessagePanel.this, false);
+
+        responseViewer = callbacks.createMessageEditor(MessagePanel.this, false);
+        tabs.addTab("Request", requestViewer.getComponent());
+        tabs.addTab("Response", responseViewer.getComponent());
+        splitPane.setRightComponent(tabs);
+    }
+
+    public JSplitPane getPanel() {
+        return splitPane;
+    }
+
+    public Table getTable() {
+        return logTable;
+    }
+
+    public List<LogEntry> getLogs() {
+        return log;
+    }
+
+    @Override
+    public int getRowCount()
+    {
+        return filteredLog.size();
+    }
+
+    @Override
+    public int getColumnCount()
+    {
+        return 6;
+    }
+
+    @Override
+    public String getColumnName(int columnIndex)
+    {
+        switch (columnIndex)
+        {
+            case 0:
+                return "Method";
+            case 1:
+                return "URL";
+            case 2:
+                return "Comment";
+            case 3:
+                return "Status";
+            case 4:
+                return "Length";
+            case 5:
+                return "Color";
+            default:
+                return "";
+        }
+    }
+
+    @Override
+    public Class<?> getColumnClass(int columnIndex)
+    {
+        return String.class;
+    }
+
+    @Override
+    public Object getValueAt(int rowIndex, int columnIndex)
+    {
+        if (filteredLog.isEmpty()) {
+            return "";
+        }
+        LogEntry logEntry = filteredLog.get(rowIndex);
+        switch (columnIndex)
+        {
+            case 0:
+                return logEntry.getMethod();
+            case 1:
+                return logEntry.getUrl().toString();
+            case 2:
+                return logEntry.getComment();
+            case 3:
+                return logEntry.getStatus();
+            case 4:
+                return logEntry.getLength();
+            case 5:
+                return logEntry.getColor();
+            default:
+                return "";
+        }
+    }
+
+    public void applyHostFilter(String filterText) {
+        filteredLog.clear();
+        fireTableDataChanged();
+        String cleanedText = StringHelper.replaceFirstOccurrence(filterText, "*.", "");
+
+        for (LogEntry entry : log) {
+            String host = entry.getUrl().getHost();
+            if (filterText.contains("*.") && StringHelper.matchFromEnd(host, cleanedText)) {
+                filteredLog.add(entry);
+            } else if (host.equals(filterText) || filterText.contains("*")) {
+                filteredLog.add(entry);
+            }
+        }
+        fireTableDataChanged();
+    }
+
+    public void applyMessageFilter(String tableName, String filterText) {
+        filteredLog.clear();
+        for (LogEntry entry : log) {
+            IHttpRequestResponsePersisted requestResponse = entry.getRequestResponse();
+            byte[] requestByte = requestResponse.getRequest();
+            byte[] responseByte = requestResponse.getResponse();
+
+            String requestString = new String(requestResponse.getRequest(), StandardCharsets.UTF_8);
+            String responseString = new String(requestResponse.getResponse(), StandardCharsets.UTF_8);
+
+            List<String> requestTmpHeaders = helpers.analyzeRequest(requestByte).getHeaders();
+            String requestHeaders = new String(String.join("\n", requestTmpHeaders).getBytes(StandardCharsets.UTF_8), StandardCharsets.UTF_8);
+            int requestBodyOffset = helpers.analyzeRequest(requestByte).getBodyOffset();
+            String requestBody = new String(Arrays.copyOfRange(requestByte, requestBodyOffset, requestByte.length), StandardCharsets.UTF_8);
+
+            List<String> responseTmpHeaders = helpers.analyzeResponse(responseByte).getHeaders();
+            String responseHeaders = new String(String.join("\n", responseTmpHeaders).getBytes(StandardCharsets.UTF_8), StandardCharsets.UTF_8);
+            int responseBodyOffset = helpers.analyzeResponse(responseByte).getBodyOffset();
+            String responseBody = new String(Arrays.copyOfRange(responseByte, responseBodyOffset, responseByte.length), StandardCharsets.UTF_8);
+
+            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 = requestString.contains(filterText) || responseString.contains(filterText);
+                                break;
+                            case "request":
+                                match = requestString.contains(filterText);
+                                break;
+                            case "response":
+                                match = responseString.contains(filterText);
+                                break;
+                            case "any header":
+                                match = requestHeaders.contains(filterText) || responseHeaders.contains(filterText);
+                                break;
+                            case "request header":
+                                match = requestHeaders.contains(filterText);
+                                break;
+                            case "response header":
+                                match = responseHeaders.contains(filterText);
+                                break;
+                            case "any body":
+                                match = requestBody.contains(filterText) || responseBody.contains(filterText);
+                                break;
+                            case "request body":
+                                match = requestBody.contains(filterText);
+                                break;
+                            case "response body":
+                                match = responseBody.contains(filterText);
+                                break;
+                            default:
+                                break;
+                        }
+
+                        if (match) {
+                            isMatched[0] = true;
+                            break;
+                        }
+                    }
+                }
+            });
+
+            if (isMatched[0]) {
+                filteredLog.add(entry);
+            }
+        }
+        fireTableDataChanged();
+        logTable.lastSelectedIndex = -1;
+    }
+
+    public void deleteByHost(String filterText) {
+        filteredLog.clear();
+        List<Integer> rowsToRemove = new ArrayList<>();
+        for (int i = 0; i < log.size(); i++) {
+            LogEntry entry = log.get(i);
+            String host = entry.getUrl().getHost();
+            if (StringHelper.matchFromEnd(host, filterText) || filterText.contains("*")) {
+                rowsToRemove.add(i);
+            }
+        }
+
+        for (int i = rowsToRemove.size() - 1; i >= 0; i--) {
+            int row = rowsToRemove.get(i);
+            log.remove(row);
+        }
+
+        if (!rowsToRemove.isEmpty()) {
+            int[] rows = rowsToRemove.stream().mapToInt(Integer::intValue).toArray();
+            fireTableRowsDeleted(rows[0], rows[rows.length - 1]);
+        }
+    }
+
+    @Override
+    public byte[] getRequest()
+    {
+        return currentlyDisplayedItem.getRequest();
+    }
+
+    @Override
+    public byte[] getResponse()
+    {
+        return currentlyDisplayedItem.getResponse();
+    }
+
+    @Override
+    public IHttpService getHttpService()
+    {
+        return currentlyDisplayedItem.getHttpService();
+    }
+
+    public void add(IHttpRequestResponse messageInfo, String comment, String color) {
+        synchronized(log) {
+            IRequestInfo iRequestInfo = helpers.analyzeRequest(messageInfo);
+            URL url = iRequestInfo.getUrl();
+            String method = iRequestInfo.getMethod();
+            String status = String.valueOf(helpers.analyzeResponse(messageInfo.getResponse()).getStatusCode());
+            String length = String.valueOf(messageInfo.getResponse().length);
+            LogEntry logEntry = new LogEntry(callbacks.saveBuffersToTempFiles(messageInfo), method, url, comment, length, color, status);
+
+            try {
+                // 比较Hash，如若存在重复的请求或响应，则不放入消息内容里
+                byte[] reqByteA = messageInfo.getRequest();
+                byte[] resByteA = messageInfo.getResponse();
+                boolean isDuplicate = false;
+
+                if (log.size() > 0) {
+                    for (LogEntry entry : log) {
+                        IHttpRequestResponsePersisted reqResMessage = entry.getRequestResponse();
+                        byte[] reqByteB = reqResMessage.getRequest();
+                        byte[] resByteB = reqResMessage.getResponse();
+                        try {
+                            // 通过URL、请求和响应报文、匹配数据内容，多维度进行对比
+                            if ((entry.getUrl().toString().equals(url.toString()) || (Arrays.equals(reqByteB, reqByteA) || Arrays.equals(resByteB, resByteA))) && (areMapsEqual(getCacheData(reqByteB), getCacheData(reqByteA)) && areMapsEqual(getCacheData(resByteB), getCacheData(resByteA)))) {
+                                isDuplicate = true;
+                                break;
+                            }
+                        } catch (Exception e) {
+                            e.printStackTrace();
+                        }
+                    }
+                }
+
+                if (!isDuplicate) {
+                    log.add(logEntry);
+                }
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+
+    }
+
+    private Map<String, Map<String, Object>> getCacheData(byte[] content)
+            throws NoSuchAlgorithmException {
+        String hashIndex = HashCalculator.calculateHash(content);
+        return GlobalCachePool.getFromCache(hashIndex);
+    }
+
+    private boolean areMapsEqual(Map<String, Map<String, Object>> map1, Map<String, Map<String, Object>> map2) {
+        if (map1 == null || map2 == null) {
+            return false;
+        }
+        if (map1.size() != map2.size()) {
+            return false;
+        }
+
+        for (String key : map1.keySet()) {
+            if (!map2.containsKey(key)) {
+                return false;
+            }
+            if (!areInnerMapsEqual(map1.get(key), map2.get(key))) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    private boolean areInnerMapsEqual(Map<String, Object> innerMap1, Map<String, Object> innerMap2) {
+        if (innerMap1.size() != innerMap2.size()) {
+            return false;
+        }
+
+        for (String key : innerMap1.keySet()) {
+            if (!innerMap2.containsKey(key)) {
+                return false;
+            }
+            Object value1 = innerMap1.get(key);
+            Object value2 = innerMap2.get(key);
+
+            // 如果值是Map，则递归对比
+            if (value1 instanceof Map && value2 instanceof Map) {
+                if (!areInnerMapsEqual((Map<String, Object>) value1, (Map<String, Object>) value2)) {
+                    return false;
+                }
+            } else if (!value1.equals(value2)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    public class Table extends JTable {
+        LogEntry logEntry;
+        private SwingWorker<Object, Void> currentWorker;
+        // 设置响应报文返回的最大长度为3MB
+        private final int MAX_LENGTH = 3145728;
+        private int lastSelectedIndex = -1;
+
+        public Table(TableModel tableModel) {
+            super(tableModel);
+        }
+
+        @Override
+        public void changeSelection(int row, int col, boolean toggle, boolean extend) {
+            super.changeSelection(row, col, toggle, extend);
+            int selectedIndex = convertRowIndexToModel(row);
+            if (lastSelectedIndex != selectedIndex) {
+                lastSelectedIndex = selectedIndex;
+                logEntry = filteredLog.get(selectedIndex);
+
+                requestViewer.setMessage("Loading...".getBytes(), true);
+                responseViewer.setMessage("Loading...".getBytes(), false);
+                currentlyDisplayedItem = logEntry.getRequestResponse();
+
+                if (currentWorker != null && !currentWorker.isDone()) {
+                    currentWorker.cancel(true);
+                }
+
+                currentWorker = new SwingWorker<Object, Void>() {
+                    @Override
+                    protected byte[][] doInBackground() throws Exception {
+                        byte[] requestByte = logEntry.getRequestResponse().getRequest();
+                        byte[] responseByte = logEntry.getRequestResponse().getResponse();
+
+                        if (responseByte.length > MAX_LENGTH) {
+                            String ellipsis = "\r\n......";
+                            responseByte = Arrays.copyOf(responseByte, MAX_LENGTH + ellipsis.length());
+                            byte[] ellipsisBytes = ellipsis.getBytes();
+                            System.arraycopy(ellipsisBytes, 0, responseByte, MAX_LENGTH, ellipsisBytes.length);
+                        }
+
+                        return new byte[][] {requestByte, responseByte};
+                    }
+
+                    @Override
+                    protected void done() {
+                        if (!isCancelled()) {
+                            try {
+                                byte[][] result = (byte[][]) get();
+                                requestViewer.setMessage(result[0], true);
+                                responseViewer.setMessage(result[1], false);
+                            } catch (Exception e) {
+                                e.printStackTrace();
+                            }
+                        }
+                    }
+                };
+                currentWorker.execute();
+            }
+        }
+    }
+
+}
--- 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/resources/logo.png
+++ b/src/main/resources/logo.png
--- a/src/main/resources/logo_black.png
+++ b/src/main/resources/logo_black.png
Author	SHA1	Message	Date
gh0stkey	e08b930fb5	Version: 2.5.11 Update	2024-01-18 12:07:20 +08:00
gh0stkey	49647d68d0	Version: 2.5.10 Update	2023-12-12 14:54:16 +08:00
gh0stkey	1c63841140	Version: 2.5.10 Update	2023-12-12 14:19:50 +08:00
gh0stkey	105c506039	Version: 2.5.10 Update	2023-12-12 14:19:28 +08:00
gh0stkey	f1941bccd7	Version: 2.5.9 Update	2023-11-28 15:26:25 +08:00
gh0stkey	d38e70523a	Version: 2.5.9 Update	2023-11-28 09:11:56 +08:00
gh0stkey	1f7651c114	Version: 2.5.9 Update	2023-11-27 15:09:31 +08:00
gh0stkey	fc9a253d2b	Version: 2.5.9 Update	2023-11-27 14:55:28 +08:00
ᴋᴇʏ	4cbcc1bcc4	Update issue templates	2023-11-27 09:11:52 +08:00
gh0stkey	765807de6e	Version: 2.5.8 Update	2023-11-16 19:44:27 +08:00
gh0stkey	548315e163	Version: 2.5.8 Update	2023-11-16 19:33:38 +08:00
ᴋᴇʏ	d3ab207825	Update issue templates	2023-11-16 14:31:15 +08:00
ᴋᴇʏ	44260dd4ff	Update issue templates	2023-11-16 14:27:15 +08:00
gh0stkey	cf3ac4978f	Update README.md	2023-11-15 13:18:50 +08:00
gh0stkey	9c8dad8ac0	Version: 2.5.7 Update	2023-11-13 08:59:53 +08:00
gh0stkey	5cd216e45d	Version: 2.5.7 Update	2023-11-13 08:28:44 +08:00
gh0stkey	87c5f713fa	Version: 2.5.6 Update	2023-11-07 12:05:55 +08:00
gh0stkey	a0946bb723	Version: 2.5.6 Update	2023-11-07 11:32:44 +08:00
gh0stkey	bcb5177b54	Version: 2.5.6 Update	2023-11-07 11:15:20 +08:00
gh0stkey	0225c00f69	Version: 2.5.5 Update	2023-10-26 14:17:56 +08:00
gh0stkey	eafae602b8	Version: 2.5.4.1	2023-10-25 16:02:07 +08:00
gh0stkey	e56d8eb5d5	Version: 2.5.4 Update	2023-10-24 17:54:44 +08:00
gh0stkey	681cce0644	Version: 2.5.4 Update	2023-10-24 17:51:21 +08:00
gh0stkey	d43809e25f	Version: 2.5.3 Update	2023-10-23 21:59:08 +08:00
gh0stkey	567dea6c60	Version: 2.5.3 Update	2023-10-23 21:51:12 +08:00
ᴋᴇʏ	8c388510c5	Version: 2.5.2 Update	2023-10-19 22:57:40 +08:00
ᴋᴇʏ	e22596819b	Version: 2.5.2 Update	2023-10-19 22:46:11 +08:00
ᴋᴇʏ	d2cd7a0d03	Version: 2.5.2 Update	2023-10-19 22:45:44 +08:00
ᴋᴇʏ	67afe1f650	Version: 2.5.2 Update	2023-10-19 22:44:34 +08:00
ᴋᴇʏ	0602346249	Version: 2.5.2 Update	2023-10-19 22:43:29 +08:00
ᴋᴇʏ	953b966961	Version: 2.5.2 Update	2023-10-19 22:42:54 +08:00
ᴋᴇʏ	4c23d62576	Version: 2.5.2 Update	2023-10-19 22:41:50 +08:00
ᴋᴇʏ	6e9b8c8f37	Version: 2.5.2 Update	2023-10-19 22:41:14 +08:00
ᴋᴇʏ	ed58d891d5	Version: 2.5.2 Update	2023-10-19 22:40:06 +08:00
ᴋᴇʏ	33f5cab037	Version: 2.5.2 Update	2023-10-19 22:38:50 +08:00
ᴋᴇʏ	8b79c71df9	Version: 2.5.1 Update	2023-10-18 17:28:07 +08:00
ᴋᴇʏ	9ea0e4be9c	Version: 2.5.1 Update	2023-10-18 17:08:09 +08:00
ᴋᴇʏ	41f197bcb2	Version: 2.5.1 Update	2023-10-18 15:17:45 +08:00
ᴋᴇʏ	31e419aed2	Version: 2.5.1 Update	2023-10-18 15:14:48 +08:00
ᴋᴇʏ	cf90a9366a	Version: 2.5.1 Update	2023-10-18 15:14:33 +08:00
ᴋᴇʏ	6546446e4f	Add files via upload	2023-10-18 00:51:20 +08:00
ᴋᴇʏ	6c4073c8ee	Version: 2.5.1 Update	2023-10-18 00:51:01 +08:00
ᴋᴇʏ	1e1d51921d	Version: 2.5.1 Update	2023-10-18 00:50:05 +08:00
ᴋᴇʏ	9135b8cbd2	Add files via upload	2023-10-18 00:49:02 +08:00
ᴋᴇʏ	cc7956d8dc	Version: 2.5.1 Update	2023-10-18 00:48:12 +08:00
ᴋᴇʏ	405efdd5da	Version: 2.5.1 Update	2023-10-18 00:47:41 +08:00
ᴋᴇʏ	0bb425f00b	Version: 2.5.1 Update	2023-10-18 00:47:34 +08:00
ᴋᴇʏ	0bdff6fe28	Version: 2.5.1 Update	2023-10-18 00:46:21 +08:00
ᴋᴇʏ	6bd153d16a	Version: 2.5.1 Update	2023-10-18 00:45:22 +08:00
ᴋᴇʏ	b12f9355fa	Version: 2.5.1 Update	2023-10-18 00:44:50 +08:00
ᴋᴇʏ	fa9dcfc3d2	Version: 2.5.1 Update	2023-10-18 00:43:39 +08:00
ᴋᴇʏ	2e23388925	Version: 2.5.1 Update	2023-10-18 00:42:46 +08:00
ᴋᴇʏ	06fd54c9ce	Delete BurpExtender.java	2023-10-18 00:42:22 +08:00
ᴋᴇʏ	0707a773c8	Version: 2.5.1 Update	2023-10-18 00:41:51 +08:00
ᴋᴇʏ	d0f49f8e6c	Version: 2.5.1 Update	2023-10-18 00:40:37 +08:00
gh0stkey	5404c90c00	Update	2023-10-12 21:51:49 +08:00
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
AnonymousUser	e43a96b8ad	Version: 2.0.1 Fixed bug	2021-06-11 12:36:30 +08:00
AnonymousUser	a7112ad297	Version: 2.0 Update	2021-06-11 08:22:45 +08:00
AnonymousUser	efc7a2d7e3	Version: 2.0 Update	2021-06-10 23:20:46 +08:00
AnonymousUser	0cfebb8464	Version: 2.0 Update	2021-06-10 23:02:51 +08:00
AnonymousUser	2b4e56ea8c	Version: 2.0 Update	2021-06-10 22:59:27 +08:00
AnonymousUser	4bdb576448	Add Public Rules	2020-12-11 23:55:11 +08:00
Key	e7a7f823df	Merge pull request #11 from PortSwigger/master BApp	2020-12-04 23:02:57 +08:00
PortSwigger Support	a0d33f8c58	1.5.1 update	2020-12-04 14:51:33 +00:00
Uthman Eqbal	72511d9f14	Merge pull request #7 from gh0stkey/master HaE 1.5.1	2020-12-04 12:02:26 +00:00
Uthman Eqbal	2336a49023	Merge branch 'master' into master	2020-12-04 12:02:16 +00:00
AnonymousUser	d89bec65e3	Update	2020-12-04 19:52:36 +08:00
AnonymousUser	2239ca1e90	Update	2020-12-04 19:48:22 +08:00
AnonymousUser	27fbf465b7	update	2020-12-04 16:00:40 +08:00
AnonymousUser	2879a1494c	update	2020-12-04 02:46:19 +08:00
AnonymousUser	d9e0bf4714	Update: Customize HaE's Regex Engine Now you can customize HaE's regex engine: NFA/DFA, but the premise is that you need to test your regex is running ok under the engine you choose.	2020-12-04 02:43:34 +08:00
AnonymousUser	170ed412b3	Add gitignore	2020-11-27 21:31:54 +08:00
PortSwigger Support	91009337c1	BApp update v1.5	2020-11-27 10:24:49 +00:00
Uthman Eqbal	a0127d75a9	Merge pull request #5 from gh0stkey/master HaE 1.5	2020-11-27 09:17:41 +00:00
PortSwigger Support	df0f4bd41b	BApp update	2020-11-12 14:22:18 +00:00
HannahLaw-Portswigger	d0a61ba9ac	Merge pull request #4 from gh0stkey/master HaE 1.4.1	2020-11-12 11:26:34 +00:00
PortSwigger Support	78628b03d1	BApp preparation	2020-10-08 10:06:10 +00:00