Burp Suite高级实战指南：从抓包到插件开发全流程详解

小新讲网安

910人浏览 · 2026-08-13 19:51:44

小新讲网安 · 2026-08-13 19:51:44 发布

一、前言与简介

在Web安全测试领域，Burp Suite毫无疑问是最具统治力的工具。无论是日常的
渗透测试、漏洞挖掘、还是安全研究与Bug Bounty，Burp Suite都是安全从业
人员手中不可或缺的瑞士军刀。然而，很多人对Burp的使用仍停留在简单的
抓包和Intruder暴力破解层面，对其强大的插件生态、扫描策略定制、
Session管理等高级功能知之甚少。

本文将从零开始，系统性地讲解Burp Suite的核心模块使用、高级配置技巧、
插件开发全流程以及完整的Web渗透测试实战案例。无论你是刚入门的安全初学
者，还是有一定经验的渗透测试工程师，都能从中获取实战可用的知识。

【提示】本文所有操作均在授权环境下进行，请勿用于非法用途。未经授权的
渗透测试行为可能违反《网络安全法》及相关法律法规。

本文适合人群：
- Web安全初学者，希望系统掌握Burp Suite
- 渗透测试工程师，希望提升Burp使用效率
- 安全研究人员，希望开发自定义Burp插件
- Bug Bounty猎人，希望优化工作流程

阅读本文你将掌握：
- Burp Suite全部核心模块的深度使用方法
- Intruder四种攻击类型的实战场景
- 使用Java和Python开发自定义Burp插件
- 常用BApp Store插件的配置与使用
- 宏录制与Session处理机制
- Collaborator服务器的高级用法
- 完整的Web应用渗透测试流程

二、Burp Suite概述与版本对比

Burp Suite由PortSwigger公司开发，创始人Dafydd Stuttard同时也是《The
Web Application Hacker's Handbook》的作者。Burp Suite不仅仅是一个代理
工具，而是一个完整的Web安全测试平台，集成了抓包代理、漏洞扫描、
请求重放、暴力破解、会话管理、插件扩展等全方位功能。

目前Burp Suite提供三个主要版本：社区版（Community Edition）、专业版
（Professional Edition）和企业版（Enterprise Edition）。

各版本功能对比表：

| 功能特性 | 社区版(免费) | 专业版(付费) | 企业版(付费) |
|---------------------|-------------|---------------|-----------------|
| 代理抓包功能 | 支持 | 支持 | 支持 |
| Target站点地图 | 基础功能 | 完整功能 | 完整功能 |
| Repeater请求重放 | 支持 | 支持 | 支持 |
| Intruder暴力破解 | 有限制 | 完整功能 | 完整功能 |
| Sequencer随机性分析 | 不支持 | 支持 | 支持 |
| Decoder解码器 | 支持 | 支持 | 支持 |
| Comparer比较器 | 支持 | 支持 | 支持 |
| 主动漏洞扫描 | 不支持 | 支持 | 支持 |
| 被动漏洞扫描 | 有限 | 完整功能 | 完整功能 |
| 扫描策略定制 | 不支持 | 支持 | 支持 |
| Burp Collaborator | 不支持 | 支持(云端) | 支持(私有部署) |
| BApp Store插件市场 | 部分免费 | 全部可用 | 全部可用 |
| REST API接口 | 不支持 | 支持 | 支持 |
| CI/CD集成 | 不支持 | 有限支持 | 完整支持 |
| 多用户协作 | 不支持 | 不支持 | 支持 |
| 分布式扫描 | 不支持 | 不支持 | 支持 |
| 报告导出 | 不支持 | 支持 | 支持 |
| 价格 | 免费 | 约449美元/年 | 联系销售获取报价 |

【注意】社区版的Intruder模块有速率限制和功能限制，专业版没有这些限制。
对于专业安全测试工作，强烈建议购买专业版许可证。

各版本适用场景：

社区版适用场景：
- 安全入门学习
- 简单的HTTP请求分析和修改
- 手动漏洞验证
- 非商业用途的小规模测试

专业版适用场景：
- 专业渗透测试服务
- Bug Bounty漏洞挖掘
- 安全审计与合规评估
- 安全研究与漏洞分析

企业版适用场景：
- 大型企业内部持续安全监控
- DevSecOps CI/CD流水线集成
- 大规模资产漏洞扫描与管理
- 多团队协作的安全测试

三、环境配置与浏览器代理设置

3.1 Burp Suite安装

下载地址：https://portswigger.net/burp/releases

安装步骤（以Windows为例）：

步骤1：下载安装包
- 访问PortSwigger官网下载页面
- 选择对应操作系统的安装包（Windows为.exe或.jar）

步骤2：安装JDK环境
Burp Suite基于Java开发，需要JDK环境支持。

```
# 检查Java版本（建议JDK 17+）
java -version

# 输出示例
# openjdk version "17.0.8" 2023-08-24
# OpenJDK Runtime Environment (build 17.0.8+0)
# OpenJDK 64-Bit Server VM (build 17.0.8+0)
```

步骤3：安装Burp Suite
- 运行下载的安装程序
- 按照向导提示完成安装
- 首次启动时选择Community或Professional版本
- 专业版用户输入许可证密钥激活

步骤4：配置Burp Suite内存
建议为Burp Suite分配充足的内存，避免在大量数据处理时出现卡顿。

```
# 命令行启动并指定内存
java -Xmx4g -jar burpsuite_pro.jar
```

【提示】对于大型目标的扫描，建议至少分配4GB内存。如果内存不足，
可能导致扫描中断或Burp崩溃。

3.2 浏览器代理设置

Burp Suite默认监听127.0.0.1:8080，需要配置浏览器将流量代理到该地址。

方法一：手动设置浏览器代理（以Firefox为例）

步骤1：打开Firefox设置
- 菜单 -> 设置 -> 常规 -> 网络设置 -> 设置

步骤2：配置代理
- 选择"手动代理配置"
- HTTP代理：127.0.0.1
- 端口：8080
- 勾选"也将此代理用于HTTPS"
- 点击确定保存

方法二：使用浏览器代理插件（推荐）

推荐使用FoxyProxy或SwitchyOmega插件，可以快速切换代理状态。

FoxyProxy配置步骤：
步骤1：安装FoxyProxy插件
步骤2：添加代理配置
- 代理名称：Burp Suite
- 代理类型：HTTP
- 代理地址：127.0.0.1
- 代理端口：8080

步骤3：一键切换代理模式
- 点击FoxyProxy图标
- 选择"Burp Suite"配置即可启用

【提示】使用FoxyProxy的好处是可以快速在"直连"和"Burp代理"之间切换，
不影响其他网页的正常浏览。

3.3 安装Burp CA证书

默认情况下，浏览器拦截HTTPS流量时会显示证书不受信任的错误。需要将
Burp Suite的CA证书导入浏览器信任列表。

安装步骤：

步骤1：配置好代理后，在浏览器访问以下地址
```
http://burp
```

步骤2：点击右上角的"CA Certificate"按钮下载证书文件
- 证书文件名：cacert.der

步骤3：在Firefox中导入证书
- 菜单 -> 设置 -> 隐私与安全 -> 查看证书 -> 导入
- 选择下载的cacert.der文件
- 勾选"信任此CA以识别网站"和"信任此CA以识别邮件用户"
- 点击确定完成导入

步骤4：验证HTTPS拦截是否正常
- 访问任意HTTPS网站
- 确认浏览器不再提示证书错误
- 在Burp的Proxy -> HTTP history中查看是否成功捕获HTTPS流量

【注意】安装Burp CA证书后，意味着Burp可以解密你的所有HTTPS流量。
在非测试环境下，建议禁用Burp代理或移除CA证书，防止敏感信息泄露。

3.4 Burp Suite全局设置优化

Proxy选项卡 -> Options -> Proxy Listeners

建议进行以下优化配置：

| 配置项 | 默认值 | 建议值 | 说明 |
|-------------------------|--------------|-----------------|-------------------------|
| Bind to address | 127.0.0.1 | 127.0.0.1 | 安全考虑，仅本地监听 |
| Bind to port | 8080 | 8080 | 默认端口 |
| Request handling | 不勾选 | 勾选 | 统一处理HTTP请求 |
| Intercept on/off | Intercept on | Intercept off | 关闭拦截，避免手动操作 |
| Match and replace rules | 默认 | 根据需求添加 | 自定义匹配替换规则 |

User options -> Connections -> Upstream Proxy Servers

如果测试目标需要通过上游代理访问，在此处配置上游代理信息。

User options -> SSL -> TLS Protocols
建议保持默认设置，确保TLS版本兼容性。

四、Proxy模块详解

Proxy模块是Burp Suite最基础也是最核心的功能模块，它充当浏览器与目标
服务器之间的中间人，负责拦截、查看和修改HTTP/HTTPS请求与响应。

4.1 HTTP历史记录

Proxy -> HTTP history 选项卡记录了所有经过Burp代理的HTTP请求和响应。

HTTP历史记录的核心功能：

- 请求列表：显示每个HTTP请求的概要信息
- Host：目标主机
- Path：请求路径
- Method：HTTP方法（GET/POST/PUT/DELETE等）
- Status code：响应状态码
- URL：完整请求URL
- Length：响应体长度
- MIME type：响应内容类型
- Extension：URL文件扩展名
- Title：HTML页面标题
- Comment：自定义注释（可手动添加）

- 过滤器（Filter Bar）
点击过滤栏可以设置显示过滤条件，快速定位特定请求。

常用过滤条件：
- 按MIME类型过滤：只显示HTML/Script/CSS/图片等
- 按状态码过滤：只显示特定状态码的请求
- 按关键词过滤：搜索请求/响应中包含特定内容
- 按扩展名过滤：显示/隐藏特定扩展名的请求
- 按注释过滤：显示带有特定注释的请求
- 按scope过滤：只显示目标范围内的请求

【提示】在大型测试中，HTTP历史记录可能包含成千上万条记录。善用过滤器
可以大幅提高工作效率。建议在测试前设置好scope，配合scope过滤使用。

- 请求/响应详情查看
点击任意一条历史记录，右侧面板显示该请求的详细内容。
- Request：显示完整的HTTP请求，包含请求行、请求头、请求体
- Response：显示完整的HTTP响应，包含状态行、响应头、响应体
- 可切换Raw/Params/Headers/Hex等视图模式

4.2 WebSockets历史记录

Proxy -> WebSockets history 选项卡记录所有WebSocket通信数据。

WebSocket历史记录功能：
- 显示每个WebSocket连接的完整消息历史
- 支持按连接方向（客户端->服务端 / 服务端->客户端）筛选
- 支持查看消息的Hex视图
- 支持发送到Repeater进行消息重放

【注意】WebSockets历史记录默认会被Burp记录，但在某些情况下可能需要
在Proxy Options中确认WebSocket拦截功能已启用。

4.3 拦截功能

Proxy -> Intercept 选项卡提供实时拦截HTTP请求和响应的能力。

拦截功能配置选项：

| 配置项 | 说明 |
|-----------------------------|-----------------------------------------|
| Intercept is on/off | 开启/关闭拦截功能 |
| Forward | 放行当前拦截的请求/响应 |
| Drop | 丢弃当前拦截的请求/响应 |
| Intercept Client Requests | 配置拦截客户端请求的规则 |
| Intercept Server Responses | 配置拦截服务端响应的规则 |
| Intercept WebSocket Messages| 配置拦截WebSocket消息的规则 |

拦截规则配置示例：

场景1：只拦截POST请求
- 添加规则
- Match type: HTTP method
- Match value: POST
- Action: Intercept

场景2：只拦截特定域名的请求
- 添加规则
- Match type: Host header
- Match value: target.example.com
- Action: Intercept

场景3：只拦截包含Cookie的请求
- 添加规则
- Match type: Request header
- Match value: Cookie
- Action: Intercept

场景4：只拦截JSON格式的响应
- 添加规则
- Match type: Response Content-Type header
- Match value: application/json
- Action: Intercept

【提示】在实际测试中，建议关闭默认拦截（Intercept is off），让所有
请求自动通过。需要时再通过HTTP history查看和修改。频繁的手动放行
会严重影响测试效率。

4.4 拦截规则高级配置

Proxy -> Options -> Intercept rules

支持多条件组合，使用AND/OR逻辑连接。每条规则包含三部分：

- Match type：匹配类型
- Request method、URL、HTTP header、Body content等

- Match condition：匹配条件
- Contains、Does not contain、Matches regex等

- Action：执行动作
- Intercept（拦截）、Do not intercept（不拦截）

高级规则示例：

规则1：拦截所有包含登录凭据的POST请求
- AND条件组
- Match: HTTP method = POST
- Match: Request body contains password
- Action: Intercept

规则2：不拦截静态资源请求
- AND条件组
- Match: URL path matches regex \.(jpg|png|gif|css|js)$
- Action: Do not intercept

4.5 Match and Replace 功能

Proxy -> Options -> Match and Replace

此功能可以在请求/响应经过Burp时自动执行文本匹配和替换，无需手动
修改每条请求。

常见应用场景：

场景1：修改User-Agent绕过简单的WAF检测
- Match (regex): User-Agent: .*
- Replace: User-Agent: Mozilla/5.0 (compatible; Googlebot/2.1)
- Type: Request header

场景2：自动移除客户端IP泄露头
- Match (regex): X-Forwarded-For: .*
- Replace: (留空)
- Type: Request header

场景3：在所有请求中添加自定义Header
- Match (regex): ^$
- Replace: X-Custom-Header: CustomValue
- Type: Request header

场景4：替换响应中的敏感信息
- Match (regex): \b\d{16,19}\b (匹配信用卡号模式)
- Replace: [REDACTED-CARD]
- Type: Response body

【警告】Match and Replace规则会对所有匹配的请求/响应生效。请确保
正则表达式正确，避免误替换导致请求异常。建议在使用前先用测试数据
验证规则效果。

五、Target模块实战

Target模块用于管理和分析目标站点信息，包括站点地图浏览、目标范围
设置、漏洞信息汇总等功能。

5.1 站点地图分析

Target -> Site map 选项卡以树形结构展示目标站点的所有URL和页面关系。

站点地图的核心价值：
- 直观展示目标站点的目录结构和页面层级关系
- 快速发现隐藏路径和敏感接口
- 查看每个请求的完整详情
- 发现测试遗漏的功能点

站点地图的三个视图层级：

层级1：站点域名级别
- 显示所有访问过的目标域名
- 展开后显示各域名下的路径结构

层级2：目录/路径级别
- 以树形结构展示URL路径层级
- 叶子节点表示具体的页面或接口

层级3：请求级别
- 显示该路径下的具体HTTP请求
- 点击可查看请求和响应详情

实战技巧：

技巧1：快速发现敏感接口
在站点地图中，重点检查以下路径模式：
- /api/ - API接口目录
- /admin/ - 管理后台
- /debug/ - 调试接口
- /config/ - 配置文件
- /backup/ - 备份文件
- /test/ - 测试页面
- /.git/ - 版本控制泄露
- /.env - 环境配置文件

技巧2：利用Content-Type筛选接口
在站点地图中，可以按响应的Content-Type筛选：
- application/json - JSON API接口
- application/xml - XML接口
- text/xml - SOAP接口

5.2 目标范围设置

Target -> Scope 选项卡用于配置测试范围，限定Burp的操作目标。

Scope配置的重要性：
- 控制扫描范围，避免测试越界目标
- 提高Intruder等模块的效率
- 配合Proxy过滤，只记录目标范围内的请求
- 防止误操作非目标域名

Scope配置步骤：

步骤1：打开Scope设置
- Target -> Scope -> Add

步骤2：添加目标范围
- 添加单个URL: https://target.example.com
- 添加通配符匹配: https://*.example.com
- 添加路径前缀: https://target.example.com/api/
- 添加正则匹配: ^https://target\.example\.com/(api|admin)/

步骤3：配置Scope过滤选项
- Include in scope：包含在范围内的目标
- Exclude from scope：从范围内排除的目标

步骤4：在Proxy中启用Scope过滤
- Proxy -> Options -> 勾选"And only in-scope items"
- Proxy -> HTTP history -> 过滤栏勾选"Show only in-scope items"

【注意】Scope设置不影响已有的HTTP历史记录，只影响新产生的请求。
如果需要清除历史记录中的非目标请求，可以右键选择"Delete items"。

5.3 目标信息汇总

Target -> Site map -> 右键站点 -> "Engagement tools"

Burp提供了一系列 Engagement tools 用于目标分析：

工具1：Find comments
- 搜索目标站点所有页面中的HTML注释
- 可发现隐藏的开发信息、测试账号、内部接口等

工具2：Find scripts
- 查找目标站点引用的所有JavaScript文件
- 有助于发现隐藏的API接口和业务逻辑

工具3：Find reference
- 查找目标站点中的外部链接和引用
- 发现关联系统和子域名

工具4：Analyze target
- 统计目标站点的各类信息
- 包括静态/动态URL数量、参数数量等
- 输出详细的统计分析报告

工具5：Discover content
- 对目标站点进行目录爆破
- 使用内置字典和自定义字典
- 发现隐藏目录和文件

六、Scanner模块详解

Scanner模块是Burp Suite专业版的核心功能，支持主动扫描和被动扫描，
能够自动发现Web应用中的安全漏洞。

6.1 主动扫描

主动扫描（Active Scan）会向目标发送大量探测请求，用于发现注入类
漏洞、逻辑漏洞等。

主动扫描的触发方式：

方式1：从Proxy历史记录发起
- 右键HTTP历史记录中的请求
- 选择"Do active scan"

方式2：从Repeater发起
- 在Repeater中右键
- 选择"Do active scan"

方式3：从Target站点地图发起
- 右键目标URL或目录
- 选择"Actively scan this host"或"Actively scan this branch"

方式4：批量扫描
- Dashboard -> New scan -> Active scan
- 选择目标URL列表

主动扫描配置选项：

| 配置项 | 说明 |
|-----------------------|-------------------------------------------|
| Scan type | Crawl and audit / Crawl only / Audit only |
| URL scope | 在范围内 / 自定义URL列表 |
| Crawl configuration | 爬虫深度、最大URL数、是否提交表单等 |
| Audit configuration | 审计策略、并发数、超时设置等 |
| Application login | 配置登录凭据用于扫描需要认证的页面 |

扫描策略配置详解：

Dashboard -> New scan -> Audit configuration -> Check Groups

Burp内置了多个审计检查组：

检查组1：Injection vulnerabilities（注入漏洞检查）
- SQL注入（包括盲注、错误注入、时间盲注等）
- 操作系统命令注入
- LDAP注入
- XML/SOAP注入
- 表达式语言注入
- 模板注入（SSTI）
- HTTP请求走私

检查组2：Input handling（输入处理检查）
- 跨站脚本攻击（XSS，包括反射型、存储型、DOM型）
- HTTP响应头注入
- 开放重定向
- 路径遍历
- HTTP请求拆分

检查组3：Server-side vulnerabilities（服务端漏洞检查）
- 服务器端请求伪造（SSRF）
- XML外部实体注入（XXE）
- 不安全的反序列化
- 文件上传漏洞

检查组4：Client-side vulnerabilities（客户端漏洞检查）
- DOM型XSS
- 开放重定向
- Clickjacking
- Content Security Policy绕过

检查组5：Authentication and session（认证与会话检查）
- 认证绕过
- 会话固定
- 会话令牌预测
- 密码强度策略

检查组6：Business logic（业务逻辑检查）
- 并发问题
- 价格篡改
- 工作流绕过

检查组7：Miscellaneous checks（杂项检查）
- 信息泄露
- 安全配置错误
- 不安全的HTTP头
- SSL/TLS配置问题

【提示】根据测试需求，可以选择性地启用或禁用检查组。例如，在只需要
测试注入漏洞时，可以禁用其他检查组以提高扫描速度。

6.2 被动扫描

被动扫描（Passive Scan）在正常浏览流量经过Burp代理时自动执行，不会
向目标发送额外的探测请求。

被动扫描的优势：
- 零额外流量，不会对目标造成负载
- 实时分析，浏览即扫描
- 不会触发WAF告警
- 适合在生产环境中使用

被动扫描覆盖的漏洞类型：
- 信息泄露（错误消息、调试信息、源代码）
- 不安全的Cookie设置（缺少HttpOnly/Secure/SameSite属性）
- 缺失的安全响应头
- 敏感信息在HTML注释中泄露
- 密码字段的自动完成功能
- 表单字段类型与输入验证不匹配

被动扫描配置：
- Dashboard -> Passive scanning
- 可以配置被动扫描的检查项和严重性级别阈值

6.3 扫描结果分析

扫描完成后，在Dashboard或Target -> Issues选项卡中查看发现的漏洞。

漏洞信息展示：
- Severity（严重性）：High / Medium / Low / Information
- Confidence（置信度）：Certain / Firm / Tentative
- Issue detail：漏洞详细描述
- Issue background：漏洞背景知识
- Remediation detail：修复建议
- References：参考链接
- Request/Response：触发漏洞的具体请求和响应

【提示】扫描结果中的漏洞严重性级别仅供参考，需要人工验证确认。
有些误报需要结合业务逻辑判断。建议对High级别的漏洞逐一验证。

6.4 漏洞验证

对于扫描器发现的漏洞，需要进行人工验证确认其真实性。

验证方法：

方法1：使用Repeater重放请求
- 右键漏洞条目
- 选择"Send to Repeater"
- 在Repeater中修改参数重新发送请求
- 观察响应确认漏洞是否存在

方法2：检查完整的请求和响应
- 查看漏洞条目中的Request和Response标签页
- 分析payload和响应内容
- 确认漏洞是否被成功利用

方法3：对比正常请求和异常请求
- 将漏洞请求与正常请求发送到Comparer
- 对比两者差异，确认漏洞触发条件

七、Intruder模块详解

Intruder模块是Burp Suite最强大的暴力破解和参数模糊测试工具，支持
四种攻击类型，能够应对各种复杂的安全测试场景。

7.1 四种攻击类型详解

Intruder支持以下四种攻击类型：

攻击类型1：Sniper（狙击手模式）
- 将一个payload列表依次填入每个位置
- 如果有2个位置，每次只攻击一个位置
- 其他位置保持原值不变
- 总请求数 = 位置数 × payload数量

攻击类型2：Battering Ram（攻城锤模式）
- 所有位置使用相同的payload列表
- 每次请求所有位置使用相同的payload值
- 总请求数 = payload数量

攻击类型3：Pitchfork（叉子模式）
- 每个位置使用不同的payload列表
- 多个位置同步前进，即第N个请求使用各列表的第N个值
- 总请求数 = 最短payload列表的长度

攻击类型4：Cluster Bomb（集束炸弹模式）
- 每个位置使用不同的payload列表
- 对所有payload组合进行笛卡尔积排列
- 总请求数 = payload列表1长度 × payload列表2长度 × ...

四种攻击类型对比表：

| 攻击类型 | Payload列表数量 | 位置间关系 | 适用场景 | 总请求数公式 |
|---------------|----------------|--------------|-------------------|------------------------|
| Sniper | 1个 | 独立逐个测试 | 单参数模糊测试 | 位置数 × payload数 |
| Battering Ram | 1个 | 同步相同值 | 多参数同值测试 | payload数 |
| Pitchfork | 每位置1个 | 同步不同值 | 多参数对应值测试 | 最短列表长度 |
| Cluster Bomb | 每位置1个 | 全组合排列 | 多参数组合测试 | 各列表长度之积 |

7.2 实际攻击场景示例

场景1：Sniper模式 - 单参数SQL注入测试

目标：测试用户ID参数是否存在SQL注入
原始请求：
```
POST /api/user HTTP/1.1
Host: target.example.com
Content-Type: application/json

{"user_id": "1"}
```

配置步骤：
步骤1：将请求发送到Intruder（右键 -> Send to Intruder）
步骤2：在Positions选项卡中清除所有自动标记
步骤3：手动选择payload位置
- 标记位置：§1§（即payload为1的位置）
- 最终请求体：{"user_id": "§1§"}

步骤4：在Payloads选项卡中加载SQL注入payload列表

部分SQL注入测试payload列表：
```
'
"
\
'
OR'1'='1
' OR '1'='1' --
' OR '1'='1' #
' UNION SELECT NULL --
' UNION SELECT NULL,NULL --
' UNION SELECT NULL,NULL,NULL --
'; WAITFOR DELAY '0:0:5' --
' AND SLEEP(5) --
' AND (SELECT * FROM (SELECT(SLEEP(5)))a) --
1' AND EXTRACTVALUE(1, CONCAT(0x7e, (SELECT VERSION())))
```

步骤5：在Options选项卡中配置匹配规则
- Grep - Match：添加关键词 "error"、"SQL"、"syntax"
- 可以快速定位出现SQL错误信息的响应

步骤6：点击"Start attack"开始攻击
步骤7：分析结果
- 按Length（响应长度）排序，查找异常长度的响应
- 按Status code排序，查找返回非200状态码的请求
- 查看包含错误关键词的响应

场景2：Battering Ram模式 - Cookie会话固定测试

目标：测试多个接口是否使用相同的Session Token
配置：将Session Token作为payload，所有位置使用相同值
通过Battering Ram模式快速验证Session共享问题。

场景3：Pitchfork模式 - 用户名密码批量验证

目标：使用已知的用户名和密码对列表进行登录测试
原始请求：
```
POST /login HTTP/1.1
Host: target.example.com
Content-Type: application/x-www-form-urlencoded

username=admin&password=admin123
```

配置步骤：
步骤1：选择攻击类型为Pitchfork
步骤2：设置两个payload位置
- §admin§（用户名）
- §admin123§（密码）

步骤3：Payload Set 1加载用户名列表
```
admin
administrator
root
test
user
guest
support
```

步骤4：Payload Set 2加载密码列表
- 与用户名列表一一对应

步骤5：配置Options
- 添加Grep - Match关键词 "login failed"、"invalid"、"error"
- 设置Request Engine的并发数和延迟

步骤6：开始攻击并分析结果

【注意】使用Intruder进行密码爆破时，请注意目标是否有以下防护措施：
- 账号锁定机制
- 验证码
- 频率限制
如果存在以上防护，需要调整攻击策略或间隔时间。

场景4：Cluster Bomb模式 - 多参数组合模糊测试

目标：测试搜索接口的两个参数的交互行为
原始请求：
```
GET /search?q=test&sort=asc HTTP/1.1
Host: target.example.com
```

配置步骤：
步骤1：选择攻击类型为Cluster Bomb
步骤2：设置两个payload位置
- §test§（搜索关键词q参数）
- §asc§（排序sort参数）

步骤3：Payload Set 1 - 关键词列表
```
test
admin
test' OR 1=1 --
../../etc/passwd
<script>alert(1)</script>
```

步骤4：Payload Set 2 - 排序参数列表
```
asc
desc
id; DROP TABLE
1 UNION SELECT 1
```

步骤5：开始攻击，生成 5 × 4 = 20 个请求

7.3 Payload类型与处理

Intruder支持多种Payload类型和处理方式：

Payload类型：

| 类型 | 说明 |
|---------------------|------------------------------------------|
| Simple list | 简单列表，手动输入或从文件加载 |
| Runtime file | 运行时文件，从文件逐行读取payload |
| Numbers | 数字序列，指定范围和步长 |
| Brute forcer | 暴力破解，指定字符集和长度范围 |
| Null payloads | 空payload，发送固定字符串 |
| Character blocks | 字符块，用于缓冲区溢出测试 |
| Character substitution | 字符替换，如大小写、编码替换 |
| Case modification | 大小写变换 |
| Recursive grep | 递归提取，从响应中提取下一次的payload |
| Illegal Unicode | 非法Unicode字符 |
| Character frobber | 字符逐位变换 |
| Bit flipper | 位翻转 |

Payload Processing规则：

可以对payload列表中的每个值进行额外处理：

规则1：Add prefix（添加前缀）
- 在payload前添加指定字符串
- 例：prefix为"，payload为"admin"，结果为"admin"

规则2：Add suffix（添加后缀）
- 在payload后添加指定字符串

规则3：Match/replace（匹配替换）
- 对payload执行正则匹配并替换

规则4：Base64-encode（Base64编码）
- 将payload进行Base64编码

规则5：URL-encode（URL编码）
- 对payload进行URL编码

规则6：Hash（哈希计算）
- 对payload进行MD5/SHA1/SHA256等哈希

规则7：Case modification（大小写变换）
- 转换为大小写、首字母大写等

Payload Encoding配置：

在Options选项卡中，可以配置URL编码字符集：
- 默认编码字符集包括：空格、&、=、+、#等特殊字符
- 可以自定义需要编码的字符
- 可以选择对整个payload进行编码还是仅对特殊字符编码

7.4 Intruder高级配置

Options选项卡中的关键配置项：

| 配置区域 | 配置项 | 说明 |
|-------------------|---------------------------|-------------------------------|
| Request Engine | Number of threads | 并发线程数（建议10-20） |
| Request Engine | Number of retries | 失败重试次数（建议3次） |
| Request Engine | Pause before retry | 重试前等待时间 |
| Request Engine | Max concurrent requests | 最大并发请求数 |
| Redirects | Follow redirections | 是否跟随重定向（最多5次） |
| Redirects | Process cookies in redirects | 重定向时是否处理Cookie |
| Speed | Delay between requests | 请求间隔时间（毫秒） |
| Speed | Jitter | 随机抖动时间（模拟人类行为） |
| Grep - Match | 添加匹配关键词 | 在响应中搜索特定字符串 |
| Grep - Extract | 正则提取响应内容 | 提取Token、错误码等 |
| Grep - Extract | 定义提取的正则表达式 | 自动提取到结果表格中 |

Grep - Extract 实战配置示例：

场景：提取CSRF Token用于后续请求
- 添加Grep - Extract规则
- 设置正则表达式：name="csrf_token" value="([^"]*)"
- 结果表格中将新增一列显示提取的Token值

八、Repeater模块详解

Repeater模块允许安全测试人员对HTTP请求进行手动修改和重发，是漏洞
验证和利用过程中最常用的工具。

8.1 请求重放与修改

基本操作流程：

步骤1：发送请求到Repeater
- 在Proxy历史记录中右键 -> Send to Repeater
- 或使用快捷键 Ctrl+R

步骤2：查看请求
- 左侧面板显示完整的HTTP请求
- 可以修改请求的任何部分（请求行、请求头、请求体）

步骤3：发送请求
- 点击"Send"按钮发送修改后的请求
- 右侧面板显示服务器响应

步骤4：分析响应
- 查看响应状态码、响应头、响应体
- 使用Hex/Render/Render（浏览器视图）等模式查看

Repeater面板功能详解：

| 区域 | 功能 |
|---------------|-----------------------------------------|
| 请求面板 | 显示和编辑HTTP请求 |
| 响应面板 | 显示服务器响应 |
| Target | 显示当前请求的目标主机和端口 |
| 标签页 | 支持多个请求标签页，每个标签独立工作 |
| 视图模式 | Pretty / Raw / Hex / 还可以查看参数 |

8.2 JSON请求处理

现代Web应用大量使用JSON格式的API请求。Repeater对JSON请求有良好的
支持。

JSON请求测试示例：

原始请求：
```
POST /api/v1/user/profile HTTP/1.1
Host: api.target.example.com
Content-Type: application/json
Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...
Content-Length: 85

{
"user_id": 1001,
"action": "update",
"data": {
"name": "John",
"email": "john@example.com",
"role": "user"
}
}
```

测试场景1：越权测试 - 修改role字段
将请求中的 "role": "user" 修改为 "role": "admin"
发送请求观察是否成功提权。

测试场景2：IDOR测试 - 修改user_id
将 "user_id": 1001 修改为其他用户ID
观察是否可以访问其他用户的数据。

测试场景3：类型混淆测试
将 "user_id": 1001 修改为以下值：
```
"user_id": "1001"
"user_id": 1001.0
"user_id": true
"user_id": {"$gt": 0}
"user_id": [1001, 1002, 1003]
"user_id": null
```

测试场景4：JSON注入测试
在JSON值中注入特殊字符：
```
{"name": "John\", \"role\": \"admin"}
{"name": "John\", \"role\": \"admin//"}
```

8.3 XML请求处理

SOAP Web服务和其他旧式系统常用XML格式请求。

XML请求测试示例：

原始请求：
```
POST /api/service HTTP/1.1
Host: target.example.com
Content-Type: text/xml

<?xml version="1.0" encoding="UTF-8"?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<GetUser>
<userId>1001</userId>
</GetUser>
</soap:Body>
</soap:Envelope>
```

测试场景1：XXE注入测试
将XML内容修改为：
```
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE foo [
<!ENTITY xxe SYSTEM "file:///etc/passwd">
]>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<GetUser>
<userId>&xxe;</userId>
</GetUser>
</soap:Body>
</soap:Envelope>
```

测试场景2：XML注入测试
在XML标签值中注入XML标签：
```
<userId>1001</userId><isAdmin>true</isAdmin>
```

8.4 Repeater高级功能

功能1：请求标签页管理
- 支持创建多个标签页
- 每个标签页独立保存请求状态
- 可以对标签页重命名和分组

功能2：Inspector面板
- 自动解析请求参数
- 支持快速编辑请求参数
- 显示Cookie、Query参数、Body参数

功能3：请求历史
- 每个请求的修改历史被保存
- 可以回溯到之前的请求版本
- 方便对比不同payload的效果

功能4：右键菜单功能
- Send to Intruder：发送到Intruder进行批量测试
- Send to Repeater（新标签）：在新的Repeater标签中打开
- Change request method：快速切换GET/POST
- Convert selection：各种编码/解码转换
- URL-encode as you type：输入时自动URL编码

【提示】在Repeater中修改请求时，注意Content-Length的值。Burp会自动
更新Content-Length，但如果手动修改了请求体长度，请确认Content-Length
与实际请求体长度一致。

九、Sequencer模块详解

Sequencer模块用于分析随机数据的统计特性，主要用于评估Token、Session
ID等敏感数据的随机性和可预测性。

9.1 随机性分析

Sequencer对采集的数据样本进行多层次的统计分析：

分析层次1：字符级分析（Character-level analysis）
- 每个字符位置的可转移性（字符转换概率）
- 字符分布的均匀性测试
- 单字符熵分析

分析层次2：双位级分析（Bit-level analysis）
- 每个比特位的分布测试
- 比特位的0/1分布比例
- 比特级熵分析

分析层次3：序列分析（Sequence analysis）
- 相邻样本之间的相关性分析
- 序列的可预测性评估
- 模式识别

9.2 Token强度评估

Token强度评估实战流程：

步骤1：采集Token样本
- 在Proxy历史记录中找到包含目标Token的响应
- 右键 -> Send to Sequencer
- 或者使用Live Capture模式

步骤2：配置采样
- 选择Token所在位置（响应头或响应体）
- 定义Token提取规则（正则表达式或直接位置）
- 设置采样数量（建议至少200个样本）

步骤3：开始采集
- 点击"Start capture"开始采集
- Burp会不断发送请求获取新的Token
- 采集足够样本后点击"Stop capture"或"Pause"

步骤4：执行分析
- 采集完成后点击"Analyze now"
- 分析完成后查看结果

步骤5：查看分析结果

分析结果包含以下关键指标：

| 指标 | 说明 | 安全标准 |
|--------------------------|-------------------------------|----------------|
| Overall result | 综合评估结果 | Pass/Fail |
| Entropy (bits) | 熵值（比特数） | >=64 bits 安全 |
| Reliability | 结果可靠性 | >=80% 较可靠 |
| Samples obtained | 采集样本数量 | >=200个 |
| Character set size | 字符集大小 | 越大越好 |
| Significance level | 显著性水平 | <1% 为正常 |

分析结果详细展示：

1. 字符级分析结果
- 每个字符位置的平均熵
- 字符分布图
- 转移概率矩阵

2. 比特级分析结果
- 每个比特位的0/1分布
- 比特位熵分布图
- 比特位独立性测试

3. 序列分析结果
- 序列相关性图
- 自相关函数（ACF）图
- 周期性检测

9.3 Token强度评估实战

场景：评估网站CSRF Token的安全性

步骤1：在登录页面找到CSRF Token
步骤2：发送包含CSRF Token的请求到Sequencer
步骤3：配置Token提取规则
- Token位置：响应体中的隐藏字段
- 提取正则：name="csrf_token" value="([a-f0-9]{32})"

步骤4：采集500个样本
步骤5：执行分析

评估标准：
- 熵值 >= 64 bits：Token强度充足
- 熵值 32-64 bits：Token强度中等，需要改进
- 熵值 < 32 bits：Token强度不足，存在被预测的风险

【提示】Sequencer需要足够多的样本才能提供可靠的统计结果。建议
至少采集500个样本进行分析。样本数量越多，结果越准确。

十、Decoder与Comparer模块详解

10.1 Decoder模块

Decoder模块提供多种编码格式之间的转换功能。

支持的编码格式：

| 编码格式 | 解码格式 | 说明 |
|-------------------|-------------------|--------------------------|
| URL | URL decode | URL编码/解码 |
| Base64 | Base64 decode | Base64编码/解码 |
| HTML | HTML decode | HTML实体编码/解码 |
| Hex | Hex decode | 十六进制编码/解码 |
| ASCII Hex | ASCII Hex decode | ASCII十六进制编码 |
| gzip | gzip decode | gzip压缩/解压 |
| URL-encode all | - | URL全字符编码 |

Decoder使用方法：

方法1：直接输入
- 在Decoder面板输入待编码/解码的数据
- 选择"Encode as"或"Decode as"
- 选择目标编码格式

方法2：从其他模块发送
- 在任何模块中选中数据
- 右键 -> Send to Decoder
- 在Decoder中选择编码/解码操作

实战示例1：解码Base64编码的JWT
```
输入：eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9
操作：Decode as -> Base64
输出：{"alg":"HS256","typ":"JWT"}
```

实战示例2：解码URL编码的参数
```
输入：%3Cscript%3Ealert(1)%3C%2Fscript%3E
操作：Decode as -> URL
输出：<script>alert(1)</script>
```

实战示例3：十六进制转ASCII
```
输入：48656c6c6f20576f726c64
操作：Decode as -> Hex
输出：Hello World
```

实战示例4：多重解码
某些数据可能经过多重编码，Decoder支持连续应用多个解码操作。
例如：先Base64解码，再URL解码。
- 输入数据 -> Decode as Base64 -> 结果选中 -> Decode as URL -> 最终结果

【提示】Decoder还支持Hash计算功能，可以对输入数据计算MD5、SHA1、
SHA256等哈希值。

10.2 Comparer模块

Comparer模块用于比较两个HTTP请求或响应的差异。

使用场景：
- 对比正常请求和异常请求的差异
- 对比不同用户的响应内容（发现越权数据）
- 对比修改前后的响应变化

Comparer使用方法：

步骤1：发送数据到Comparer
- 在任何模块中右键 -> Send to Comparer
- 需要发送两份数据（分别作为对比的两个端）

步骤2：选择对比模式
- Words模式：按单词级别对比
- Bytes模式：按字节级别对比

步骤3：查看对比结果
- 差异部分以颜色高亮显示
- 红色表示仅在第一份数据中存在
- 绿色表示仅在第二份数据中存在

Comparer对比示例：

场景：对比两个用户的个人信息API响应

用户A的响应发送到Comparer（1），用户B的响应发送到Comparer（2）。

选择Words模式对比，结果可能显示：
- 用户A有额外字段："credit_card": "****-****-****-1234"
- 用户B的role字段值为"user"，而用户A为"admin"

通过Comparer可以快速发现响应内容的差异，辅助发现越权漏洞。

十一、Burp插件开发实战

Burp Suite的强大之处在于其可扩展性。用户可以使用Java或Python
开发自定义插件（Extender），扩展Burp的功能。

11.1 Burp Extender API基础

Burp提供了两套API：

旧版API（Legacy API）：
- 基于IBurpExtender接口
- 使用Jython（Python 2）或Java开发
- 逐步被淘汰

新版API（Montoya API）：
- 基于BurpExtension接口
- 使用Java开发（支持Java 11+）
- 推荐使用的新API

主要API接口说明：

| 接口名称 | 说明 |
|------------------------|-------------------------------------|
| IBurpExtender | 扩展入口接口（旧版API） |
| BurpExtension | 扩展入口接口（新版Montoya API） |
| IProxyListener | 代理事件监听 |
| IHttpListener | HTTP请求/响应监听 |
| IScannerListener | 扫描结果监听 |
| IExtensionStateListener| 扩展状态监听 |
| ITab | 自定义UI标签页 |
| IContextMenuFactory | 右键菜单扩展 |
| IMessageEditorTab | 自定义消息编辑器标签页 |
| IHttpRequestResponse | HTTP请求响应对象 |

11.2 Java插件开发实战（Montoya API）

开发环境准备：

步骤1：安装JDK 17+
步骤2：安装Maven
步骤3：创建Maven项目

pom.xml配置文件：
```xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>

<groupId>com.security</groupId>
<artifactId>custom-burp-extension</artifactId>
<version>1.0.0</version>
<packaging>jar</packaging>

<properties>
<maven.compiler.source>17</maven.compiler.source>
<maven.compiler.target>17</maven.compiler.target>
</properties>

<dependencies>
<dependency>
<groupId>net.portswigger.burp.extensions</groupId>
<artifactId>montoya-api</artifactId>
<version>2023.12.1</version>
</dependency>
</dependencies>

<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-assembly-plugin</artifactId>
<version>3.4.2</version>
<configuration>
<descriptorRefs>
<descriptorRef>jar-with-dependencies</descriptorRef>
</descriptorRefs>
<archive>
<manifest>
<mainClass>com.security.CustomExtension</mainClass>
</manifest>
</archive>
</configuration>
<executions>
<execution>
<phase>package</phase>
<goals>
<goal>single</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
</project>
```

Java插件完整代码示例：自定义请求日志记录插件

```java
package com.security;

import burp.api.montoya.MontoyaApi;
import burp.api.montoya.BurpExtension;
import burp.api.montoya.core.ByteArray;
import burp.api.montoya.http.message.requests.HttpRequest;
import burp.api.montoya.http.message.responses.HttpResponse;
import burp.api.montoya.proxy.http.HttpRequestResponse;
import burp.api.montoya.proxy.http.ProxyRequestHandler;
import burp.api.montoya.proxy.http.ProxyRequestReceivedAction;
import burp.api.montoya.proxy.http.ProxyRequestToBeSentAction;
import burp.api.montoya.proxy.http.ProxyResponseHandler;
import burp.api.montoya.proxy.http.ProxyResponseReceivedAction;
import burp.api.montoya.proxy.http.ProxyResponseToBeSentAction;
import burp.api.montoya.ui.contextmenu.ContextMenuEvent;
import burp.api.montoya.ui.contextmenu.ContextMenuItemsProvider;

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.List;

public class CustomExtension implements BurpExtension, ProxyRequestHandler {

private MontoyaApi api;
private JTextArea logArea;
private int requestCount = 0;
private final List<String> loggedRequests = new ArrayList<>();

@Override
public void initialize(MontoyaApi api) {
this.api = api;

// 设置扩展名称
api.extension().setName("Custom Request Logger");

// 注册代理请求处理器
api.proxy().registerRequestHandler(this);

// 创建自定义UI标签页
createCustomTab();

// 注册右键菜单
api.userInterface().registerContextMenuItemsProvider(
new CustomContextMenuProvider(api, this)
);

// 输出日志到Burp的控制台
api.logging().logToOutput("[Custom Extension] 初始化成功！");
api.logging().logToOutput("[Custom Extension] 请求日志记录器已启动");
}

// 创建自定义UI标签页
private void createCustomTab() {
JPanel mainPanel = new JPanel(new BorderLayout());

// 日志显示区域
logArea = new JTextArea();
logArea.setEditable(false);
logArea.setFont(new Font("Monospaced", Font.PLAIN, 12));
JScrollPane scrollPane = new JScrollPane(logArea);

// 工具栏
JToolBar toolBar = new JToolBar();
JButton clearButton = new JButton("清空日志");
JButton exportButton = new JButton("导出日志");
JButton searchButton = new JButton("搜索");

clearButton.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
logArea.setText("");
loggedRequests.clear();
requestCount = 0;
}
});

exportButton.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
JFileChooser fileChooser = new JFileChooser();
if (fileChooser.showSaveDialog(mainPanel) == JFileChooser.APPROVE_OPTION) {
// 导出逻辑省略，实际应用中实现文件保存
api.logging().logToOutput("日志导出功能触发");
}
}
});

searchButton.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
String keyword = JOptionPane.showInputDialog(mainPanel, "输入搜索关键词:");
if (keyword != null && !keyword.isEmpty()) {
searchInLog(keyword);
}
}
});

toolBar.add(clearButton);
toolBar.add(exportButton);
toolBar.add(searchButton);

// 状态栏
JLabel statusLabel = new JLabel(" 就绪 - 等待请求...");

mainPanel.add(toolBar, BorderLayout.NORTH);
mainPanel.add(scrollPane, BorderLayout.CENTER);
mainPanel.add(statusLabel, BorderLayout.SOUTH);

// 注册UI标签页
api.userInterface().registerSuiteTab("Request Logger", mainPanel);
}

// 在日志中搜索关键词
private void searchInLog(String keyword) {
StringBuilder results = new StringBuilder();
results.append("=== 搜索结果: ").append(keyword).append(" ===\n\n");

for (String entry : loggedRequests) {
if (entry.toLowerCase().contains(keyword.toLowerCase())) {
results.append(entry).append("\n---\n");
}
}

if (results.toString().equals("=== 搜索结果: " + keyword + " ===\n\n")) {
results.append("未找到匹配结果");
}

JOptionPane.showMessageDialog(null, results.toString(),
"搜索结果", JOptionPane.INFORMATION_MESSAGE);
}

// 处理接收到的代理请求
@Override
public ProxyRequestReceivedAction handleRequestReceived(
HttpRequestResponse requestResponse) {

HttpRequest request = requestResponse.request();

requestCount++;
String timestamp = LocalDateTime.now().format(
DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")
);

StringBuilder logEntry = new StringBuilder();
logEntry.append("[").append(timestamp).append("] ");
logEntry.append("Request #").append(requestCount).append("\n");
logEntry.append("Method: ").append(request.method()).append("\n");
logEntry.append("URL: ").append(request.url()).append("\n");
logEntry.append("Host: ").append(request.headerValue("Host")).append("\n");

// 记录请求头
logEntry.append("Headers:\n");
request.headers().forEach(header -> {
logEntry.append(" ").append(header.name())
.append(": ").append(header.value()).append("\n");
});

// 记录请求体（如果有）
if (request.body().length() > 0) {
logEntry.append("Body:\n");
logEntry.append(request.bodyToString()).append("\n");
}

logEntry.append("========================================\n");

// 添加到日志区域
SwingUtilities.invokeLater(() -> {
logArea.append(logEntry.toString());
});

loggedRequests.add(logEntry.toString());

return ProxyRequestReceivedAction.continueWith(requestResponse);
}

@Override
public ProxyRequestToBeSentAction handleRequestToBeSent(
HttpRequestResponse requestResponse) {
return ProxyRequestToBeSentAction.continueWith(requestResponse);
}

// 获取请求计数
public int getRequestCount() {
return requestCount;
}

// 添加自定义日志条目
public void addCustomLogEntry(String entry) {
String timestamp = LocalDateTime.now().format(
DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")
);
String logEntry = "[" + timestamp + "] [手动] " + entry + "\n";
SwingUtilities.invokeLater(() -> {
logArea.append(logEntry);
});
loggedRequests.add(logEntry);
}
}

// 自定义右键菜单提供者
class CustomContextMenuProvider implements ContextMenuItemsProvider {

private final MontoyaApi api;
private final CustomExtension extension;

public CustomContextMenuProvider(MontoyaApi api, CustomExtension extension) {
this.api = api;
this.extension = extension;
}

@Override
public List<Component> provideMenuItems(ContextMenuEvent event) {
List<Component> menuItems = new ArrayList<>();

JMenuItem addToLogItem = new JMenuItem("添加到自定义日志");

addToLogItem.addActionListener(e -> {
if (event.messageEditorRequestResponse().isPresent()) {
String requestInfo = event.messageEditorRequestResponse()
.get().requestResponse().request().url();
extension.addCustomLogEntry("右键添加: " + requestInfo);
}
});

menuItems.add(addToLogItem);
return menuItems;
}
}
```

编译与打包：
```
# 在项目根目录执行
mvn clean package -DskipTests

# 生成的JAR文件位于 target/ 目录下
# 文件名格式：custom-burp-extension-1.0.0-jar-with-dependencies.jar
```

在Burp中加载插件：
步骤1：Burp -> Extensions -> Installed -> Add
步骤2：Extension type 选择 Java
步骤3：选择编译好的JAR文件
步骤4：点击Next加载插件
步骤5：查看Output和Errors面板确认加载成功

11.3 Python插件开发实战

Burp支持通过Jython使用Python开发插件。需要安装Jython环境。

Jython环境配置：

步骤1：下载Jython
- 访问 https://www.jython.org/download.html
- 下载 Jython 2.7 Standalone版本（jython-standalone-2.7.3.jar）

步骤2：在Burp中配置Jython
- Extensions -> Options -> Python Environment
- 选择Jython的JAR文件路径

步骤3：创建Python插件文件

Python插件完整代码示例：敏感信息扫描插件

```python
# -*- coding: utf-8 -*-
# 文件名: sensitive_info_scanner.py
# 功能: 被动扫描HTTP响应中的敏感信息泄露

from burp import IBurpExtender, IScannerCheck, IScanIssue
from java.net import URL
import re

# 敏感信息正则模式列表
SENSITIVE_PATTERNS = [
{
"name": "Email Address",
"pattern": r"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b",
"severity": "Low"
},
{
"name": "Phone Number (CN)",
"pattern": r"\b1[3-9]\d{9}\b",
"severity": "Low"
},
{
"name": "ID Card Number (CN)",
"pattern": r"\b\d{17}[\dXx]\b",
"severity": "High"
},
{
"name": "Credit Card Number",
"pattern": r"\b(?:\d[ -]*?){13,19}\b",
"severity": "High"
},
{
"name": "AWS Access Key",
"pattern": r"\bAKIA[0-9A-Z]{16}\b",
"severity": "High"
},
{
"name": "AWS Secret Key",
"pattern": r"\b(?<![A-Za-z0-9/+])[A-Za-z0-9/+]{40}(?![A-Za-z0-9/+])\b",
"severity": "High"
},
{
"name": "GitHub Token",
"pattern": r"\bghp_[A-Za-z0-9]{36}\b",
"severity": "High"
},
{
"name": "Slack Token",
"pattern": r"\bxox[baprs]-[A-Za-z0-9-]{10,}\b",
"severity": "High"
},
{
"name": "Private IP Address",
"pattern": r"\b(?:10|172\.(?:1[6-9]|2\d|3[01])|192\.168)\.\d{1,3}\.\d{1,3}\b",
"severity": "Information"
},
{
"name": "JWT Token",
"pattern": r"\beyJ[A-Za-z0-9_-]+\.eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b",
"severity": "Medium"
},
{
"name": "Database Connection String",
"pattern": r"(?:mysql|postgresql|mongodb)://[^\s<>'\"]+",
"severity": "High"
},
{
"name": "Stack Trace",
"pattern": r"(?:at\s+\w+\.\w+$[^)]+$|Traceback $most recent call last$)",
"severity": "Medium"
},
{
"name": "Internal Server Error",
"pattern": r"(?:Internal Server Error|StackOverflowException|NullPointerException)",
"severity": "Medium"
}
]

class BurpExtender(IBurpExtender, IScannerCheck):

def registerExtenderCallbacks(self, callbacks):
# 保存回调对象
self._callbacks = callbacks

# 设置扩展名称
callbacks.setExtensionName("Sensitive Info Scanner")

# 注册被动扫描检查器
callbacks.registerScannerCheck(self)

# 获取辅助对象
self._helpers = callbacks.getHelpers()

# 输出加载信息
print("[Sensitive Info Scanner] 插件加载成功")
print("[Sensitive Info Scanner] 已注册 %d 个敏感信息检测规则" % len(SENSITIVE_PATTERNS))

return

def doPassiveScan(self, baseRequestResponse):
"""
被动扫描：分析HTTP响应中的敏感信息
"""
issues = []

# 获取响应内容
responseInfo = self._helpers.analyzeResponse(
baseRequestResponse.getResponse()
)

if responseInfo is None:
return issues

# 提取响应体
responseBytes = baseRequestResponse.getResponse()
if responseBytes is None:
return issues

responseStr = self._helpers.bytesToString(responseBytes)

# 获取响应头
headers = responseInfo.getHeaders()
headersStr = "\n".join(headers)

# 合并响应头和响应体进行扫描
fullResponse = headersStr + "\n" + responseStr

# 遍历所有敏感信息模式
for pattern_info in SENSITIVE_PATTERNS:
matches = re.finditer(pattern_info["pattern"], fullResponse)

match_count = 0
found_values = []

for match in matches:
match_count += 1
matched_text = match.group()
# 截断过长的匹配结果
if len(matched_text) > 100:
matched_text = matched_text[:100] + "..."
found_values.append(matched_text)

# 限制最大匹配数量
if match_count >= 5:
break

if match_count > 0:
# 创建扫描问题
issue = SensitiveInfoIssue(
self._callbacks,
baseRequestResponse,
pattern_info["name"],
pattern_info["severity"],
found_values
)
issues.append(issue)

return issues

def doActiveScan(self, baseRequestResponse, insertionPoint):
# 主动扫描不做处理
return None

def consolidateDuplicateIssues(self, existingIssue, newIssue):
# 如果是同一个类型的问题，保留已有的
if existingIssue.getIssueName() == newIssue.getIssueName():
return -1 # 保留已有问题
return 0

class SensitiveInfoIssue(IScanIssue):
"""
自定义扫描问题类
"""

def __init__(self, callbacks, requestResponse, issueName, severity, foundValues):
self._callbacks = callbacks
self._requestResponse = requestResponse
self._issueName = issueName
self._severity = severity
self._foundValues = foundValues

# 获取URL
url = self._callbacks.getHelpers().analyzeResponse(
requestResponse.getResponse()
).getUrl()
self._url = url

def getUrl(self):
return self._url

def getIssueName(self):
return "Sensitive Information: " + self._issueName

def getIssueType(self):
# 0x04000000 表示信息泄露类型
return 0x04000000

def getSeverity(self):
severity_map = {
"High": "High",
"Medium": "Medium",
"Low": "Low",
"Information": "Information"
}
return severity_map.get(self._severity, "Information")

def getConfidence(self):
return "Firm"

def getIssueBackground(self):
return ("该响应中包含敏感信息泄露。敏感信息泄露可能导致用户隐私泄露、"
"凭据被窃取、内部架构暴露等安全风险。")

def getIssueDetail(self):
detail = "在HTTP响应中检测到以下敏感信息:\n\n"
for value in self._foundValues:
detail += "- %s\n" % value
detail += "\n建议检查这些信息是否应该出现在响应中。"
return detail

def getRemediationDetail(self):
return ("1. 检查响应内容，确认敏感信息是否需要脱敏处理。\n"
"2. 避免在客户端响应中包含服务器端敏感数据。\n"
"3. 对日志、错误消息等进行脱敏处理。\n"
"4. 定期审计API响应内容，确保不泄露敏感信息。")

def getIssueBackground(self):
return None

def getRemediationBackground(self):
return None

def getHttpMessages(self):
return [self._requestResponse]

def getHttpService(self):
return self._requestResponse.getHttpService()
```

在Burp中加载Python插件：
步骤1：Extensions -> Installed -> Add
步骤2：Extension type 选择 Python
步骤3：选择 sensitive_info_scanner.py 文件
步骤4：点击Next加载插件
步骤5：正常浏览目标网站，被动扫描自动运行

11.4 自定义Passive Scanner插件

以下是一个更完整的被动扫描插件示例，使用Montoya API（Java）开发，
用于检测HTTP响应中缺失的安全头。

```java
package com.security;

import burp.api.montoya.BurpExtension;
import burp.api.montoya.MontoyaApi;
import burp.api.montoya.scanner.AuditResult;
import burp.api.montoya.scanner.ConsolidationAction;
import burp.api.montoya.scanner.audit.insertionpoint.AuditInsertionPoint;
import burp.api.montoya.scanner.audit.issues.AuditIssue;
import burp.api.montoya.scanner.audit.issues.AuditIssueSeverity;
import burp.api.montoya.scanner.audit.issues.AuditIssueConfidence;
import burp.api.montoya.http.message.HttpRequestResponse;
import burp.api.montoya.http.message.responses.HttpResponse;
import burp.api.montoya.core.ByteArray;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.HashMap;

public class SecurityHeaderScanner implements BurpExtension {

private MontoyaApi api;

// 需要检查的安全头列表
private static final Map<String, String[]> SECURITY_HEADERS = new HashMap<>();

static {
// headerName, [expectedValue, description, severity]
SECURITY_HEADERS.put("X-Content-Type-Options",
new String[]{"nosniff", "防止MIME类型嗅探攻击", "Medium"});
SECURITY_HEADERS.put("X-Frame-Options",
new String[]{"DENY or SAMEORIGIN", "防止点击劫持攻击", "Medium"});
SECURITY_HEADERS.put("X-XSS-Protection",
new String[]{"1; mode=block", "启用浏览器XSS过滤器", "Low"});
SECURITY_HEADERS.put("Strict-Transport-Security",
new String[]{"max-age=31536000", "强制使用HTTPS", "Medium"});
SECURITY_HEADERS.put("Content-Security-Policy",
new String[]{"default-src", "内容安全策略", "Medium"});
SECURITY_HEADERS.put("Referrer-Policy",
new String[]{"no-referrer or same-origin", "控制Referrer信息泄露", "Low"});
SECURITY_HEADERS.put("Permissions-Policy",
new String[]{"各种权限控制", "控制浏览器功能权限", "Low"});
}

@Override
public void initialize(MontoyaApi api) {
this.api = api;

api.extension().setName("Security Header Scanner");

// 注册被动扫描检查器
api.scanner().registerScanCheck(new SecurityHeaderScanCheck(api));

api.logging().logToOutput("[Security Header Scanner] 插件加载成功");
api.logging().logToOutput("[Security Header Scanner] 检查 %d 个安全头",
SECURITY_HEADERS.size());
}
}
```

【注意】以上插件代码为完整可用的示例。在实际开发中，请根据Burp的
版本选择对应的API。Montoya API是新版API，推荐用于新开发。旧版
IBurpExtender接口仍可使用，但未来可能不再支持。

十二、常用BApp Store插件推荐与配置

BApp Store是Burp Suite的官方插件市场，提供了大量社区开发的扩展插件。
以下推荐最常用的高价值插件。

12.1 Active Scan++

功能：增强Burp的主动扫描能力，添加额外的漏洞检测规则。

安装：BApp Store -> 搜索 "Active Scan++" -> Install

主要功能：
- 添加了额外的注入测试payload
- 增强的XSS检测能力
- 更全面的命令注入检测
- 时间盲注检测优化

配置建议：安装后无需额外配置，自动集成到主动扫描流程中。

12.2 Authz

功能：权限测试辅助工具，用于检测越权漏洞（IDOR/水平越权/垂直越权）。

安装：BApp Store -> 搜索 "Authz" -> Install

使用方法：
步骤1：配置两组Cookie/Authorization头
- Cookie1：低权限用户A的Session
- Cookie2：高权限用户B的Session

步骤2：以用户A身份浏览目标，在Proxy历史记录中选中请求
步骤3：右键 -> Send to Authz
步骤4：在Authz面板点击"Send"
步骤5：对比两组响应
- 如果用户A的请求返回了用户B的数据，存在越权漏洞
- 如果两个响应完全相同，可能存在水平越权

12.3 Logger++

功能：增强的日志记录工具，支持多维度过滤和导出。

安装：BApp Store -> 搜索 "Logger++" -> Install

主要功能：
- 记录所有HTTP请求和响应
- 支持多列自定义显示
- 支持高级过滤表达式
- 支持导出为CSV/JSON/XML格式
- 支持Grep搜索
- 支持请求重放

配置建议：
- 在Logger++选项中配置要记录的请求字段
- 设置过滤规则排除静态资源
- 配置自动导出路径用于后续分析

12.4 HTTP Request Smuggler

功能：HTTP请求走私漏洞检测和利用工具。

安装：BApp Store -> 搜索 "HTTP Request Smuggler" -> Install

主要功能：
- 自动检测HTTP请求走私漏洞
- 支持CL.TE和TE.CL两种走私方式
- 支持自定义走私payload
- 提供请求走私利用功能

使用方法：
步骤1：在Repeater中选中目标请求
步骤2：右键 -> Send to HTTP Request Smuggler
步骤3：选择探测方式（CL.TE探测 / TE.CL探测）
步骤4：点击"Start"开始探测
步骤5：观察结果判断是否存在漏洞

【警告】HTTP请求走私测试可能对目标服务器造成影响，请在授权环境下
使用，并注意控制测试频率。

12.5 Autorize

功能：自动化越权漏洞检测工具。

安装：BApp Store -> 搜索 "Autorize" -> Install

使用方法：
步骤1：配置低权限用户的Cookie
- 在Autorize面板的Configuration中输入低权限用户的Authorization头或Cookie

步骤2：以高权限用户身份正常浏览目标
- Autorize会自动使用低权限凭据重放每个请求
- 自动对比响应，判断是否存在越权

步骤3：查看检测结果
- Bypassed（红色）：低权限用户成功访问了高权限资源，存在越权漏洞
- Enforced（绿色）：低权限用户被正确拦截，无越权
- Is Enforced???（黄色）：无法确定，需手动检查

12.6 JSON Web Tokens

功能：JWT Token的查看、解码、修改和攻击工具。

安装：BApp Store -> 搜索 "JSON Web Tokens" -> Install

主要功能：
- 自动解码JWT Token
- 支持修改JWT Header和Payload
- 支持none算法绕过攻击
- 支持密钥爆破
- 自动在请求中更新过期的JWT

使用方法：
步骤1：在Proxy历史记录中找到包含JWT的请求
步骤2：右键 -> Send to JSON Web Tokens
步骤3：查看JWT的解码内容
步骤4：尝试修改Payload中的字段（如role字段）
步骤5：尝试none算法绕过（将alg修改为none）
步骤6：使用修改后的JWT重放请求

12.7 其他推荐插件

| 插件名称 | 功能 | 推荐指数 |
|---------------------------|-------------------------------------|----------|
| Param Miner | 发现隐藏参数和缓存中毒 | ★★★★★ |
| Upload Scanner | 文件上传漏洞扫描 | ★★★★☆ |
| Retire.js | 检测前端库的已知漏洞 | ★★★★☆ |
| Flow | 可视化HTTP请求/响应流程 | ★★★★☆ |
| SQLiPy | 集成SQLMap进行SQL注入检测 | ★★★★☆ |
| Hackvertor | 使用标签进行数据编码转换 | ★★★★☆ |
| JWT Heartbreaker | JWT密钥攻击和验证 | ★★★★☆ |
| WebSocket Smuggler | WebSocket走私检测 | ★★★☆☆ |
| CORS | CORS跨域漏洞检测 | ★★★★☆ |
| Backslash Powered Scanner | 基于反馈的模糊测试 | ★★★★☆ |
| Turbo Intruder | 高性能Intruder替代品 | ★★★★★ |
| Copy as Python Requests | 将请求导出为Python requests代码 | ★★★☆☆ |
| Request Randomizer | 随机化请求参数 | ★★★☆☆ |
| Bambda | 使用Python脚本过滤HTTP历史 | ★★★★☆ |
| Doppler Match and Replace | 增强的匹配替换功能 | ★★★☆☆ |

十三、高级技巧

13.1 宏录制与Session处理

宏（Macro）功能用于自动维护会话状态，如自动登录刷新Session Token。

宏录制步骤：

步骤1：打开宏配置
- Project options -> Sessions -> Macros -> Add

步骤2：录制宏
- 点击"Record Macro"
- 在浏览器中执行需要录制的操作（如登录）
- Burp会记录这些请求
- 选择需要保留的请求

步骤3：配置宏参数
- 选择需要自动更新的参数（如Session Token）
- 配置Token提取规则（从响应中提取Token值）

步骤4：配置宏触发条件
- 选择触发条件（如HTTP响应包含特定错误时触发）
- 配置重试逻辑

步骤5：设置Session Handling Rules
- Project options -> Sessions -> Session Handling Rules -> Add
- 配置规则动作：Run Macro
- 配置规则范围：所有请求或特定URL

实战场景：自动刷新过期的Session

场景描述：测试目标Session有效期为15分钟，过期后需要重新登录。
配置自动登录宏：
1. 录制登录请求作为宏
2. 配置Session Handling Rule
3. 规则动作：当检测到401/302响应时，自动执行登录宏
4. 从登录响应中提取新的Session Token
5. 自动更新后续请求中的Session Token

【提示】宏录制功能在进行长时间的扫描或Intruder攻击时非常有用，
可以确保Session不会过期导致测试中断。

13.2 Session Handling Rules详解

Session Handling Rules用于在发送请求前自动修改请求。

规则类型1：Run Macro
- 在发送请求前执行宏（如自动登录）
- 从宏执行结果中提取参数更新当前请求

规则类型2：Modify Cookie
- 自动添加或修改请求中的Cookie
- 用于维持会话状态

规则类型3：Set HTTP Header
- 自动添加或修改请求头
- 如自动添加Authorization头

规则类型4：Prompt for input
- 在发送请求前弹窗提示输入参数
- 适用于需要人工输入的场景

Session Rule配置参数：

| 配置项 | 说明 |
|---------------------------|---------------------------------|
| Rule name | 规则名称 |
| Rule enabled | 是否启用规则 |
| Rule actions | 规则动作列表 |
| Scope - URL | 规则生效的URL范围 |
| Scope - Tools | 规则在哪些模块中生效 |
| Trigger | 触发条件 |

13.3 Collaborator服务器使用

Burp Collaborator是用于检测带外（Out-of-band）漏洞的外部服务。

Collaborator的工作原理：
1. Burp向目标请求中插入Collaborator域名
2. 如果目标存在带外漏洞，会向Collaborator发起DNS/HTTP/SMTP请求
3. Collaborator记录这些请求
4. Burp查询Collaborator确认漏洞存在

Collaborator适用漏洞类型：
- 盲注SQLi（通过DNS带外提取数据）
- 盲注XXE
- 盲注SSRF
- 盲注命令注入
- 盲注反序列化

Collaborator使用方法：

方法1：手动使用
步骤1：点击"Copy to clipboard"获取一个Collaborator域名
步骤2：将域名插入到测试payload中
- 例如：XXE测试 payload中使用Collaborator域名
步骤3：发送请求
步骤4：点击"Poll now"查看是否有Collaborator交互
步骤5：如果有DNS查询或HTTP请求到达Collaborator，确认漏洞存在

方法2：在Intruder中使用
步骤1：在Intruder的Payloads选项卡中选择Payload type为"Collaborator payload"
步骤2：Intruder会自动为每个请求生成不同的Collaborator域名
步骤3：攻击完成后，Burp会自动检查所有Collaborator域名

方法3：在扫描中自动使用
- 主动扫描会自动使用Collaborator进行带外漏洞检测
- 确保Collaborator服务器可用

Collaborator交互类型：
- DNS interactions：DNS查询记录
- HTTP interactions：HTTP请求记录
- SMTP interactions：SMTP邮件记录
- TCP interactions：TCP连接记录
- TLS interactions：TLS握手记录

【提示】Collaborator服务器需要网络连接。如果在内网环境无法访问
PortSwigger的云端Collaborator，可以配置私有Collaborator服务器
（仅企业版支持）。

Collaborator实战示例：检测盲注SSRF

步骤1：获取Collaborator域名
- 点击Burp -> Collaborator -> Copy to clipboard
- 获取域名如：xxx.oastify.com

步骤2：构造SSRF测试payload
```
POST /api/import HTTP/1.1
Host: target.example.com
Content-Type: application/json

{"url": "http://xxx.oastify.com/test"}
```

步骤3：发送请求
步骤4：在Collaborator面板点击"Poll now"
步骤5：如果看到DNS或HTTP交互记录，确认存在SSRF漏洞

13.4 匹配替换规则

Project options -> Match and Replace（不同于Proxy的Match and Replace）

此处的匹配替换规则应用于所有模块的请求和响应。

实战配置示例：

规则集1：自动添加CSRF Token
- Match: <csrf_token>([^<]+)</csrf_token>（从响应中提取Token）
- Replace: 在后续请求中更新对应的CSRF Token参数

规则集2：修改请求来源IP
- Match: X-Forwarded-For: .*
- Replace: X-Forwarded-For: 127.0.0.1
- 用途：测试后端是否信任X-Forwarded-For头

规则集3：移除安全标记
- Match: Secure
- Replace: (留空)
- 用途：测试Cookie安全配置（仅用于测试环境）

十四、实战案例：使用Burp完成一次完整的Web应用渗透测试流程

以下演示使用Burp Suite完成一次完整的Web应用渗透测试全流程。

测试目标：https://demo.testapp.com（示例目标，已获授权）

14.1 第一阶段：信息收集与目标范围设置

步骤1：配置目标Scope
- Target -> Scope -> Add
- 添加 https://demo.testapp.com 到范围

步骤2：浏览目标站点
- 在浏览器中正常浏览目标站点
- 访问所有可见页面和功能
- 尝试登录、注册、搜索等核心功能
- 让Burp代理记录所有流量

步骤3：分析站点地图
- Target -> Site map
- 查看站点目录结构
- 发现隐藏的API接口
- 识别技术栈和框架

步骤4：使用Discover content进行目录爆破
- 右键目标域名 -> Engagement tools -> Discover content
- 配置字典文件进行目录爆破
- 发现隐藏目录和文件

步骤5：使用Find comments和Find scripts
- 搜索HTML注释中的敏感信息
- 发现JavaScript中的API接口

14.2 第二阶段：被动扫描与初步分析

步骤1：确认被动扫描已启用
- Dashboard -> Passive scanning
- 确保所有被动扫描检查项已启用

步骤2：浏览过程中被动扫描自动运行
- 正常浏览目标站点的所有功能
- 被动扫描会自动分析所有流量
- 查看发现的问题

步骤3：分析被动扫描结果
- 查看Dashboard中的Issues
- 记录发现的信息泄露、安全配置问题
- 标记需要深入测试的方向

14.3 第三阶段：主动扫描

步骤1：配置主动扫描
- Dashboard -> New scan -> Active scan
- 选择目标URL范围
- 配置扫描策略（Crawl and Audit）

步骤2：配置扫描选项
- 设置爬虫深度和最大URL数
- 配置审计检查组（根据测试需求选择）
- 设置并发数和超时

步骤3：如果目标需要认证
- 配置Application login
- 提供登录凭据
- 配置Session处理规则

步骤4：开始扫描
- 点击"Start scan"
- 监控扫描进度
- 查看实时发现的漏洞

步骤5：分析扫描结果
- 查看所有发现的漏洞
- 按严重性排序
- 记录需要人工验证的漏洞

14.4 第四阶段：手动漏洞验证与深入测试

步骤1：验证注入漏洞
- 将扫描发现的注入漏洞请求发送到Repeater
- 手动构造payload验证漏洞
- 使用Intruder进行批量模糊测试

步骤2：测试认证与会话管理
- 使用Sequencer分析Session Token随机性
- 测试Session固定漏洞
- 测试密码重置流程
- 测试多因素认证绕过

步骤3：测试访问控制
- 使用Autorize或Authz插件测试越权漏洞
- 测试水平越权（同级别用户之间）
- 测试垂直越权（低权限访问高权限功能）

步骤4：测试业务逻辑
- 使用Intruder测试并发条件
- 测试价格篡改
- 测试工作流绕过
- 测试负数或超大数值

步骤5：使用Collaborator测试带外漏洞
- 测试盲注SSRF
- 测试盲注XXE
- 测试盲注命令注入

14.5 第五阶段：漏洞利用与影响评估

步骤1：对已确认的漏洞进行利用
- 使用Repeater构造利用payload
- 评估漏洞的实际影响
- 获取最大权限的证明

步骤2：记录漏洞利用过程
- 截图保存关键证据
- 记录完整的请求和响应
- 编写漏洞利用步骤

步骤3：评估漏洞风险
- 结合CVSS评分标准评估漏洞严重性
- 考虑漏洞链组合的影响
- 评估对业务的影响

14.6 第六阶段：报告生成

步骤1：使用Burp生成报告
- Target -> Issues -> 右键 -> "Report issues"
- 选择报告格式（HTML/PDF）
- 配置报告内容

步骤2：补充人工测试发现
- 添加扫描器未发现的漏洞
- 补充业务逻辑漏洞
- 添加漏洞利用截图

步骤3：编写修复建议
- 针对每个漏洞提供具体修复方案
- 参考OWASP最佳实践
- 提供安全代码示例

十五、绕过WAF的Burp配置技巧

在渗透测试中，目标可能部署了Web应用防火墙（WAF），会拦截恶意请求。
以下介绍使用Burp绕过WAF的常见技巧。

15.1 修改请求特征

技巧1：修改User-Agent
- WAF可能根据User-Agent拦截扫描器请求
- 将User-Agent修改为常见浏览器UA
- 配置Match and Replace规则自动替换

配置方法：
- Proxy -> Options -> Match and Replace -> Add
- Match: User-Agent: .*
- Replace: User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36
- Type: Request header

技巧2：移除WAF识别标记
- WAF可能通过特定请求头识别Burp
- 移除如 X-Burp 等标记头
- 移除Origin头（某些WAF根据Origin判断）

15.2 请求分块与编码绕过

技巧1：使用Chunked Transfer Encoding
- 将请求体使用分块传输编码
- 可以绕过某些WAF的请求体检查

配置方法：
- 在Repeater中修改请求头
- 添加 Transfer-Encoding: chunked
- 将请求体转换为分块格式

技巧2：使用多重编码
- 对payload进行多重URL编码
- 使用Unicode编码
- 使用HTML实体编码

Intruder配置：
- Payload Processing -> Add -> URL-encode key characters
- 多次添加编码规则进行多重编码

技巧3：大小写混合
- 将SQL注入payload进行大小写混合
- 例：UnIoN SeLeCt 代替 UNION SELECT

Intruder配置：
- Payload Processing -> Add -> Case modification
- 选择"Lower case"或"To lower case"

15.3 请求频率控制

技巧1：降低请求频率
- 设置请求间隔时间
- 添加随机抖动模拟人类行为

配置方法：
- Intruder -> Options -> Request Engine
- Delay between requests: 1000-3000毫秒
- 添加随机Jitter

技巧2：分批次发送
- 将payload列表分成多个小批次
- 每批次之间添加长时间间隔
- 避免触发频率限制

技巧3：使用Turbo Intruder
- Turbo Intruder支持更精细的速率控制
- 支持HTTP/2多路复用
- 可以在单个TCP连接上发送大量请求

15.4 使用HTTP/2绕过

某些WAF对HTTP/2的解析与HTTP/1.1不一致，可以利用这种差异绕过WAF。

配置方法：
- Settings -> Network -> HTTP -> 启用HTTP/2支持
- 在Repeater中切换HTTP版本
- 对比HTTP/1.1和HTTP/2的WAF拦截差异

15.5 请求参数混淆

技巧1：参数污染
- 添加多个同名参数
- 不同的服务器对同名参数的处理方式不同
- WAF可能只检查第一个参数值

示例：
```
GET /search?q=normal&q=<script>alert(1)</script> HTTP/1.1
```

技巧2：使用不同的Content-Type
- 某些WAF只检查特定Content-Type的请求
- 尝试切换Content-Type绕过检查
- 如从application/x-www-form-urlencoded切换为application/json

技巧3：利用HTTP参数解析差异
- 使用分号分隔参数
- 使用不同的参数编码方式

【警告】绕过WAF的技巧可能因WAF类型和版本不同而效果不同。请根据
实际目标环境调整策略。绕过WAF的行为可能触发安全告警，请在授权
环境下测试。

十六、防御建议

针对Burp Suite测试中发现的常见问题，以下提供防御建议。

16.1 输入验证与输出编码

防御措施1：严格输入验证
- 对所有用户输入进行白名单验证
- 验证数据类型、长度、格式、范围
- 拒绝不符合预期的输入
- 在服务器端进行验证，不依赖客户端验证

防御措施2：安全输出编码
- 根据输出上下文选择合适的编码方式
- HTML上下文使用HTML实体编码
- JavaScript上下文使用JavaScript编码
- URL上下文使用URL编码

防御措施3：参数化查询
- 使用预编译语句（PreparedStatement）
- 避免字符串拼接SQL语句
- 使用ORM框架的参数化查询功能

16.2 认证与会话管理

防御措施1：安全的Session管理
- 使用足够随机的Session Token（至少128位熵）
- Session Token使用安全的传输方式（仅HTTPS）
- 设置Cookie的HttpOnly、Secure、SameSite属性
- 实现Session超时和注销机制

防御措施2：多因素认证
- 对敏感操作要求多因素认证
- 使用TOTP或硬件密钥
- 避免使用短信作为唯一因素

防御措施3：防暴力破解
- 实现账号锁定机制（基于IP和账号）
- 添加验证码
- 实施频率限制
- 记录和监控异常登录行为

16.3 访问控制

防御措施1：基于角色的访问控制（RBAC）
- 严格定义用户角色和权限
- 在服务器端验证每次操作的权限
- 不信任客户端传入的用户ID

防御措施2：默认拒绝原则
- 默认拒绝所有访问
- 显式授权允许的访问
- 定期审计权限配置

防御措施3：资源归属验证
- 验证请求者对资源的访问权限
- 使用间接对象引用
- 检查请求者是否拥有目标资源

16.4 安全配置

防御措施1：安全HTTP响应头
- 配置X-Content-Type-Options: nosniff
- 配置X-Frame-Options: DENY
- 配置Content-Security-Policy
- 配置Strict-Transport-Security
- 配置Referrer-Policy

防御措施2：错误处理
- 自定义错误页面，不泄露技术细节
- 记录详细错误日志到服务器端
- 禁用调试模式和详细错误输出

防御措施3：WAF配置
- 部署Web应用防火墙
- 配置合理的规则
- 定期更新WAF规则
- 监控WAF告警

16.5 持续安全测试

建议1：定期进行渗透测试
- 每年至少进行一次全面渗透测试
- 在重大版本发布前进行安全测试
- 使用自动化工具与人工测试相结合

建议2：实施安全编码规范
- 制定并执行安全编码规范
- 进行代码安全审查
- 使用静态代码分析工具

建议3：建立漏洞响应机制
- 建立漏洞报告渠道
- 制定漏洞响应流程
- 及时修复已发现的安全漏洞

十七、总结

本文系统性地介绍了Burp Suite从基础使用到高级插件开发的全流程。

核心要点回顾：

1. Burp Suite版本选择
- 社区版适合入门学习和简单测试
- 专业版适合专业渗透测试和Bug Bounty
- 企业版适合大规模持续安全监控

2. 核心模块使用
- Proxy：抓包、拦截、修改HTTP流量
- Target：站点地图分析、目标范围管理
- Scanner：主动扫描和被动扫描
- Intruder：四种攻击类型的灵活运用
- Repeater：手动请求修改和重放
- Sequencer：Token随机性分析
- Decoder/Comparer：编码转换和差异对比

3. 插件生态
- BApp Store提供了丰富的扩展插件
- 可使用Java（Montoya API）或Python（Jython）开发自定义插件
- 推荐安装的插件：Active Scan++、Logger++、Authz、Autorize、
HTTP Request Smuggler、JSON Web Tokens、Param Miner等

4. 高级技巧
- 宏录制与Session处理实现自动化会话维护
- Collaborator服务器用于检测带外漏洞
- 匹配替换规则实现自动化请求修改
- WAF绕过需要综合运用多种技巧

5. 实战流程
- 信息收集 -> 被动扫描 -> 主动扫描 -> 手动验证 -> 漏洞利用 -> 报告生成
- 每个阶段都有对应工具和技巧

6. 防御建议
- 输入验证与输出编码
- 安全的认证与会话管理
- 严格的访问控制
- 安全配置和错误处理
- 持续的安全测试

【提示】Burp Suite是一个功能极其丰富的工具，本文涵盖了主要功能模块。
在实际使用中，建议多参考官方文档和社区资源，不断探索和学习新的
使用技巧。

官方资源：
- PortSwigger官网：https://portswigger.net
- PortSwigger官方文档：https://portswigger.net/burp/documentation
- BApp Store：https://portswigger.net/bapps
- PortSwigger博客：https://portswigger.net/blog
- PortSwigger Web Security Academy：https://portswigger.net/web-security

学习建议：
- 完成PortSwigger Web Security Academy的所有实验
- 参与Bug Bounty平台实战练习
- 阅读PortSwigger研究博客的最新安全研究
- 尝试开发自己的Burp插件

================================================================================
附录A：Burp Suite常用快捷键
================================================================================

| 快捷键 | 功能 | 适用模块 |
|-----------------|-----------------------------|-------------------|
| Ctrl+R | 发送到Repeater | Proxy/Target |
| Ctrl+I | 发送到Intruder | Proxy/Target |
| Ctrl+Shift+R | 在新标签中发送到Repeater | 全局 |
| Ctrl+Shift+I | 在新标签中发送到Intruder | 全局 |
| Ctrl+B | 发送到Comparer | 全局 |
| Ctrl+D | 发送到Decoder | 全局 |
| Ctrl+Space | 切换Proxy拦截状态 | 全局 |
| Ctrl+F | 在当前面板搜索 | 全局 |
| Ctrl+T | 切换请求方法（GET/POST） | Repeater |
| Ctrl+U | URL编码选中内容 | 全局 |
| Ctrl+Shift+U | URL解码选中内容 | 全局 |
| Ctrl+H | HTML编码选中内容 | 全局 |
| Ctrl+Shift+H | HTML解码选中内容 | 全局 |
| Ctrl+B | Base64编码选中内容 | 全局 |
| Ctrl+Shift+B | Base64解码选中内容 | 全局 |

================================================================================
附录B：Burp Suite命令行参数
================================================================================

```
# 启动Burp Suite（GUI模式）
java -jar burpsuite_pro.jar

# 指定内存大小启动
java -Xmx4g -jar burpsuite_pro.jar

# 命令行模式启动（无需GUI）
java -jar burpsuite_pro.jar --project-file=/path/to/project.burp

# 指定配置文件启动
java -jar burpsuite_pro.jar --config-file=/path/to/config.json

# 以无界面模式运行扫描（CI/CD集成）
java -jar burpsuite_pro.jar --unpause-spider-and-scanner \
--project-file=/path/to/project.burp

# 使用REST API触发扫描
# 获取API密钥
curl -X GET https://127.0.0.1:1337/v0.1/api-key \
-H "Authorization: Bearer YOUR_API_KEY"

# 发起扫描
curl -X POST https://127.0.0.1:1337/v0.1/scan \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{"scan_id":"custom-scan","urls":["https://target.example.com"]}'
```

【提示】Burp Suite的命令行模式和REST API功能仅专业版和企业版支持。
在CI/CD流水线中集成Burp扫描时，使用命令行模式可以实现自动化安全
测试。

================================================================================
附录C：常见问题与解答
================================================================================

Q1: Burp Suite社区版可以用于商业用途吗？
A1: Burp Suite社区版可以免费使用，包括商业用途，但功能受限。如需
进行专业的商业渗透测试，建议购买专业版。

Q2: Burp Suite支持哪些操作系统？
A2: Burp Suite基于Java开发，支持Windows、macOS和Linux。只要有
JDK环境即可运行。

Q3: 如何提高Burp Suite的扫描速度？
A3: 可以通过以下方式提高扫描速度：
- 增加并发线程数（Settings -> Scan -> Maximum concurrent requests）
- 禁用不需要的检查组
- 减少爬虫深度
- 增加分配给Burp的内存
- 使用多台机器进行分布式扫描（企业版功能）

Q4: Burp Suite是否会触发WAF告警？
A4: 默认情况下，Burp Suite的请求特征可能被WAF识别。可以通过修改
User-Agent、降低请求频率、使用Turbo Intruder等方式减少WAF告警。
具体绕过方法参考第十五章。

Q5: 如何在CI/CD中集成Burp扫描？
A5: 使用Burp的命令行模式和REST API可以实现CI/CD集成。在流水线中
启动Burp的命令行扫描，通过API获取扫描结果，根据结果决定是否阻断
部署。企业版提供了更完善的CI/CD集成支持。

Q6: 自己开发的Burp插件如何发布到BApp Store？
A6: 将插件源码提交到PortSwigger的GitHub仓库
（https://github.com/PortSwigger/bapps），经过审核后可以发布到
BApp Store供全球用户使用。

Q7: Jython开发的插件和Java开发的插件有什么区别？
A7: Jython插件开发更简单快速，但性能较低，且不支持Python 3特性。
Java插件性能更好，功能更全，推荐使用Montoya API进行Java插件开发。

Q8: Burp Suite如何处理WebSocket？
A8: Burp Suite支持WebSocket代理，可以在Proxy -> WebSockets history
中查看WebSocket消息。可以将WebSocket消息发送到Repeater进行重放
和修改。

================================================================================
附录D：推荐的Burp配置文件模板
================================================================================

以下是一份推荐的Burp Suite项目配置模板，可在新项目开始时快速应用。

扫描策略配置推荐：
```
# 适合快速扫描的配置
检查组：Injection vulnerabilities -> 启用
检查组：Input handling -> 启用
检查组：Server-side vulnerabilities -> 启用
检查组：Client-side vulnerabilities -> 禁用（减少扫描时间）
检查组：Authentication and session -> 启用
检查组：Business logic -> 禁用（需要手动测试）
检查组：Miscellaneous checks -> 启用

并发请求：10
超时：60秒
最大URL数：5000
爬虫深度：3
```

Proxy过滤器推荐配置：
```
# 隐藏静态资源
Filter: Hide CSS, image, general non-interesting items
Filter: Show only in-scope items
```

Session Handling推荐规则：
```
# 自动维护Session
规则1: Run Macro - 自动登录
触发条件: 响应包含 "session expired" 或状态码 302
动作: 执行登录宏，更新Session Token

规则2: Set HTTP Header
匹配: 所有请求
动作: 添加 Authorization: Bearer <token>
```

Match and Replace推荐规则：
```
# 规则1: 修改User-Agent
Match: User-Agent: .*
Replace: User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) ...

# 规则2: 移除客户端IP头
Match: X-Forwarded-For: .*
Replace: (空)

# 规则3: 添加自定义测试标记
Match: ^$
Replace: X-Testing-Tool: BurpSuite
Type: Request header
```

================================================================================
全文完
================================================================================
```

以上就是Burp Suite高级实战指南的完整内容。本文涵盖了从基础环境
配置到插件开发的全流程，适合各层次的网络安全学习者参考使用。

再次提醒：所有技术操作请在授权环境下进行，遵守相关法律法规

MCP技术社区

欢迎加入 MCP 技术社区！与志同道合者携手前行，一同解锁 MCP 技术的无限可能！

更多推荐

Google能索引，AI却抓不到

很多技术团队有个错觉：只要Google能正常收录，内容就没问题。但现实是，你的页面在Google搜索结果里好好的，在ChatGPT、Perplexity、Claude的答案里却像从未存在过一样。

MCP技术社区

Windows 下部署 New API 中转站全过程实录（含 6 个真实踩坑）

MCP技术社区

初识智能体

在过去两年中，几乎所有人都体验过大语言模型（如 ChatGPT、Claude、DeepSeek）的强大能力：写周报、润色邮件、解答编程疑难。被动响应：你问一句，它答一句。如果你的 Prompt 没有写清楚约束条件，它无法主动追问或修正目标。知行脱节：大模型能用流畅的文字告诉你“如何部署一个高可用 K8s 集群”，但它无法替你登录服务器敲下命令、查看报错日志并自动回滚。信息孤岛：大模型的知识止步于预