[漏洞分析] CVE-2022-2588 route4 double free内核提权

漏洞简介

漏洞编号: CVE-2022-2588

漏洞产品: linux kernel - cls route4

影响范围: ~ linux kernel 5.19

利用条件: kernel 普通用户具有CAP_NET_ADMIN 权限

利用效果: 本地提权

该漏是Zhenpeng Lin 博士在blackhat 的议题："Cautious! A New Exploitation Method! No Pipe but as Nasty as Dirty Pipe"中的演示漏洞之一 ，并在8月25号在github公开exp，该漏洞是netlink协议中的CLS_ROUTE4模块中的route4_change函数中的UAF/double free漏洞。使用漏洞作者的dirty cred方法可以完成不依赖内核版本(特定地址)的本地提权。和之前的dirty pipe 系列利用方法一样，实现无地址依赖的本地提权攻击。

环境搭建

编译内核需要满足如下编译选项：

//下面三个可以触发poc
CONFIG_NET_CLS_ROUTE4=y
CONFIG_DUMMY=y        //或使用的其他设备
CONFIG_NET_SCH_QFQ=y  //或使用的其他设备
//跑exp还需要，并且qemu内存得大
CONFIG_NET_CLS_BASIC=y
1
2
3
4
5
6

漏洞触发poc：https://github.com/sang-chu/CVE-2022-2588

漏洞利用exp：https://github.com/Markakd/CVE-2022-2588

详见[编译能复现指定poc的内核排错过程]

漏洞原理

漏洞发生点

漏洞发生在route4_change中，大概逻辑就是生成并初始化一个route4_filter的结构，如果存在相同句柄的route4_filter，则会申请新的释放旧的，用新的代替旧的。

net\sched\cls_route.c : route4_change

static int route4_change(struct net *net, struct sk_buff *in_skb,
			 struct tcf_proto *tp, unsigned long base, u32 handle,
			 struct nlattr **tca, void **arg, bool ovr,
			 bool rtnl_held, struct netlink_ext_ack *extack)
{
	struct route4_head *head = rtnl_dereference(tp->root);
	struct route4_filter __rcu **fp;
	struct route4_filter *fold, *f1, *pfp, *f = NULL;
	struct route4_bucket *b;
	struct nlattr *opt = tca[TCA_OPTIONS];
	struct nlattr *tb[TCA_ROUTE4_MAX + 1];
	unsigned int h, th;
	int err;
	bool new = true;

    fold = *arg;//[1]来自上层函数，通过句柄找到的已经存在的route4_filter
	··· ···route4_filter
	f = kzalloc(sizeof(struct route4_filter), GFP_KERNEL);//[2]申请新的route4_filter，标志位GFP_KERNEL
	if (!f)
		goto errout;
	
	err = tcf_exts_init(&f->exts, net, TCA_ROUTE4_ACT, TCA_ROUTE4_POLICE);//[2]这里申请exts的内存空间
	if (err < 0)
		goto errout;

	if (fold) {//[3]如果当前已经存在route4_filter
		f->id = fold->id;
		f->iif = fold->iif;
		f->res = fold->res;
		f->handle = fold->handle;

		f->tp = fold->tp;
		f->bkt = fold->bkt;
		new = false;//不是新的
	}

	err = route4_set_parms(net, tp, base, f, handle, head, tb,
			       tca[TCA_RATE], new, ovr, extack);//会更新信息包括handle
	
    ··· ···
        
	//[4]如果存在route4_filter，并且handle不为0，新老handle不同，则会删除并释放老的
	if (fold && fold->handle && f->handle != fold->handle) {
		th = to_hash(fold->handle);
		h = from_hash(fold->handle >> 16);
		b = rtnl_dereference(head->table[th]);
		if (b) {
			fp = &b->ht[h];//ht存放的是route4_filter列表
			for (pfp = rtnl_dereference(*fp); pfp;
			     fp = &pfp->next, pfp = rtnl_dereference(*fp)) {
				if (pfp == fold) {
					rcu_assign_pointer(*fp, fold->next);//找到存在的那个，然后从链表中删除
					break;
				}
			}
		}
	}

	route4_reset_fastmap(head);
	*arg = f;
	if (fold) {//[5]存在route4_filter的话，则释放之前的
		tcf_unbind_filter(tp, &fold->res);
		tcf_exts_get_net(&fold->exts);
		tcf_queue_work(&fold->rwork, route4_delete_filter_work);
        //[5]启动内核进程，完成route4_delete_filter_work任务
	}
	return 0;
	··· ···
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

[1] 上层函数通过route4_get 函数找到用户传入句柄对应的route4_filter结构，就是arg参数

[2] 无论如何都要申请一个新的route4_filter结构，并初始化，其中f->exts->actions也需要额外申请空间，都用的是GFP_KERNEL标志位：

static inline int tcf_exts_init(struct tcf_exts *exts, struct net *net,
				int action, int police)
{
	··· ···
	exts->actions = kcalloc(TCA_ACT_MAX_PRIO, sizeof(struct tc_action *), //这里申请32个指针类型共256字节
				GFP_KERNEL);
	··· ···
}
1
2
3
4
5
6
7
8

[3] 存在旧的则把信息拷贝到新的上

[4] 这里如果存在旧的并且handle不为0，则会将旧的从列表中删除。

[5] 如果存在旧的，则新建内核进程任务route4_delete_filter_work 来完成释放工作。

这里逻辑没问题，先将旧的route4_filter从列表中删除，然后再将旧的route4_filter释放掉，但问题在于这两个操作的判断条件不一样。将旧的route4_filter从列表中删除操作要求handle不为0，而释放旧的route4_filter 则只要旧route4_filter存在即可。这样如果我们构造handle 为0 的route4_filter，那么就会释放后还存在在链表中，后续还可以继续释放，造成double free。

调用链

相关操作以及结构体

释放route4_filter结构使用的是内核任务route4_delete_filter_work：

net\sched\cls_route.c : route4_delete_filter_work

void tcf_exts_destroy(struct tcf_exts *exts)
{
#ifdef CONFIG_NET_CLS_ACT
	if (exts->actions) {
		tcf_action_destroy(exts->actions, TCA_ACT_UNBIND);
		kfree(exts->actions);//释放exts->actions
	}
	exts->nr_actions = 0;
#endif
}
static void __route4_delete_filter(struct route4_filter *f)
{
	tcf_exts_destroy(&f->exts);
	tcf_exts_put_net(&f->exts);
	kfree(f);//释放route4_filter
}
static void route4_delete_filter_work(struct work_struct *work)
{
	struct route4_filter *f = container_of(to_rcu_work(work),
					       struct route4_filter,
					       rwork);
	rtnl_lock();
	__route4_delete_filter(f);
	rtnl_unlock();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

在route4_delete函数中同样会调用route4_delete_filter_work 任务，所以这里doublefree可以使用route4_delete功能进行第二次free：

net\sched\cls_route.c : route4_delete

static int route4_delete(struct tcf_proto *tp, void *arg, bool *last,
			 bool rtnl_held, struct netlink_ext_ack *extack)
{
	··· ···
	for (nf = rtnl_dereference(*fp); nf;
	     fp = &nf->next, nf = rtnl_dereference(*fp)) {
		if (nf == f) {
			··· ···
			tcf_queue_work(&f->rwork, route4_delete_filter_work);

			··· ···
		}
	}

	··· ···
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

参与释放的有两个结构体：

struct route4_filter {//大小 144
	struct route4_filter __rcu	*next;
	u32			id;
	int			iif;

	struct tcf_result	res;
	struct tcf_exts		exts;
	u32			handle;
	struct route4_bucket	*bkt;
	struct tcf_proto	*tp;
	struct rcu_work		rwork;
};

struct tc_action {//大小192
	const struct tc_action_ops	*ops;
	__u32				type; /* for backward compat(TCA_OLD_COMPAT) */
	struct tcf_idrinfo		*idrinfo;

	u32				tcfa_index;
	refcount_t			tcfa_refcnt;
	atomic_t			tcfa_bindcnt;
	int				tcfa_action;
	struct tcf_t			tcfa_tm;
	struct gnet_stats_basic_packed	tcfa_bstats;
	struct gnet_stats_basic_packed	tcfa_bstats_hw;
	struct gnet_stats_queue		tcfa_qstats;
	struct net_rate_estimator __rcu *tcfa_rate_est;
	spinlock_t			tcfa_lock;
	struct gnet_stats_basic_cpu __percpu *cpu_bstats;
	struct gnet_stats_basic_cpu __percpu *cpu_bstats_hw;
	struct gnet_stats_queue __percpu *cpu_qstats;
	struct tc_cookie	__rcu *act_cookie;
	struct tcf_chain	__rcu *goto_chain;
	u32			tcfa_flags;
	u8			hw_stats;
	u8			used_hw_stats;
	bool			used_hw_stats_valid;
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

但参与释放的tc_action 不是结构体本身，而是32个结构体指针的空间，共256字节，之前分析过。

漏洞利用

dirty cred 利用方法

double free

之前提到过，通过route4_change 和route4_delete 都可以启动一个内核进程route4_delete_filter_work。在该任务中，一共会释放两个堆内存，其中之一是struct route4_filter，大小144属于kmalloc-192，另一个是一个指针数组空间，大小0x100属于kmalloc-256。

而struct file 大小232属于kmalloc-256，正好可以利用256 的chunk来double free。这里完成的目标是让两个文件描述符指向同一个struct file。

常规操作直接释放，打开file，释放即可。但问题出在释放0x100的同时还会释放一个192，而再次释放的时候192是没有被重新分配的，就会造成double free，内核检测double free部分如下：

static inline void set_freepointer(struct kmem_cache *s, void *object, void *fp)
{
	unsigned long freeptr_addr = (unsigned long)object + s->offset;

#ifdef CONFIG_SLAB_FREELIST_HARDENED
	BUG_ON(object == fp); /* naive detection of double free or corruption */
#endif

	freeptr_addr = (unsigned long)kasan_reset_tag((void *)freeptr_addr);
	*(void **)freeptr_addr = freelist_ptr(s, fp, freeptr_addr);
}
1
2
3
4
5
6
7
8
9
10
11

如果freelist指针已经指向刚释放的slab，则说明该slab释放了两次，则会崩溃。但这里只能检测出连续释放两次的slab，如果释放两次之间间隔释放了同一页的其他slab，则检测不出。

cross cache attack

struct file 结构体申请内存空间所用的slab 是filp_cache，而不是常规的kmalloc 申请空间所用的slab：

fs\file_table.c:

void __init files_init(void)
{
	filp_cachep = kmem_cache_create("filp", sizeof(struct file), 0,
			SLAB_HWCACHE_ALIGN | SLAB_PANIC | SLAB_ACCOUNT, NULL);//初始化新slab：filp，大小是file结构体大小
	percpu_counter_init(&nr_files, 0, GFP_KERNEL);
}

static struct file *__alloc_file(int flags, const struct cred *cred)
{
	struct file *f;
	int error;

	f = kmem_cache_zalloc(filp_cachep, GFP_KERNEL);//调用kmem_cache_zalloc 从filp_cachep 中申请内存
	··· ···
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

sizeof(struct file) 大小属于0x100，所以filp slab也是一个管理0x100大小的slab，只不过它和常规kmalloc-256不在一起而已。但这并不是问题，我们可以使用cross cache attack原理攻击，该利用方法的整体思路是，当一个slab 页面被全部释放的时候会被回收，这时被回收的页面是可以被其他种类的slab使用的这样就可以跨slab种类来进行利用，如Zhenpeng Lin 的ppt中演示的：

假定我们有一个非法释放漏洞(或double free)，但只能释放普通slab 中的堆块：

1. 首先喷射一堆该大小的普通堆块，这样会消耗一大堆slab 页面。我们的double free目标指针指向其中一个堆块，先将其释放
2. 然后将喷射的一大堆普通堆块都释放掉，这样double free目标堆块所在slab 页面中的所有堆块(绝大概率)会被都释放掉，该slab 页面为空，会被系统回收
3. 这时喷射一大堆filp / 其他slab 类型的堆块，这样目标指针所在页面大概率会被filp 类型slab或其他目标类型slab重新申请到吗，并且目标指针(double free漏洞指针)指向其中一个struct file结构体
4. 使用漏洞的第二次释放能力，该struct file结构体被非法释放

具体操作

所以这里采用了两个进程：

• 在添加route4_filter之前喷射若干对应大小的slab是为了让他们和route4_filter都能在一个slab page中，这样整个slab page都被释放之后对应上面cross cache attack让该kmalloc-256 page被filp slab复用。

• 释放route4_filter 之后再释放若干，就会有同slab page 中的其他堆内存释放，避免连续释放double free

• 最后喷射若干file结构，filp slab复用上面的slab page之后总会申请到目标double free结构

• 最后达到两个文件描述符指向同一个文件结构体的状态。

另外，在攻击开始前，会先喷神若干文件结构消耗掉现有struct file 申请slab 中的内存，等到之后会分配新的内存。

dirty cred部分

具体的dirty cred分析请见[kernel exploit] Dirty Cred: 一种新的无地址依赖漏洞利用方案

dirty cred 的主要利用思路是利用向文件中写入的内容的具体内核实现过程为

1. 进行权限验证，具备写权限则通过
2. 获取写入内容
3. 进行写入操作

如果我们能在1 和2 之间对struct file进行替换，则可以利用有写权限的文件进行权限判断，具体写入操作写到无写权限的问价之中。该操作需要漏洞来非法释放struct file结构体来替换，并且需要其他操作来延长替换的时间窗。dirty cred具体利用思路参见dirty cred 论文分析。这里操作分为三个进程：

• 进程A主要负责向被uaf的文件写入大量数据，同时进程C会尝试向该文件写入恶意内容。鉴权操作会同时进行，一瞬间都鉴权通过，但由于进程A写入数据量过大，inode锁会将其锁住大量时间，进程C只能等待，这期间我们要替换文件结构体
• 进程B中对之前构造的"指向同一个struct file 的两个文件描述符"分别进行close，其实是这里对该文件的引用计数是2(进程C还打开准备写入了)，需要关闭两次才可以真正释放struct file。
• 进程B中释放完毕，会立刻喷射若干passwd 的struct file结构覆盖刚刚释放的位置，这样进程C中打算写入的文件就会变成passwd。
• 进程A写入完毕，进程C继续写入，这时struct file已经被替换为passwd 的，进程C直接将任意内容写入了passwd 之中。

利用效果：

另一种思路

这里也可以直接套用之前的伪dirty pipe方法，由于时间问题没写具体exp，主要思路就是：

• 目标同样选为kmalloc-256的堆块，利用漏洞释放第一次
• 喷射若干msg_msg
• 利用漏洞释放第二次
• 喷射若干sk_buff

这样sk_buff 就跟msg_msg 共用同一块内存，然后直接套用胜利方程式即可。

参考

Markakd/CVE-2022-2588

Cautious: A New Exploitation Method! No Pipe but as Nasty as Dirty Pipe - Black Hat USA 2022 | Briefings Schedule