VulnHuntr 深度拆解:当 LLM 学会"一把梭"挖 RCE
VulnHuntr 深度拆解,从源码切入分析工具优缺点及改进方案
前言
为什么聊 VulnHuntr
2025 年底 Protect AI 开源了一个叫 VulnHuntr 的工具,用 Claude 自动扫 Python 代码库挖漏洞。上线没多久就靠几行 prompt 找到了多个真实 CVE——gpt_academic 的 LFI、ComfyUI 的 XSS、Langflow 的 RCE、Ragflow 的 RCE。一共支持 7 类漏洞,覆盖了大多数常见的 Web 漏洞类型。
说到底其实就是:把安全研究员"读代码→找入口→构造调用链→写 PoC"这一套流程,让 LLM 来干。
这事有意思的地方不在于"LLM 能挖洞"——这个结论不新鲜。之前就有用 GPT-4 做代码审计的研究。新鲜的是这帮人把 prompt 工程做到了什么程度,能让 LLM 稳定地输出可用的漏洞报告,而且连 PoC 都给你写好了。
所以这篇文章拆五块:
- Prompt 工程拆解——VulnHuntr 到底是怎么让 LLM 一步步挖出洞的
- 源码分析——上下文补全循环和模板管理是怎么实现的
- 实战复现——跑一把看看效果
- 边界测试——什么类型的洞它扫不出来,为什么
- 改进思路——能怎么让它更强
一、Prompt 工程拆解
1.1 整体架构
VulnHuntr 不是一次性把整个仓库扔给 LLM,而是分阶段走:
五个阶段各干各的:
阶段一:让 LLM 先读 README,把项目理解写入 system prompt。这样后续分析时 LLM 知道自己在看什么项目,不至于连代码是干什么的都搞不清。
阶段二:逐文件扫描。LLM 看一个文件,标记出所有"可能接收用户输入"的代码落点。这一步用的是 INITIAL_ANALYSIS_PROMPT_TEMPLATE,不限定漏洞类型,全部可疑点通杀。
阶段三:按漏洞类型下钻。发现一个可疑落点后,用对应类型的专项 prompt 做深入分析——RCE 专项重点关注 eval/subprocess/os.system,LFI 专项关注 open/file 等。
阶段四:上下文补全循环。做深潜分析时,LLM 如果看不懂某段代码(比如一个函数调用了外部定义的方法),它会主动请求从其他文件获取上下文。工具端调 Jedi 静态分析库提取定义,然后打包传回 LLM。
阶段五:生成 PoC 和置信度评分。分数低于 7 的一般不考虑,7 以上值得查,8 以上基本是真洞。
说实话,阶段四这个设计是整篇代码里最精彩的部分。不是让 LLM 一次性吞下所有代码,而是"用到什么拿什么"——既省 token,又避免上下文太长导致注意力稀释。
1.2 Prompt 结构拆解
VulnHuntr 的源码里定义了 5 个核心 prompt 模板。来看每个具体干了什么。
系统提示(SYS_PROMPT_TEMPLATE):
SYS_PROMPT_TEMPLATE = """
You are the world's foremost expert in Python security analysis...
Your task is to perform an exhaustive static code analysis...
Your analysis must:
- Meticulously track user input from remote sources to high-risk function sinks
- Uncover complex, multi-step vulnerabilities...
If you don't have the complete code chain... strategically request the necessary context
Output your findings in JSON format...
"""比较有意思的是最后一句——它明确告诉 LLM "你可以多次请求上下文"。这就是那个上下文补全循环能在 prompt 层面工作的原因。
初筛提示(INITIAL_ANALYSIS_PROMPT_TEMPLATE):
1. Identify all remote user input entry points...
2. Locate potential vulnerability sinks for: LFI, AFO, SSRF, RCE, XSS, SQLI, IDOR
3. Note any security controls or sanitization measures...
4. Highlight areas where more context is needed...注意第 4 点——LLM 需要主动标记哪些地方需要更多上下文。这是触发后续上下文补全循环的关键。
漏洞专项提示(RCE_TEMPLATE 为例):
RCE_TEMPLATE = """
Combine the code in <file_code> and <context_code> tags then analyze
for remotely-exploitable RCE vulnerabilities...
RCE-Specific Focus Areas:
1. High-Risk Functions: eval(), exec(), subprocess, os.system(), os.popen()
pickle.loads(), yaml.load(), json.loads() with custom decoders
2. Indirect Code Execution: Dynamic imports, reflection misuse, SSTI
3. Command Injection Vectors: Shell command composition
4. Deserialization Vulnerabilities
When analyzing, consider:
- How user input flows into these high-risk areas
- Potential for filter evasion or sanitization bypasses
"""7 类漏洞各有一段类似的模板。除了各自的关注点不一样,结构是一样的:Focus Areas → Analysis Instructions。而且都自带 bypass 示例列表,直接用 XML 标签注入。
1.3 关键工程决策
为什么选 Claude 不是 GPT:
VulnHuntr 支持 Claude、GPT 和 Ollama 三种后端,但官方明确说 Claude 效果最好。看源码就能发现原因——代码里专为 Claude 做了 prefill 设计:
# LLMs.py Claude 类
def create_messages(self, user_prompt: str) -> List[Dict[str, str]]:
if "Provide a very concise summary of the README.md content" in user_prompt:
messages = [{"role": "user", "content": user_prompt}]
else:
self.prefill = '{ "scratchpad": "1.'
messages = [
{"role": "user", "content": user_prompt},
{"role": "assistant", "content": self.prefill}
]
return messages先往 assistant 回复里写一个 JSON 前缀,强制 Claude 续写 JSON。这是一个非常实用的技巧——Claude 的 JSON 输出模式是隐式的,不像 GPT 有显式的 response_format={"type": "json_object"} 参数。用 prefill "引导"它往 JSON 方向走,效果比单纯靠 system prompt 约束稳定很多。
为什么锁定 Python 3.10:
因为用到了 Jedi 做静态分析,而 Jedi 在 Python 3.10 上最稳定。这其实暴露了一个现实问题——LLM 理解代码的能力再强,也需要辅助工具来定位跨文件的引用关系。纯靠 LLM 自己读代码,上下文根本不够用。
正则匹配 Web 框架:
RepoOps 类里有一个长达 90+ 行的正则列表,覆盖了几乎所有 Python Web 框架:
Flask: @app.route(...)
Django: url(...), re_path(...)
FastAPI: @app.get(...), @router.post(...)
Tornado: class Handler(RequestHandler)
aiohttp: app.router.add_get(...)
Sanic, Bottle, Falcon, CherryPy, Quart, Starlette...还包括 AWS Lambda handler、Azure Functions、gRPC server 等。这意味着 VulnHuntr 不是纯靠 LLM 理解代码结构,而是先用正则找出"可能是网络入口"的文件,再交给 LLM 做精细分析。
二、源码分析
2.1 上下文补全循环的实现
这是 VulnHuntr 最核心的工程代码。我直接从 __main__.py 里把上下文循环的完整逻辑拆出来看。
for i in range(7): # 最多迭代 7 轮
# 第 1 轮不做上下文补全
if i > 0:
for context_item in secondary_analysis_report.context_code:
if context_item.name not in stored_code_definitions:
name = context_item.name
code_line = context_item.code_line
# 用 Jedi 解析 AST 提取定义
match = code_extractor.extract(name, code_line, files)
if match:
stored_code_definitions[name] = match
code_definitions = list(stored_code_definitions.values())
definitions = CodeDefinitions(definitions=code_definitions)
# 把新找到的代码和上一个 iteration 的分析结果一起发回去
vuln_specific_user_prompt = (
FileCode(file_path=str(py_f), file_source=content).to_xml() +
definitions.to_xml() +
PreviousAnalysis(previous_analysis=previous_analysis).to_xml() +
# ... 其他 prompt 组件
)
secondary_analysis_report = llm.chat(vuln_specific_user_prompt)
# 不再请求新代码 → 循环结束
if not len(secondary_analysis_report.context_code):
break几个关键设计点:
循环上限 7 轮。 不是无限循环的。做了重复检测——如果 LLM 连续两次请求相同的上下文,说明它在原地打转,循环直接中断。
上下文逐轮累积。stored_code_definitions 是累积的,不是每轮重置的。上一轮请求过的代码,下一轮依然在上下文中。这是正确的做法——不然已经找到的上下文会丢失。
历史分析结果也累积。PreviousAnalysis 传入上一轮的分析结果。这给了 LLM 连续性——它不需要每次都从头分析,可以基于已有的结论继续深入。
不过有个小问题——源码里 previous_context_amount >= len(stored_code_definitions) 这个重复检测只检查数量没检查内容。如果 LLM 换了个名字请求同样内容的函数,检测不到。
2.2 Prompt 模板管理
# __main__.py 中的 prompt 组装逻辑
vuln_specific_user_prompt = (
FileCode(file_path=str(py_f), file_source=content).to_xml() +
definitions.to_xml() +
ExampleBypasses(
example_bypasses='\n'.join(
VULN_SPECIFIC_BYPASSES_AND_PROMPTS[vuln_type]['bypasses']
)
).to_xml() +
Instructions(
instructions=VULN_SPECIFIC_BYPASSES_AND_PROMPTS[vuln_type]['prompt']
).to_xml() +
AnalysisApproach(analysis_approach=ANALYSIS_APPROACH_TEMPLATE).to_xml() +
PreviousAnalysis(previous_analysis=previous_analysis).to_xml() +
Guidelines(guidelines=GUIDELINES_TEMPLATE).to_xml() +
ResponseFormat(response_format=json.dumps(Response.model_json_schema())).to_xml()
).decode()每个组件的用途:
组件 | 来源 | 作用 |
FileCode | 原始文件内容 | 让 LLM 看到待分析的代码 |
definitions | Jedi 提取的上下文 | 补全缺失的函数/类定义 |
ExampleBypasses | VULN_SPECIFIC_BYPASSES | 给 LLM 注入已知绕过技巧 |
Instructions | 漏洞类型模板 | 专项分析指令 |
AnalysisApproach | 固定模板 | 通用分析思路 |
PreviousAnalysis | 上一轮输出 | 保持连续性 |
Guidelines | 固定模板 | 输出格式约束 |
ResponseFormat | Pydantic Schema | JSON Schema 校验 |
这里有一个值得注意的地方:所有内容都以 XML 标签包裹。不是纯文本拼接,也不是 JSON 结构,而是 XML。用 pydantic_xml 库把 Pydantic 模型序列化成 XML。这样做的好处是 LLM 能清楚区分不同来源的内容——<file_code> 里的代码和 <context_code> 里的代码不会混淆。
2.3 静态分析模块(symbol_finder.py)
SymbolExtractor 是连接 LLM 和实际代码的桥梁。LLM 说"我需要看 UserManager.get_user 的代码",工具就去文件里找到这段代码返回。
从源码来看,它依赖 Jedi 解析 AST 树,按类名或函数名匹配定义。这个模块的精度直接决定了上下文补全的质量——如果 Jedi 找不到 LLM 请求的符号,循环就断了。
不过 Jedi 在处理动态语言特性(元类、装饰器重写、__getattr__ 动态返回)时有已知的局限。运行时的对象和源码里的静态定义可能对不上。
三、实战复现
3.1 环境搭建
git clone https://github.com/protectai/vulnhuntr
cd vulnhuntr
pip install -r requirements.txt
# 设置 API Key
export ANTHROPIC_API_KEY=sk-xxx依赖不多,Poetry 和 pip 都能装。不过要注意两点:
- Python 必须 3.10,高了低了 Jedi 可能报错
- 如果要用自定义代理,配 ANTHROPIC_BASE_URL 环境变量
随便找了一个留了洞的 Flask 应用
确认python版本
看看具体漏洞位置
3.2 基本用法
# 扫描整个仓库(自动筛选网络相关的 Python 文件)
python -m vulnhuntr -r /path/to/target-repo
# 指定单个文件或子目录
python -m vulnhuntr -a /path/to/target-repo/app.py
# 切换 LLM 后端
python -m vulnhuntr -r /path/to/target-repo -l gpt
# 开启详细输出
python -m vulnhuntr -r /path/to/target-repo -v输出示例:
我在几个有历史漏洞的开源项目上跑了一轮扫描,结果示例如下:
两个发现:
1.明显的调用链(3-5 层以内) → 命中率很高。比如有个项目直接 request.GET.get('path') 传给 open(),VulnHuntr 几乎必杀。
2.需要理解业务逻辑的洞 → 基本扫不到。比如 IDOR——你得知道"这个用户有没有权限看那个资源",LLM 没有业务上下文,判断不了。
3.4 正则预过滤的影响
VulnHuntr 先用 90+ 条正则筛选出"可能是网络入口"的文件,然后只把这些文件交给 LLM。这意味着:
- 如果正则没命中入口文件,那个文件的代码根本不会进 LLM 的分析流程
- get_network_related_files 的精度直接决定了扫描覆盖面
好处是效率高——不用浪费 token 扫描 CLI 工具或纯数据处理模块。坏处是如果某个项目的路由方式比较特殊(比如自定义装饰器),正则可能漏过。
四、边界测试——什么洞它扫不出来
这一节我觉得才是重点。VulnHuntr 能扫到什么看 README 就行了,但要真正理解这个工具的能力边界,得看它扫不到什么。
4.1 间接调用链
LLM 的上下文窗口有限。当调用链超过 5 层,或者中间涉及动态分发(比如用字符串拼接方法名然后 getattr 调用),VulnHuntr 很容易断掉。
# 这种 → 能扫到
def handle(request):
cmd = request.GET.get('cmd')
os.system(cmd)
# 这种 → 大概率扫不到
def handle(request):
action = request.GET.get('action')
getattr(self, 'handle_' + action)(request)
def handle_exec(self, request):
cmd = request.GET.get('cmd')
self.run_cmd(cmd)
def run_cmd(self, cmd):
self._execute_in_shell(cmd)中间多了一层 getattr 动态分发,LLM 就不好追踪了。而且从源码来看,symbol_finder.py 用 Jedi 做静态解析,动态生成的属性名 Jedi 也定位不到。
4.2 反序列化漏洞
Python 的反序列化漏洞有两条典型路径:
# 显式调用 → 能扫到
data = pickle.loads(request.data)
# 隐式调用 → 扫不到
# 某框架在 session 反序列化时自动调了 pickle
# 开发者自己都不知道后端在反序列化什么更隐蔽的情况是链式反序列化——A 反序列化 B,B 里又藏了一个 pickle payload。VulnHuntr 只能看到第一层。
4.3 业务逻辑漏洞
这个比较致命,但公平地说——LLM 不理解"业务"。
正常的用户 A 能看到订单 1
用户 B 把订单 ID 改成 1 也能看到 → IDOR这个逻辑对 LLM 来说太抽象了。代码里可能只有一行 Order.objects.get(id=order_id),LLM 知道这个接口需要权限校验,但它不知道"权限校验写没写对"。
VulnHuntr 在这类洞上的误报率和漏报率都很高——要么把正常的权限校验误判为 IDOR,要么漏掉真正缺了校验的接口。
看看它的 IDOR prompt 是怎么写的:
IDOR_TEMPLATE = """
1. Look for code segments involving IDs, keys, filenames...
2. Common Locations: URLs/Routes, Form Parameters, API Endpoints
3. Ensure Authorization is Enforced:
- Verify that the code checks the user's authorization...
- Look for authorization checks immediately after the object reference...
4. Absence of such checks could indicate a potential IDOR vulnerability.
"""注意 prompt 说的是"检查有没有权限校验代码"。问题是"有"不等于"对"。开发者写了 is_authorized = True 也是"有",但显然不对。LLM 区分不了。
4.4 多语言和微服务场景
VulnHuntr 只支持 Python。这意味着:
- 前端 JS 的输入校验不能作为参考(但攻击者可能直接打 API)
- 微服务间 RPC 调用链断在服务边界上
- 用 protobuf/thrift 做序列化的场景,LLM 看不懂 schema
对于现代 Web 应用,这是一个很大的限制。
4.5 正则覆盖盲区
源码里 RepoOps 的正则列表虽然覆盖了主流框架,但有明显的盲区:
- 自研路由框架 — 正则写死的框架名匹配不到
- 通过配置文件注入路由 — 运行时决定的路径,静态分析看不到
- 中间件体系中的入口 — VulnHuntr 只找路由装饰器,不找中间件中的入口点
五、改进思路
5.1 双重验证机制
VulnHuntr 的置信度评分只是一次输出。改进方向:
当前:
LLM 分析 → 评分 → 结束
改进:
LLM 分析 → 评分 → 用另一个 prompt 独立验证 → 交叉对比同一个可疑点换两个不同角度的 prompt 分别跑,如果结果一致才出报告。这样能大幅降低误报。
5.2 更好的上下文管理
当前上下文补全是被动的——LLM 说"我需要更多代码",工具才去拿。
改进方向是主动预取:当 LLM 分析一个文件时,用 AST 解析器提前找出这个文件引入了哪些外部函数和类,自动预取它们的定义。在 LLM 需要之前就准备好。
不过这增加了 token 消耗——是个 trade-off。
5.3 漏洞类型的深度定制
VulnHuntr 的 7 类场景是写死在代码里的。如果要加新类型(比如 ORM Leak)或调整某个类型的策略,得改源码:
VULN_SPECIFIC_BYPASSES_AND_PROMPTS = {
"LFI": { "prompt": LFI_TEMPLATE, "bypasses": [...] },
"RCE": { "prompt": RCE_TEMPLATE, "bypasses": [...] },
# 要加新的 → 必须改源码
}更好的做法是把检测规则做成可配置的 YAML 文件,用户自己写规则,VulnHuntr 动态生成 prompt。这样框架的上下文补全能力和自定义规则可以复用。
5.4 结合动态分析
纯静态分析的天然瓶颈:不知道运行时的值是什么。
如果能结合动态分析:
- 用 taint 追踪标注数据流
- 实际发送 PoC 看能不能跑通
- 结合覆盖率信息告诉 LLM 漏掉了哪些分支
不过这就不只是 VulnHuntr 的范畴了,更像是 LLM + 传统 DAST 的结合。
5.5 评分校准
VulnHuntr 的置信度评分在不同项目上飘得厉害。原因很简单——LLM 的"自信"不等于"准确"。
改进方向:
- 多轮采样取方差——同一份代码跑 3 次,看评分稳定性
- 交叉验证——同一个可疑落点,用两个不同类型的 prompt 分别验证
- 设置最低 token 消耗阈值——LLM 分析得越少,结论越不可信
六、总结
VulnHuntr 的价值不在于"它能完全替代安全研究员",而在于它展示了 LLM 在代码审计上的一个可行方向。
从 prompt 工程的角度,它的多阶段设计值得学习——不是一股脑把活全扔给 LLM,而是拆成初筛、下钻、补上下文、输出报告几个独立阶段,每阶段只做一件事。从工程实现的角度,上下文补全的 7 轮迭代循环、XML 标签结构化传参、Claude prefill JSON 引导——这些具体的技术选型,都有可借鉴的地方。
说实话,VulnHuntr 现在的状态大概相当于 2018 年的自动化漏扫——能帮你干不少重复劳动,但别指望它一把梭出高端洞。
不过方向是对的。
总结一句话:VulnHuntr 帮你搞定"明显但量大"的洞,但理解业务逻辑和长调用链的事,还得人干。