1. 项目概述：为什么我们需要一个自定义的加解密插件？

在渗透测试和Web应用安全评估的日常工作中，Burpsuite几乎是每个从业者手中的瑞士军刀。无论是抓包、重放、扫描还是模糊测试，它都提供了强大的基础设施。然而，当测试目标涉及自定义的、非标准的通信协议或数据格式时，我们常常会遇到一个痛点：Burpsuite的原始数据视图是“透明”的，但我们的眼睛却是“盲”的。想象一下，你拦截到一串请求，其请求体或Cookie值是一长串看似随机的Base64字符串，或者是一段经过AES加密的密文。你无法直观地理解其含义，更无法在Repeater模块中手动修改某个参数值（比如把userId从10086改成10010），因为一旦你修改了明文的某个字符，整个加密结构就被破坏了，服务器会直接拒绝你的请求。

这就是自定义加解密插件的用武之地。它的核心价值在于，让Burpsuite能够“理解”并“操作”经过特定算法处理的数据。插件在Burpsuite的各个关键节点（Proxy、Repeater、Intruder、Scanner）充当一个透明的编解码器。当数据流经Burpsuite时，插件自动将其解密为明文供你查看和编辑；当你完成编辑后，它又自动将明文重新加密，生成服务器能够识别的合法请求。整个过程对测试者来说是无感的，你就像在操作一个普通的HTTP请求一样，但实际上底层已经完成了复杂的密码学变换。

在Burpsuite Extender API的演进史上，Montoya API是一个重要的里程碑。它取代了旧有的、略显笨拙的Extender API，提供了更现代、更清晰、更强大的编程接口。基于Montoya API开发插件，意味着你可以更专注于业务逻辑（即你的加解密算法），而不用在API的兼容性和生命周期管理上耗费太多精力。对于需要开发高效、稳定插件的安全工程师来说，直接基于Montoya API是当前的最优选择。

2. 环境准备与项目初始化

2.1 开发环境搭建

工欲善其事，必先利其器。开发Burpsuite插件，首要任务是搭建一个顺手的Java开发环境。

JDK选择与配置：Burpsuite是基于Java开发的，因此插件也必须使用Java编写。我强烈推荐使用JDK 11或JDK 17的LTS（长期支持）版本。这两个版本在企业级应用和Burpsuite自身环境中得到了广泛验证，兼容性最好。你可以从Adoptium（原AdoptOpenJDK）或Oracle官网下载。安装后，请务必确认环境变量JAVA_HOME已正确设置，并且在命令行中执行java -version和javac -version命令能输出预期的版本信息。

构建工具选型：现代Java项目离不开构建工具。对于插件开发，我首推Gradle。相比Maven，Gradle的构建脚本（build.gradle.kts）更简洁灵活，依赖管理也更直观。更重要的是，后续我们将使用一个专门为Montoya API设计的Gradle插件来简化开发流程，这个插件目前对Gradle的支持最为友好。

IDE的选择：IntelliJ IDEA无疑是Java开发者的首选，其社区版（免费）功能已完全足够。在IDEA中创建新项目时，选择“Gradle”作为构建系统，并勾选“Kotlin DSL”选项，这会让我们的build.gradle.kts脚本更易读。

2.2 创建Montoya API插件项目骨架

项目初始化是第一步，也是最容易踩坑的一步。一个清晰的项目结构能避免后续无数麻烦。

步骤一：初始化Gradle项目在IDEA中新建项目后，我们需要修改根目录下的build.gradle.kts文件。核心是引入burp-gradle-plugin。这个由PortSwagger官方社区维护的插件，能自动处理依赖下载、打包生成BurpExtender.jar等繁琐工作。

plugins { `java-library` id("com.github.psxpaul.execfork") version "0.2.0" // 用于运行Burpsuite id("burp.gradle.plugin") version "0.0.5" // 核心插件 } group = "com.yourcompany" version = "1.0.0" repositories { mavenCentral() } burp { burpVersion.set("2024.6") // 指定你使用的Burpsuite版本 // 插件在Burpsuite中显示的名称 name.set("Crypto Assistant") // 作者信息 author.set("Your Name") }

步骤二：配置主类与依赖接下来，在src/main/java目录下创建你的包和主类，例如com.yourcompany.crypto.CryptoPlugin。然后，在build.gradle.kts中指定主类并添加Montoya API依赖。

tasks.jar { manifest { attributes( "Main-Class” to “com.yourcompany.crypto.CryptoPlugin” // 非必需，但建议保留 ) } } dependencies { // Montoya API依赖，burp-gradle-plugin会自动将其打包 implementation("net.portswigger.burp.extensions:montoya-api:+") // 如果你需要额外的加解密库，例如BouncyCastle implementation(“org.bouncycastle:bcprov-jdk15on:1.70") }

步骤三：首次构建与验证在终端执行./gradlew build。如果一切顺利，你会在build/libs/目录下看到一个以-burp.jar结尾的JAR文件，例如CryptoAssistant-1.0.0-burp.jar。这个就是可以直接加载到Burpsuite中的插件文件。

注意：首次构建可能会因为下载Burpsuite的API JAR而较慢。确保网络通畅。另外，burpVersion一定要和你本地安装的Burpsuite专业版或社区版大版本号匹配，否则可能导致运行时错误。

3. 理解Montoya API的核心架构与事件流

在动手写代码之前，我们必须像理解交通网络一样理解Montoya API的事件驱动模型。你的插件就像一个设在各个路口的智能收费站，数据包就是车辆，你需要决定在哪个路口拦截、检查（解密）还是改装（加密）它们。

3.1 Montoya API 的关键接口

Montoya API的核心是几个接口，你的主类需要实现它们来声明自己具备哪些能力。

1. BurpExtension: 这是插件的总入口。它只有一个initialize()方法，当Burpsuite加载插件时首先调用这个方法。在这里，你将获得一个MontoyaApi对象，它是你与Burpsuite世界交互的唯一入口。
2. HttpHandler: 这是处理HTTP流量的核心接口。实现它，并注册到MontoyaApi中，你的插件就能拦截到所有流经Burpsuite的HTTP请求和响应。HttpHandler有两个关键方法：
   • handleHttpRequestToBeSent(HttpRequestToBeSent request): 当一个HTTP请求即将从Burpsuite发往目标服务器时调用。这是执行请求体加密的黄金位置。
   • handleHttpResponseReceived(HttpResponseReceived response): 当Burpsuite从服务器收到一个HTTP响应时调用。这是执行响应体解密的黄金位置。
3. ProxyHttpRequestHandler与ProxyHttpResponseHandler: 这两个接口提供了更细粒度的、专门针对Proxy历史记录和UI显示的控制。例如，你可以在这里修改Proxy历史中显示的内容（将密文解密后显示为明文），而不会影响实际传输的数据包。这对于“只读”式的解密展示非常有用。

3.2 数据流与插件介入点

理解数据在Burpsuite中的流动路径至关重要。下图展示了插件如何嵌入到这个流程中：

[浏览器/客户端] | (发送明文请求) v [Burpsuite Proxy] | -- (1) 请求到达，`ProxyHttpRequestHandler`可介入，修改UI显示内容 v [你的插件 - `HttpHandler.handleHttpRequestToBeSent`] | -- (2) **关键介入点：将明文请求体加密** v [目标服务器] | (处理请求，返回加密响应) v [Burpsuite Proxy] | -- (3) 响应到达，`ProxyHttpResponseHandler`可介入，修改UI显示内容 v [你的插件 - `HttpHandler.handleHttpResponseReceived`] | -- (4) **关键介入点：将加密响应体解密** v [浏览器/客户端] (收到明文响应)

一个重要的概念：作用域。你肯定不希望插件对所有网站的流量都进行加解密操作，那会带来混乱和错误。因此，在你的插件逻辑里，必须有一个“开关”或“判断”机制。通常，我们会检查请求的URL（HttpRequestToBeSent.url()）或主机名，只有匹配我们目标测试域名的流量，才触发加解密逻辑。这个判断通常放在handleHttpRequestToBeSent和handleHttpResponseReceived方法的最开始。

4. 核心功能实现：请求加密与响应解密

这是插件最核心的部分。我们将以一个常见的场景为例：假设目标API的JSON请求体在传输前，会对整个data字段的值进行AES-CBC加密，然后Base64编码；响应亦然。

4.1 定义加解密服务

首先，我们应该将加解密算法逻辑封装成一个独立的服务类，保持主流程代码的清晰。这里以AES为例。

package com.yourcompany.crypto.service; import javax.crypto.Cipher; import javax.crypto.spec.IvParameterSpec; import javax.crypto.spec.SecretKeySpec; import java.util.Base64; public class AesCryptoService { private final String secretKey; // 例如：“0123456789abcdef0123456789abcdef” private final String iv; // 例如：“abcdefghijklmnop” public AesCryptoService(String secretKey, String iv) { this.secretKey = secretKey; this.iv = iv; } public String encrypt(String plainText) throws Exception { Cipher cipher = Cipher.getInstance(“AES/CBC/PKCS5Padding"); SecretKeySpec keySpec = new SecretKeySpec(secretKey.getBytes(“UTF-8”), “AES”); IvParameterSpec ivSpec = new IvParameterSpec(iv.getBytes(“UTF-8”)); cipher.init(Cipher.ENCRYPT_MODE, keySpec, ivSpec); byte[] encrypted = cipher.doFinal(plainText.getBytes(“UTF-8”)); return Base64.getEncoder().encodeToString(encrypted); } public String decrypt(String base64CipherText) throws Exception { Cipher cipher = Cipher.getInstance(“AES/CBC/PKCS5Padding"); SecretKeySpec keySpec = new SecretKeySpec(secretKey.getBytes(“UTF-8”), “AES”); IvParameterSpec ivSpec = new IvParameterSpec(iv.getBytes(“UTF-8”)); cipher.init(Cipher.DECRYPT_MODE, keySpec, ivSpec); byte[] decoded = Base64.getDecoder().decode(base64CipherText); byte[] decrypted = cipher.doFinal(decoded); return new String(decrypted, “UTF-8”); } }

实操心得：算法与模式。实际项目中，加解密算法千变万化。除了AES，还可能遇到DES、RSA、SM4（国密）等。模式除了CBC，还有ECB、GCM等。填充方式也有PKCS5Padding、PKCS7Padding、NoPadding等。务必与开发文档或逆向工程的结果保持绝对一致。一个错误的模式或填充设置会导致解密失败。建议将算法、模式、填充、密钥、IV等参数设计为可配置项，方便后期调整。

4.2 实现HttpHandler处理请求加密

现在，在主插件类中实现HttpHandler接口，并在initialize中注册它。

package com.yourcompany.crypto; import burp.api.montoya.MontoyaApi; import burp.api.montoya.core.ByteArray; import burp.api.montoya.http.handler.*; import burp.api.montoya.http.message.requests.HttpRequestToBeSent; import burp.api.montoya.http.message.responses.HttpResponseReceived; import com.yourcompany.crypto.service.AesCryptoService; import static burp.api.montoya.http.handler.RequestToBeSentAction.continueWith; import static burp.api.montoya.http.handler.ResponseReceivedAction.continueWith; public class CryptoPlugin implements BurpExtension, HttpHandler { private MontoyaApi api; private AesCryptoService cryptoService; private final String TARGET_DOMAIN = “vulnerable-app.com”; // 目标域名 @Override public void initialize(MontoyaApi api) { this.api = api; this.cryptoService = new AesCryptoService(“your-secret-key-here”, “your-iv-here”); // 设置插件名称 api.extension().setName(“Crypto Assistant”); // 注册自己为HTTP处理器 api.http().registerHttpHandler(this); api.logging().logToOutput(“Crypto Assistant Plugin Loaded!”); } @Override public RequestToBeSentAction handleHttpRequestToBeSent(HttpRequestToBeSent request) { // 1. 判断是否为目标流量 if (!request.url().contains(TARGET_DOMAIN)) { return continueWith(request); // 不是目标，直接放行 } // 2. 获取请求体（假设是JSON格式，且加密字段为`data`） String body = request.bodyToString(); if (body != null && body.contains(“\"data\":”)) { try { // 3. 这是一个简化的JSON解析，实际应用建议使用Jackson或Gson // 提取出data字段的明文值 int dataStart = body.indexOf(“\"data\":\””) + 8; int dataEnd = body.indexOf(“\””, dataStart); if (dataStart > 8 && dataEnd > dataStart) { String plainData = body.substring(dataStart, dataEnd); // 4. 加密 String encryptedData = cryptoService.encrypt(plainData); // 5. 替换原请求体中的data字段值 String newBody = body.substring(0, dataStart) + encryptedData + body.substring(dataEnd); // 6. 构造新的请求并返回 HttpRequestToBeSent newRequest = request.withBody(ByteArray.byteArray(newBody)); api.logging().logToOutput(“[+] Encrypted request data for: “ + request.url()); return continueWith(newRequest); } } catch (Exception e) { api.logging().logToError(“[-] Failed to encrypt request: “ + e.getMessage()); } } // 如果不符合条件或出错，返回原请求 return continueWith(request); } @Override public ResponseReceivedAction handleHttpResponseReceived(HttpResponseReceived response) { // 解密逻辑与加密类似，方向相反 if (!response.initiatingRequest().url().contains(TARGET_DOMAIN)) { return continueWith(response); } String body = response.bodyToString(); // 假设响应JSON中也有一个`encryptedData`字段 if (body != null && body.contains(“\"encryptedData\":”)) { try { // 提取、解密、替换响应体 // ... (解密逻辑，与请求加密类似) // HttpResponseReceived newResponse = response.withBody(...); // return continueWith(newResponse); } catch (Exception e) { api.logging().logToError(“[-] Failed to decrypt response: “ + e.getMessage()); } } return continueWith(response); } }

代码解析与关键点：

• 作用域判断：if (!request.url().contains(TARGET_DOMAIN))这行代码至关重要，它确保了插件只处理我们关心的流量，避免干扰其他测试。
• 请求/响应不可变：Montoya API的设计遵循不可变（Immutable）原则。HttpRequestToBeSent和HttpResponseReceived对象本身不能被修改。任何修改都必须通过其withXxx()方法（如withBody()）创建一个新的对象副本。
• 动作返回：handleHttpRequestToBeSent方法必须返回一个RequestToBeSentAction。continueWith(request)是最常用的，表示用这个（可能被修改过的）请求继续后续流程。你也可以返回drop()来丢弃请求，但这在加解密场景中很少用。
• 日志输出：使用api.logging().logToOutput()和logToError()进行日志记录，这对于调试插件行为至关重要。你可以在Burpsuite的Extender标签页的“Output”和“Errors”子标签中看到这些日志。

4.3 处理非标准数据格式与流式数据

上面的例子基于一个简单的JSON键值对。但现实往往更复杂：

1. 整个请求体/响应体加密：数据可能不是JSON，或者整个HTTP Body就是一个加密后的二进制块。这时，你需要判断Content-Type，然后对整个body进行加解密操作，而不是解析特定字段。
2. 自定义二进制协议：数据可能根本不是文本，而是纯二进制流。你需要使用ByteArray类提供的getBytes()方法获取原始字节数组，进行加解密后，再用ByteArray.byteArray(encryptedBytes)构造新的ByteArray。
3. URL参数或Header加密：有些应用会对URL中的查询参数或特定的HTTP Header进行加密。你需要通过request.path()和request.headers()来获取并处理这些部分。

注意事项：字符编码。在字符串和字节数组转换时，务必明确指定字符编码（如“UTF-8”）。使用平台默认编码是万恶之源，会导致在不同操作系统上运行结果不一致，出现中文乱码或加解密失败。

5. 增强插件：UI配置与动态规则

一个只有硬编码密钥和域名的插件是不实用的。我们需要一个图形界面（GUI）让测试者能动态配置这些参数，甚至管理多套加解密规则。

5.1 使用Swing构建配置面板

Montoya API允许你轻松添加自定义的标签页到Burpsuite主界面。我们将创建一个简单的Swing面板。

首先，创建一个配置面板类：

package com.yourcompany.crypto.ui; import javax.swing.*; import java.awt.*; public class CryptoConfigPanel extends JPanel { private final JTextField targetDomainField; private final JTextField secretKeyField; private final JTextField ivField; private final JCheckBox enablePluginCheckBox; public CryptoConfigPanel() { setLayout(new GridBagLayout()); GridBagConstraints gbc = new GridBagConstraints(); gbc.fill = GridBagConstraints.HORIZONTAL; gbc.insets = new Insets(5, 5, 5, 5); gbc.gridx = 0; gbc.gridy = 0; add(new JLabel(“Enable Plugin:”), gbc); gbc.gridx = 1; enablePluginCheckBox = new JCheckBox(“”， true); add(enablePluginCheckBox, gbc); gbc.gridx = 0; gbc.gridy = 1; add(new JLabel(“Target Domain:”), gbc); gbc.gridx = 1; targetDomainField = new JTextField(“vulnerable-app.com”, 25); add(targetDomainField, gbc); gbc.gridx = 0; gbc.gridy = 2; add(new JLabel(“Secret Key (Hex):”), gbc); gbc.gridx = 1; secretKeyField = new JTextField(“0123456789ABCDEF0123456789ABCDEF”, 32); add(secretKeyField, gbc); gbc.gridx = 0; gbc.gridy = 3; add(new JLabel(“IV (Hex):”), gbc); gbc.gridx = 1; ivField = new JTextField(“ABCDEFGHIJKLMNOP”, 16); add(ivField, gbc); // 可以添加保存、加载配置的按钮 gbc.gridx = 0; gbc.gridy = 4; gbc.gridwidth = 2; JButton saveBtn = new JButton(“Save Configuration”); saveBtn.addActionListener(e -> saveConfig()); add(saveBtn, gbc); } private void saveConfig() { // 这里应该将配置保存到持久化存储，例如Burpsuite的持久化项目设置中 // 可以使用 api.persistence().preferences() 来存储键值对 JOptionPane.showMessageDialog(this, “Config saved (In memory).”); } // Getter methods for the main plugin to read configuration public boolean isPluginEnabled() { return enablePluginCheckBox.isSelected(); } public String getTargetDomain() { return targetDomainField.getText().trim(); } public String getSecretKey() { return secretKeyField.getText().trim(); } public String getIv() { return ivField.getText().trim(); } }

然后，在主插件initialize方法中，将这个面板注册为Burpsuite的一个标签页：

@Override public void initialize(MontoyaApi api) { this.api = api; this.configPanel = new CryptoConfigPanel(); // 假设已将面板声明为类变量 api.extension().setName(“Crypto Assistant”); // 添加自定义标签页 api.userInterface().registerSuiteTab(“Crypto Config”, configPanel); api.http().registerHttpHandler(this); // 从持久化设置中加载配置（如果有） loadConfiguration(); }

现在，当你在Burpsuite中切换到“Crypto Config”标签页，就可以动态修改目标域名、密钥等参数了。你的handleHttpRequestToBeSent方法中的判断逻辑和AesCryptoService的初始化，都需要改为从configPanel的Getter方法实时读取配置。

5.2 实现多规则管理与上下文菜单

对于更复杂的测试环境，一个目标可能对应多套加解密规则（例如，登录接口用一种密钥，支付接口用另一种）。我们可以设计一个规则管理器。

设计规则模型：

public class CryptoRule { private String name; private String pattern; // URL匹配模式，支持正则 private String algorithm; private String key; private String iv; private boolean enabled; // ... getters and setters }

实现规则匹配：在handleHttpRequestToBeSent中，遍历所有已启用的CryptoRule，用pattern去匹配请求的URL。匹配成功，则使用该规则对应的算法和密钥进行加解密。

添加上下文菜单：Montoya API允许你为HTTP请求/响应编辑器添加自定义的上下文菜单项。这非常有用，例如，你可以添加一个“Decrypt This”的右键菜单，手动触发对选中密文的解密，并将结果显示在一个对话框中。

api.userInterface().registerContextMenuItemsProvider(new ContextMenuItemsProvider() { @Override public List<Component> provideMenuItems(ContextMenuEvent event) { List<Component> menuItems = new ArrayList<>(); if (event.isFromHttpRequestEditor() || event.isFromHttpResponseEditor()) { // 获取用户选中的文本 String selectedText = event.selectedText(); if (selectedText != null && !selectedText.isEmpty()) { JMenuItem decryptItem = new JMenuItem(“Crypto: Decrypt”); decryptItem.addActionListener(e -> { try { String decrypted = cryptoService.decrypt(selectedText); // 弹窗显示结果 showTextDialog(“Decryption Result”, decrypted); } catch (Exception ex) { api.logging().logToError(“Manual decryption failed: “ + ex.getMessage()); } }); menuItems.add(decryptItem); } } return menuItems; } });

6. 调试、打包与发布

6.1 高效调试技巧

开发插件时，调试是家常便饭。以下是我总结的几个高效方法：

1. 充分利用日志：在关键决策点、异常捕获处、加解密前后，使用api.logging()输出详细信息。这是定位问题最直接的手段。
2. 使用Gradle插件启动Burpsuite：前面提到的burp-gradle-plugin通常集成了execFork插件。你可以在build.gradle.kts中配置，让./gradlew runBurp命令直接启动一个带有你插件JAR的Burpsuite实例，这比手动加载方便得多。
3. 单元测试独立算法：将加解密算法逻辑单独剥离出来，编写JUnit单元测试。确保你的算法逻辑在各种边界情况下（空字符串、特殊字符、超长文本）都能正确工作，这能排除大部分核心逻辑错误。
4. 使用调试器：在IDEA中，你可以远程调试运行中的Burpsuite。配置Burpsuite的启动参数，添加-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=5005，然后在IDEA中创建Remote JVM Debug配置并连接到localhost:5005，即可进行断点调试。

6.2 打包与依赖管理

使用./gradlew build生成的-burp.jar文件已经包含了所有必要的依赖（除了Montoya API本身，它由Burpsuite运行时提供）。这个JAR就是最终产物。

关于依赖冲突：如果你的插件引入了第三方库（如BouncyCastle, Gson），而目标测试环境使用的Burpsuite可能也自带旧版本的相同库，可能会引发冲突。Gradle的shadow插件（或现在叫gradle-shadow-jar）可以帮你打一个“胖JAR”，将所有依赖类重命名后打包进去，有效避免冲突。在build.gradle.kts中应用并配置它：

plugins { id(“com.github.johnrengelman.shadow”) version “8.1.1” } // ... tasks.shadowJar { archiveClassifier.set(“all”) // 生成一个 -all.jar 文件 // 可选：重命名依赖包路径 relocate(“org.bouncycastle”, “com.yourcompany.shaded.bouncycastle”) }

6.3 发布与分享

一个成熟的插件，除了核心功能，还需要考虑用户体验。

1. 版本管理：在build.gradle.kts中清晰定义version，每次功能更新或Bug修复后递增版本号。
2. 编写README：创建一个详细的README.md文件，说明插件的功能、安装方法、配置步骤、常见问题。这对于其他测试者使用你的插件至关重要。
3. 错误处理与兼容性：确保你的插件有良好的异常处理，不会因为单个请求处理失败而导致整个Burpsuite崩溃。考虑不同Burpsuite版本的API兼容性，如果使用了新版本API的特性，需要在文档中注明最低版本要求。
4. 开源与反馈：考虑将插件开源在GitHub等平台。这不仅能帮助他人，也能通过社区反馈发现你未曾考虑到的问题和使用场景，从而不断完善插件。

开发一个高效的Burpsuite加解密插件，就像为你的安全测试工作流安装了一个自动翻译器。它消除了手动编解码的繁琐和错误，让你能聚焦于更重要的逻辑漏洞挖掘。从理解Montoya API的事件流，到实现核心的加解密逻辑，再到构建友好的配置界面，每一步都需要耐心和细致的调试。当你看到经过加密的乱码在Burpsuite中实时变成可读、可编辑的明文时，那种顺畅的测试体验就是对这项工作最好的回报。记住，最好的插件往往源于你自己最真实的测试痛点，解决它，然后分享它，这就是安全社区的协作精神。