引子

732 字节!!

一个 Linux 内核本地提权漏洞的完整 PoC,只有 732 字节。

而且它不需要竞争条件,不需要内核版本特定的偏移量,不需要任何复杂的前置配置。它就是直线逻辑缺陷——内核按设计意图执行,却产生了设计意图之外的后果。从 2017 年一个无辜的 in-place 优化 commit 引入,存在了 9 年,直到 2026 年 4 月才被发现。

它公开后不到 48 小时就进了 CISA KEV(已知被利用漏洞目录)。K8s 容器逃逸 PoC 随即跟进。受影响版本覆盖 4.14 到 6.19 之间的几乎所有主流发行版。

大概流程① 内核版本和环境确认 → ② PoC 仅有 732 字节 → ③ 执行 PoC 输出页缓存污染日志 → ④ whoami 变成 root → ⑤ sha256sum 显示磁盘文件未被修改。整张图的核心信息:从普通用户到 root,磁盘校验正常,但进程读到的是被篡改的版本。

这篇文章会带你走完这条利用链上的每一个环节——为什么 splice() 能让只读文件的页缓存进入可写路径?为什么 authencesn 会越界写那 4 个字节?为什么磁盘校验工具查不出?以及在容器场景下,这个问题为什么比裸机严重十倍。

一、漏洞速览

先把基本信息摊开,后面的分析全部建立在这个基础之上。

项目

内容

CVE

CVE-2026-31431

别名

Copy Fail

类型

Linux 内核本地权限提升

CVSS

7.8 High(Ubuntu)/ 8.8(SUSE)

引入时间

2017 年(commit 72548b093ee3)

存在时长

约 9 年

公开日期

2026-04-29

发现者

Theori / Xint Code

PoC

732 字节 Python 脚本

默认目标

/usr/bin/su

CISA KEV

2026-05-01 收录,要求联邦机构 15 天内修复

核心模块

crypto/algif_aead + authencesn

攻击原语

页缓存写入(page cache write)

漏洞性质

直线逻辑缺陷——不是竞争条件

受影响范围

说明:Google Sheets 风格的电子表格。第一列是发行版(Ubuntu/RHEL/Debian/SUSE/Amazon Linux),第二列是受影响内核版本范围,第三列是修复版本,第四列是修复状态。表格底部单列一行标注"CISA 要求联邦机构 2026-05-15 前修复"。这张图让读者一眼看清自己有没有中招。

受影响的内核分支包括 4.14、5.10、5.15、6.1、6.6、6.12、6.18、6.19、7.0-rc 全系列。几乎覆盖所有主流发行版的默认内核。

受影响的发行版包括 Ubuntu 14.04 到 24.04、RHEL 8/9/10、Debian 11/12/13、SUSE 企业版全系列、Amazon Linux、NixOS 等。这不是"某个冷门发行版的问题"——如果你的 Linux 服务器在 2017 年到 2026 年 5 月之间装的内核,大概率中招。

二、原理拆解:从 splice() 到页缓存污染

先说结论:这个漏洞不是某个检查缺失,不是某个边界条件没处理好,而是两个正确的设计行为撞在一起,产生了一个不正确的后果。

1. AF_ALG:内核里的加密 Socket

AF_ALG 是 Linux 提供给用户态的内核加密接口。你可以把它理解成一个特殊的 socket——你在用户态创建它、往里面 send 数据、从里面 recv 结果,加密/解密在内核里完成。

关键点:AF_ALG 支持 AEAD(Authenticated Encryption with Associated Data),也就是认证加密。AEAD 的数据格式分三块:关联数据(AAD)、密文、认证标签(authentication tag)。

验证阶段,内核需要确认 AAD + 密文 + tag 的完整性。如果验证通过,解密输出就放进用户给的接收缓冲区。

2. splice():零拷贝的诱惑

splice() 是 Linux 的一个神奇系统调用——它可以在两个文件描述符之间搬数据,而且尽量不复制。

比如你把一个文件 splice 到一个 pipe,pipe buffer 直接引用文件的页缓存页面,而不是新分配内存复制一份。这就是"零拷贝"。

把 pipe 再 sendmsg 到 AF_ALG socket,内核的 scatterlist 就指向了文件在页缓存中的原始页面。

说明:Excalidraw 手绘风格的流程图。从左到右展示:磁盘文件 → 页缓存(只读)→ splice(file→pipe) → pipe buffer 引用页缓存 → sendmsg(pipe→AF_ALG) → TX scatterlist 指向页缓存 → 进入 AEAD 解密路径。关键节点用不同颜色标记——页缓存节点标橙色("本是只读"),scatterlist 节点标红色("进入了可写链路")。核心信息一目了然。

到这里还没问题——页缓存被 scatterlist 引用,但只是读,不写。

3. 根因一:Tag 页被链入可写 dst scatterlist

问题出在 algif_aead.c 的 receive 路径上。

AEAD 解密的输入缓冲区包含 AAD + 密文 + tag。解密后,AAD 和明文被拷贝到用户接收缓冲区,但 tag 不需要输出——它已经验证过了,没用了。

然而,代码做了一个"优化":tag 没有拷贝,而是通过 sg_chain() 直接把 TX scatterlist 中 tag 对应的那段链接到了输出 scatterlist 的尾部。

为什么这样做?因为 in-place 模式下 req->dst = req->src,不需要关心它。但问题是:

req->src(输入 scatterlist)里 tag 那段 → 指向 splice 进来的文件页缓存页面req->dst(输出 scatterlist)→ 被 sg_chain() 接上了 tag 段crypto_aead_decrypt(req) → 对 req->dst 做解密写入

文件页缓存(只读页面)就这样进入了可写 scatterlist。

4. 根因二:authencesn 的 4 字节越界写

光有"只读页面在可写 scatterlist 里"还不够——还需要有人真的往那个位置写。

authencesn 登场了。authencesn 是 IPsec ESN(Extended Sequence Number)场景用的 AEAD wrapper。ESN 的高 32 位序列号 seqno_hi 需要在认证计算时做临时处理——恰好是 4 个字节的 scratch write。

这个 scratch write 的落点是由 scatterlist 的偏移量决定的。由于 tag 段被 sg_chain() 接到了输出链尾,authencesn 的 4 字节写入就越过了合法输出区域,直接落到了链尾的 tag 页上。

写入之前: tag 页是 /usr/bin/su 的页缓存内容(原封不动)写入之后: tag 页被 authencesn 的临时计算结果覆盖了 4 个字节

说明:简洁笔记风格的分析图。上半部分展示正常的 AEAD 输出布局(AAD),下半部分展示漏洞场景——scatterlist 链尾挂上了来自文件页缓存的 tag 页面,authencesn 的 4 字节 scratch write 越过合法边界落到 tag 页上。中间用红色虚线框标注越界区域。核心信息:4 字节的越界写,污染的目标恰好是 setuid 程序的页缓存。

5. 为什么是直线逻辑缺陷

大多数 Linux 内核提权漏洞靠竞争条件。你需要在一个极窄的时间窗口里完成操作——创建线程、触发页错误、在内核还没来得及检查权限之前修改内存映射。

Copy Fail 不需要这些。

它不是"内核做错了检查",而是"内核按设计做对了所有事,但两个正确行为叠在一起产生了错误效果"。splice 的零拷贝是对的,sg_chain 的优化是对的,authencesn 的 scratch write 也是对的——只是三者凑到一起,就变成了页缓存污染。

这也是为什么它的影响范围这么广。因为不依赖特定版本的偏移量,不依赖特定架构的竞争窗口。只要内核里有这三个正确行为即可——而它们存在于过去 9 年的几乎所有内核版本中。

三、复现过程

公开 PoC 由 Theori / Xint Code 发布,732 字节 Python。GitHub 仓库 theori-io/copy-fail-CVE-2026-31431。后来出现了 C 版本(跨平台、nolibc)、Rust 版本、Go 版本,以及专门的 K8s 容器逃逸版本。

利用流程

整体的利用链分五步:

第一步:创建 AF_ALG socket。 指定 authencesn 模板的 AEAD 算法。代码大概长这样:

sock = socket(AF_ALG, SOCK_SEQPACKET, 0)
sock.bind((b'aead', b'authencesn(cbc(aes),hmac(sha256))'))

第二步:splice 目标文件到 pipe。 打开 /usr/bin/su,通过 splice 将文件内容传入 pipe。此时 pipe buffer 直接引用页缓存页面。

第三步:sendmsg 到 AF_ALG。 将 pipe 的内容作为 AEAD 输入发送到 AF_ALG socket。内核将 scatterlist 指向页缓存。

第四步:触发 AEAD 解密。 构造特定的 AEAD 请求,触发 authencesn 的 scratch write。这 4 个字节的写入落点经过精心计算,恰好落在页缓存中 su 二进制的关键偏移位置。

第五步:执行被污染的目标。 此时磁盘上的 /usr/bin/su 完全未变,但内核页缓存中的内容已被修改。执行 su 时,进程从页缓存读出被篡改的版本,攻击者获得 root shell。

关键坑位:偏移量的选择

这里有一个容易被忽略的细节——那 4 个字节写在哪里不是随便选的。

authencesn 的 scratch write 内容是 ESN 高 32 位的计算结果,你没办法直接控制"写什么值"。你只能控制"写在哪里"和"写入的条件"。

PoC 的做法是选择 /usr/bin/su 中一个特定的位置——某个对执行流影响可控的偏移——让 4 字节的写入恰好修改 su 的行为,使其跳过权限检查。

这也是为什么 PoC 默认目标是 /usr/bin/su 而不是别的 setuid 程序——su 的二进制结构相对稳定,偏移量好预测,修改效果可靠。

不过,攻击者完全可以用同样的原语攻击任何可读文件在页缓存中的副本。目标不限于 su——任何 setuid 程序、任何共享库、任何配置文件都可能被利用。

四、踩坑:这个漏洞到底难在哪

写了这么多原理,说一个我在分析过程中真正踩过的认知坑。

我一开始的理解是:splice 让只读文件的页缓存进入了 AF_ALG 的 scatterlist → authencesn 越界写污染了它 → 搞定了。

这个理解方向没错,但缺了最关键的一环——为什么 authencesn 的越界写能够"恰好"落在 tag 页上?

如果你去看 algif_aead.c 的 receive 代码,你会发现 scatterlist 的布局比你想象的要复杂。TX scatterlist(输入)有多个段:AAD 段、密文段、tag 段。RX scatterlist(输出)是用户 recvmsg 提供的缓冲区。

sg_chain() 把 TX scatterlist 中的 tag 段链接到 RX scatterlist 的尾部,形成一个新的链表。crypto_aead_decrypt 处理的是这个链表。

但 authencesn 的 scratch write 不是处理"链表尾"——它处理的是 scatterlist 中某个特定的位置偏移。这个位置偏移是由 AEAD 算法的内部状态决定的。如果 tag 段恰好被链在这个位置偏移的范围之内,越界就发生了。

问题的核心是:AEAD 算法的 scatterlist 遍历逻辑和 algif_aead 的 scatterlist 拼接逻辑之间存在一个未文档化的对齐假设。算法假设 scatterlist 是连续的、完整的、由调用者提供的;但 algif_aead 的 sg_chain 拼接行为打破了"连续"这个假设。

这不是一个简单的"忘记检查"——这是两个模块各自独立设计的 scatterlist 使用方式之间的冲突。如果你只看其中一个模块的代码,你会发现它完全正确。只有当你同时追踪 scatterlist 在 AF_ALG 框架和 AEAD 算法中的完整生命周期,你才会发现冲突点。

这就是为什么它躲过了 9 年的代码审查。

五、为什么绕过磁盘完整性检查

这个漏洞真正精妙的地方不在于提权——提权的 LPE 太多了。精妙的是污染的只有页缓存,磁盘纹丝不动。

想一想后果:

$ sha256sum /usr/bin/su
a1b2c3d4e5...  /usr/bin/su     ← 和官方包完全一致

$ rpm -V coreutils
(无输出)                         ← RPM 验证通过

$ ls -la /usr/bin/su
-rwsr-xr-x 1 root root 67816 Jan 15 2024 /usr/bin/su  ← 时间戳正常
                                                                  
$ /usr/bin/su                                                   
# id                                                            
uid=0(root) gid=0(root)        ← 但执行时变成了 root

磁盘校验工具(sha256sum、rpm -V、dpkg --verify、Tripwire、AIDE)全部失效,因为它们检查的是磁盘上的内容,而攻击修改的是内存中的页缓存。

这不是一个 bug——这是页缓存机制的根本设计。页缓存就是为了让"读磁盘"更快而存在的内存副本。内核不认为你还需要"校验内存中的副本是否和磁盘一致",因为内存中的副本不应该被非授权修改。但 Copy Fail 证明了它可以。

关键点:页缓存是跨进程共享的。攻击者在一个进程里污染了 su 的页缓存,其他进程——甚至其他容器——执行 su 时都会读到被污染的版本。

重启能清除吗?能。echo 3 > /proc/sys/vm/drop_caches 能清除吗?能。但问题在于:在你发现被攻击之前,你不会去清除页缓存。而"发现被攻击"这件事——磁盘校验工具帮不了你。

六、容器场景:这个漏洞在容器里更危险

裸机上的 Copy Fail 已经够严重了。但在容器场景下,问题指数级放大。

1. 页缓存是跨容器共享的

Linux 内核的页缓存不是 per-namespace 的。同一个文件在宿主机上只有一份页缓存,所有容器和宿主机进程共享它。

这意味着:

  • 容器 A(低权限)污染了 /usr/bin/su 的页缓存
  • 容器 B("隔离"的)执行 su 时读到被污染版本
  • 宿主机上的任何进程执行 su 也读到被污染版本

一个"隔离"的容器,通过页缓存污染,影响了宿主机上的所有进程。

2. K8s Pod 级别逃逸

GitHub 上已经出现了专门针对 Kubernetes 的 PoC——Percivalll/Copy-Fail-CVE-2026-31431-Kubernetes-PoC。它的描述是"fully unprivileged container escape to node-level code execution"。

完全无特权的容器逃逸到节点级代码执行。

在 K8s 场景下,一个租户的 Pod——没有任何特权、没有任何 hostPath、没有任何 cap 添加——可以通过 Copy Fail 污染页缓存、影响宿主机、最终控制整个节点。

这对多租户 K8s 平台(比如云厂商的 Serverless K8s、CI/CD 平台)来说,是灾难级的。

说明:Excalidraw 手绘风格的架构图。左侧:三个容器(A/B/C)和宿主机进程,它们各自有自己的 namespace 隔离。中间:Linux 内核的页缓存层——标注"跨容器共享,per-file 只有一份"。右侧:从容器 A 出发的攻击箭头——"容器 A 污染页缓存 → 内核页缓存被修改 → 容器 B/宿主机读取被污染的文件"。核心信息:容器之间是隔离的,但它们的页缓存是同一份。

3. CI/CD Runner 的特殊风险

CI/CD runner 是另一个高危场景。Runner 通常运行不受信任的构建代码——来自 MR/PR 的任意代码。这些代码以低权限运行,但可以触发 Copy Fail。

一旦 runner 节点上的页缓存被污染,后续的构建任务——可能来自完全不同的项目和组织——就会在不知情的情况下执行被篡改的二进制文件。

在 GitHub Actions 或 GitLab CI 的共享 runner 场景下,一个恶意 PR 可以影响整个 runner 集群。

七、修复分析

核心修复思路

修复的逻辑非常直接——让 AF_ALG AEAD 退出 in-place 模式。

具体做法:回退 2017 年 commit 72548b093ee3 中的 in-place 优化,恢复 out-of-place 操作。关联数据(AD)仍然拷贝,但 tag 不再通过 sg_chain 链入输出 scatterlist。

修复 commit:a664bf3d603dc3bdcf9ae47cc21e0daec706d7a5

这个修复影响 10 个内核稳定分支,修复后版本包括:

分支

修复版本

5.10

5.10.254

5.15

5.15.204

6.1

6.1.170

6.6

6.6.137

6.12

6.12.85

6.18

6.18.22

6.19

6.19.12

临时缓解

在生产环境不能立即重启升级内核的情况下,可以临时禁用 algif_aead 模块:

rmmod algif_aead
echo "blacklist algif_aead" > /etc/modprobe.d/disable-algif-aead.conf

代价:依赖 AF_ALG AEAD 的加密应用(如某些 IPsec 配置、硬件加密卸载)将无法工作。需要评估业务影响。

修复验证

升级后验证三条:

# 1. 内核版本 >= 修复版本
uname -r

# 2. PoC 不再生效
python3 copy_fail_poc.py  # 预期:失败,不能提权

# 3. 页缓存干净(可选)
grep a664bf3d603d /proc/kallsyms 2>/dev/null  # 无输出 = 修复已应用

八、防御与检测

补丁是第一道防线,但安全团队还需要在"补丁窗口期"内具备检测能力。

1. 目前能检测吗?基本不能

Copy Fail 的利用过程在系统层面极难区分于正常的加密操作:

  • AF_ALG socket 创建 → 正常的加密 socket 使用
  • splice 文件到 pipe → 正常的零拷贝操作
  • sendmsg 到 AF_ALG → 正常的加密请求
  • 页缓存修改 → 正常的页缓存写回

传统安全工具的视角下,这些都是"正常的内核行为"。

2. 能做点什么

auditd 规则:

监控 AF_ALG socket 的创建行为。AF_ALG address family 值通常是 38。在正常生产环境中,AF_ALG socket 的创建极为罕见——除非你的应用显式使用了内核加密接口。

-a always,exit -F arch=b64 -S socket -F a0=38 -k af_alg_usage

如果一个从来不碰加密的进程突然创建了 AF_ALG socket,应该告警。

eBPF 检测思路:

更精细的做法是用 eBPF hook splice() + AF_ALG 的 recvmsg() 路径。检测模式:一个进程同时执行了 splice(普通文件→pipe) 和 sendmsg(pipe→AF_ALG socket),且目标文件是 setuid 二进制。

这不是完美的检测(有误报可能),但在没有补丁的情况下,比什么都不做强。

容器运行时检测:

在 K8s 环境下,可以用 Falco 或其他容器安全工具监控 AF_ALG socket 的创建。正常情况下容器内几乎不会使用 AF_ALG。

3. 检测的本质困难

说句实话:Copy Fail 这类"设计级漏洞"的检测,本质上是困难的。它不是输入验证错误(可以用 WAF 规则防),不是内存破坏(可以用 sanitizer 找),而是"设计假设被打破了"。

所有检测手段都是启发式的——它们检测的不是"有人触发了漏洞",而是"有人做了触发漏洞所需的准备工作"。这两者之间存在天然的 gap。

九、多视角拆解

1.对于红队

利用前提极低。 你只需要目标系统满足两个条件:受影响的内核版本 + 本地低权限代码执行。这两个条件在渗透测试中几乎总是成立的。

利用质量很高。 不依赖竞争条件意味着可以稳如老狗地复现,不会像一些竞态漏洞那样打几十次才成功一次。不依赖特定内核偏移量意味着跨发行版可移植性好——同一个 PoC 在 Ubuntu 24.04 和 RHEL 10 上都工作。

持久化隐蔽。 页缓存污染不修改磁盘,不产生文件系统事件,不触发 inotify。在红队拿到了 root 后,可以把污染保持到需要的时候再触发,增加溯源难度。

容器逃逸价值。 K8s PoC 的存在意味着红队可以用 Copy Fail 从容器内逃逸到宿主机——这在云原生渗透测试中是黄金级别的能力。

2. 对于蓝队

盲区一: 传统完整性监控(Tripwire、AIDE、rpm -V)看不到——它们检查的是磁盘。

盲区二: 安全日志看不到——AF_ALG socket 的创建没有专门的安全审计事件。

盲区三: EDR 看不到——exploit 不需要创建新进程、不需要修改注册表、不需要加载内核模块。

盲区四: 容器安全产品看不到——容器内创建 AF_ALG socket 不被现有规则覆盖。

能做的最实际的事:

  1. 确认所有系统的内核版本,统计漏洞窗口内的主机数量
  2. 制定分批次升级计划——先容器节点,后裸金属
  3. 在 SIEM 里加 AF_ALG socket 创建事件的审计规则(auditd → SIEM)
  4. 在 K8s 环境里用 Falco 监控容器内的 AF_ALG 活动

[图 6:红蓝对抗评分——Copy Fail 的攻防态势评估]

图片位置:images-html/red-blue-scoring.html

说明:Google Sheets 风格的评分表。7 个评估维度(攻击面发现、初始利用、持久化、容器逃逸、攻击检测、完整性校验、应急响应),每行标注红队能力和蓝队盲区,评分全列红胜。表格底部一行总结:"7/7 维度红胜,该漏洞处于典型的攻击者优势窗口"。

3. 对于内核开发者

Copy Fail 给内核社区上的一课是:scatterlist 的生命周期管理是加密子系统中一个被低估的攻击面。

scatterlist 不只是"一段内存"——它携带了页面所有权、可写性、引用关系等语义信息。当不同的模块通过 sg_chain 拼接 scatterlist 时,这些语义可能被打破。

in-place 优化的假设——"源和目标来自相同的 scatterlist 所以安全"——在 scatterlist 经过 sg_chain 拼接后不再成立。这不是加密算法的问题,不是 AF_ALG 框架的问题,而是 scatterlist 作为一种"传递数据结构"的语义侵蚀问题。

也许 Linux 加密子系统应该引入一个更严格的 scatterlist 类型系统——read_only_sg vs write_sg vs shared_sg——让编译器或运行时在 scatterlist 被链入不匹配的路径时发出警告。

十、总结

Copy Fail 是那种让我兴奋又让我后背发凉的漏洞。

兴奋的是它的精巧——732 字节就能稳定拿到 root,不靠竞争条件,不靠偏移量,就靠理解内核的行为模式。

发凉的是它的存在时间——9 年。9 年里,无数安全研究员审查过 AF_ALG 的代码,无数内核维护者 review 过加密子系统的修改,无数发行版安全团队扫描过 CVE 数据库——没发现。

不是因为他们不够聪明。是因为这类"设计级漏洞"天然免疫传统的代码审查和静态分析工具。审查者看到 splice 零拷贝,觉得 OK。看到 sg_chain 拼接,觉得 OK。看到 authencesn scratch write,觉得 OK。没有人把这三件事放在同一张图上推演。

对运维/安全工程师: 跑 uname -r,确定你的内核版本。如果低于本文列出的修复版本,尽快升级。容器节点优先。

对开发者: 下次你在代码里做 in-place 优化的时候,问自己一个问题:我真的能保证源和目标的所有 segment 都来自同一个信任域吗?Copy Fail 的教训是——sg_chain 之后,这件事不再成立。

对安全研究员: 加密子系统的 scatterlist 管理是一个值得深挖的攻击面。Copy Fail 踩了 algif_aead 的坑,但还有 algif_skcipher、algif_hash 可以继续看。

最后的最后:这个漏洞完美诠释了"直线逻辑缺陷"的威力。大多数安全漏洞是"做错了什么",而这类漏洞是"做了正确的事,但不应该同时做"。这可能是未来几年内核漏洞挖掘里最高价值的方向。