【Kernel Exploit】CVE-2025-39946 (Kernel One Gadget) 漏洞分析
1. 测试环境
测试版本:Linux-6.12.48 内核镜像地址
笔者测试的内核版本是 Linux alpine 6.12.48 #1 SMP PREEMPT_DYNAMIC Mon Nov 9 16:54:17 CST 2026 x86_64 Linux。
编译选项:开启CONFIG_IO_URING、CONFIG_TMPFS、CONFIG_SHMEM、CONFIG_SECURITY、CONFIG_BINFMT_MISC、CONFIG_THREAD_INFO_IN_TASK、CONFIG_KCMP、CONFIG_MEMCG、CONFIG_MEMCG_KMEM、CONFIG_CGROUPS、CONFIG_SLAB_FREELIST_RANDOM、CONFIG_SLAB_FREELIST_HARDENED、CONFIG_RANDOM_KMALLOC_CACHES、CONFIG_SHUFFLE_PAGE_ALLOCATOR、CONFIG_HARDENED_USERCOPY、CONFIG_FUSE_FS、CONFIG_USERFAULTFD、CONFIG_SYSVIPC、CONFIG_KEYS、CONFIG_STACKPROTECTOR、CONFIG_STACKPROTECTOR_STRONG、CONFIG_SLUB、CONFIG_SLUB_DEBUG、CONFIG_E1000、CONFIG_E1000E、CONFIG_PACKET、CONFIG_PACKET_DIAG、CONFIG_USER_NS、CONFIG_NET_NS、CONFIG_NAMESPACES、CONFIG_CHECKPOINT_RESTORE、CONFIG_IPC_NS、CONFIG_TLS、CONFIG_TLS_DEVICE、CONFIG_NVME_TCP_TLS、CONFIG_NVME_TARGET_TCP_TLS、CONFIG_CHELSIO_TLS_DEVICE、CONFIG_MLX5_EN_TLS、CONFIG_CRYPTO、CONFIG_CRYPTO_ALGAPI、CONFIG_CRYPTO_ALGAPI2、CONFIG_CRYPTO_AEAD、CONFIG_CRYPTO_AEAD2、CONFIG_CRYPTO_MANAGER、CONFIG_CRYPTO_MANAGER2、CONFIG_CRYPTO_NULL、CONFIG_CRYPTO_NULL2、CONFIG_CRYPTO_CCM、CONFIG_CRYPTO_AES、CONFIG_CRYPTO_CTR、CONFIG_CRYPTO_CRYPTD、CONFIG_CRYPTO_USER_API、CONFIG_CRYPTO_USER_API_AEAD、CONFIG_CRYPTO_SIMD、CONFIG_CRYPTO_AES_NI_INTEL选项。完整配置参考(6.12.48).config。
保护机制:KASLR/SMEP/SMAP/KPTI
2. 漏洞背景
2-1. 漏洞概述
CVE-2025-39946 是 Linux 内核 kTLS(kernel TLS)接收路径中的一个堆越界写漏洞(CWE-787 Out-of-bounds Write)。kTLS 将 TLS 记录的加解密与边界处理从用户态下沉至内核网络栈,以降低数据拷贝与上下文切换开销;接收侧的记录重组由 kTLS 自带的流解析器(strparser)承担,它在 TCP 字节流之上识别 TLS 记录边界,将跨多个 skb 到达的数据拼装为完整记录后交由解密路径处理。漏洞即位于这一重组路径的数据搬运环节。
缺陷的直接表现是 tls_strp_copyin_frag() 以 skb->len / PAGE_SIZE 作为 skb_shared_info->frags[] 的索引,却未将该索引与 nr_frags 做任何比对:
frag = &skb_shinfo(skb)->frags[skb->len / PAGE_SIZE];
chunk = min_t(size_t, len, PAGE_SIZE - skb_frag_size(frag));
...
skb_copy_bits(in_skb, offset, skb_frag_address(frag) + ..., chunk);
当接收侧 SO_RCVBUF 被压缩至不足以容纳一条完整 TLS 记录时,内核为避免连接停顿而进入 copy 模式,将已到达数据先行搬运进一个以 nr_frags == 0 起始的锚点 skb(anchor skb)。此时 frags[] 并不由该函数在写入前初始化,而是沿用 skb_shared_info 中的既有内容,nr_frags 与 skb->len / PAGE_SIZE 之间不存在同步关系,索引因此可以越过有效分片范围继续增长。
这一越界按索引区间呈现分层结构,其分层方式直接决定了漏洞的可利用面。frags[0] 处于数组物理范围内但语义无效,其分片描述中的 netmem 可能承载残留页引用;copy 模式的首次搬运会写入该槽位引用的页面,但此时页面往往仍处于活跃状态,故它虽同样借助残留引用,却一般不被视作 OOB 的主体。frags[1] 至 frags[MAX_SKB_FRAGS - 1] 是主要 OOB 区:索引仍在数组物理范围内,不会触发任何针对 skb_shared_info 边界的基础设施检查,但其内容在 nr_frags == 0 时本不应被当作分片引用,写入落点由残留 netmem 解出的页决定,可导向已释放并重新回收的内核页面。frags[MAX_SKB_FRAGS] 及更高索引构成数组物理越界:其写入目标不再由数组内槽位的 netmem 决定,而由 skb_shared_info 数组外相邻字段的内容决定。但这一区间无法绕过数组内槽位直接到达——skb->len 必须先从 frags[0] 逐页推进过 frags[MAX_SKB_FRAGS - 1],才可能进入数组物理越界区;因此在 init_on_alloc=1 下,frags[0].netmem 即为 0,首次搬运即触发 NULL 解引用,这一区间同样不可达。由此可见,本漏洞可利用性的核心并不在于“越过 skb_shared_info 的结构边界”,而在于“在 nr_frags == 0 的语义前提下,将数组内本应无效的槽位当作有效分片使用”。
从风险层面看,该漏洞的本质不在于单次越界的写入量,而在于越界写入的目标可控性、内容可控性与可重复性三重叠加。落点可控,是因为主要 OOB 区的写入目标由残留 netmem 解出的页决定,而该残留内容来自此前释放的 skb->head slab,可在页面的释放与回收时序中被塑造并收窄至特定内核对象。内容可控,是因为 copy 模式搬运的正是对端递送的数据,越界写入的字节处于对端控制之下。可重复,是因为记录头解析失败并不中止流解析状态机,且 tls_strp_copyin_frag() 在返回负值之前已完成 skb->len += chunk,使每次失败调用都确实把索引向前推进一页;后续数据到达时,主要 OOB 槽位因而能被逐页、反复激活。三者叠加,使该缺陷从一个局部的索引校验缺失,具备了构成完整堆写入原语的关键要素;而这三者的成立,又共同依赖于同一条缺陷链——局部边界检查的缺失与错误路径未中止状态机,二者缺一不可。
由于缺陷位于网络接收路径,对端无需持有任何认证凭据;一个能与目标建立 TCP 连接、且目标在接收侧启用了 kTLS 的对端,即可通过构造 TLS 记录头序列触发越界写入,触发面落在网络可达范围内。在配置层面,init_on_alloc=0 是该漏洞具备可利用性的必要条件:若 init_on_alloc=1,锚点 skb 的 skb_shared_info->frags[0].netmem 即为 0,首次数据搬运时 skb_frag_address() 返回 NULL,skb_copy_bits() 随即以 NULL 为目标写入并触发内核 NULL 解引用,索引尚未离开 frags[0] 进程即已终止。因此该漏洞在零初始化配置下不可利用,笔者的利用思路与官方 PoC 的利用思路均以 init_on_alloc=0 为基准。
从发现脉络看,该缺陷由 syzbot 通过 MSG_OOB 递送序列构造触发场景并上报,上游修复说明中明确记录了这一构造方式。Red Hat 将其归入“重要”(Important)影响等级,NVD 则因信息不足将其分类为 NVD-CWE-noinfo,但从技术实质看,其类别明确属于 skb_shared_info 分片引用机制上的堆越界写。综合其网络可达性、对端无需凭据即可触发、以及越界写入目标与内容的可控性,该漏洞在启用 kTLS 接收卸载的部署环境中值得给予较高关注。
2-2. 漏洞根因
CVE-2025-39946 的根因并非单一的索引校验缺失,而是由局部边界检查缺失与错误处理路径语义缺陷两处独立缺陷耦合而成的复合结构。前者提供了越界写入的“动作”,后者提供了让该动作在同一对象上反复发生的“条件”。二者缺一不可:仅有边界缺失而无状态存续,越界写至多是一次性的异常访问;仅有状态存续而无边界缺失,则根本不存在越界。理解这一耦合关系,是理解该漏洞为何能从数行代码的疏漏演化为稳定的堆写入原语的关键。
2-2-1. 动作源
动作源位于 net/tls/tls_strp.c 中的 tls_strp_copyin_frag()。该函数在入口处以 skb->len / PAGE_SIZE 计算目标分片索引,并直接取出对应 skb_frag_t 指针,全程未将该索引与 skb_shinfo(skb)->nr_frags 做任何比对,也未在写入前确认目标槽位是否已被初始化为有效分片:
static int tls_strp_copyin_frag(struct tls_strparser *strp, struct sk_buff *skb,
struct sk_buff *in_skb, unsigned int offset,
size_t in_len)
{
size_t len, chunk;
skb_frag_t *frag;
int sz;
/* 以 skb->len / PAGE_SIZE 作为 frags[] 索引,
* 未校验该索引是否小于 skb_shinfo(skb)->nr_frags。
* 锚点 skb 以 nr_frags == 0 起始时,frags[0] 即为未初始化槽位,
* 任何索引 >= 1 的写入都越过有效分片的语义边界。 */
frag = &skb_shinfo(skb)->frags[skb->len / PAGE_SIZE];
len = in_len;
/* 首先确保已取得记录头 */
if (!strp->stm.full_len) {
/* 假定一页足以容纳记录头 */
chunk = min_t(size_t, len, PAGE_SIZE - skb_frag_size(frag));
/* 将 in_skb 中的数据写入 frag 所引用的页面。
* 目标地址由 skb_frag_address(frag) 与 skb_frag_size(frag) 共同决定。
* 当 frag 指向残留槽位时,写入落点由残留 netmem 解出的页决定。 */
WARN_ON_ONCE(skb_copy_bits(in_skb, offset,
skb_frag_address(frag) +
skb_frag_size(frag),
chunk));
/* 先推进 skb->len,再解析记录头 */
skb->len += chunk;
skb->data_len += chunk;
skb_frag_size_add(frag, chunk);
/* 后解析记录头;失败时直接返回负值,
* 但此时 skb->len 已经增加。 */
sz = tls_rx_msg_size(strp, skb);
if (sz < 0)
return sz;
/* 可能发生过度读取;sz == 0 时保证是读取不足。
* 若发生过度读取,则回退 skb->len、data_len 与分片长度。 */
if (unlikely(sz && sz < skb->len)) {
int over = skb->len - sz;
WARN_ON_ONCE(over > chunk);
skb->len -= over;
skb->data_len -= over;
skb_frag_size_add(frag, -over);
chunk -= over;
}
frag++;
len -= chunk;
offset += chunk;
strp->stm.full_len = sz;
if (!strp->stm.full_len)
goto read_done;
}
/* 继续装载更多数据 */
while (len && strp->stm.full_len > skb->len) {
chunk = min_t(size_t, len, strp->stm.full_len - skb->len);
chunk = min_t(size_t, chunk, PAGE_SIZE - skb_frag_size(frag));
WARN_ON_ONCE(skb_copy_bits(in_skb, offset,
skb_frag_address(frag) +
skb_frag_size(frag),
chunk));
skb->len += chunk;
skb->data_len += chunk;
skb_frag_size_add(frag, chunk);
frag++;
len -= chunk;
offset += chunk;
}
read_done:
return in_len - len;
}
frags[] 的宿主结构由 skb_shinfo() 定位,其本质是 skb->head 尾部的一块元数据区。skb_shinfo()、skb_end_pointer() 与 skb_frag_size() 均为 include/linux/skbuff.h 中的内联函数,skb_frag_address() 与 skb_frag_page() 则决定了残留槽位最终解出的写入地址:
/* 定位 skb->head 尾部的 skb_shared_info 结构 */
#define skb_shinfo(SKB) ((struct skb_shared_info *)(skb_end_pointer(SKB)))
/* skb->head 起始地址加上 skb->end 偏移,得到共享信息区起始位置 */
static inline unsigned char *skb_end_pointer(const struct sk_buff *skb)
{
return skb->head + skb->end;
}
/* 读取分片描述中的长度字段 */
static inline unsigned int skb_frag_size(const skb_frag_t *frag)
{
return frag->len;
}
/* 由分片描述解出 struct page 指针。
* 若残留槽位被解释为 net_iov,则返回 NULL,
* 使 skb_frag_address() 返回 NULL,写入落点失效。 */
static inline struct page *skb_frag_page(const skb_frag_t *frag)
{
if (skb_frag_is_net_iov(frag))
return NULL;
return netmem_to_page(frag->netmem);
}
/* 计算分片对应的虚拟地址。
* 写入地址 = 残留 netmem 解出的页地址 + 残留 off 字段。 */
static inline void *skb_frag_address(const skb_frag_t *frag)
{
if (!skb_frag_page(frag))
return NULL;
return page_address(skb_frag_page(frag)) + skb_frag_off(frag);
}
由此可以看清动作源的精确性质:frag = &skb_shinfo(skb)->frags[skb->len / PAGE_SIZE] 本身只是取了一个数组元素的地址,真正的内存破坏发生在 skb_copy_bits() 以 skb_frag_address(frag) + skb_frag_size(frag) 为目标执行写入时。当 nr_frags == 0 时,frags[0] 是未初始化槽位,frags[1] 及更高索引则不但未初始化,还越过了有效分片的语义边界。在 init_on_alloc=0 的前提下,这些槽位中的 netmem、len、off 字段可能承载此前 slab 释放后遗留的内容,写入便会落到由该遗留内容解出的任意内核页面上,而非锚点 skb 的合法数据面。若 init_on_alloc=1,frags[0].netmem 即为 0,skb_frag_page() 返回 NULL,skb_frag_address() 随之返回 NULL,而 chunk 因 skb_frag_size(frag) == 0 取 min(len, PAGE_SIZE) 非零,首次 skb_copy_bits() 即以 NULL 为目标写入并触发内核 NULL 解引用,动作源在第一个槽位即失效,frags[1] 及更高索引无从触及。 这一配置边界决定了动作源只有在 init_on_alloc=0 下才具备后续条件源与推进机制得以耦合的前提。
2-2-2. 条件源
条件源在于 copy 模式路径上 tls_strp_abort_strp() 的不可达。要看清这一点,需从 tls_strp_read_sock() 的分支结构入手。该函数在入口处先判断 strp->copy_mode,若为真则在调用 tls_strp_load_anchor_with_queue() 之前直接转入 copyin 路径并返回,因而根本不进入后续包含 tls_strp_abort_strp() 的主路径代码块:
/* 调用时持有底层 socket 的锁 */
static int tls_strp_read_sock(struct tls_strparser *strp)
{
int sz, inq;
inq = tcp_inq(strp->sk);
if (inq < 1)
return 0;
/* 关键分支:copy 模式下直接转入 copyin 路径并返回,
* 下方主路径中的 tls_strp_abort_strp() 在此分支上不可达。 */
if (unlikely(strp->copy_mode))
return tls_strp_read_copyin(strp);
if (inq < strp->stm.full_len)
return tls_strp_read_copy(strp, true);
tls_strp_load_anchor_with_queue(strp, inq);
if (!strp->stm.full_len) {
sz = tls_rx_msg_size(strp, strp->anchor);
if (sz < 0) {
/* 仅主路径在此处补上了 abort */
tls_strp_abort_strp(strp, sz);
return sz;
}
strp->stm.full_len = sz;
if (!strp->stm.full_len || inq < strp->stm.full_len)
return tls_strp_read_copy(strp, true);
}
if (!tls_strp_check_queue_ok(strp))
return tls_strp_read_copy(strp, false);
WRITE_ONCE(strp->msg_ready, 1);
tls_rx_msg_ready(strp);
return 0;
}
copyin 路径的入口是 tls_strp_read_copyin()。它调用 tcp_read_sock(strp->sk, &desc, tls_strp_copyin),其中第三个参数 tls_strp_copyin 即读循环中的 recv_actor 回调;tls_strp_read_copyin() 自身只把 desc.error 作为返回值向上传递,并不设置 strp->stopped:
static int tls_strp_read_copyin(struct tls_strparser *strp)
{
read_descriptor_t desc;
desc.arg.data = strp;
desc.error = 0;
/* 每次调用允许处理多个 skb */
desc.count = 1;
/* 此处应已持有 sk 锁,因此可以安全调用 read_sock。
* 第三个参数 tls_strp_copyin 即 __tcp_read_sock() 循环中的 recv_actor,
* 每取到一个可读 skb,__tcp_read_sock() 就以该回调处理之。 */
tcp_read_sock(strp->sk, &desc, tls_strp_copyin);
/* 返回值是 desc.error,而非 strparser 状态;
* 此处不设置 strp->stopped。 */
return desc.error;
}
tcp_read_sock() 是对 __tcp_read_sock() 的薄封装,把 tls_strp_copyin 作为 recv_actor 原样转发。__tcp_read_sock() 在循环中以 used = recv_actor(desc, skb, offset, len) 逐 skb 调用该回调——对 kTLS 而言,这一行的实际调用对象就是 tls_strp_copyin();当回调返回 used <= 0 时循环 break,把控制权交回 tls_strp_read_copyin()。该函数自身既不理解 TLS 语义,也不改变 strparser 状态:
int tcp_read_sock(struct sock *sk, read_descriptor_t *desc,
sk_read_actor_t recv_actor)
{
return __tcp_read_sock(sk, desc, recv_actor, false,
&tcp_sk(sk)->copied_seq);
}
static int __tcp_read_sock(struct sock *sk, read_descriptor_t *desc,
sk_read_actor_t recv_actor, bool noack,
u32 *copied_seq)
{
/* [...] */
while ((skb = tcp_recv_skb(sk, seq, &offset)) != NULL) {
if (offset < skb->len) {
/* [...] */
/* kTLS 场景下 recv_actor 即 tls_strp_copyin():
* 该回调成功消费数据时返回正数,
* 因记录头解析失败而停止时返回 0(负值已存入 desc->error)。 */
used = recv_actor(desc, skb, offset, len);
if (used <= 0) {
/* 回调返回非正值时停止本轮读取;
* 若此前未搬运任何数据,则把 used 作为结果返回。 */
if (!copied)
copied = used;
break;
}
/* [...] */
}
/* [...] */
}
/* [...] */
return copied;
}
作为 recv_actor 绑定进上述循环的 tls_strp_copyin(),其职责是调用 tls_strp_copyin_frag() 并处理其返回值:成功时返回实际消费的字节数(in_len - len),失败时则把 tls_strp_copyin_frag() 的负返回值旁路保存到 desc->error,同时将自身返回值置为 0,使 __tcp_read_sock() 的 used <= 0 判断成立而停止本轮读取:
static int tls_strp_copyin(read_descriptor_t *desc, struct sk_buff *in_skb,
unsigned int offset, size_t in_len)
{
struct tls_strparser *strp = (struct tls_strparser *)desc->arg.data;
struct sk_buff *skb;
int ret;
if (strp->msg_ready)
return 0;
skb = strp->anchor;
/* [...] */
ret = tls_strp_copyin_frag(strp, skb, in_skb, offset, in_len);
if (ret < 0) {
/* 负值被存入 desc->error,而非向上传播;
* 对 __tcp_read_sock() 的 used 返回 0,表示停止读取。 */
desc->error = ret;
ret = 0;
}
if (strp->stm.full_len && strp->stm.full_len == skb->len) {
desc->count = 0;
WRITE_ONCE(strp->msg_ready, 1);
tls_rx_msg_ready(strp);
}
return ret;
}
真正决定“是否中止 strparser”的函数是 tls_rx_msg_size() 与两个 abort 函数。tls_rx_msg_size() 在记录头解析失败时进入 read_failure,仅调用 tls_err_abort() 设置 sk_err,函数自身并不设置 strp->stopped;tls_err_abort() 与 sk_error_report() 只负责向 socket 层报告错误:
int tls_rx_msg_size(struct tls_strparser *strp, struct sk_buff *skb)
{
/* [...] */
if (strp->stm.offset + prot->prepend_size > skb->len)
return 0;
/* [...] */
ret = skb_copy_bits(skb, strp->stm.offset, header, prot->prepend_size);
if (ret < 0)
goto read_failure;
/* [...] */
if (data_len > TLS_MAX_PAYLOAD_SIZE + cipher_overhead +
prot->tail_size) {
ret = -EMSGSIZE;
goto read_failure;
}
/* [...] */
if (header[1] != TLS_1_2_VERSION_MINOR ||
header[2] != TLS_1_2_VERSION_MAJOR) {
ret = -EINVAL;
goto read_failure;
}
/* [...] */
return data_len + TLS_HEADER_SIZE;
read_failure:
/* 只设置 sk_err 并报告错误,不设置 strp->stopped;
* 是否中止 strparser 取决于调用者。 */
tls_err_abort(strp->sk, ret);
return ret;
}
noinline void tls_err_abort(struct sock *sk, int err)
{
WARN_ON_ONCE(err >= 0);
/* sk->sk_err 应保存正错误码 */
WRITE_ONCE(sk->sk_err, -err);
/* 与 tcp_poll() 中的 smp_rmb() 配对 */
smp_wmb();
sk_error_report(sk);
}
void sk_error_report(struct sock *sk)
{
sk->sk_error_report(sk);
/* [...] */
}
唯一设置 strp->stopped = 1 的函数是 tls_strp_abort_strp()。它在主路径上被 tls_strp_read_sock() 在 sz < 0 时调用,但 copy 模式路径从 strp->copy_mode 分支返回时不会经过此处:
static void tls_strp_abort_strp(struct tls_strparser *strp, int err)
{
if (strp->stopped)
return;
/* 唯一一处把 strparser 置为停止状态的赋值;
* copy 模式路径不会到达此处。 */
strp->stopped = 1;
/* 在底层 socket 上报告错误 */
WRITE_ONCE(strp->sk->sk_err, -err);
/* 与 tcp_poll() 中的 smp_rmb() 配对 */
smp_wmb();
sk_error_report(strp->sk);
}
与此对照,主路径上的 tls_strp_load_anchor_with_queue() 只在 strp->copy_mode == 0 时才可能被调用。它承担“把接收队列首 skb 的头信息与分片链表接到锚点 skb 上”的职责,正是主路径能够进入 tls_rx_msg_size() 失败分支并调用 tls_strp_abort_strp() 的前提:
static void tls_strp_load_anchor_with_queue(struct tls_strparser *strp, int len)
{
struct tcp_sock *tp = tcp_sk(strp->sk);
struct sk_buff *first;
u32 offset;
first = tcp_recv_skb(strp->sk, tp->copied_seq, &offset);
if (WARN_ON_ONCE(!first))
return;
/* 将状态赋予锚点 skb */
strp->anchor->len = offset + len;
strp->anchor->data_len = offset + len;
strp->anchor->truesize = offset + len;
skb_shinfo(strp->anchor)->frag_list = first;
skb_copy_header(strp->anchor, first);
strp->anchor->destructor = NULL;
strp->stm.offset = offset;
}
综合上述调用关系,copy 模式路径上的状态变化可以概括为:tls_strp_read_sock() 在 copy_mode 为真时直接返回 tls_strp_read_copyin(),不经过主路径;tls_strp_read_copyin() 把 tls_strp_copyin 作为 recv_actor 交给 tcp_read_sock(),并返回 desc.error 而不设置 strp->stopped;__tcp_read_sock() 在循环中逐 skb 调用 recv_actor,即实际调用 tls_strp_copyin();tls_strp_copyin() 将 tls_strp_copyin_frag() 的负值旁路到 desc->error 并把 used 置 0;tls_rx_msg_size() 只调用 tls_err_abort(),自身不设 strp->stopped;tls_err_abort() 只写 sk_err 并触发 sk_error_report()。整条路径上没有任何一处把 strp->stopped 置 1,strparser 因而继续停留在 copy 模式,锚点 skb 的 skb->len 得以在后续数据到达时继续增长。
2-2-3. 推进机制
条件源提供了“连接不断、状态不退”的外部环境,而真正让主要 OOB 槽位被逐页激活的,是 tls_strp_copyin_frag() 内部 skb->len += chunk 与 tls_rx_msg_size() 的语句顺序。在首次搬运行中:
static int tls_strp_copyin_frag(struct tls_strparser *strp, struct sk_buff *skb,
struct sk_buff *in_skb, unsigned int offset,
size_t in_len)
{
/* [...] */
chunk = min_t(size_t, len, PAGE_SIZE - skb_frag_size(frag));
WARN_ON_ONCE(skb_copy_bits(in_skb, offset,
skb_frag_address(frag) +
skb_frag_size(frag),
chunk));
skb->len += chunk; /* ① 先推进 skb->len */
skb->data_len += chunk;
skb_frag_size_add(frag, chunk);
sz = tls_rx_msg_size(strp, skb); /* ② 后解析记录头 */
if (sz < 0)
return sz; /* ③ 返回负值,但 skb->len 已增加 */
/* [...] */
}
这三行的次序决定了每一次失败调用都先把 skb->len 推进一个 chunk(其上限为 PAGE_SIZE - 残留 len),再因头解析失败返回。下一次数据到达时,tls_strp_copyin_frag() 重新以新的 skb->len / PAGE_SIZE 计算 frag 指针,索引便随累积的 skb->len 逐页前移,依次落入 frags[1]、frags[2]……若没有这一语句顺序,skb->len 在失败返回时保持不变,下一次调用仍会命中同一槽位,逐页推进便无从发生。
2-2-4. 耦合关系
动作源、条件源与推进机制三者并非彼此独立,而是形成了一条首尾相接的正反馈链。局部边界检查的缺失本身并不罕见,若错误路径按预期中止流解析器,则一次头解析失败即会终结连接,frags[] 索引至多推进一次,越界写入沦为一次性的异常访问,其破坏面与可控性都极为有限。反过来,错误路径的语义缺陷单独存在时,也不会造成任何内存破坏——没有越界索引,就无所谓越界写。真正使该漏洞具备稳定原语性质的,是三者形成的正反馈:
- 错误路径不中止状态机,使
skb->len得以在多次数据到达间持续增长; skb->len的持续增长又不断驱动无边界校验的索引向frags[]更深处推进;- “先推进、后失败”的语句顺序保证每次失败调用都确实把
skb->len向前推进一个chunk,而非原地踏步。
三者叠加,才使 frags[1]、frags[2] 等主要 OOB 槽位能被依次激活,进而将越界写入的落点从“随机的相邻内存”收窄为“可由残留槽位内容塑造、并可在释放回收时序中定向的页面”。这一正反馈的成立同样以 init_on_alloc=0 为前提:若为 init_on_alloc=1,动作源在 frags[0] 处即因 NULL 解引用而失效,条件源与推进机制再完整也无从耦合。这也解释了为何该漏洞的前置条件中,SO_RCVBUF 压缩(进入 copy 模式)与记录头构造失败(触发错误路径)必须同时满足:前者是动作源生效的模式前提,后者是条件源被激活的触发前提。
综上,CVE-2025-39946 的根因可概括为:tls_strp_copyin_frag() 对 frags[] 索引的无校验使用,与 copy 模式路径上 tls_strp_abort_strp() 的不可达相互叠加,使原本应被错误处理终止的越界访问获得了反复执行的条件;而“先推进 skb->len、后解析记录头”的语句顺序,则保证每次失败调用都确实把越界索引向前推进一页。三者共同构成了该漏洞的复合根因。
2-3. 触发条件
CVE-2025-39946 的触发是一条自内核配置至协议递送的链式条件,共七个层次:内核配置提供编译基础,零初始化配置决定可利用性,运行时启用提供调用入口,copy 模式提供模式前提,记录头构造失败提供错误触发,MSG_OOB 提供反复递送,最后由协同关系说明各层如何衔接。任何一环缺失,链条即断在对应位置。以下每一层次单独成节,按从底层到上层的顺序展开。
2-3-1. 内核配置
触发链的最底层是内核编译配置。kTLS 接收路径整体位于 CONFIG_TLS 之下,未启用该选项的内核不包含 net/tls/tls_strp.c,tls_strp_copyin_frag() 根本不存在。启用 kTLS 还需一组密码学原语支撑,CONFIG_TLS 所依赖的 AEAD 类实现(例如 CONFIG_CRYPTO_AEAD、CONFIG_CRYPTO_CCM、CONFIG_CRYPTO_AES 等)须一并就绪,否则 setsockopt(SOL_TLS, TLS_RX, ...) 会因算法不可用而失败,后续路径无法进入。
在同一组配置中,CONFIG_TLS_DEVICE 的存在会影响数据搬运分支的走向。tls_strp_copyin() 在选择搬运函数时按如下逻辑分流:
static int tls_strp_copyin(read_descriptor_t *desc, struct sk_buff *in_skb,
unsigned int offset, size_t in_len)
{
/* [...] */
if (IS_ENABLED(CONFIG_TLS_DEVICE) && strp->mixed_decrypted)
ret = tls_strp_copyin_skb(strp, skb, in_skb, offset, in_len);
else
ret = tls_strp_copyin_frag(strp, skb, in_skb, offset, in_len);
/* [...] */
}
若 CONFIG_TLS_DEVICE 启用且 strp->mixed_decrypted 为真,数据将走 tls_strp_copyin_skb() 而非 tls_strp_copyin_frag(),动作源被替换,越界索引不会产生。mixed_decrypted 只在锚点 skb 上混合了“已解密”与“未解密”两种 skb 时置位;纯软件接收卸载路径下所有 skb 均未被标记为已解密,该标志保持为假,因而走 tls_strp_copyin_frag() 分支。
2-3-2. 零初始化配置
init_on_alloc 决定锚点 skb 的 frags[] 槽位是否保留残留内容,进而决定该漏洞是否具备可利用性。这一配置的作用需与 skb 分配路径自身的初始化区分开。__alloc_skb() 只负责取 sk_buff 结构体、通过 kmalloc_reserve() 取得 skb->head 内存,然后调用 __build_skb_around();kmalloc_reserve() 只分配不清零,__build_skb_around() 本身也不直接清零,真正的有范围清零发生在 __finalize_skb_around() 中:
static inline void __finalize_skb_around(struct sk_buff *skb, void *data,
unsigned int size)
{
struct skb_shared_info *shinfo;
size -= SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
/* Assumes caller memset cleared SKB */
/* [...] */
shinfo = skb_shinfo(skb);
memset(shinfo, 0, offsetof(struct skb_shared_info, dataref));
atomic_set(&shinfo->dataref, 1);
/* [...] */
}
struct skb_shared_info 中 nr_frags、tx_flags、gso_size 等元数据在前,dataref 居中,frags[] 数组位于最后。offsetof(..., dataref) 覆盖不到 frags[],因此该 memset 只清零 nr_frags 及其之前的字段,frags[0] 至 frags[MAX_SKB_FRAGS - 1] 原封不动。nr_frags 被显式置零,这是“锚点 skb 以 nr_frags == 0 起始”的来源;而 frags[] 槽位中的 netmem、len、off 仍保留该内存在成为 skb->head 之前的内容。init_on_alloc 位于更底层:启用时 slab 分配器在返回对象前将整个对象清零,自然包括 frags[] 数组。默认情况下 init_on_alloc 为 0(关闭),除非内核以 init_on_alloc=1 启动或设置了 CONFIG_INIT_ON_ALLOC_DEFAULT_ON。
取 0 时具备可利用性。 __finalize_skb_around() 不碰 frags[],slab 层也不清零,frags[0] 至 frags[MAX_SKB_FRAGS - 1] 的内容即为此前释放留下的残留数据。锚点 skb 分配时复用同一 slab,frags[1] 至 frags[MAX_SKB_FRAGS - 1] 中的残留 netmem 被继承为分片页引用,主要 OOB 区的写入落点因而可由释放与回收时序塑造。这是该漏洞具备可利用性的唯一配置前提,也是笔者的利用思路与官方 PoC 的利用思路共同采用的基准。
取 1 时不可利用。 整个 slab 对象被清零,frags[0].netmem 即为 0。第一次调用 tls_strp_copyin_frag() 时,索引为 0,skb_frag_size(frag) == 0 使 chunk 取 min(len, PAGE_SIZE) 非零,而 skb_frag_page() 因 netmem == 0 返回 NULL,skb_frag_address() 随之返回 NULL,skb_copy_bits() 随即以 NULL 为目标写入,第一次递送即触发内核 NULL 解引用。此时 skb->len 尚未推进到 PAGE_SIZE,索引仍停在 frags[0],frags[1] 及更高索引无从触及——不存在“先逐槽推进、再进入数组物理越界区”的过程,进程在第一个槽位即已终止。
这一结论可由正常路径与漏洞路径的对照印证。正常路径下,内核通过 skb_fill_page_desc() 之类的函数显式分配并填充 frags[] 槽位,完成后立即将 nr_frags 更新为对应索引 + 1;槽位初始化与 nr_frags 递增同步发生,循环边界始终以 nr_frags 为准,不会触及未初始化槽位。tls_strp_copyin_frag() 的差异在于:它默认 frags[skb->len / PAGE_SIZE] 有效,却从未检查 nr_frags 是否覆盖该索引。常规 TCP 接收路径中这一假设由底层网络栈的填充机制保证;但 kTLS copy 模式下的锚点 skb 是被“清空”后重新使用的容器,nr_frags == 0 而 frags[] 未经 skb_fill_page_desc() 填充,函数却延续了“假设 frag 有效”的逻辑,越界索引由此产生。正常路径与漏洞路径在这一层的差异,正是 init_on_alloc 取值能够决定可利用性的根本原因。
2-3-3. 运行时启用
在内核配置就绪的基础上,触发要求接收侧 socket 完成 kTLS 软件接收卸载的启用。典型序列为:
/* 将 TCP socket 的上层协议切换为 TLS */
setsockopt(fd, SOL_TCP, TCP_ULP, "tls", sizeof("tls"));
/* 配置接收方向的密码学参数,启用软件卸载 */
setsockopt(fd, SOL_TLS, TLS_RX, &crypto_info, sizeof(crypto_info));
TCP_ULP 将 socket 的上层协议切换为 TLS,此后 TCP 层的读取会经 tls_sw_recvmsg() 等入口进入 strparser;TLS_RX 完成接收方向的密码学参数配置,使 tls_strp_read_sock() 具备可用的 prot_info。两步均成功,tls_strp_read_sock() 才会在接收路径上被调用,tls_strp_copyin_frag() 才有被执行的可能。任一步失败,socket 仍按普通 TCP 处理,触发链在此中断。
2-3-4. 模式切换
kTLS 接收路径的两种模式决定了锚点 skb 的分片数组是否由正常构造流程填充。常规模式下,strparser 等待接收队列凑齐一条完整记录后整体处理,frags[] 与 nr_frags 保持同步,越界索引无从产生。只有当接收侧 SO_RCVBUF 被压缩至不足以容纳一条完整 TLS 记录时,tls_strp_read_sock() 才会在 inq < strp->stm.full_len 或队列检查失败时转入 tls_strp_read_copy(),进而将 strp->copy_mode 置位,使后续读取均经由 tls_strp_read_copyin() 进入数据搬运路径。
进入 copy 模式后,锚点 skb 以 nr_frags == 0 起始,frags[] 不由 tls_strp_copyin_frag() 填充,而是沿用 skb_shared_info 中的既有内容。SO_RCVBUF 的具体取值需小于一条完整 TLS 记录(记录头 + 载荷 + 加密开销),实际配置中常取 64KB 量级。
2-3-5. 解析失败
copy 模式与解析失败共同构成动作源生效的条件。每次 tls_strp_copyin_frag() 在推进 skb->len 后都会调用 tls_rx_msg_size()。要让该函数进入 read_failure 并返回负值,递送的 TLS 记录头须不满足以下任一条件:
- 载荷长度
data_len超过TLS_MAX_PAYLOAD_SIZE + cipher_overhead + prot->tail_size,返回-EMSGSIZE; - 载荷长度小于
cipher_overhead,返回-EBADMSG; - 版本号字段不等于
TLS_1_2_VERSION_MINOR/TLS_1_2_VERSION_MAJOR,返回-EINVAL。
记录头长度不足 prot->prepend_size 时,tls_rx_msg_size() 返回 0(数据不足),不构成失败。线性化失败同样会进入 read_failure,但正常递送下较难稳定构造。
最直接的构造方式是在 TLS 记录的前几个字节填入非法版本号。记录头本身在首次搬运中即被写入 frags[0] 引用的页面,对端只需控制记录头的版本号字段,即可稳定触发 read_failure。
2-3-6. 递送方式
仅有 copy 模式与解析失败尚不足以让 skb->len 逐页推进。常规数据递送在解析失败后停止本轮读取,下一次数据到达时 tcp_read_sock 仍会从同一位置开始,skb->len 未必增加。MSG_OOB 递送提供了关键的推进手段。__tcp_read_sock() 在循环中对紧急数据有特殊处理:
static int __tcp_read_sock(struct sock *sk, read_descriptor_t *desc,
sk_read_actor_t recv_actor, bool noack,
u32 *copied_seq)
{
/* [...] */
/* 遇到紧急数据边界时停止本轮读取 */
if (unlikely(tp->urg_data)) {
u32 urg_offset = tp->urg_seq - seq;
if (urg_offset < len)
len = urg_offset;
if (!len)
break;
}
/* [...] */
}
读取位置抵达紧急数据边界时,本轮读取被截断。对 kTLS 而言,每次 MSG_OOB 递送都会触发一次 tls_strp_copyin() 调用,该调用在 tls_strp_copyin_frag() 内部完成“先 skb->len += chunk、后解析失败返回”的循环后即结束。下一次 MSG_OOB 递送再触发一次,skb->len 再推进一页。如此反复,索引依次落入 frags[1]、frags[2]、frags[3]。tls_strp_copyin() 开头的 if (strp->msg_ready) return 0; 保证在记录尚未凑齐时不会重复触发 msg_ready,使多次 OOB 递送能够连续作用于同一锚点 skb。
2-3-7. 协同关系
七个层次各自的职责已经明确:内核配置提供编译基础,零初始化配置决定可利用性,运行时启用提供调用入口,copy 模式提供模式前提,记录头构造失败提供错误触发,MSG_OOB 提供反复递送。前两层解决“代码是否存在、残留内容是否存在”的问题,中间三层解决“路径能否被走到”的问题,最后一层解决“越界能否被反复执行”的问题。
在 init_on_alloc=0 的可利用配置下,各层协同的结果是:每一次 OOB 递送都把 skb->len 推进一步,索引依次越过 frags[1]、frags[2]……而每一次写入的目标页面,由此前释放并可能已被重新回收的 skb->head slab 中残留的分片描述决定。这就把“一次性的越界访问”转化为了“可重复、落点由残留内容决定的堆写入”。若 init_on_alloc=1,则零初始化配置这一层首先不成立,frags[0].netmem 即为 0,第一次递送就在 frags[0] 处 NULL 解引用,后续层次再完整也无从衔接。该配置下不存在仅依赖本漏洞的利用路径。
2-4. 影响范围
CVE-2025-39946 的影响范围从三个维度界定:上游版本谱系回答“哪些内核含缺陷”,评分口径回答“风险如何量化”,缓解措施回答“如何收窄暴露面”。三者共同构成从代码到部署的完整影响图景。
2-4-1. 上游版本谱系
漏洞由commit 84c61fe1a75b(“tls: rx: do not use the standard strparser”)引入 Linux 6.0,早于 6.0 的内核不含缺陷代码。此后各受影响区间与修复版本如下:
| 受影响区间 | 修复版本 | 稳定分支修复提交 |
|---|---|---|
| 6.0 ≤ v < 6.1.154 | 6.1.154 | b36462146d86 |
| 6.2 ≤ v < 6.6.108 | 6.6.108 | 4cefe5be7388 |
| 6.7 ≤ v < 6.12.49 | 6.12.49 | 208640e6225c |
| 6.13 ≤ v < 6.16.9 | 6.16.9 | 61ca2da5fb8f |
| 6.17-rc1 ≤ v < 6.17-rc7 | 6.17-rc7 | 0aeb54ac4cd5(上游主提交) |
受影响区间并不限于新内核,6.1 与 6.6 与 6.12 三个长期维护分支同样在列,这意味着大量仍处于生产支持期的系统在修复前均处于暴露状态。
2-4-2. 评分口径
该漏洞的 CVSS 评分在不同机构之间存在分歧:
| 评分来源 | 分数 | 向量特征 |
|---|---|---|
| NVD | 5.5 (Medium) | AV:L,仅可用性影响 |
| Red Hat | 6.4 (Medium) | AV:N/AC:H,三项影响均有限 |
| cve.org | 9.8 (Critical) | AV:N/AC:L,三项影响均为高 |
分歧源于建模选择而非技术事实之争。NVD 采用本地向量,将“kTLS 已启用”视为降低可利用性的本地配置前提;Red Hat 与 cve.org 采用网络向量,将“对端可通过 TCP 连接递送记录”计入暴露面,但对复杂度与影响程度的评估不同。无论采用何种口径,实际风险都取决于目标是否在接收侧启用了 kTLS——该漏洞位于接收侧软件卸载路径,只有接收方向设置了 TLS_RX 的 socket 才会进入 tls_strp_copyin_frag(),仅启用 TLS_TX 的部署不受影响。Red Hat 将“kTLS 默认未启用”作为收窄暴露面的依据,在其默认配置下成立;但在主动启用 kTLS 接收卸载的环境中该前提不再适用,仍需以补丁为准。
2-4-3. 缓解措施
根治性修补。 升级至含修复提交 0aeb54ac4cd5 的内核是唯一消除缺陷的措施,各线目标版本见 2-4-1。发行版以勘误为准:RHEL 10 已通过 RHSA-2025:21463 修复,Ubuntu Noble 与 Plucky 已 cherry-pick 上游补丁,RHEL 9 处于 deferred,勘误发布前需依赖临时规避。
临时规避。 三类手段可切断触发链。其一,阻止 tls 模块加载:Red Hat 建议“prevent module tls from being loaded”,模块不加载则缺陷函数在运行时不存在,setsockopt(SOL_TCP, TCP_ULP, "tls") 失败,前提是系统不依赖 kTLS。其二,避免在 kTLS socket 上使用过小的 SO_RCVBUF:copy 模式仅在缓冲区小于一条完整记录时进入,但对端仍可通过流量模式间接影响进入时机,故只能降低触发概率,不宜作为独立屏障。其三,在用户态终止 TLS:接收路径不再经过 kTLS 软件卸载分支,从根本避免进入缺陷函数,代价是放弃 kTLS 的性能优势。
配置强化:init_on_alloc=1。 该选项可在不修补内核的前提下使漏洞不可利用。slab 层清零使 frags[0].netmem 为 0,首次搬运时 skb_frag_address() 返回 NULL 而 chunk 非零,skb_copy_bits() 以 NULL 为目标写入并触发 NULL 解引用,越界写入 frags[1] 及更高索引的路径被阻断。启用方式为启动参数添加 init_on_alloc=1 或以内核配置 CONFIG_INIT_ON_ALLOC_DEFAULT_ON=y 编译。代价是全局性性能开销,且不消除缺陷本身——以 init_on_alloc=0 重启即可利用性恢复,应视作补丁不可用期间的临时强化。
检测与监控。 可通过 /proc/net/tls_stat 计数器与 lsmod | grep tls 确认 kTLS 是否被使用;触发序列在流量层面表现为“分片极小、SO_RCVBUF 持续偏紧、记录头反复不合法”的模式,可据此设计检测规则,但需注意并非签名式检测。
2-5. 总结
CVE-2025-39946 的技术形态并不复杂:tls_strp_copyin_frag() 缺少一行 nfrag >= nr_frags 的边界校验。但这一行缺失本身并不足以构成稳定原语,真正使其从数行疏漏演化为可重复堆写入的,是它与 copy 模式路径上流中止语义缺失的耦合。漏洞的本质,是一个错误处理语义缺陷对一个局部边界检查缺失的放大。
从根因结构看,这一放大由三部分共同完成。动作源是 tls_strp_copyin_frag() 以 skb->len / PAGE_SIZE 直接索引 frags[]:在锚点 skb 以 nr_frags == 0 起始的 copy 模式下,frags[0] 即为未初始化槽位,frags[1] 及更高索引则越过有效分片的语义边界。条件源是 copy 模式路径上 tls_strp_abort_strp() 的不可达:tls_strp_read_sock() 在 strp->copy_mode 为真时直接转入 tls_strp_read_copyin() 并返回,主路径上的 abort 不会执行;tls_rx_msg_size() 的 read_failure 仅调用 tls_err_abort();tls_strp_copyin() 将负值旁路到 desc->error 而不设 strp->stopped——整条路径上没有任何一处把 strparser 置为停止状态。推进机制则是 tls_strp_copyin_frag() 内部“先 skb->len += chunk、后解析失败返回”的语句顺序,它使每次失败调用都确实把索引向前推进一页,而非原地踏步。三者缺一不可:仅有边界缺失而无状态存续,越界写至多是一次性的异常访问;仅有状态存续而无边界缺失,则根本不存在越界;即便二者兼备,若无“先推进、后失败”的语句顺序,下一次调用仍会命中同一槽位,主要 OOB 槽位无从被逐页激活。
该漏洞的可利用性受配置边界严格约束。在 init_on_alloc=0 下,skb_shared_info 的清零止于 dataref 之前,frags[] 数组保留此前 slab 释放的残留内容;锚点 skb 复用同一 slab 时继承残留 netmem 为分片页引用,越界写入的落点可由释放与回收时序塑造,收窄至特定内核对象。主要 OOB 区落在 frags[1] 至 frags[MAX_SKB_FRAGS - 1]——索引仍在数组物理范围内,不触发结构边界检查,但写入目标已由残留内容决定,可导向已释放并重新回收的内核页面。在 init_on_alloc=1 下,slab 层将整个对象清零,frags[0].netmem 即为 0,首次搬运时 skb_frag_address() 返回 NULL 而 chunk 非零,skb_copy_bits() 以 NULL 为目标写入并触发内核 NULL 解引用,进程在索引离开 frags[0] 之前即终止。该配置下不存在“逐槽推进至数组物理越界区”的过程,也不存在仅依赖本漏洞的利用路径。笔者的利用思路与官方 PoC 的利用思路均以 init_on_alloc=0 为基准,这一配置并非可选前提,而是可利用性的必要条件。
从防御角度看,该漏洞提供了三点值得记录的经验。局部缓冲区的边界检查必须与协议状态机的错误终止策略协同设计:单点的 if (idx >= nr_frags) 补丁若缺少状态机层面的配合,可能只能消除症状,而不足以消除触发链条;反之,仅靠状态机中止而缺乏局部边界防御,则在状态机被绕过或出现新的错误路径时仍会留下缺口。tls_strp_copyin_frag() 对 nr_frags 的隐含假设,在常规 TCP 接收路径中由底层填充机制保证,但在 kTLS copy 模式这一特定上下文中不成立——这类“在某个上下文中成立、在另一个上下文中失效”的前提,正是局部边界检查应当防御的对象。“先推进、后失败”的语句顺序同样值得注意:skb->len += chunk 先于 tls_rx_msg_size() 执行,使失败返回时长度已经增加;这一顺序在正常路径下无害,但在错误路径未被终止的环境中,它把一次性失败转化为了逐页推进。对于涉及“先搬运、后解析”的增量处理路径,语句顺序与错误处理策略的交互,应当与边界检查一并纳入审查范围。配置前提则决定漏洞的可利用性边界:init_on_alloc 的取值使同一缺陷在一种配置下是稳定的堆写入原语,在另一种配置下只是可控的 NULL 解引用。漏洞评估不能脱离部署配置讨论可利用性,而在补丁不可用的窗口期,配置层的强化可以作为可评估代价的临时屏障。
综合来看,CVE-2025-39946 是一个需要同时满足多项条件的漏洞:内核版本落在 6.0 之后、接收侧启用了 kTLS 软件卸载、SO_RCVBUF 被压缩至 copy 模式、记录头构造失败、对端具备 MSG_OOB 递送能力,且系统运行于 init_on_alloc=0。这些条件叠加之后暴露面显著收窄,但在主动启用 kTLS 接收卸载的高吞吐服务中仍构成实际风险。修复应以上游提交 0aeb54ac4cd5 及对应稳定分支版本为准;在补丁不可用的窗口期,移除 tls 模块、用户态终止 TLS 或启用 init_on_alloc=1 均可作为可评估代价的临时手段,具体取舍取决于系统对 kTLS 功能的依赖程度与对性能开销的容忍度。
3. 利用思路(Kernel One Gadget)
本章描述针对 CVE-2025-39946 的一条完整利用链。漏洞本身只提供一个带约束的越界写原语:写入落点由锚点 skb 的 frags[] 槽位决定,写入内容由对端递送的数据决定,而单次写入的量不超过一页。要把这一原语兑现为控制流转移,需要回答两个问题——在不知道内核地址的前提下,如何定位一个可被间接调用的目标;在不构造栈帧的前提下,如何让一次间接调用直接进入可执行的内核态代码。
笔者的利用思路对这两个问题分别给出回答:控制流目标的定位不依赖任何地址泄漏,CEA 基址通过 sgdt 在运行时读取当前 CPU 的 GDT 基址获得,模块区则由宽范围喷射覆盖来吸收 KASLR 随机化;控制流转移不经过 ROP 或 JOP,pipe_buf_release() 的一次间接调用即从伪造的 pipe_buf_operations 跳入 eBPF JIT 生成的内核态代码,由该代码完成 core_pattern 的改写。
这一路径与官方 PoC 形成对照。官方 PoC 以 EntryBleed 时序侧信道推断内核 text 基址,并以栈迁移加 ROP 链完成 core_pattern 的改写;其侧信道依赖 prefetch 在已映射与未映射地址上的时序差异,该差异只在物理 CPU 上成立,TCG 模拟环境下失效。笔者的利用思路不涉及时序侧信道,也不构造 ROP 链,整条链在物理 CPU 与 TCG 模拟环境下行为一致。
3-1. 整体架构设计
3-1-1. 三个原语
笔者的利用思路把利用链拆成三个可以独立验证的原语,它们依次回答”写入落在哪”“写入落在什么对象上”“写入如何转化为控制流”。
陈旧分片原语。 漏洞只提供”按 skb->len / PAGE_SIZE 索引 frags[] 并写入”的能力,写入落点由锚点 skb 的 frags[] 槽位承载的页引用决定。要让这一落点可控,需要让锚点 skb 在分配时继承一组可预期的页引用。笔者的利用思路通过 AF_VSOCK 的 MSG_ZEROCOPY 把 AIO ring 的页引用写入 vsock skb 的 frags[];该 skb 被 kfree_skb() 释放后,skb->head slab 保留这些引用;随后 kTLS 锚点 skb 复用同一 slab,继承陈旧分片。这一步把”随机的相邻内存”收窄为”可由释放与回收时序定向的页面”。
页级回收原语。 AIO ring 被释放回 buddy 分配器后,其物理页可被 kmalloc-cg-192 缓存重新取回。笔者的利用思路以 msg_msgseg 与 pipe_buffer 共同堆喷的方式推动该缓存增长:msg_msgseg 限制宽松,作为主力耗尽空闲槽位;pipe_buffer 限制较紧,作为命中源随新页一同插入。二者比例经过设计,使新申请的每一页中都至少有一个 pipe_buffer。只要 AIO ring 的页 2 或页 3 被 kmalloc-cg-192 取回为新 slab 页,该页上就必然存在可被越界写覆盖的 pipe_buffer;两页都被取回则命中更稳。这一步把”已释放的页面”转化为”承载目标对象的页面”。
控制流接管原语。 pipe_buffer 的 ops 字段在管道关闭时被 pipe_buf_release() 解引用为 buf->ops->release(pipe, buf)。笔者的利用思路将 ops 覆盖为 CPU entry area 中一块伪造的 pipe_buf_operations,其 release 槽位指向 eBPF JIT 生成的内核态代码;该代码在内核态完成 core_pattern 的改写,随后由内核的 core dump 处理器以 root 身份重新执行利用程序,取得交互式 shell。这一步把”对 pipe_buffer 的越界写”转化为”单次间接调用进入内核态 payload”。
三个原语的衔接关系是单向的:陈旧分片决定”写到哪里”,页级回收决定”那里现在是什么对象”,控制流接管决定”覆盖之后如何被触发”。
3-1-2. 与官方 PoC 的分歧
笔者的利用思路与官方 PoC 共享同一个内核缺陷、同一套陈旧分片原语、同一条 pipe_buffer 回收路径;分歧集中在两处。
第一处分歧:控制流目标的定位方式。 官方 PoC 以 EntryBleed 时序侧信道推断内核 text 基址,该方式不依赖泄漏接口,但要求 prefetch 在已映射与未映射地址上的时序差异真实存在。这一差异只在物理 CPU 上成立;TCG 模拟环境下指令由动态翻译器解释执行,时序特征被抹平,扫描无法收敛。笔者的利用思路改用两条互补的路径:CEA 内的 GDT 基址由 sgdt 在运行时读取当前 CPU 的 GDT 基址获得,该 GDT 位于该 CPU 的 entry area 内,因而读取结果直接反映其实际位置,不受 CEA 随机化影响;模块区基址则由宽范围喷射覆盖来吸收,不依赖模块基址的精确值。这一分歧的代价是喷射规模较大,收益是不依赖物理 CPU 语义。
第二处分歧:控制流转移的构造方式。 官方 PoC 以 module_sysfs_ops->store 作为跳板,把 pipe_buffer 指针送入 rdi,再以栈迁移加 ROP 链完成 core_pattern 的改写。笔者的利用思路利用 pipe_buf_release() 只做一次间接调用的特性,把 ops 指向 CEA 中的伪造结构,其 release 槽位即 eBPF JIT payload 的入口。一次调用即完成控制流转移,无需构造栈帧、无需串联 gadget、无需在寄存器与栈之间搬运参数。payload 由内核 JIT 编译器生成,不把用户态代码放入内核执行;越界写入的目标是内核页,源数据通过合法的 skb_copy_bits() 从内核 skb 搬运,不经过 usercopy 路径。
两处取舍共享同一个硬性前提:init_on_alloc=0。陈旧分片原语依赖 skb->head slab 在释放后不被清零;init_on_alloc=1 下 frags[0].netmem 即为 0,首次搬运即触发 NULL 解引用,利用链在第一个槽位即终止。这一前提对官方 PoC 与笔者的利用思路同样成立。
3-1-3. 阶段与进程结构
笔者的利用思路按时间顺序划分为十个阶段,进程角色为三个。main 负责全部用户态编排;worker 由 main 在进程准备阶段派生,绑定 CPU 0,把伪造 pipe_buf_operations 写入 CEA 并进入缺页循环;watcher 由 main 在同一位置派生,绑定 CPU 1,轮询 core_pattern 并在检测到改写后触发自身崩溃。
进程准备阶段做两件事——提升文件描述符上限、创建四对 IPC 管道。fork 在该阶段之后由 main 直接完成,随后是两个子进程的 CPU 绑定与 online 握手。worker 与 watcher 在收到各自的启动信号之前阻塞等待,main 独立推进至触发阶段。main 在阶段 1 至阶段 6 期间不与任何子进程同步。
| 阶段 | 目标 | 关键产出 |
|---|---|---|
| 0 | 进程与通道准备 | 提升 fd 上限、创建四对 IPC 管道、派生 worker/watcher、绑定 CPU、online 握手 |
| 1 | eBPF JIT 喷射 | 模块区宽范围覆盖,预期 payload 地址被至少一个镜像命中 |
| 2 | 内核对象准备 | msg 队列、vsock 对、AIO ring、payload 管道 |
| 3 | TLS 客户端建立 | 回环 TCP 监听器与客户端连接就位 |
| 4 | 陈旧分片注入 | vsock 零拷贝、排空、启用 kTLS、服务端接受连接、TCP_NODELAY、SO_RCVBUF |
| 5 | 载荷暂存 | 接收 worker 地址、5 字节带外数据、64KB 伪造载荷进入 TCP 缓冲 |
| 6 | 释放与回收 | AIO ring 释放、msg_msgseg 与 pipe_buffer 双堆喷、msg_msgseg 排空 |
| 7 | worker 启动 | 向 worker 发出启动信号、main 迁移 CPU 1、worker 写 CEA 并进入缺页循环 |
| 8 | 触发 | watcher 启动轮询、三次带外数据越界写、关闭全部 payload 管道 |
| 9 | core_pattern 接管 | watcher 崩溃、内核以 root 重新执行、取得 root shell |
3-1-4. 总体时序
把十个阶段摊到一条时间线上,三个进程与内核的相对位置如下。横向的箭头表示跨进程的消息或系统调用,斜向的调用则穿过内核。worker 在阶段 1 收到 JIT 地址后立即计算 CEA 地址并回报,此后阻塞到阶段 7;watcher 在阶段 0 完成握手后阻塞到阶段 8;main 从阶段 1 到阶段 6 连续推进。
sequenceDiagram
autonumber
participant M as main
participant W as worker
participant C as watcher
participant K as 内核
Note over M,K: 阶段 0 进程与通道准备
M->>K: prlimit 提升 RLIMIT_NOFILE
M->>K: pipe 乘 4 建四对 IPC 通道
M->>M: 绑定 CPU 0
M->>W: fork
W->>W: 绑定 CPU 0
W-->>M: WORKER_ONLINE
M->>C: fork
C->>C: 绑定 CPU 1
C-->>M: WATCHER_ONLINE
M->>M: 收尾管道端 重新绑定 CPU 0
Note over M,K: 阶段 1 eBPF JIT 喷射
M->>K: SO_ATTACH_FILTER 乘 N_PROGS
K->>K: JIT 编译 分配模块区槽位
M->>W: JIT_ADDR
W->>K: sgdt 读 GDT 基址
W-->>M: WORKER_READY 带 payload_addr
Note over M,K: 阶段 2 至 4 对象准备与分片注入
M->>K: msgget 乘 NUM_MSG_QUEUES
M->>K: vsock 对 加 SO_ZEROCOPY
M->>K: io_setup 得 AIO ring 4 页
M->>K: pipe 乘 NUM_PIPES
M->>K: 监听器 bind listen 与客户端 connect
M->>K: vsock MSG_ZEROCOPY 从 aio_ring 加 PAGE 起
M->>K: vsock read 排空 释放 skb head slab
M->>K: setsockopt TCP_ULP tls、TLS_TX、TLS_RX
M->>K: accept 服务端、TCP_NODELAY、SO_RCVBUF
Note over M,K: 阶段 5 至 6 载荷暂存与页回收
M->>K: send 5 字节 MSG_OOB 触发锚点 skb 分配
K->>K: 锚点 skb 复用 vsock slab 继承 frags
M->>K: send 64KB 伪造 pipe_buffer 载荷
M->>K: io_destroy 释放 AIO ring 4 页
M->>K: msg_msgseg 与 pipe_buffer 双堆喷
K->>K: 缓存耗尽后向 buddy 或 PCP 申请新页
M->>K: msgrcv 排空 msg_msgseg
Note over M,K: 阶段 7 worker 启动
M->>W: CEA_GO
M->>M: 迁移 CPU 1
W->>K: 内联汇编写入 pt_regs
W->>K: 触发缺页 进入 SIGSEGV 循环
Note over M,K: 阶段 8 触发
M->>C: WATCH_GO
C->>K: 开始轮询 core_pattern
loop 三次 OOB
M->>K: send 5 字节 MSG_OOB
K->>K: 越界写覆盖 pipe_buffer ops 为 CEA 地址
end
M->>K: close 全部 payload 管道
K->>K: pipe_buf_release 进入 JIT payload 改写 core_pattern
Note over M,K: 阶段 9 core_pattern 接管
C->>K: read core_pattern 发现新值
C->>C: 空指针解引用 崩溃
K->>K: 按新 core_pattern 以 root 派生辅助程序
K-->>M: 重新执行利用程序 getuid 为 0
M->>M: pidfd_open 与 pidfd_getfd 接管 0 1 2
M->>M: execve bin sh 得到 root 交互式 shell
阶段 1 的 WORKER_READY 与阶段 5 之间隔着阶段 2 至 4 的连续操作:worker 在阶段 1 发出地址后回到阻塞状态,main 直到阶段 5 才取出该消息。阶段 7 的 CEA_GO 与阶段 8 的 WATCH_GO 同理:worker 在阶段 7 进入缺页循环后不再与 main 交互,watcher 在阶段 8 开始轮询后不再接受新指令。main 在阶段 8 的两次触发循环之间不需要与任何子进程同步。
3-2. 阶段 0:进程与通道准备
这一阶段分两段:进程级配置与进程派生。
前一段取得当前文件描述符上限并把软限制提升到硬限制,随后依次创建四对管道,分别用于 main 与 worker、main 与 watcher 之间的双向通信。任意一步失败,main 直接返回,由注册的清理函数释放已创建的管道。
后一段由 main 完成派生。main 绑定 CPU 0 后 fork 出 worker 与 watcher:worker 关闭不需要的管道端、绑定 CPU 0、回报 online 信号,随后阻塞等待 JIT 地址;watcher 关闭不需要的管道端、绑定 CPU 1、回报 online 信号,随后阻塞等待触发信号。main 关闭不再使用的管道端,依次等待两个 online 信号,然后重新绑定 CPU 0。
sequenceDiagram
participant M as main
participant W as worker
participant C as watcher
participant K as 内核
M->>K: prlimit 提升 RLIMIT_NOFILE 至硬上限
M->>K: pipe 乘 4 建四对 IPC 通道
M->>M: 绑定 CPU 0
M->>W: fork
W->>W: 收尾管道端 绑定 CPU 0
W-->>M: WORKER_ONLINE
W->>W: 阻塞等待 JIT_ADDR
M->>C: fork
C->>C: 收尾管道端 绑定 CPU 1
C-->>M: WATCHER_ONLINE
C->>C: 阻塞等待 WATCH_GO
M->>M: 收尾管道端 等待两个 online 后重新绑定 CPU 0
Note over M: 进入阶段 1
握手完成后,worker 与 watcher 停在各自的阻塞点上,main 继续推进。worker 与 main 同绑 CPU 0,watcher 绑 CPU 1。vsock skb 的释放、AIO 页的回收、pipe_buffer 的扩展都在 CPU 0 的 per-CPU freelist 上完成;watcher 的 core_pattern 轮询运行在 CPU 1,与 worker 的缺页循环不在同一 CPU 上。
3-3. 阶段 1:eBPF JIT 喷射
这一阶段让模块区中的预期地址被至少一个 eBPF JIT 镜像覆盖。该地址由一个编译期基准加固定偏移、再加 JIT 前导长度与一字节偏移构成。模块区基址受 KASLR 影响,因此笔者的利用思路不依赖该基址的精确值,而是通过喷射足够多的程序覆盖足够宽的地址范围。
每个 BPF 程序由三部分构成:一段 NOP 滑板,由大量单字节指令构成,用于吸收对齐差异;一段 payload,即实际执行的内核态指令序列;一段位于 payload 之前的跳转桥接,用于从 JIT 镜像的常规入口跳转到 payload 的起始字节。程序被依次挂载到大量 AF_INET/SOCK_DGRAM socket 上,socket 文件描述符保持打开,使 JIT 镜像不会被释放。每次挂载由 JIT 编译器分配一个模块区槽位,槽位地址不可预知,覆盖足够宽后预期地址落在某个镜像内部。
喷射完成后,main 计算预期 payload 地址并通过 worker 命令管道发给 worker。worker 从等待状态中解除阻塞,立即执行 sgdt 读取当前 CPU 的 GDT 基址,加上 CEA 中的固定偏移计算出伪造 pipe_buf_operations 的地址,并通过 worker 回报管道发回 main。main 在阶段 5 才读取该回报,因而消息在管道中停留至此时。
sequenceDiagram
participant M as main
participant K as 内核 BPF JIT
participant W as worker
M->>M: 构造 NOP 滑板 加 payload 加跳转桥接
loop N_PROGS 次 直至模块区覆盖足够宽
M->>K: socket AF_INET SOCK_DGRAM
K-->>M: fd 保持打开不释放
M->>K: setsockopt SO_ATTACH_FILTER
K->>K: JIT 编译 分配模块区槽位 写入镜像
end
M->>M: 计算 payload 预期地址 基准加固定偏移
M->>W: 发送 JIT_ADDR
W->>W: 解除阻塞 暂存 jit_addr
W->>K: sgdt 读取当前 CPU GDT 基址
K-->>W: GDT 基址
W->>W: 加上 CEA 固定偏移得 payload_addr
W-->>M: WORKER_READY 携带 payload_addr
W->>W: 阻塞等待 CEA_GO
Note over M: WORKER_READY 在管道中等待 阶段 5 读取
worker 发出 WORKER_READY 后立即回到阻塞状态,该消息留在管道里。main 在阶段 2 至阶段 4 连续完成对象准备、通道建立与分片注入,阶段 5 才读取该消息。
3-4. 阶段 2:内核对象准备
四类内核对象按以下顺序创建:msg 队列、vsock 对、AIO ring、payload 管道。
先清理系统上可能残留的消息队列,随后创建大量消息队列,用于阶段 6 的 msg_msgseg 填充。接着创建一个带 SO_ZEROCOPY 的 AF_VSOCK 客户端与服务端对,用于阶段 4 把 AIO 页引用注入 skb 的 frags[]。再通过 io_setup() 分配一个 4 页的 AIO ring,作为阶段 4 页引用的来源与阶段 6 释放回 buddy 的目标。最后创建大量管道并各写入 1 字节,使每个管道至少有一个 pipe_buffer。
msg 队列与 payload 管道是阶段 6 堆喷的两个来源。msg_msgseg 的续段由 kmalloc(sizeof(*seg) + alen, GFP_KERNEL_ACCOUNT) 分配,GFP_KERNEL_ACCOUNT 使它落在 kmalloc-cg 系列缓存;alen 经过计算,使续段大小恰好落在 kmalloc-cg-192。pipe_buffer 本身也在 kmalloc-cg-192。二者同缓存,阶段 6 以交错方式共同推动该缓存增长。
进程能创建的管道数量受 RLIMIT_NOFILE 等限制,每个管道一次 F_SETPIPE_SZ 只追加少量 pipe_buffer,单靠管道扩展不足以把 kmalloc-cg-192 推入新页申请。msg_msgseg 的限制宽松得多——消息队列数与每队列消息数都远高于管道数,可以持续申请大量 msg_msgseg。因此阶段 6 以 msg_msgseg 为主力推动缓存增长,以管道扩展为命中源追加 pipe_buffer,二者的比例经过设计,使新申请的每一页中都至少有一个 pipe_buffer。详细机制在 3-8 展开。
sequenceDiagram
participant M as main
participant K as 内核
M->>K: 清理残留 msg 队列
loop NUM_MSG_QUEUES 次
M->>K: msgget IPC_PRIVATE
K-->>M: msqid 存入队列数组
end
M->>M: 初始化消息模板 mtype 与 mtext
M->>K: socket AF_VSOCK 加 setsockopt SO_ZEROCOPY
M->>K: bind listen connect accept
K-->>M: vsock 客户端与服务端 fd
M->>K: io_setup 分配 AIO ring
K-->>M: aio_ring 4 页
loop NUM_PIPES 次
M->>K: pipe
M->>K: write 1 字节使 pipe_buffer 存在
end
Note over M: 四类对象就位 进入阶段 3
msg 队列先于 vsock 对,vsock 对先于 AIO ring,AIO ring 先于 payload 管道。这一顺序使阶段 4 的零拷贝能够取到 AIO 页,使阶段 6 的交错喷射比例能够对上 AIO 页释放的时序。任意一步失败时,main 通过注册的清理函数释放已创建的资源。
3-5. 阶段 3:TLS 客户端建立
这一阶段完成 TLS 通道的客户端侧:在回环地址上打开 TCP 监听器,创建客户端 socket 并发起连接。服务端接受连接的操作放在阶段 4,在 kTLS 配置与陈旧分片注入之后。
这一顺序使锚点 skb 的 skb->head slab 在服务端接受连接之后第一次数据到达时才分配,与阶段 4 释放的 vsock slab 对接。若在这一阶段就接受连接,accept() 本身触发的 skb 分配会占用 slab 槽位,改变阶段 4 至阶段 6 之间的复用时序。
这一阶段结束时,客户端已完成 connect() 并进入已连接状态,服务端尚未 accept(),三次握手的最后一步留待阶段 4 推进。
sequenceDiagram
participant M as main
participant L as 监听器
participant T as 客户端
participant K as 内核 TCP
M->>L: socket AF_INET SOCK_STREAM
M->>L: setsockopt SO_REUSEADDR
M->>L: bind 127.0.0.1 端口 4444
M->>L: listen 1
M->>T: socket AF_INET SOCK_STREAM
M->>T: connect 127.0.0.1 4444
T->>K: SYN
K-->>T: SYN ACK 连接进入已连接状态
Note over M: 服务端接受连接推迟到阶段 4
3-6. 阶段 4:陈旧分片注入
这是整个链中的 slab 对接步骤,六个子步骤按以下顺序执行:vsock 零拷贝发送、vsock 排空、启用 kTLS、服务端接受连接、TCP_NODELAY、SO_RCVBUF。前两步在 vsock 侧完成页引用的注入与释放,第三步在客户端启用 kTLS,后三步在服务端完成连接收尾与缓冲区配置。
零拷贝的覆盖范围。 AIO ring 的 mmap 区域为 4 页,覆盖 [aio_ring, aio_ring + 0x4000),即页 0 至页 3。zero-copy 的起点是 aio_ring + PAGE_SIZE,发送 0x50c0 字节,覆盖 6 个页:frags[0] 至 frags[2] 分别指向 AIO ring 的页 1 至页 3;frags[3] 指向 aio_ring + 0x4000(页 4)、frags[4] 指向 aio_ring + 0x5000(页 5)、frags[5] 指向 aio_ring + 0x6000 的前 0xc0 字节(页 6 前段),后三者已越过 AIO ring 的 4 页范围,属于进程地址空间中 aio_ring 之后相邻的 VMA 页。io_destroy() 只释放 AIO ring 的页 0 至页 3,页 4、页 5、页 6 前段仍属于用户进程,保持活跃。
sequenceDiagram
participant M as main
participant V as vsock 对
participant T as TLS 客户端
participant S as TLS 服务端
participant K as 内核 skb slab
M->>V: send aio_ring 加 PAGE 起 长度 0x50c0 MSG_ZEROCOPY
V->>K: vsock skb frags 0 至 2 指向 AIO ring 页 1 至 3
V->>K: vsock skb frags 3 至 4 指向 VMA 页 4 至 5
V->>K: vsock skb frags 5 指向 VMA 页 6 前 0xc0 字节
M->>V: read 排空服务端
V->>K: kfree_skb 释放 skb head slab 内容未清零
Note over K: frags 中页引用仍保留在 slab 中
M->>T: setsockopt TCP_ULP tls
M->>T: setsockopt TLS_TX 与 TLS_RX
Note over K: 锚点 skb 存在 但 skb head slab 未分配
M->>S: accept 完成三次握手
M->>S: setsockopt TCP_NODELAY
M->>S: setsockopt SO_RCVBUF 缩小至 64KB
M->>M: close tcp_listener_fd
Note over M: 待对接就绪 进入阶段 5
图中的三个 Note 对应这一阶段的关键状态。vsock 排空之后,kfree_skb() 释放 skb->head slab 而不清零其内容,frags[] 中的页引用保留。kTLS 启用之后,锚点 skb 已存在,但承载 skb_shared_info->frags[] 的 skb->head slab 尚未分配,它在阶段 5 第一次数据到达时才分配。六步全部完成之后,vsock skb 的 skb->head slab 处于空闲状态且保留页引用,kTLS 锚点 skb 的 skb->head slab 尚未分配。
TCP_NODELAY 避免 Nagle 算法合并小包,使阶段 5 的 5 字节带外数据能够独立触发一次数据搬运;SO_RCVBUF 把服务端接收缓冲区压缩到 64KB 量级,配合客户端接收缓冲形成 copy 模式所需的内存压力。
3-7. 阶段 5:载荷暂存
这一阶段把伪造的 pipe_buffer 载荷送入 TCP 接收缓冲区,并触发锚点 skb 的 skb->head slab 分配。kTLS 在客户端启用,数据由 main 从服务端发出,经回环 TCP 到达客户端,由客户端的 kTLS 解析器接收并处理。
sequenceDiagram
participant M as main
participant W as worker
participant S as TLS 服务端
participant T as TLS 客户端
participant K as 内核 skb slab
W-->>M: WORKER_READY 在管道中等待
M->>M: 取出 WORKER_READY 记录 payload_addr
M->>S: send 5 字节 MSG_OOB
S->>T: 数据经回环 TCP 递送
T->>K: 首次搬运触发 tls_strp_copyin_frag
K->>K: 分配锚点 skb head slab
K->>K: 复用刚释放的 vsock slab 继承 frags
Note over K: frags 0 至 2 指向 AIO ring 页 1 至 3
Note over K: frags 3 至 5 指向 VMA 页 4 至 6 前段
M->>M: 构建伪造载荷 每槽 ops 写 payload_addr
M->>S: send 64KB 伪造 pipe_buffer 载荷
S->>T: 数据经回环 TCP 进入客户端接收缓冲
T->>K: 首次搬运写入 frags 0 即 AIO 页 1
Note over K: 余下数据留在 TCP 缓冲 待阶段 8 逐页递送
Note over M: 载荷已暂存 进入阶段 6
图中第一行是阶段 1 遗留的延迟消费:worker 在阶段 1 发出的 WORKER_READY 此刻才被 main 取出,payload_addr 是 CEA 中伪造 pipe_buf_operations 的地址。随后 5 字节带外数据经服务端发出、客户端接收,客户端 kTLS 解析器在此刻分配锚点 skb 的 skb->head slab。该 slab 刚被 vsock skb 释放,分配器将其复用,锚点 skb 继承阶段 4 遗留的 6 个槽位:frags[0] 至 frags[2] 分别指向 AIO ring 的页 1 至页 3,frags[3] 至 frags[5] 指向 AIO ring 之后的 VMA 页 4 至页 6 前段。
64KB 普通发送随后进行。每个 0xc0 对齐槽位的 ops 字段被写入 payload_addr,数据进入客户端 TCP 接收缓冲区,但只有第一页被搬运并写入 frags[0](即 AIO ring 的页 1,此时该页仍活跃),剩余数据留在缓冲区等待阶段 8 的带外数据触发逐页递送。
3-8. 阶段 6:释放与回收
这一阶段把 AIO 页释放回 buddy,再以 pipe_buffer slab 的形式重新取回,分三步:释放 AIO ring、双堆喷、排空 msg_msgseg。
释放 AIO ring。 AIO ring 的全部 4 页被释放回 buddy,随后休眠 1 秒等待页释放完全生效。AIO ring 的页释放涉及延迟回收,休眠使释放完成。此时锚点 skb 的 frags[] 中 frags[0] 至 frags[2] 保存的页引用指向已释放页面;frags[3] 至 frags[5] 指向的 VMA 页从未被释放,仍属于用户进程。
双堆喷。 堆喷的目标是让 kmalloc-cg-192 在增长过程中向 buddy 或 PCP 申请新页,使 AIO ring 的页 2 与页 3 被重新取回为新 slab 页。这一目标由两个来源共同完成。
第一个来源是 msg_msgseg。它的续段由 kmalloc(sizeof(*seg) + alen, GFP_KERNEL_ACCOUNT) 分配,GFP_KERNEL_ACCOUNT 使它落在 kmalloc-cg 系列缓存;alen 经过计算,使续段大小恰好落在 kmalloc-cg-192。msg_msgseg 的限制宽松——消息队列数与每队列消息数都远高于管道数——因此它可以持续申请大量对象,把 kmalloc-cg-192 的空闲槽位逐步耗尽。该缓存的 per-CPU freelist 与 partial slab 填满后,分配器向 buddy 或 PCP 申请新的物理页,把新页切分为 0xc0 大小的槽位。
第二个来源是 pipe_buffer。管道数量受 RLIMIT_NOFILE 等限制,单靠管道扩展不足以耗尽 kmalloc-cg-192。管道扩展作为命中源:在 msg_msgseg 推动缓存增长的过程中,每追加一定数量的 msg_msgseg,扩展两个管道,把少量 pipe_buffer 插入到刚刚申请的新页中。
两个来源的比例经过设计,使新申请的每一页中都至少有一个 pipe_buffer。只要 AIO ring 的页 2 或页 3 被 kmalloc-cg-192 取回为新 slab 页,该页上就必然存在可被越界写覆盖的 pipe_buffer;两页都被取回则命中更稳。
排空 msg_msgseg。 堆喷完成后,用非阻塞方式接收全部消息,释放全部 msg_msgseg。越界写若破坏它们的 next 指针,后续任何一次消息遍历都会解引用无效指针并触发内核 panic;排空之后只有 pipe_buffer 存活,它们是越界写的目标。
sequenceDiagram
participant M as main
participant K as 内核 buddy 与 kmalloc-cg-192
M->>K: io_destroy aio_ring
K->>K: AIO ring 页 0 至 3 回到 buddy freelist
M->>M: 休眠 1 秒等待释放完全生效
Note over K: frags 中页引用已指向释放页
loop 以固定比例为一组
M->>K: msgsnd 写 msg_msgseg 到 kmalloc-cg-192
K->>K: 缓存空闲槽位被逐步耗尽
M->>K: 扩展两个管道触发 pipe_buffer 分配
K->>K: 缓存满时向 buddy 或 PCP 申请新页
K->>K: 新页被切分为 0xc0 槽位
Note over K: 新页中每页至少一个 pipe_buffer
end
K->>K: AIO ring 页 2 与页 3 以 pipe_buffer slab 形式重新出现
loop 全部消息队列
M->>K: msgrcv 非阻塞 释放 msg_msgseg
K->>K: msg_msgseg next 指针不再存活
end
Note over K: 仅 pipe_buffer 存活 进入阶段 7
图中中间的循环是这一阶段的核心。msgsnd 与管道扩展以固定比例交错推进:每 21 条 msg_msgseg 触发两次管道扩展,msg_msgseg 推动缓存增长,管道扩展把 pipe_buffer 插入新页。新申请的每一页中至少包含一个 pipe_buffer,无论 buddy 分配器把哪一页交还给 kmalloc-cg-192,该页上都有可被越界写覆盖的目标。
排空之后,缓存中只剩下 pipe_buffer 与少量无关对象。AIO ring 释放早于堆喷,AIO 页进入 buddy 供 kmalloc-cg-192 取回;msg_msgseg 排空晚于堆喷、早于阶段 8,msg_msgseg 被释放而 pipe_buffer 保留。
需要把这一阶段的覆盖目标与阶段 5、阶段 8 的写入时序对照来看。zero-copy 的起点是 aio_ring + PAGE_SIZE,这一页偏移使 frags[] 索引与 AIO ring 的物理页号错开一位:frags[0] 至 frags[2] 分别指向 AIO ring 的页 1 至页 3,frags[3] 指向 aio_ring + 0x4000(页 4)、frags[4] 指向 aio_ring + 0x5000(页 5)、frags[5] 指向页 6 前 0xc0 字节,后三者已越过 AIO ring 的 4 页范围,属于用户进程的其他 VMA 页。
frags[0] 在阶段 5 的首次 64KB 搬运时即被写入,彼时 AIO ring 的页 1 尚未经 io_destroy 释放,仍处于活跃状态,这次写入不构成可利用的 OOB。阶段 8 的三次带外数据递送把 skb->len 从 PAGE_SIZE 推进到 4 * PAGE_SIZE,索引依次落入 frags[1]、frags[2]、frags[3]:前两次分别覆盖 AIO ring 的页 2 与页 3,这两页被 io_destroy() 释放、被双堆喷回收,是本阶段需要命中的目标;第三次落在 frags[3] 指向的 VMA 页 4 上,该页不在 AIO ring 内、从不被 io_destroy() 释放,写入落在用户进程自己的 VMA 上,不触及任何内核对象。frags[4]、frags[5] 从未被索引,因为 skb->len 最高只到 4 * PAGE_SIZE,索引最大为 3。双堆喷的比例设计针对的正是 AIO ring 的页 2 与页 3 这两页:只要新申请的每一页中都至少有一个 pipe_buffer,这两页被 buddy 交还给 kmalloc-cg-192 时,页上就必然存在可被覆盖的 pipe_buffer。
3-9. 阶段 7:worker 启动
这一阶段把伪造的 pipe_buf_operations 写入 CPU entry area,并使 worker 进入缺页循环。main 与 worker 在这一阶段分成两条线:main 发出启动信号后立即迁移到 CPU 1,worker 在收到信号后完成写入并进入循环。
sequenceDiagram
participant M as main
participant W as worker CPU0
participant K as 内核 CEA
M->>W: 发送 CEA_GO
W->>W: 解除阻塞 伪造结构 release 槽位填 JIT payload 地址
W->>K: 注册空 SIGSEGV 处理器
W->>K: 内联汇编 栈指针指向伪造结构 逐字段装入寄存器
W->>K: 执行触发异常的指令
K-->>W: SIGSEGV
W->>W: 信号处理器返回
K->>K: 重新执行异常指令 再次填充 pt_regs
Note over K: 伪造 pipe_buf_operations 持续驻留
M->>M: 迁移到 CPU 1
Note over M: worker 独占 CPU 0 进入阶段 8
图中两条线并行推进:main 的迁移只依赖”信号已发出”,worker 的写入与循环独立进行。阶段 8 的管道关闭在 CPU 1 上执行,CPU 0 由 worker 的缺页循环占用。
worker 侧的内联汇编把栈指针指向伪造结构,用一串 pop 把该结构的字段装入各寄存器,最后执行一条会触发异常的指令。信号处理器返回后内核重新执行该指令,pt_regs 被重新填充为伪造结构的字段布局。这一循环使 CEA 中的伪造结构持续存在,直到阶段 8 的 pipe_buf_release() 读取它。
3-10. 阶段 8:触发
这一阶段完成越界写与控制流转移,两个循环分别对应”覆盖哪些 pipe_buffer“与”哪些被覆盖的 pipe_buffer 触发控制流转移”。
sequenceDiagram
participant M as main CPU1
participant C as watcher CPU1
participant S as TLS 服务端
participant T as TLS 客户端
participant P as pipe_buffer
participant J as eBPF JIT payload
participant K as 内核 core_pattern
M->>C: 发送 WATCH_GO
C->>C: 解除阻塞 转入轮询
C->>K: 周期读取 core_pattern
loop 三次 OOB
M->>S: send 5 字节 MSG_OOB
S->>T: 数据经回环 TCP 递送
T->>T: 触发 tls_strp_copyin_frag
T->>P: 索引落入 frags 1 至 3 越界写
P->>P: 对应 pipe_buffer ops 被覆盖为 CEA 地址
end
Note over P: AIO ring 页 2 与页 3 上的 pipe_buffer 已被覆盖
loop 全部 payload 管道
M->>P: 关闭管道读端与写端
P->>P: pipe_buf_release 读 ops 偏移 0x08
P->>J: 间接调用进入 JIT payload
J->>K: 改写 core_pattern
J-->>P: 返回
P-->>M: 关闭继续执行至完成
end
Note over M: payload 已执行 进入阶段 9
第一个循环中,每次带外数据递送触发一次数据搬运调用,skb->len 从 PAGE_SIZE 推进到 4 * PAGE_SIZE,索引依次落入 frags[1](AIO ring 页 2)、frags[2](AIO ring 页 3)、frags[3](AIO ring 之后的 VMA 页 4,无害)。前两次写入落在已回收为 pipe_buffer slab 的 AIO ring 页上,覆盖对应 pipe_buffer 的 ops 字段;第三次落在 VMA 页,不影响利用链。
第二个循环中,每次关闭触发 pipe_buf_release(),该函数读取伪造结构偏移 +0x08 处的值(即 JIT payload 地址),间接调用进入 eBPF JIT payload。payload 在内核态完成 core_pattern 的改写后返回,关闭操作继续执行至完成。未被覆盖的 pipe_buffer 在关闭时走正常释放路径。
3-11. 阶段 9:core_pattern 接管
这一阶段完成从内核态 payload 返回到用户态 root shell 的过渡。watcher 在轮询中检测到 core_pattern 已被改写为利用程序设定的值,主动触发一次空指针解引用使自身崩溃;内核的 core dump 处理器按新的 core_pattern 以 root 身份重新执行利用程序,并把 watcher 的进程号作为参数传入。
sequenceDiagram
participant C as watcher
participant K as 内核 core dump
participant R as 利用程序 root
participant S as bin sh
C->>K: read core_pattern 发现新值
C->>C: 空指针解引用 崩溃
K->>K: 按新 core_pattern 派生 core dump 辅助程序
K->>R: execve 利用程序 传入 watcher 进程号
R->>R: getuid 等于 0 跳过全部利用阶段
R->>C: pidfd_open watcher 进程号
R->>C: pidfd_getfd 取得 0 1 2
R->>R: dup2 到自身 0 1 2
R->>S: execve bin sh 交互模式
S-->>R: root 交互式 shell
Note over R: 原终端出现 root 提示符
重新执行的利用程序检测到 getuid() == 0,跳过全部利用阶段,直接通过 pidfd_open 与 pidfd_getfd 取得崩溃 watcher 的标准输入、标准输出、标准错误,dup2 到自身文件描述符 0/1/2,随后 execve("/bin/sh", ...) 启动交互式 shell。
3-12. 保护机制应对策略
笔者的利用思路对内核常见防护机制逐项处理。以下逐项说明各机制在本思路下的实际约束。与 3-1-2 的设计取舍互为表里:3-1-2 说明”为什么这样选”,本节说明”这样选之后每个机制是否还构成障碍”。
KASLR:不构成障碍。CEA 内的 GDT 基址由
sgdt在运行时读取,模块区由宽范围喷射覆盖,整条链不包含泄漏步骤,也不依赖任何被随机化的地址的精确值。作为对照,官方 PoC 的 EntryBleed 绕过依赖 prefetch 在已映射与未映射地址上的时序差异,这一条件只在物理 CPU 上成立;TCG 模拟环境下指令由动态翻译器解释执行,时序特征被抹平,扫描无法收敛,官方 PoC 在该环境中不可用。本思路不涉及时序侧信道,在两类环境下行为一致。SMEP:不构成约束。控制流转移的目标是 eBPF JIT 生成的内核态代码,位于模块区;root shell 由内核的 core dump 处理器以用户态
execve启动,内核态全程未执行用户态代码。SMAP:不构成约束。越界写入的目标是内核页,源数据通过合法的
skb_copy_bits()从内核 skb 搬运,不经过 usercopy 路径;core_pattern的改写由 eBPF JIT payload 在内核态完成,不涉及用户态对内核页的映射或写入。KPTI:不构成约束。全程通过合法系统调用完成状态迁移,不直接访问内核虚拟地址空间,也不依赖用户态对内核页的映射。
CONFIG_MEMCG/CONFIG_MEMCG_KMEM:不构成约束,理由分两层。其一,AIO ring 的页释放与重新取回发生在 buddy 页分配器层:io_destroy()把 4 页归还 buddy,kmalloc-cg-192在增长时向 buddy 或 PCP 申请新页;memcg 的 slab 记账作用于缓存层,不改变 buddy 层的页分配与回收行为。其二,msg_msgseg与pipe_buffer均以GFP_KERNEL_ACCOUNT分配,同属KMALLOC_CGROUP类型,落在同一个kmalloc-cg-192缓存;memcg 的作用是把带记账标志的分配从kmalloc-*分离到kmalloc-cg-*,并不会在kmalloc-cg-192内部再按 cgroup 细分。二者因此仍可在同一 slab 页上交错,3-8 的交错比例不受影响。CONFIG_RANDOM_KMALLOC_CACHES:不构成约束。该配置仅对KMALLOC_NORMAL类型的kmalloc-*缓存生效,通过将不同调用点的分配哈希到多个随机子缓存来增加堆喷的不确定性。本思路中用于堆喷的msg_msgseg与pipe_buffer均通过GFP_KERNEL_ACCOUNT分配,属于KMALLOC_CGROUP类型,落在独立的kmalloc-cg-*缓存集中。该缓存集不参与这一随机化,二者始终位于同一个确定性的kmalloc-cg-192缓存中,分配顺序与调用点无关。因此该配置对本思路的堆喷布局不产生任何影响。CONFIG_SLAB_FREELIST_RANDOM:不构成约束。该配置在 slab 创建时打乱对象的初始排列。本思路的核心是页级回收与双堆喷:AIO 页以整页形式释放回 buddy,被kmalloc-cg-192重新申请为新 slab 页;该新页中对象的初始排列即便被打乱,本思路也不依赖”第几次分配取到目标对象”的精确预测,而是依靠双堆喷使新申请的每一页中都至少包含一个pipe_buffer。越界写只需覆盖新页中的任意一个pipe_buffer的ops字段,与对象在该页中的具体位置无关。因此该配置不构成约束。CONFIG_SLAB_FREELIST_HARDENED:不构成约束。该配置对 freepointer 做编码,并在设置 freepointer 时检查目标对象是否等于空闲指针并触发BUG_ON。本思路不修改任何空闲对象的 freepointer:AIO 页以整页形式释放回 buddy,不经过 slab 的kfree路径;被kmalloc-cg-192重新申请为新 slab 页时,页中对象的 freepointer 由分配器正常写入;越界写目标是活跃pipe_buffer的ops字段,而非空闲对象。释放与分配序列中 freepointer 始终由内核正常维护,不会触发该检查。CONFIG_HARDENED_USERCOPY:不构成约束。各系统调用中的用户缓冲区均在合法 VMA 范围内;伪造的pipe_buf_operations由 worker 通过内联汇编写入自身栈帧,不经 usercopy 路径。CONFIG_SHUFFLE_PAGE_ALLOCATOR:增加不确定性,但不构成硬性阻断。该配置打乱页分配器的 freelist,使目标页的复用顺序不可预测;本思路通过双堆喷持续向 buddy 或 PCP 申请新页,为 AIO ring 的页 2 与页 3 提供多次被kmalloc-cg-192取回的机会,命中是概率问题而非确定事件,双堆喷的规模提高命中概率。
整体上,本思路不做内核控制流经由 ROP 或 JOP 的转移,全部内核交互通过合法系统调用、页层对象复用与一次受控的间接调用完成。这一设计使 SMEP、SMAP、KPTI、CONFIG_HARDENED_USERCOPY 均不构成约束,而 KASLR 因 sgdt 动态读取与宽范围覆盖而不需要绕过。
3-13. 前提条件与局限性
前提条件:
- 目标内核运行于
init_on_alloc=0。init_on_alloc=1下frags[0].netmem即为 0,首次搬运时skb_frag_address()返回 NULL 而chunk非零,skb_copy_bits()以 NULL 为目标写入并触发内核 NULL 解引用,利用链在第一个槽位终止。 - 接收侧启用了 kTLS 软件卸载。未启用接收方向卸载的 socket 不进入数据搬运函数。
- 服务端 socket 的
SO_RCVBUF可被压缩至 copy 模式。接收缓冲区始终足以容纳完整记录时,strparser 走主路径而非 copy 模式。 - 内核版本落在受影响区间内,且未应用上游修复提交或其稳定分支回移植。
- 目标架构为 x86_64。
sgdt路径不依赖 4-level 或 5-level paging 的 CEA 常量;sgdt返回的地址在当前分页模式下直接可用。 - eBPF JIT 已启用。eBPF JIT payload 的生成依赖该配置;未启用时需改用其他内核态代码生成方式。
局限性:
- 对双堆喷规模的依赖。 AIO ring 的页 2 与页 3 的回收依赖”新申请的每一页中都至少有一个
pipe_buffer“这一比例关系。该比例由管道数量、消息队列数量、每组消息数三个常量共同决定;管道数量受RLIMIT_NOFILE限制,msg_msgseg数量受消息队列上限限制。随机化缓存与页分配器打乱的配置下,命中是概率事件而非确定事件,单次尝试失败需要重试。eBPF JIT payload 的命中依赖喷射程序的数量覆盖宽度。 - 不解决
init_on_alloc=1场景。 笔者的利用思路的所有原语都建立在”释放的 slab 保留陈旧内容”之上。init_on_alloc=1下这一前提不成立,思路不提供对应的替代路径。该配置下的可利用性在第二章已分析,结论为不可利用。
与官方 PoC 相比,笔者的利用思路在环境依赖上有一处优势:官方 PoC 的 EntryBleed 绕过要求 prefetch 时序差异真实存在,因而必须在物理 CPU 上运行;在指令由动态翻译器解释执行的 TCG 模拟环境中,时序特征被抹平,绕过失效。笔者的思路以 sgdt 动态读取 CEA 基址、以宽范围覆盖应对模块区随机化,不涉及时序侧信道,在物理 CPU 与 TCG 模拟环境下行为一致,因而在虚拟化环境中具备更好的可复现性。
3-14. 章节总结
本章描述的利用思路与官方 PoC 共享同一个内核缺陷、同一套陈旧分片原语、同一条 pipe_buffer 回收路径,分歧集中在两处:KASLR 的处理方式,以及控制流接管的实现方式。前者以 sgdt 动态读取与宽范围喷射覆盖取代 EntryBleed 时序侧信道;后者以 CEA 伪造 pipe_buf_operations 加 eBPF JIT one_gadget 取代栈迁移加 ROP 链。
这两处分歧各自对应一组结构性收益。用 sgdt 取代侧信道,使利用链不依赖物理 CPU 语义:官方 PoC 的 EntryBleed 依赖 prefetch 在已映射与未映射地址上的时序差异,该差异只在物理 CPU 上成立,在指令由动态翻译器解释执行的 TCG 模拟环境中被抹平;本思路在两类环境下行为一致,在虚拟化环境中具备更好的可复现性。用 one_gadget 取代 ROP 链,使控制流转移退化为一次间接调用,无需构造栈帧、无需串联 gadget、无需在寄存器与栈之间搬运参数;payload 由内核 JIT 编译器生成,不把用户态代码放入内核执行,SMEP、SMAP、KPTI、CONFIG_HARDENED_USERCOPY 均不构成约束。
页级回收是决定稳定性的环节。msg_msgseg 与 pipe_buffer 均以 GFP_KERNEL_ACCOUNT 分配,落在同一个 kmalloc-cg-192 缓存中。前者限制宽松,作为主力推动缓存增长,把空闲槽位逐步耗尽,迫使分配器向 buddy 或 PCP 申请新页;后者限制较紧,以扩展管道的方式随新页一同插入。两者按固定比例交错推进,使新申请的每一页中都至少包含一个 pipe_buffer。
越界写的覆盖范围需要与写入时序、页归属对照界定。AIO ring 的 mmap 区域为 4 页,覆盖 [aio_ring, aio_ring + 0x4000)。zero-copy 的起点是 aio_ring + PAGE_SIZE,覆盖 6 个页:frags[0] 至 frags[2] 分别指向 AIO ring 的页 1 至页 3,frags[3] 指向 aio_ring + 0x4000(页 4)、frags[4] 指向页 5、frags[5] 指向页 6 前 0xc0 字节,后三者已越过 AIO ring 的 4 页范围,属于进程地址空间中 aio_ring 之后相邻的 VMA。io_destroy() 只释放 AIO ring 的页 0 至页 3,页 4、页 5、页 6 前段仍属于用户进程,保持活跃,因而无需为它们堆喷 pipe_buffer。
frags[0] 的写入发生在阶段 5 的首次 64KB 搬运时,彼时 AIO ring 的页 1 尚未被释放,仍处于活跃状态,这次写入不构成可利用的 OOB。阶段 8 的三次带外数据递送把 skb->len 从 PAGE_SIZE 推进到 4 * PAGE_SIZE,索引依次落入 frags[1]、frags[2]、frags[3]:前两次写入落在已由 pipe_buffer 回收的 AIO ring 页 2 与页 3 上,覆盖对应 pipe_buffer 的 ops 字段;第三次落在 frags[3] 指向的 VMA 页 4 上,该页不在 AIO ring 内、从不被 io_destroy() 释放,写入落在用户进程自己的 VMA 上,不触及任何内核对象;frags[4]、frags[5] 从未被索引。双堆喷的意义正在于此:它把”AIO ring 页 2 与页 3 必须由 pipe_buffer 占据”这一要求,转化为”新申请的每一页中都至少有一个 pipe_buffer“。前者取决于 buddy 分配器把哪几页交还给 kmalloc-cg-192,后者仅取决于双堆喷的比例是否成立,可控性完全不同。
进程编排上,三个角色的生命周期按信号严格分段。main 负责全部用户态编排:先完成 fd 上限提升与四对 IPC 管道创建,随后绑定 CPU 0 并派生 worker 与 watcher,收尾管道端后等待两个 online 信号,再重新绑定 CPU 0。worker 与 watcher 从派生点开始各自阻塞:worker 等待 JIT 地址,收到后计算 CEA 地址并回报,随即回到阻塞等待启动信号;watcher 则一直等待触发信号。阶段 1 至阶段 6 期间,main 独立推进,不与任何子进程同步——JIT 喷射、内核对象准备、TLS 客户端建立、陈旧分片注入、载荷暂存、释放与回收六个阶段全部由 main 单向完成。阶段 7 向 worker 发出启动信号后,main 迁移到 CPU 1,worker 在 CPU 0 上写入 CEA 并进入缺页循环。阶段 8 向 watcher 发出触发信号,watcher 转入轮询;main 在 CPU 1 上完成三次越界写并关闭全部 payload 管道。阶段 9 由 watcher 的崩溃触发,内核按新的 core_pattern 以 root 身份重新执行利用程序,取得 root shell。
代价集中在前提与稳定性上。init_on_alloc=0 是硬性前提,init_on_alloc=1 下思路不可用;CPU 亲和性与双堆喷比例决定了单次尝试的命中概率,页分配器随机化配置下需要重试;未启用 eBPF JIT 的内核需要改用其他内核态代码生成方式。这些代价与收益的权衡,构成了笔者的利用思路选择这一路径而非官方 PoC 路径的完整理由。
3-15. 测试结果

4. 漏洞修复
CVE-2025-39946 的修复由上游提交 0aeb54ac4cd5(“tls: make sure to abort the stream if headers are bogus”)完成。该提交由 Jakub Kicinski 于 2025 年 9 月 16 日提交,经 Sabrina Dubroca 审阅,由 Paolo Abeni 于 2025 年 9 月 18 日合入上游主线。修复源于 Lee Jones 的报告,Fixes 标签指向引入该缺陷的提交 84c61fe1a75b(“tls: rx: do not use the standard strparser”)。本章从补丁概述、技术分析、利用链切断、版本回溯与要点总结五个层面展开。
4-1. 修复补丁概述
补丁的核心判断写在提交信息中:正常路径下内核等待 socket 缓冲完整记录后才处理;当 socket 缓冲区极小、为避免连接停顿时,内核会提前读出数据。此时若事后才发现记录无效,必须中止连接——重试解析本身没有问题,但每次重试都会先搬运一段数据、再解析,累积之下可能越过已分配的 skb 空间。构造“缓冲区吃紧且数据不足以先行解析长度”的场景并不容易,syzbot 通过小规模带外数据递送配合大规模普通发送构造出了这一状态。补丁的结论是:tls_rx_msg_size() 一旦判定记录无效,就应中止 strparser,不存在恢复的余地。
补丁共触及三个文件,改动可分四组:tls.h 中为 tls_strp_abort_strp() 补充跨文件声明;tls_strp.c 中解除该函数的 static 限定;tls_strp.c 中在 tls_strp_copyin_frag() 入口增加索引边界检查;tls_sw.c 中将 tls_rx_msg_size() 失败路径的中止动作从 tls_err_abort() 改为 tls_strp_abort_strp(),并移除 tls_strp_read_sock() 中因此冗余的显式调用。前三组是使第四组可行的配套——声明与解除 static 让 tls_sw.c 能够调用该函数,边界检查则从另一侧阻断越界索引。三处 hunk 的内容如下。
net/tls/tls.h:为跨文件调用补充声明。 tls_strp_abort_strp() 原为 tls_strp.c 内的 static 函数,无法从 tls_sw.c 调用。本文件加入其原型声明:
diff --git a/net/tls/tls.h b/net/tls/tls.h
index 4e077068e6d98..e4c42731ce39a 100644
--- a/net/tls/tls.h
+++ b/net/tls/tls.h
@@ -141,6 +141,7 @@ void update_sk_prot(struct sock *sk, struct tls_context *ctx);
int wait_on_pending_writer(struct sock *sk, long *timeo);
void tls_err_abort(struct sock *sk, int err);
+void tls_strp_abort_strp(struct tls_strparser *strp, int err);
int init_prot_info(struct tls_prot_info *prot,
const struct tls_crypto_info *crypto_info,
net/tls/tls_strp.c:解除 static 限定、增加索引边界检查、移除冗余调用。 本文件包含三处 hunk。第一处把 tls_strp_abort_strp() 的 static 限定去掉,使其在链接层面可见;第二处在 tls_strp_copyin_frag() 入口把索引存入局部变量 nfrag,与 nr_frags 比较后再取分片指针;第三处移除 tls_strp_read_sock() 中因中止动作下沉而变得冗余的显式调用:
diff --git a/net/tls/tls_strp.c b/net/tls/tls_strp.c
index d71643b494a1a..98e12f0ff57e5 100644
--- a/net/tls/tls_strp.c
+++ b/net/tls/tls_strp.c
@@ -13,7 +13,7 @@
static struct workqueue_struct *tls_strp_wq;
-static void tls_strp_abort_strp(struct tls_strparser *strp, int err)
+void tls_strp_abort_strp(struct tls_strparser *strp, int err)
{
if (strp->stopped)
return;
@@ -211,11 +211,17 @@ static int tls_strp_copyin_frag(struct tls_strparser *strp, struct sk_buff *skb,
struct sk_buff *in_skb, unsigned int offset,
size_t in_len)
{
+ unsigned int nfrag = skb->len / PAGE_SIZE;
size_t len, chunk;
skb_frag_t *frag;
int sz;
- frag = &skb_shinfo(skb)->frags[skb->len / PAGE_SIZE];
+ if (unlikely(nfrag >= skb_shinfo(skb)->nr_frags)) {
+ DEBUG_NET_WARN_ON_ONCE(1);
+ return -EMSGSIZE;
+ }
+
+ frag = &skb_shinfo(skb)->frags[nfrag];
len = in_len;
/* First make sure we got the header */
@@ -520,10 +526,8 @@ static int tls_strp_read_sock(struct tls_strparser *strp)
tls_strp_load_anchor_with_queue(strp, inq);
if (!strp->stm.full_len) {
sz = tls_rx_msg_size(strp, strp->anchor);
- if (sz < 0) {
- tls_strp_abort_strp(strp, sz);
+ if (sz < 0)
return sz;
- }
strp->stm.full_len = sz;
net/tls/tls_sw.c:tls_rx_msg_size() 失败路径改用 tls_strp_abort_strp()。 本文件包含一处 hunk,位于 read_failure 标签处,把原来的 tls_err_abort() 替换为 tls_strp_abort_strp():
diff --git a/net/tls/tls_sw.c b/net/tls/tls_sw.c
index bac65d0d4e3e1..daac9fd4be7eb 100644
--- a/net/tls/tls_sw.c
+++ b/net/tls/tls_sw.c
@@ -2474,8 +2474,7 @@ int tls_rx_msg_size(struct tls_strparser *strp, struct sk_buff *skb)
return data_len + TLS_HEADER_SIZE;
read_failure:
- tls_err_abort(strp->sk, ret);
-
+ tls_strp_abort_strp(strp, ret);
return ret;
}
从补丁与第二章根因分析的对应关系看:tls_strp_copyin_frag() 的边界检查针对“动作源”,tls_rx_msg_size() 的失败路径改动针对“条件源”,tls.h 的声明与 tls_strp.c 的 static 解除是条件源修补的配套准备,tls_strp_read_sock() 的删除是条件源修补之后的冗余清理。
4-2. 补丁的技术分析
动作源的修补:tls_strp_copyin_frag() 的索引边界检查。 修补前该函数以 skb_shinfo(skb)->frags[skb->len / PAGE_SIZE] 直接取分片指针,索引与 nr_frags 之间没有任何比较。修补后先把索引存入局部变量 nfrag,再与 nr_frags 比较,越界时执行 DEBUG_NET_WARN_ON_ONCE(1) 并返回 -EMSGSIZE,只有通过检查才取指针:
unsigned int nfrag = skb->len / PAGE_SIZE;
size_t len, chunk;
skb_frag_t *frag;
int sz;
if (unlikely(nfrag >= skb_shinfo(skb)->nr_frags)) {
DEBUG_NET_WARN_ON_ONCE(1);
return -EMSGSIZE;
}
frag = &skb_shinfo(skb)->frags[nfrag];
比较对象是 nr_frags,而非 MAX_SKB_FRAGS。这一选择决定了修补的语义层级:若比较对象是 MAX_SKB_FRAGS,则只防御数组物理越界,frags[1]、frags[2] 等“数组内、语义外”的写入仍会发生;比较对象是 nr_frags,则防御的是有效分片边界。第三章的分析表明,可利用的写入窗口恰恰是“数组内、语义外”的那一段,因此以 nr_frags 为比较对象是切断动作源的必要条件。
在常规处理路径下,锚点 skb 的分片由正常 skb 构造流程填充,nr_frags > 0,检查通过;在第三章所述的漏洞场景中,锚点 skb 以 nr_frags == 0 起始(第二章 2-2-1 已述),首次搬运时 nfrag == 0 即满足 nfrag >= nr_frags,函数返回 -EMSGSIZE,不进入写入路径。检查不改变正常路径的行为,只阻断漏洞场景中未经正常填充的索引。
条件源的修补:tls_rx_msg_size() 失败路径改用 tls_strp_abort_strp()。 修补前,read_failure 标签只调用 tls_err_abort(),该函数仅设置 sk_err 并触发 sk_error_report(),不改变 strparser 状态。修补后改为调用 tls_strp_abort_strp(),该函数设置 strp->stopped = 1,再报告错误:
read_failure:
- tls_err_abort(strp->sk, ret);
-
+ tls_strp_abort_strp(strp, ret);
return ret;
这一改动使中止动作从调用者侧下沉至 tls_rx_msg_size() 内部。修补前,主路径上的调用者显式执行中止,copy 模式路径上的调用者不执行,形成责任不一致;修补后,无论调用者是谁,失败路径都会一致地终止 strparser。提交信息对此有明确说明:“Make sure that tls_rx_msg_size() aborts strp, if we reach an invalid record there’s really no way to recover.”
配套改动:解除 static 限定与移除冗余调用。 tls_strp_abort_strp() 原为 tls_strp.c 内的 static 函数,无法从 tls_sw.c 调用。补丁将其改为非 static,并在 tls.h 中加入声明。与此同时,tls_strp_read_sock() 中原先的显式调用被移除——tls_rx_msg_size() 自身已在失败路径上中止,主路径上的显式调用成为重复动作。tls_strp_abort_strp() 开头有 if (strp->stopped) return; 的守卫,重复调用本身无害,移除它使中止责任的归属单一化。
4-3. 漏洞利用链的切断
第二章把根因拆成动作源、条件源与推进机制三层。补丁对前两层各有一处针对性改动,两处改动分别从不同环节阻断第三章的利用链。
动作源:越界索引在产生处被拒绝。 第三章的利用链依赖 tls_strp_copyin_frag() 在 nr_frags == 0 时仍按 skb->len / PAGE_SIZE 取分片指针,使 frags[0] 至 frags[3] 被当作有效分片使用。补丁后 nfrag >= nr_frags 即返回 -EMSGSIZE,锚点 skb 的 nr_frags == 0 时首次搬运就被拒绝,frags[0] 至 frags[3] 均不再被写入。第三章利用链在阶段 5 首次 64KB 搬运处即断裂——不仅后续的 frags[1]、frags[2] 越界写被阻断,连 frags[0] 的首次写入也不再发生。
条件源:失败路径统一终止 strparser。 第三章的利用链还依赖 copy 模式路径上 tls_strp_abort_strp() 的不可达,使记录头解析失败后连接保持存活、skb->len 得以在多次递送间继续增长。补丁后 tls_rx_msg_size() 在失败路径上直接调用 tls_strp_abort_strp(),strp->stopped 被置 1,strparser 终止。这意味着即便某次搬运在边界检查上未触发(例如 nr_frags > 0 且索引尚未越界),只要记录头解析失败,连接即被终止,不再有后续递送。两处改动分别从“写入是否发生”与“连接是否延续”两个环节阻断了利用链。
推进机制的消解。 第三章的推进依赖“先 skb->len += chunk、后解析失败返回”的语句顺序,使每次失败调用都确实把索引向前推进一页。补丁后这一顺序本身未变,但它的两个前提都已不成立:动作源被边界检查阻断,skb->len 不会因失败调用而增长;条件源被中止语义切断,失败后不再有下一次调用。推进机制失去其作用对象,无需单独修补。
对第三章各原语的影响。 陈旧分片原语在补丁后无法建立——锚点 skb 的首次搬运即被拒绝,frags[] 中的残留内容不再被解释为分片引用。页级回收原语失去目标——没有越界写,AIO 页的回收与 pipe_buffer 的堆喷不再有意义。控制流接管原语无从触发——pipe_buffer 的 ops 字段不会被覆盖,close(pipe) 走正常释放路径。三个原语在补丁后依次失效,失效点在链条的最前端。
4-4. 修复版本与回溯状态
补丁进入上游主线的版本为 6.17-rc7。此后被回移植至各稳定分支,对应关系如下:
| 受影响区间 | 修复版本 | 稳定分支修复提交 |
|---|---|---|
| 6.0 ≤ v < 6.1.154 | 6.1.154 | b36462146d86 |
| 6.2 ≤ v < 6.6.108 | 6.6.108 | 4cefe5be7388 |
| 6.7 ≤ v < 6.12.49 | 6.12.49 | 208640e6225c |
| 6.13 ≤ v < 6.16.9 | 6.16.9 | 61ca2da5fb8f |
| 6.17-rc1 ≤ v < 6.17-rc7 | 6.17-rc7 | 0aeb54ac4cd5(上游主提交) |
发行版侧的修复状态在第二章已逐项列出:RHEL 10 已通过 RHSA-2025:21463 修复,RHEL 9 处于 deferred,RHEL 8 及更早版本因不含缺陷代码而标记为不受影响;Ubuntu Noble 与 Plucky 已从上游 cherry-pick,Jammy 及更早版本因内核版本低于 6.0 而不受影响。
从版本回溯的角度看,补丁的适用范围与缺陷的引入点严格对应:Fixes 标签指向 84c61fe1a75b,该提交进入 6.0,因此 6.0 之前的全部内核分支无需回溯,6.0 之后的每一支持分支都有对应的回移植版本。
4-5. 修复的技术要点
边界检查的比较对象是 nr_frags 而非 MAX_SKB_FRAGS。 以 nr_frags 为比较对象,防御的是有效分片边界,而非数组物理容量。第三章的分析表明,可利用的写入窗口是“数组内、语义外”的那一段——索引仍在 frags[] 的物理范围内,但已越过 nr_frags 所定义的有效分片边界。只有以 nr_frags 为比较对象,才能覆盖这一段写入窗口。
中止责任的下沉而非分散。 修补前,中止动作由主路径上的调用者显式执行,copy 模式路径上的调用者未执行,形成责任不一致。修补后,中止动作下沉至 tls_rx_msg_size() 的失败路径,所有调用者一致生效。提交信息对此有明确说明:一旦到达无效记录,就没有恢复的余地。责任集中之后,新增的调用上下文自动获得中止语义,不再依赖每个调用者自行判断。
补丁在 tls_strp_copyin_frag() 与 tls_rx_msg_size() 两处各有一处改动,分别对应动作源与条件源。 提交信息对两处改动的理由均有说明:对边界检查,理由是“since we copy some more data each time before we parse we can overflow the allocated skb space”;对中止语义,理由是“if we reach an invalid record there’s really no way to recover”。两处改动分别从“写入是否发生”与“连接是否延续”两个环节切入,与第二章的三层根因分析形成对应。
对同类缺陷的参照意义。 该补丁的形态对“先搬运、后解析”的增量处理路径具有参照价值:局部缓冲区的边界检查必须与协议状态机的错误终止策略协同设计,单点补丁只能消除症状,不足以消除触发链条。第三章 3-14 已从工程角度讨论过这一点,本节的补丁分析从修复侧给出了同一结论的印证——修复者没有选择只加一行边界检查,也没有选择只改中止路径,而是同时处理两侧,正是因为二者是两条独立路径,缺一不可。
5. 免责声明
本文档旨在提供 CVE-2025-39946 漏洞的技术分析与教育性内容,仅供学习、研究和安全防御目的使用。作者与发布平台对以下事项声明如下:
合法使用原则:本文档中描述的任何技术细节、代码示例或利用方法仅供教育研究之用。读者不得将这些信息用于任何非法、未经授权或恶意的活动,包括但不限于未经授权的系统入侵、数据破坏、服务干扰或其他违反法律法规的行为。
知识共享与责任:本文档基于公开可获取的信息、官方漏洞公告和学术研究资料编写。作者力求确保技术内容的准确性,但不对信息的完整性、时效性或适用性作任何明示或暗示的保证。读者应自行验证信息的准确性,并在专业环境中谨慎应用。
环境限制:所有技术分析和实验应在受控的、隔离的测试环境中进行,例如使用特制的虚拟机或专用硬件。禁止在任何生产环境、公共网络或他人系统中尝试漏洞利用或相关技术。
法律合规性:读者应遵守所在国家或地区的所有适用法律法规,包括但不限于计算机安全法、数据保护法和知识产权法。任何使用本文档内容的行为所产生的法律后果,由行为者自行承担。
技术中立性:本文档对漏洞的分析保持技术中立立场,旨在促进安全社区的防御能力提升。文中提及的任何工具、技术或方法不应被视为对任何组织、产品或技术的背书或批判。
更新与修正:技术领域发展迅速,本文档内容可能随时间而过时。作者保留更新、修正或撤回文档内容的权利,不承诺另行通知。
版权声明:本文档内容受版权法保护,未经明确书面许可,不得用于商业目的。允许在注明出处的前提下进行非商业性的分享与引用。
重要提示:安全研究应始终遵循道德准则,以提升整体网络安全为目标。如发现安全漏洞,建议通过负责任的披露流程向相关厂商或机构报告,共同维护数字生态的安全与稳定。
本文档的撰写参考了公开的漏洞公告、内核源码(Linux 6.12.48)及相关技术分析文献。所有实验均在封闭的测试环境中完成,未对任何实际系统造成影响。
参考
- https://github.com/BinRacer/pwn4cve/tree/master/src/CVE-2025-39946
- https://github.com/google/security-research/tree/master/pocs/linux/kernelctf/CVE-2025-39946_lts_cos
- https://github.com/google/security-research/tree/master/pocs/linux/kernelctf/CVE-2025-39946_mitigation
- https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=84c61fe1a75b4255df1e1e7c054c9e6d048da417
- https://git.kernel.org/stable/c/b36462146d86b1f22e594fe4dae611dffacfb203
- https://git.kernel.org/stable/c/4cefe5be73886f383639fe0850bb72d5b568a7b9
- https://git.kernel.org/stable/c/208640e6225cc929a05adbf79d1df558add3e231
- https://git.kernel.org/stable/c/61ca2da5fb8f433ce8bbd1657c84a86272133e6b
- https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=0aeb54ac4cd5cf8f60131b4d9ec0b6dc9c27b20d
- https://www.cve.org/CVERecord?id=CVE-2025-39946
- https://nvd.nist.gov/vuln/detail/CVE-2025-39946
- https://access.redhat.com/security/cve/cve-2025-39946
- https://ubuntu.com/security/CVE-2025-39946
文档信息
- 本文作者:BinRacer
- 本文链接:https://BinRacer.github.io/2026/11/10/KernelExploit-CVE-2025-39946/
- 版权声明:自由转载-非商用-非衍生-保持署名(创意共享3.0许可证)