前言

为什么聊 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 都给你写好了。

所以这篇文章拆五块:

  1. Prompt 工程拆解——VulnHuntr 到底是怎么让 LLM 一步步挖出洞的
  2. 源码分析——上下文补全循环和模板管理是怎么实现的
  3. 实战复现——跑一把看看效果
  4. 边界测试——什么类型的洞它扫不出来,为什么
  5. 改进思路——能怎么让它更强

一、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 帮你搞定"明显但量大"的洞,但理解业务逻辑和长调用链的事,还得人干。