CVE-2026-31431 深度技术分析：AF_ALG + splice() 页面缓存污染导致 Talos Linux 节点完全沦陷

🔐 CVE-2026-31431 “copy.fail” 深度技术分析

摘要： CVE-2026-31431（别名 “copy.fail”）是 Linux 内核 algif_aead 子系统中存在的一个高危本地权限提升（LPE）漏洞。该漏洞通过 AF_ALG 加密接口与 splice() 系统调用的不安全组合，使无特权的容器 workload 能够破坏任意文件页缓存（page-cache）页面。在 Talos Linux 发行版上，攻击者只需能够在 worker 节点上创建 Pod，即可绕过 Kubernetes 权限模型，通过投毒特权 Pod（如 kube-proxy）中的二进制文件，实现宿主机上以 root 身份执行任意代码，并进一步访问节点机密。本分析将深入该漏洞的内核根因、攻击链、PoC 利用原理、检测机制及修复策略。

📌 漏洞概述

该漏洞的独特之处在于，它打破了传统 LPE 的“内存破坏”模式——不需要 Dirty COW 式的竞态，也不需要复杂的堆布局。它属于逻辑错误引发的页缓存污染：攻击者可以让内核将一个加密操作的输出错误地写入到属于文件页缓存的内存页面中，从而修改宿主机上任意可读文件的内容。在容器环境下，这相当于直接拥有了宿主机文件系统的写能力。

Talos Linux 官方通告将受影响范围限定为使用受影响 Linux 内核版本的所有 Talos 节点。由于 Talos 采用不可变基础设施（immutable infrastructure），其所有系统组件以容器方式运行，内核漏洞天然成为容器逃逸和节点接管的重要入口。

🔬 漏洞根因分析

2.1 AF_ALG 与 splice 机制简析

AF_ALG 是 Linux 内核提供的一个内核级加密 API 的用户空间接口，用户可以通过创建 AF_ALG 套接字与内核密码学子系统交互。通常用法是：创建一个算法 socket（例如“aead”或“skcipher”），然后通过 accept() 得到连接 socket，用 write()/send() 写入明文或密文，用 read()/recv() 得到输出。

splice() 是 Linux 特有的高效 I/O 原语，允许用户从文件或套接字向另一个文件描述符移动数据，无需在用户空间进行数据拷贝。它依赖管道缓冲区（pipe_buffer）实现零拷贝数据传递。

2.2 缺陷核心：aead_sendmsg 与 srecvmsg 的页面所有权误判

在 algif_aead 子系统中，当用户调用 splice(af_alg_socket, ..., fd_to_file, ...) 时，内核调用 aead_sendmsg() / aead_recvmsg() 来处理。设计上，AF_ALG 的接收操作需要使用用户提供的缓冲区（通常是通过 recvmsg() 传入 iovec）。但当配合 splice() 时，内核会创建一个“虚拟”的 pipe，将加密结果直接写入到目标文件对应的页缓存页面。

问题出现在 aead_recvmsg() 中的 af_alg_alloc_tsgl() 与 splice_to_pipe() 的交互上。具体来说：

static int aead_recvmsg(struct socket *sock, struct msghdr *msg, size_t len, int flags)
{
    ...
    // 若 msg 指定了 MSG_SPLICE_PAGES，则内核试图直接从源套接字获取页面
    if (msg->msg_flags & MSG_SPLICE_PAGES)
        err = process_splice_pages(sk, ..., msg); 
    // 否则走传统的 copy 到用户缓冲区路径
    ...
}

在 process_splice_pages() 路径中，内核将目标文件页缓存页面（而非新建的匿名页面）作为加密输出的目的页面。然而，当算法的输出长度与输入长度不一致时（AEAD 通常包含认证标签，输出长度会大于输入长度），内核在计算需要分配的页数时未考虑额外的 auth_size（或同样的问题存在于 TLS 记录处理时）。这导致一个或多个页缓存页面被错误地引用为 skcipher_request 的 dst 散射列表项。

2.3 页面错误写入：“copy.fail” 的语义

普通用户态调用 read() 时，用户提供的缓冲区来自进程地址空间；如果内核发生了缓冲区溢出，最多破坏该进程用户态内存。但 splice() 将目标页面直接绑定到文件页缓存，内核不进行虚拟地址转换检测，而是直接操作 struct page。当 AEAD 算法引擎向 dst 散射列表中写入输出数据时，内核假设每一个 page 都足够容纳完整的 AES 块和 Tag 长度，而实际上：

• 最后一个有效数据页之后，紧跟着的是文件页缓存中的下一个连续页面（可能与文件无关，例如 XFS 的延迟分配、共享块等）。
• 当 Tag 区（例如 16 字节）越过页面边界时，写入操作会静默落入该相邻页面

在正常的splice语义中，页面所有权应该由管道/加密引擎持有，是一种临时引用。但由于 get_page() 和 put_page() 的引用计数在异路径上没有配对，被错误写入的页缓存页面永远无法被标记为 dirty，然而其内容已经被篡改。这就是“copy.fail”——加密复制过程失败，但页面内容已被破坏。该操作表现为：

攻击者向 AF_ALG socket 发送一个包含恶意 payload 的明文，并调用 splice() 读出加密结果，同时指定目标为宿主文件 /foo 的页缓存。实际写入的并非完整的密文，而是 残留的明文数据，并且被写到 /foo 页缓存中偏移等于跨页边界的位置。

由于所有文件 I/O 均通过页缓存，目标文件在短时间内（直到 cache 被回收前）显示出被篡改的内容。若攻击者持续构造，可以实现稳定、可定向的单字节或任意长度覆盖。

2.4 为什么不需要竞态

传统 DSO 型攻击（如 DirtyCow）依赖页表和 swap 机制的竞态窗口。而此漏洞是纯逻辑错误——AEAD 的散射列表构造与 splice 的目标页选择不匹配。每一次调用都是可重现的确定性错误，对于攻击者来说利用可靠性接近 100%。

💥 影响与危害

该漏洞最危险的场景是容器集群中的同级容器攻击（container-to-host）。在 Kubernetes + Talos 节点中，攻击者拥有最小的“创建 Pod”权限，然后可以：

3.1 投毒特权容器镜像层（/usr/sbin/nft）

Talos 默认的节点网络组件 kube-proxy 以 privileged DaemonSet 运行。kube-proxy 容器在初始化网络规则时会调用 nft（nftables 用户态程序）。而该程序来自 containerd 的镜像层。由于 containerd 在 overlayfs 中使用共享的 XFS 下层（lowerdir）缓存，攻击者可以在自己的 Pod 中读取该镜像层上的 /usr/sbin/nft 文件（相同镜像或基础层），并利用 CVE-2026-31431 破坏该文件的页缓存。

由于页缓存是全局共享的（同一节点上不同容器命名空间共享同一内核页缓存），即使攻击者只在自己的挂载命名空间中映射该文件，写穿页缓存的效果会直接影响到所有共享该下层镜像的容器——包括 kube-proxy。

3.2 从特权容器到宿主 root

一旦 kube-proxy 在下次执行 nft 时加载了恶意代码（投毒的 ELF 文件），该进程已经位于宿主 root 命名空间（privileged: true），并拥有全部 capability（CAP_SYS_ADMIN、CAP_NET_ADMIN 等）。攻击者植入的代码可以：

• 作为 root 在宿主网络命名空间执行任意命令
• 挂载宿主根文件系统（由于 privileged 容器已可达宿主设备）
• 读取节点级 Secret（例如 TLS 证书、ServiceAccount token）
• 利用 nsenter 逃逸容器运行时，直接控制宿主机 systemd

3.3 持久化与横向移动

攻击者获得宿主机 root 后，可以修改 EFI 启动分区（Talos 的 GRUB 校验可能被绕过）、安装内核模块、伪造新的 Kubernetes 节点身份，甚至将控制平面（etcd）数据加密勒索。在管理平面与数据平面分离的集群中，攻陷 worker 节点往往可以进一步通过 Kubernetes API 凭据横向移动到 master 节点。

3.4 破坏完整性 vs 机密性

CVE-2026-31431 直接破坏页缓存，意味着攻击者能够篡改宿主上任何世界可读的文件，包括 /etc/passwd、系统二进制、甚至内核模块签名缓存。同时，如果攻击者瞄准关键文件（如 SSH 主机密钥），还可能引发拒绝服务。这比单纯的只读越权危害更大。

🧪 PoC 复现分析

4.1 公开 PoC 仓库概览

4.2 利用原理逐步拆解（以 copy-fail-c 为例）

步骤一：建立 AF_ALG 套接字

int afd = socket(AF_ALG, SOCK_SEQPACKET, 0);
bind(afd, (struct sockaddr *)&sa, sizeof(sa)); // sa.salg_type = "aead"; sa.salg_name = "gcm(aes)";
int opfd = accept(afd, NULL, NULL);

密钥和 IV 通过 setsockopt 设置。其中选用 AEAD 而非 skcipher 是因为 AEAD 输出带有 auth tag，长度超出输入长度，从而更容易触发跨页边界。

步骤二：选择目标页缓存页面

int target_fd = open("/target/file", O_RDONLY);
// 该文件必须已经在页缓存中，或只需触发一次 read 使其被缓存
read(target_fd, buf, 4096); // 预加载

这样目标文件的第 N 个页面（例如第 5 页）被映射到页缓存。攻击者无法直接获取该页的内核地址，但可以控制页的“相对位置”——因为 splice 写入时指定的 offset 决定了内核写入的文件内偏移，如果写入长度跨页，则相邻页被覆盖。

步骤三：触发写入

int p[2];
pipe(p);
// 将 AF_ALG socket 读取通道与管道连接
splice(opfd, NULL, p[1], NULL, 4096, SPLICE_F_MOVE);
// 然后再从管道 splice 到目标 fd（以文件偏移填充）
splice(p[0], NULL, target_fd, &off, 4096, SPLICE_F_MOVE);

这里的关键在于，某些 PoC 的变体是直接将 AF_ALG socket 的 recv 操作绑定到目标文件描述符：splice(opfd, NULL, target_fd, NULL, 4096, 0)。这种调用在内核内部会产生 src 页（来自 AF_ALG 内部的 skcipher 结果页）和 dst 页（target_fd 的页缓存页）。当加密结果需要写到 dst 页时，若大小超过了一个页，将写越界至下一物理页。攻击者可以利用这一特性，将任意选择的明文数据段（payload）以密文的形式覆盖到目标页的后半段。

步骤四：精确控制覆盖的数据

由于 GCM 模式的密文与明文有一一对应关系，攻击者只需用简单的 AES-GCM 加密自己所需注入的字节（例如 ELF 文件某段 shellcode），就能决定写入目标页的字节内容。整个覆盖操作不需要目标文件可写，因为操作发生在内核页缓存层，绕过了文件权限检查。

4.3 “DIRTYFAIL” 的增强之处

DIRTYFAIL（基于 DirtyCOW 命名）在 C PoC 之上封装了逐字节写入的侧信道：由于无法直接读取目标页面，但可以通过观察加密输出与原始页面的 CRC 差异，或通过文件 md5 值的变化来判定是否命中目标偏移。这种灵活性允许攻击者将任意数据覆盖到任意文件偏移，极大降低了对缓存布局的依赖。

⚔️ EXP 利用分析

在真实攻击场景中（如针对 Talos Linux 集群），EXP 利用链设计如下：

5.1 攻击前置条件

• 目标节点运行存在漏洞的 Linux 内核（例如 Talos v1.11.0 之前版本）
• 攻击者可以在节点上创建 Pod（不需要 privileged）
• 节点上存在 kube-proxy DaemonSet（Talos 默认部署）
• 攻击者的 Pod 能够读取 kube-proxy 镜像的部分镜像层（通常相同的基础镜像或软件包镜像）

5.2 利用流程

Phase 1: 侦查与镜像层对齐
  1. 攻击者 Pod 枚举 containerd 镜像层路径（通常为 /var/lib/containerd/tmpmounts/...）
  2. 定位到 kube-proxy 使用的 containerd 镜像 snapshot 目录
  3. 选择目标文件：/usr/sbin/nft（或 /usr/sbin/iptables、/sbin/mount 等）

Phase 2: 页缓存投毒
  1. 在自己的 Pod 命名空间中打开该镜像层的 nft 文件 (O_RDONLY)
  2. 读取该文件到页缓存（触发 page fault，建立页缓存项）
  3. 使用 CVE-2026-31431 漏洞（AF_ALG+splice）覆盖 nft 文件中某个函数偏移处的字节
  4. 将覆盖内容构造为一段保存上下文后跳转的 shellcode（例如 32 字节跳板）

Phase 3: 等待触发
  1. kube-proxy 定期 reconcile 规则，或 nodeport 服务更新时触发 nft 的执行
  2. 内核在 execve() 时会首先读取 ELF 文件头部；由于页缓存已被污染，读取到的是恶意 ELF 内容（如果覆盖了 head 或特定段）
  3. kube-proxy 容器内的进程执行该 ELF，实际上执行了攻击者 code

Phase 4: 权限提升与逃逸
  1. kube-proxy 进程已经拥有 privileged 权限（因为 DaemonSet 设置了 privileged: true）
  2. shellcode 将自身 fork 到宿主机 PID 命名空间之外（setns(CLONE_NEWPID)）
  3. 挂载宿主 / 文件系统，写 SSH 公钥或创建 cron job
  4. 清理痕迹：由于页缓存污染是临时的，攻击后可以触发内存回收以避免留下文件修改痕迹

5.3 与容器逃逸的经典手段对比

传统的容器逃逸需要 host PID 或特权模式漏洞；copy.fail 是“文件级投毒”，通过共享缓存实现了间接的跨容器写入，因此不需要任何 Docker/Kubernetes 配置错误。从安全检测角度来看，常规的 HostPath 扫描、 privileged 容器检测均无法发现攻击。

🕵️ 检测指纹说明

6.1 Semgrep 静态检测规则

资料中提供了两条 Semgrep 规则（CVE-2026-31431-rce-go），专门用于扫描 Go 代码中对 syscall.Splice 的危险调用。其核心匹配特征为：

syscall.Splice($R, nil, $W, nil, $N, 0)

规则关注的是第一个参数（$R）是 AF_ALG socket、第三个参数（$W）是文件描述符的场景。在代码审计中，如果发现类似调用且无法验证 fd 类型，就会被标记为 ERROR 级别。

6.2 部署建议

• 软件成分分析：在 CI/CD 流水线集成 Semgrep 规则，扫描所有引入 golang.org/x/sys/unix 或 syscall 的容器组件，重点关注 Talos 系统扩展（system extensions）
• 运行时检测：监控 splice 系统调用，可用 BPF 程序过滤 splice(fd_from_af_alg) 情况。利用 TRACEFS 或 kprobe 检查 splice() 的源 fd 是否指向 AF_ALG 类型的 socket（通过 sock->ops->family == AF_ALG 判断）
• 文件校验：对宿主机关键二进制（/usr/sbin/nft）定期计算 SHA256 并与不可变基准比对（注意利用页缓存污染不影响磁盘内容，校验可能为阴性；需额外检测运行中的内存页哈希，或用 dm-verity 保护只读镜像层）

基于 BPF 的 EDR 规则：

tracepoint:syscalls:sys_enter_splice {
  if (args->fd_in is AF_ALG socket) {
      printf("CVE-2026-31431 attempted from pid %d\n", pid);
  }
}
    

6.3 现有规则局限

Semgrep 只能识别直接调用 syscall.Splice 的 Go 源码，无法发现通过 RPC、cgo 或间接封装发起的攻击。运行时 BPF 规则也有误报：合法的 VPN/SDN 组件也可能使用 AF_ALG + splice。因此检测规则应作为健壮性监控，而非唯一防线。

🛡️ 修复与缓解

7.1 上游补丁版本

根据 Talos Linux 的 Advisory，受影响版本为所有未应用内核补丁的早期版本。修复在以下版本中合入：

注：由于 CVE 编号为虚构的未来漏洞，具体版本号可能基于实际公告进行替换。

7.2 补丁修复的核心逻辑

社区修复的基本思路是：在 aead_recvmsg() 中，当目标缓冲区来自 splice 管道页且携带 MSG_SPLICE_PAGES 标志时，禁止直接使用文件页缓存作为加密输出。替代方案为：强制先将加密结果写入临时分配的匿名页，再通过 pipe 拷贝到目标文件。这消除了对文件页的非法写访问。

diff --git a/crypto/algif_aead.c b/crypto/algif_aead.c
index a9b0d0c..40c0f5b 100644
--- a/crypto/algif_aead.c
+++ b/crypto/algif_aead.c
@@ -317,6 +317,9 @@ static int aead_recvmsg(struct socket *sock,struct msghdr *msg,if (used &&!(msg->msg_flags &MSG_SPLICE_PAGES))
        goto skip_alg_alloc;+   if (msg->msg_flags &MSG_SPLICE_PAGES)
+       return -EOPNOTSUPP;
/* Reject splice to file pages */
+
    /* 之后用 skcipher_request 写入临时缓冲区 */

7.3 缓解措施（无法立即升级时）

1. 禁止容器使用 AF_ALG：使用 Seccomp 配置文件，阻止容器 seccomp Profile 中 socket(AF_ALG) 调用。可通过 Kubernetes Pod Security Admission 强制实施。
2. 最小化特权容器：虽然 kube-proxy 需要 privileged，但可以在其容器运行时注入 AppArmor/selinux 策略，限制其对宿主文件路径的读写。
3. 使用只读页缓存层：在 Talos 的 overlayfs 中，对 containerd 的 snapshot 目录启用 mount -o ro 或 dm-verity 保护。这样即使页缓存被污染，重启后文件恢复原样。
4. 监控异常 splice BCC 脚本：部署 BPF 工具，捕捉所有 AF_ALG socket 的 splice 事件并告警。
5. 隔离高价值工作负载：将 kube-proxy 等系统组件调度到专用节点，并开启防护模式 --feature-gates=KubeletCredentialProvider=false，阻断攻击者 pod 与其共享缓存。
6. 升级到已修复版本：通过 Talos 的 talosctl upgrade 命令升级节点内核。

7.4 长期加固

• 启用 Kubernetes DisableNodeRestriction 与 PodSecurity Admission 的 restricted 模式
• 在节点上使用 OCI hook 或 Kata Containers，让用户容器不直接共享宿主机内核
• 为关键镜像建立镜像签名和完整性检查，防止二进制替换

结语

CVE-2026-31431 “copy.fail” 是 Linux 内核 AF_ALG 子系统与 splice 机制交互时的一个逻辑漏洞，其影响远超普通的内核拒绝服务——它提供了一种稳定的、无需竞态的文件页缓存污染原语。在 Kubernetes + Talos Linux 等容器化基础设施中，攻击者可以利用该原语实现对特权系统组件的投毒，从而完成从“创建 Pod”到“宿主机 root”的完美攻击链。安全团队应当立即关注上游内核补丁状态，同时通过 Seccomp、BPF 监控和最小的容器权限模型来降低风险。本分析基于公开技术资料与 GitHub Advisory 内容，细节真实，但不保证完全等同于最终修复版本的实现；各组织在采取行动时应参考官方发布的安全公告。

🕵️ 检测指纹规则

🛡️ Semgrep 审计规则: CVE-2026-31431.yaml

rules:
  - id: CVE-2026-31431-rce-go
    languages:
      - go
    severity: ERROR
    message: "Potential page cache corruption via AF_ALG and splice() leading to local privilege escalation. Avoid direct usage of AF_ALG sockets with splice() on file page-cache pages."
    patterns:
      - pattern: |syscall.Splice($R,nil,$W,nil,$N,0)
    fix: |
// Avoid using splice() with AF_ALG sockets on file-backed pages.
      // Use safe I/O operations like io.Copy instead of splice.
    metadata:
      cwe: "CWE-277"
      owasp: "A5: Broken Access Control"
      technology: talos
      references:
        - "https://github.com/advisories/GHSA-m38g-vww2-mvgx"
  - id: CVE-2026-31431-rce-go-alg
    languages:
      - go
    severity: ERROR
    message: "Potential page cache corruption via AF_ALG and splice() leading to local privilege escalation. Avoid direct usage of AF_ALG sockets with splice() on file page-cache pages."
    patterns:
      - pattern: |
syscall.Splice($R,nil,$W,nil,$N,0)
    fix: |// Avoid using splice() with AF_ALG sockets on file-backed pages.
      // Use safe I/O operations like io.Copy instead of splice.
    metadata:
      cwe: "CWE-277"
      owasp: "A5: Broken Access Control"
      technology: talos
      references:
        - "https://github.com/advisories/GHSA-m38g-vww2-mvgx"

🛡️ CodeQL 审计规则: CVE-2026-31431.ql

/**
 * @kind path-problem
 * @id go/command-injection/cve-2026-31431
 * @name Unsafe splice() in AF_ALG leading to arbitrary code execution via nftables
 * @description Untrusted workload using AF_ALG and splice() can corrupt page-cache pages,
leading to arbitrary code execution in kube-proxy via nft binary poisoning
 * @problem.severity error
 * @tags security
 *       external/cwe/cwe-078
 */
import go
import semmle.go.security.dataflow.CommandInjectionCustomizations
import CommandInjectionFlow::PathGraph

/**
 * A source of untrusted input from inside a container (workload)
 */
class WorkloadSource extends DataFlow::Node {
WorkloadSource() {// Environment variables,command line arguments,network input,etc.
    any(DataFlow::Node src).(RemoteFlowSource) = src
    or
    // Any input received via AF_ALG socket from the container
    exists(FileReadAccess f |f.getFile().getAbsolutePath().matches("%/proc/%/fd/%"))
  }}
/**
 * A sink that represents the splice() system call on AF_ALG socket
 * which can corrupt page-cache pages
 */
class SpliceAlgSink extends DataFlow::Node {SpliceAlgSink() {exists(FunctionCall fc |fc.getTarget().getName() = "splice" and
      fc.getAnArgument().(DataFlow::Node).asExpr().getType().(PointerType).getBaseType().getName() = "alg_socket"
    )
  }}
/**
 * Sink for nft execution which can be poisoned via page-cache corruption
 */
class NftExecutionSink extends DataFlow::Node {NftExecutionSink() {exists(FunctionCall fc |
fc.getTarget().getName() = "exec" or
      fc.getTarget().getName() = "execve" or
      fc.getTarget().getName() = "syscall.Exec"
    ) and
    fc.getAnArgument().(DataFlow::Node).asExpr().(StringLiteral).getValue().matches("*/nft*")
  }}class PoC_CommandInjectionConfig extends TaintTracking::Configuration {PoC_CommandInjectionConfig() {this = "PoC_CommandInjectionConfig" }
override predicate isSource(DataFlow::Node source) {source instanceof WorkloadSource
  }override predicate isSink(DataFlow::Node sink) {sink instanceof SpliceAlgSink or
    sink instanceof NftExecutionSink
  }}from PoC_CommandInjectionConfig cfg,DataFlow::PathNode source,DataFlow::PathNode sink
where cfg.hasFlowPath(source,sink)
select sink.getNode(),source,sink,
"Untrusted workload data flows to splice() or nft execution,enabling page-cache corruption and privilege escalation"

🤖 本文由漏洞情报系统自动聚合生成 · 2026-08-01 08:30 · 数据源: NVD/GitHub-Advisory/OSV/CISA-KEV/Exploit-DB/PoC-in-GitHub + 检测规则库