潜伏9年、一键提权：Linux 内核 CVE-2026-31431 "Copy Fail" 漏洞深度剖析与攻防实战

写在前面

2026年4月29日，韩国安全团队 Theori 向全世界披露了一个令人脊背发凉的漏洞：CVE-2026-31431，代号 "Copy Fail"。

这不是一个需要竞争条件（Race Condition）的漏洞。不需要堆喷射（Heap Spraying），不需要复杂的ROP链，甚至不需要深厚的漏洞利用经验。攻击者只需要几行 Python 代码、几十秒时间，就能把一个普通用户变成 root。

更让人不安的是：漏洞的代码 2017年就存在了。9年。无数台服务器、无数个容器集群、无数个云主机，在过去9年里每一天都暴露在这个漏洞之下。而这一切的起点，不过是一次看似无害的"性能优化"。

这篇文章，我们从漏洞的底层机制讲起，深入内核加密子系统，完整拆解攻击链，给出从检测到修复的全套方案，并对容器逃逸风险做专门分析。目标只有一个：让每一个读到这篇文章的工程师，都能在自己的系统上做到心中有数、手上有招。

一、背景：为什么这个漏洞值得关注

1.1 漏洞档案卡

1.2 一句话总结

攻击者利用 Linux 内核加密子系统（algif_aead）与 splice() 零拷贝系统调用的组合缺陷，向任意可读文件的页缓存（Page Cache）写入 4 字节的受控数据，从而篡改 setuid 程序（如 /usr/bin/su）在内存中的执行逻辑，无需竞争条件即可直接获得 root 权限。

1.3 为什么值得关注

第一，利用门槛极低。 公开的 PoC 只有 732 字节的 Python 代码，不需要复杂的漏洞利用技术。这意味着不只是国家级黑客，普通的恶意用户、甚至是内部人员的误操作，都可能造成灾难性后果。

第二，影响面极广。 从 2017 年到 2026 年，所有使用 4.14 及以上内核的服务器都受到影响。主流云服务商（AWS/GCP/Azure/阿里云等）的大量 Linux 实例均在此范围内。

第三，容器隔离可以被击穿。 这个漏洞不只是影响宿主机本身。容器内的普通用户，利用相同的机制，可以突破容器隔离，逃逸到宿主机获得 root 权限。对于 Kubernetes 集群来说，这意味着整个集群的安全性都受到了威胁。

第四，检测和修复并不容易。 由于漏洞利用过程只修改内存中的页缓存，不修改磁盘文件，因此传统的主机入侵检测系统（HIDS）很难通过文件完整性检查发现攻击痕迹。

二、漏洞技术机制：从加密子系统到页缓存的致命链路

理解 CVE-2026-31431，需要理解三个关键组件之间的交互：AF_ALG 套接字、splice() 系统调用、以及 authencesn AEAD 算法。单独看每个组件都没有问题，漏洞产生于它们组合使用时的边界条件。

2.1 组件一：AF_ALG 套接字接口

Linux 内核从 2.6.38 开始引入 AF_ALG 协议族，这是一种让用户态程序直接使用内核加密服务的机制。相比于传统的 /dev/crypto 接口，AF_ALG 更安全、更规范，是现代 Linux 系统使用内核加密的事实标准。

创建和使用 AF_ALG 套接字的基本流程如下：

import socket

# 创建一个 AF_ALG 套接字
sock = socket.socket(socket.AF_ALG, socket.SOCK_SEQPACKET, 0)

# 绑定到一个加密算法（比如 authencesn）
sock.bind(('aead', 'authencesn(GenericMAC)'))

# 设置密钥
sock.setsockopt(socket.SOL_ALG, socket.ALG_SET_KEY, key)

# 获取文件描述符用于读写
afd = sock.dup()

AF_ALG 支持多种加密原语，包括 AEAD（Authenticated Encryption with Associated Data，带关联数据的认证加密）。AEAD 保证了数据的机密性和完整性，是 IPsec、WireGuard 等安全协议的基石。

2.2 组件二：splice() 系统调用

splice() 是 Linux 2.6.17 引入的一个天才设计。它的核心思想是：在两个文件描述符之间移动数据，而不需要在用户态和内核态之间复制数据。

传统的数据传输路径：

用户缓冲区 → 内核缓冲区 → （系统调用拷贝）→ 目标缓冲区

splice() 的数据传输路径：

文件描述符 A → 内核管道缓冲区 → 文件描述符 B
（全程在内核中完成，无需用户态参与）

零拷贝对于大文件传输、高性能网络编程等场景有巨大的性能优势。这就是为什么在 nginx、git 等工具的底层，我们经常能看到 splice() 的身影。

splice() 的一个关键特性是：它可以在套接字和普通文件之间零拷贝传输数据。当 splice() 用于将文件内容传入 AF_ALG 套接字时，内核实际上是将该文件的页缓存页面直接链入到加密处理流程中。

2.3 组件三：authencesn 算法与 AEAD in-place 优化

authencesn 是一个专门为 IPsec 扩展序列号（ESN）设计的 AEAD 算法。它在解密时有一个特殊的需求：需要写入解密结果的序列号低位（seqno_lo）。

2017 年，为了优化性能，内核加密团队在 algif_aead 模块中引入了一项 in-place（就地）优化。在此优化之前，AEAD 解密操作需要分离的输入缓冲区和输出缓冲区；引入优化后，输出可以复用输入的缓冲区空间，从而减少内存分配和拷贝。

问题出在这里：algif_aead 的 in-place 优化假设输入和输出缓冲区都是用户态分配的内存，并且这些内存区域是受信任的。

但 splice() 的介入打破了这一假设。当用户通过 splice() 将文件的页缓存页面传入 AF_ALG 套接字时，页缓存页面被链入了可写的 scatterlist（散列表）——而这个页面原本属于内核维护的文件缓存，通常是只读的或至少不应被用户态直接覆写的。

2.4 漏洞根因：4 字节越界写入

authencesn 在解密 AEAD 数据时，会将解密结果的序列号低位（seqno_lo，4字节）写入到一个输出缓冲区边界之外的位置——这个位置恰好是传入的页缓存页面中的某个偏移处。

// authencesn_decrypt 简化示意（非实际代码）
static int authencesn_decrypt(struct aead_request *req)
{
    // ... 初始化解密 ...

    // 解密输出到 out 缓冲区
    skcipher_decrypt(&decrypt_req);

    // 关键缺陷：在合法输出边界之外写入 seqno_lo
    // 这个写入假设 out 缓冲区末尾有额外 4 字节的空间
    // 但如果 out 来自文件页缓存，这里就会覆写页缓存内容
    put_unaligned_le32(seqno, out + cryptlen);

    return 0;
}

这就是为什么这个漏洞被命名为 "Copy Fail"：解密操作的"复制"行为因为逻辑缺陷而"失败"，越界写入了本不应该被修改的文件页缓存。

2.5 为什么 4 字节足够完成提权

很多读者会好奇：只写入 4 字节，怎么可能完成提权？

这涉及到 ELF 二进制文件的执行逻辑。我们知道，ELF 可执行文件在加载到内存后，包含代码段（.text）和数据段（.data）等区域。在代码段中，存在大量条件跳转指令，例如：

# 常见的权限检查伪代码
mov  eax, [uid_from_process]    # 读取当前进程的 uid
cmp  eax, 0                     # 检查是否为 0（root）
jne  access_denied              # 不为 0 则跳转拒绝访问

一个 x86-64 的条件跳转指令（如 jne）的机器码是 2 字节（操作码 0x75 + 相对偏移 1 字节）。如果改成无条件跳转（jmp，操作码 0xEB + 1 字节偏移），同样只需要 2 字节。

4 字节足以完成以下任一操作：

• 将 jne access_denied（2字节）覆盖为 jmp skip_check（2字节），跳过权限检查
• 将返回地址低位 4 字节覆写成指向 /bin/sh gadget 的地址
• 修改 GOT（全局偏移表）条目，将某个 libc 函数的地址指向 system()

这就是为什么如此"微小"的越界写入，能够成为致命武器。

三、攻击链完整拆解：从普通用户到 root

3.1 攻击前置条件

攻击者需要满足以下条件：

1. 拥有一个非 root 的本地账户，或者容器内的普通用户
2. 目标系统的内核版本在 4.14 ~ 6.18.21 / 6.19.11 之间
3. 目标内核启用了 CONFIG_CRYPTO_USER_API_AEAD=y（大多数发行版默认启用）

注意：满足以上条件并不难。对于容器场景，Docker/Kubernetes 默认不限制创建 AF_ALG 套接字，这使得容器内用户可以直接发起攻击。

3.2 攻击流程分步解析

第一步：探测漏洞存在性

import socket
import os

# 检查系统是否支持 AF_ALG 且 authencesn 可用
try:
    sock = socket.socket(socket.AF_ALG, socket.SOCK_SEQPACKET, 0)
    sock.bind(('aead', 'authencesn(GenericMAC)'))
    print("[+] AF_ALG + authencesn 可用，漏洞可能存在")
except OSError as e:
    print(f"[-] 不可利用: {e}")
    exit(1)

第二步：定位要篡改的目标文件

攻击者需要选择 /usr/bin/su 或 /usr/bin/sudo 等 setuid 程序。这些程序在磁盘上的文件内容不受影响，攻击者只需要修改内存中正在运行的进程所对应的页缓存。

# 确保目标文件的页缓存被加载到内存
with open('/usr/bin/su', 'rb') as f:
    # 读取文件触发页缓存预加载
    f.read(8192)

第三步：通过 splice() 将页缓存注入 AF_ALG 管线

这是整个攻击链最精妙的部分。用户态程序通过 splice() 系统调用，将 /usr/bin/su 的页缓存页面直接送入内核的加密处理管线：

import socket, os

# 创建管道（splice 需要管道作为中介）
r_fd, w_fd = os.pipe()

# 读取目标文件到管道（此时页缓存被激活）
with open('/usr/bin/su', 'rb') as f_src:
    os.write(w_fd, f_src.read(8192))

# 创建 AF_ALG 套接字
af_sock = socket.socket(socket.AF_ALG, socket.SOCK_SEQPACKET, 0)
af_sock.bind(('aead', 'authencesn(GenericMAC)'))

# 设置伪造的密钥（实际用于构造 AEAD 数据）
fake_key = b'\x00' * 64
af_sock.setsockopt(socket.SOL_ALG, socket.ALG_SET_KEY, fake_key)

# 通过 splice() 将页缓存数据注入 AF_ALG
afd = af_sock.dup()
# 关键步骤：splice 将页缓存页面链入 scatterlist
os.splice(r_fd, None, afd.fileno(), None, 4096, 0)

第四步：触发 authencesn 越界写入

# 构造恶意的 AEAD 密文（包含 seqno_lo 写入偏移控制）
# ... 完整的 exploit 逻辑见公开 PoC（732字节）...

# 发送解密请求，触发 authencesn 的越界写
# 越界写入恰好覆盖 su 二进制在页缓存中的权限检查代码
os.read(afd.fileno(), 4096)

第五步：执行被篡改的 setuid 程序

页缓存被修改后，当 /usr/bin/su 被再次执行时，加载到内存的是已经被篡改过的代码。攻击者精心控制的 4 字节覆盖了权限检查逻辑，使得 su 程序在执行时认为自己有 root 权限。

# 执行被篡改的 su
/usr/bin/su -

# 预期输出：uid=0(root) gid=0(root)
id
# uid=0(root) gid=0(root) groups=0(root)

3.3 容器逃逸场景

在容器环境中，攻击流程几乎完全相同，但攻击目标是宿主机的 setuid 二进制：

1. 容器内普通用户通过 /proc/self/fd 访问宿主机的文件描述符（需要特情配置，通常在特权容器或不安全的 seccomp 配置下可行）
2. 或者，利用 cgroups v1 的某些特性，通过共享的页缓存实现跨容器覆写

对于 Kubernetes 集群来说，如果某个容器被攻破，攻击者可以利用这个漏洞逃逸到宿主机，进而横向移动到其他容器，威胁整个集群的安全。

四、漏洞检测与诊断

4.1 第一步：检查内核版本

uname -r

对照以下版本判断是否受影响：

4.2 第二步：检查内核编译配置

仅仅看内核版本还不够，还需要确认 CONFIG_CRYPTO_USER_API_AEAD 是否启用：

# 检查静态编译进内核的情况
grep CONFIG_CRYPTO_USER_API_AEAD /boot/config-$(uname -r)

# 可能出现三种结果：
# CONFIG_CRYPTO_USER_API_AEAD=n     → 彻底关闭，不受影响
# CONFIG_CRYPTO_USER_API_AEAD=y     → 静态编译，存在漏洞风险
# CONFIG_CRYPTO_USER_API_AEAD=m     → 模块方式，lsmod 可查到

4.3 第三步：检查模块加载状态

# 检查 algif_aead 模块是否加载
lsmod | grep algif_aead

# 如果有输出，说明模块已加载，漏洞路径激活
# authencesn 模块通常随 algif_aead 加载而加载
lsmod | grep authencesn

4.4 第四步：AF_ALG 套接字可用性测试

import socket

try:
    sock = socket.socket(socket.AF_ALG, socket.SOCK_SEQPACKET, 0)
    sock.bind(('aead', 'authencesn(GenericMAC)'))
    print("[!] 系统存在漏洞风险：AF_ALG + authencesn 可用")
except OSError as e:
    print(f"[+] 安全：无法使用 authencesn - {e}")

五、漏洞修复：从临时止血到根治

5.1 方案一：临时缓解（无需重启）

适用场景：无法立即安排重启窗口的生产环境。

核心思路：通过 modprobe 配置，永久禁止 algif_aead 模块加载。

# 1. 创建模块禁用配置
sudo tee /etc/modprobe.d/disable-algif-aead.conf << 'EOF'
install algif_aead /bin/false
EOF

# 2. 立即卸载已加载的模块（无需重启）
sudo rmmod algif_aead 2>/dev/null && echo "[+] 已卸载" || echo "[i] 模块未加载"

# 3. 验证缓解生效
lsmod | grep algif_aead
# 无输出 = 缓解成功

对于 RHEL/CentOS/Alibaba Cloud Linux，还需要更新 initramfs 确保重启后依然生效：

# Ubuntu/Debian
sudo update-initramfs -u

# RHEL/CentOS/Alibaba Cloud Linux
sudo dracut -f

关于 Docker 容器的 seccomp 防护

如果容器环境不需要使用 AF_ALG，可以通过 seccomp 配置文件阻止容器创建 AF_ALG 套接字，从根本上阻断漏洞利用路径：

// block-algof.json
{
    "defaultAction": "SCMP_ACT_ALLOW",
    "syscalls": [
        {
            "name": "socket",
            "action": "SCMP_ACT_ERRNO",
            "args": [
                {
                    "index": 0,
                    "value": 38,  // AF_ALG = 38
                    "op": "SCMP_CMP_EQ"
                }
            ]
        }
    ]
}

# 启动容器时加载防护规则
docker run \
    --security-opt seccomp:block-algof.json \
    -it your_image:latest /bin/bash

5.2 方案二：升级内核（根本修复）

这是彻底解决问题的方法。内核官方补丁为 commit a664bf3d603dc3bdcf9ae47cc21e0daec706d7a5。

5.2.1 通用内核源码修复

下载官方补丁：

# 从 kernel.org 下载
curl -O https://git.kernel.org/stable/c/a664bf3d603dc3d603dc3bdcf9ae47cc21e0daec706d7a5.patch

# 或从 GitHub
curl -O https://github.com/torvalds/linux/commit/a664bf3d603dc3bdcf9ae47cc21e0daec706d7a5.patch

# 国内镜像（速度快）
curl -O https://mirrors.aliyun.com/linux-kernel/pub/linux/kernel/v6.x/linux-6.18.22.tar.xz

5.2.2 Ubuntu / Debian

# 更新软件仓库
sudo apt update

# 升级所有包（含内核）
sudo apt full-upgrade -y

# 安装最新版内核
sudo apt install linux-image-amd64 linux-headers-amd64 -y

# 更新 GRUB
sudo update-grub

# 重启
sudo reboot

5.2.3 RHEL / Rocky Linux / AlmaLinux / Amazon Linux

# 清理缓存
sudo dnf clean all && sudo dnf makecache

# 升级内核
sudo dnf update kernel -y

# 重启（必须）
sudo reboot

# 重启后验证
uname -r
# 确认版本 >= 6.18.22 或 >= 6.19.12

5.2.4 国产操作系统

统信 UOS / 深度 Deepin：

sudo apt update && sudo apt full-upgrade -y
sudo reboot

麒麟 Kylin / 欧拉 OpenEuler：

sudo dnf clean all && sudo dnf makecache
sudo dnf update kernel -y
sudo reboot

龙蜥 Anolis OS：

sudo dnf update kernel -y
sudo reboot

5.3 修复验证

无论使用哪种方案，修复后都需要验证：

# 1. 检查内核版本
uname -r
# 内核版本应在 6.18.22+ / 6.19.12+ / 7.0+

# 2. 检查 algif_aead 模块（如果使用模块化内核）
lsmod | grep algif_aead
# 应无输出

# 3. RHEL 系：检查变更日志
rpm -qa --changelog kernel | grep CVE-2026-31431

# 4. Debian 系：检查变更日志
apt changelog linux-image-$(uname -r) | grep CVE-2026-31431

5.4 内网/离线环境修复

对于无法连接互联网的内网服务器，需要在有网环境中下载离线补丁包，传输到内网后再安装：

# 有网机器下载 Rocky Linux 9.7 修复内核包示例
cd /tmp/offline-kernel
wget https://download.rockylinux.org/pub/rocky/9.7/BaseOS/x86_64/os/Packages/k/\
kernel-5.14.0-611.45.1.el9_7.x86_64.rpm

# 拷贝到内网服务器
scp /tmp/offline-kernel/*.rpm user@内网服务器:/opt/offline-kernel/

# 内网服务器上安装
cd /opt/offline-kernel
sudo dnf install -y *.rpm --disablerepo=*
sudo grub2-mkconfig -o /boot/grub2/grub.cfg
sudo reboot

六、容器安全专项加固

6.1 为什么容器环境更危险

在传统服务器场景中，攻击者需要拥有该服务器的本地账户。而在容器场景中，容器内的普通用户（非 root）本身就可能触发漏洞，从而实现容器逃逸。

更危险的是：许多多租户 Kubernetes 集群中，不同租户的容器共享宿主机内核。一旦某个容器利用此漏洞逃逸，攻击者可以横向移动到其他租户的容器，甚至控制整个节点。

6.2 seccomp 加固（推荐）

创建阻止 AF_ALG 套接字的 seccomp 配置文件：

// no-algof-syscalls.json
{
  "defaultAction": "SCMP_ACT_ALLOW",
  "syscalls": [
    {
      "names": ["socket"],
      "action": "SCMP_ACT_ERRNO",
      "args": [
        {
          "index": 0,
          "value": 38,
          "op": "SCMP_CMP_EQ"
        }
      ]
    }
  ]
}

# 应用到 Pod
kubectl apply -f - << 'EOF'
apiVersion: v1
kind: Pod
metadata:
  name: secured-app
spec:
  securityContext:
    seccompProfile:
      type: Localhost
      localhostProfile: no-algof-syscalls.json
  containers:
  - name: app
    image: your-image
EOF

全局应用到所有 Pod（Kubernetes 级别）：

# 使用 PodSecurityStandards (PSS) 或 seccomp 配置文件
apiVersion: apiserver.config.k8s.io/v1
kind: SeccompProfile
metadata:
  name: no-algof
spec:
  syscalls:
  - action: SCMP_ACT_ERRNO
    names:
    - socket
    args:
    - index: 0
      value: 38
      op: SCMP_CMP_EQ

6.3 容器运行时限制

对于 Docker，可以直接使用 --cap-drop 限制容器权限：

docker run --cap-drop=ALL \
           --security-opt=no-new-privileges \
           --read-only \
           your_image

6.4 宿主机侧防护

对于 Kubernetes 集群管理员，以下配置可以有效阻断容器逃逸路径：

# 检查节点上 algif_aead 模块状态
kubectl get nodes -o jsonpath='{range .items[*]}Node: {.metadata.name}
Kernel: {.status.nodeInfo.kernelVersion}
Architecture: {.status.nodeInfo.architecture}
---
'

建议在所有集群节点上统一升级内核，并在节点初始化脚本中加入模块禁用逻辑：

# kubeadm node init 脚本中追加
cat << 'KERNEL_FIX' >> /etc/rc.local
# CVE-2026-31431 mitigation
if [ -f /etc/modprobe.d/disable-algif-aead.conf ]; then
    rmmod algif_aead 2>/dev/null
fi
KERNEL_FIX
chmod +x /etc/rc.local

七、各发行版修复状态汇总

截至 2026 年 7 月，各主流发行版的修复状态如下：

八、长期安全策略

8.1 内核自动更新

不要等到漏洞披露才想起来打补丁。配置自动化的内核安全更新：

RHEL 系（yum-cron）：

sudo dnf install -y yum-cron
sudo systemctl enable --now yum-cron
# 编辑 /etc/yum/yum-cron.conf
update_messages = yes
download_updates = yes
apply_updates = yes

Debian 系（unattended-upgrades）：

sudo apt install -y unattended-upgrades
sudo dpkg-reconfigure -plow unattended-upgrades

8.2 容器运行时安全基线

# Kubernetes Pod Security Standards - Restricted
apiVersion: v1
kind: Namespace
metadata:
  name: production
  labels:
    pod-security.kubernetes.io/enforce: restricted
    pod-security.kubernetes.io/audit: restricted
    pod-security.kubernetes.io/warn: restricted

8.3 定期漏洞扫描

建议在 CI/CD 流水线中加入容器镜像和主机内核的漏洞扫描：

# 使用 trivy 扫描容器镜像
trivy image --severity HIGH,CRITICAL your_image:latest

# 使用 lynis 扫描主机安全基线
sudo lynis audit system

九、总结

关键结论

1. CVE-2026-31431 是一个被严重低估的高危漏洞。 9 年的潜伏期、极低的利用门槛、极广的影响范围，使得这个漏洞成为 2026 年最重要的基础设施安全事件之一。

2. 修复并不复杂，难的是意识到问题的严重性。 内核升级是根本解决方案，临时缓解（禁用 algif_aead 模块）可以作为短期内快速止血的手段。

3. 容器逃逸是这个漏洞最容易被利用的场景。 任何运行 Kubernetes 或 Docker 的团队，都应该将这个漏洞的修复列为最高优先级。

4. 长期来看，Linux 内核安全需要更严格的接口边界管理。 AF_ALG 这样的内核-用户态接口，在设计之初没有充分考虑与 splice() 等零拷贝机制组合使用时的安全问题。这个教训值得所有内核开发者深思。

行动清单

[ ] 检查所有 Linux 服务器的内核版本（uname -r）
[ ] 对受影响系统执行临时缓解（禁用 algif_aead 模块）
[ ] 制定内核升级计划（含维护窗口）
[ ] 检查容器环境：确认是否需要 seccomp 防护
[ ] 更新容器运行时配置，限制 AF_ALG 套接字
[ ] 扫描 CI/CD 流水线中的容器镜像漏洞
[ ] 配置内核自动更新机制
[ ] 建立 CVE 响应流程，避免类似漏洞遗漏

愿每一位工程师在面对这样的漏洞时，都能做到：心中有数，手上有招，脚下有路。