msg1500路由器设置教程,傻瓜路由器参数设置

首页 > 实用技巧 > 作者:YD1662023-11-30 22:49:44

msg1500路由器设置教程,傻瓜路由器参数设置(1)

题目及exp下载 —— https://github.com/bsauce/CTF/tree/master/corCTF 2021

介绍:本文示例是来自corCTF 2021中 的两个内核题,由 BitsByWill 和 D3v17 所出。针对UAF漏洞,漏洞对象从kmalloc-64到kmalloc-4096,都能利用 msg_msg 结构实现任意写。本驱动是基于NetFilter所写,有两个模式,简单模式(对应题目Fire_of_Salvation)和复杂模式(对应题目Wall_of_Perdition),所用的内核bzImage相同。二者的区别是,简单模式下,rule_t 规则结构包含长度 0x800 的字符串成员 rule_t->desc,漏洞对象位于kmalloc-4k,复杂模式下rule_t 规则 也即漏洞对象位于kmalloc-64。

总结:如果UAF的漏洞对象是kmalloc-4096,就很容易构造重叠的漏洞对象和msg_msg结构消息块(都位于kmalloc-4096),篡改MSG_msg->m_ts和msg_msg->next实现任意地址读写

如果UAF的漏洞对象小于kmalloc-4096,例如kmalloc-64,则可以先构造重叠的漏洞对象和msg_msg结构消息块(都位于kmalloc-64),篡改msg_msg->m_ts和msg_msg->next实现越界读任意地址读;然后篡改msg_msg->next实现任意地址释放,再构造重叠的消息块(位于kmalloc-4096的msg_msgseg消息和msg_msg消息),利用userfault用户页错误处理控制消息写入的时机,篡改msg_msg->next指针指向cred地址,实现任意地址写

注意,调用msgrcv()读取内核数据时,如果带上MSG_COPY标志,就能避免内核unlink消息,以避免第一次泄露地址时未正确伪造msg_msg->m_list.next和msg_msg->m_list.prev导致unlink时崩溃。

缓解机制:开启 CONFIG_SLAB_FREELIST_RANDOM 机制后,就能阻止该利用,但其实 CONFIG_SLAB_FREELIST_RANDOM 只能降低第2题泄露地址的成功率,但是泄露失败后程序会停止,泄露成功后程序会提权成功,所以多试几次就能提权成功了。


1. 漏洞分析

代码分析:共5个函数功能,用户通过传入 user_rule_t 结构来创建路由规则并存入 rule_t 结构中,多条进出处理规则分别存入 firewall_rules_in 和 firewall_rules_out 全局数组中(每个数组最多存0x80条规则)。

漏洞:只能UAF写 0x28 – 0x30 字节,不能UAF读,因为没有实现firewall_show_rule()功能。

保护机制:SMAP/SMEP/KPTI, FG-KASLR, SLAB_RANDOM, SLAB_HARDENED, STATIC_USERMODE_HELPER。使用SLAB分配器。可以从给出的配置文件中看出,允许userfaultfd 调用、hardened_userCOPY、CHECKPOINT_RESTORE。

利用局限


2. 内核IPC——msgsnd()与msgrcv()源码分析

介绍:内核提供了两个syscall来进行IPC通信, msgsnd() 和 msgrcv(),内核消息包含两个部分,消息头 msg_msg 结构和紧跟的消息数据。长度从kmalloc-64 到 kmalloc-4096。消息头 msg_msg 结构如下所示。

struct msg_msg { struct list_head m_list; long m_type; size_t m_ts; /* message text size */ struct msg_msgseg *next; void *security; // security指针总为0,因为未开启SELinux /* the actual message follows immediately */ }; 2.1msgsnd()数据发送

总体流程:当调用 msgsnd() 来发送消息时,调用 msgsnd() -> ksys_msgsnd() -> do_msgsnd() -> load_msg() -> alloc_msg() 来分配消息头和消息数据,然后调用 load_msg() -> copy_from_user() 来将用户数据拷贝进内核。

示例:例如,如果想要发送一个包含 0x1fc8 个 A的消息,用户态首先调用msgget() 创建消息队列,然后调用 msgsnd()发送数据:

[...] struct msgbuf { long mtype; char mtext[0x1fc8]; } msg; msg.mtype = 1; memset(msg.mtext, 'A', sizeof(msg.mtext)); qid = msgget(IPC_PRIVATE, 0666 | IPC_CREAT)); msgsnd(qid, &msg, sizeof(msg.mtext), 0); [...]

创建消息: do_msgsnd() -> load_msg() -> alloc_msg() 。总结,如果消息长度超过0xfd0,则分段存储,采用单链表连接,第1个称为消息头,用 msg_msg 结构存储;第2、3个称为segment,用 msg_msgseg 结构存储。消息的最大长度由 /proc/sys/kernel/msgmax 确定, 默认大小为 8192 字节,所以最多链接3个成员。

static struct msg_msg *alloc_msg(size_t len) { struct msg_msg *msg; struct msg_msgseg **pseg; size_t alen; alen = min(len, DATALEN_MSG); // [1] len 是用户提供的数据size,本例中为0x1fc8。 DATALEN_MSG = ((size_t)PAGE_SIZE - sizeof(struct msg_msg)) = 0x1000-0x30 = 0xfd0。 本例中 alen = 0xfd0 msg = kmalloc(sizeof(*msg) alen, GFP_KERNEL_ACCOUNT); // [2] 这里分配 0x1000 堆块,对应 kmalloc-4096 if (msg == NULL) return NULL; msg->next = NULL; msg->security = NULL; len -= alen; // [3] 待分配的size,继续分配,用单链表存起来。 len = 0x1fc8-0xfd0 = 0xff8 pseg = &msg->next; while (len > 0) { struct msg_msgseg *seg; cond_resched(); alen = min(len, DATALEN_SEG); // [4] DATALEN_SEG = ((size_t)PAGE_SIZE - sizeof(struct msg_msgseg)) = 0x1000-0x8 = 0xff8。 alen = 0xff8 seg = kmalloc(sizeof(*seg) alen, GFP_KERNEL_ACCOUNT); // [5] 还是分配 0x1000,位于kmalloc-4096 if (seg == NULL) goto out_err; *pseg = seg; // [6] 单链表串起来 seg->next = NULL; pseg = &seg->next; len -= alen; } return msg; out_err: free_msg(msg); return NULL; }

拷贝消息: do_msgsnd() -> load_msg() -> copy_from_user() 。将消息从用户空间拷贝到内核空间。

struct msg_msg *load_msg(const void __user *src, size_t len) { struct msg_msg *msg; struct msg_msgseg *seg; int err = -EFAULT; size_t alen; msg = alloc_msg(len); // [1] if (msg == NULL) return ERR_PTR(-ENOMEM); alen = min(len, DATALEN_MSG); if (copy_from_user(msg 1, src, alen)) // [2] 从用户态拷贝数据,0xfd0字节 goto out_err; for (seg = msg->next; seg != NULL; seg = seg->next) { len -= alen; src = (char __user *)src alen; alen = min(len, DATALEN_SEG); if (copy_from_user(seg 1, src, alen)) // [3] 剩下的拷贝到其他segment,0xff8字节 goto out_err; } err = security_msg_msg_alloc(msg); if (err) goto out_err; return msg; out_err: free_msg(msg); return ERR_PTR(err); }

内核消息结构

msg1500路由器设置教程,傻瓜路由器参数设置(2)

2.2msgsrv()数据接收

总体流程: msgrcv() -> ksys_msgrcv() -> do_msgrcv() -> find_msg() & do_msg_fill() & free_msg()。 调用 find_msg() 来定位正确的消息,将消息从队列中unlink,再调用 do_msg_fill() -> store_msg() 来将内核数据拷贝到用户空间,最后调用 free_msg() 释放消息。

long ksys_msgrcv(int msqid, struct msgbuf __user *msgp, size_t msgsz, long msgtyp, int msgflg) { return do_msgrcv(msqid, msgp, msgsz, msgtyp, msgflg, do_msg_fill); } 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)) { // 注意:msg_handler 参数实际指向 do_msg_fill() 函数 int mode; struct msg_queue *msq; struct ipc_namespace *ns; struct msg_msg *msg, *copy = NULL; DEFINE_WAKE_Q(wake_q); ... ... if (msgflg & MSG_COPY) { if ((msgflg & MSG_EXCEPT) || !(msgflg & IPC_NOWAIT)) return -EINVAL; copy = prepare_copy(buf, min_t(size_t, bufsz, ns->msg_ctlmax)); // [4] if (IS_ERR(copy)) return PTR_ERR(copy); } mode = convert_mode(&msgtyp, msgflg); rcu_read_lock(); msq = msq_obtain_object_check(ns, msqid); ... ... for (;;) { struct msg_receiver msr_d; msg = ERR_PTR(-EACCES); if (ipcperms(ns, &msq->q_perm, S_IRUGO)) goto out_unlock1; ipc_lock_object(&msq->q_perm); /* raced with RMID? */ if (!ipc_valid_object(&msq->q_perm)) { msg = ERR_PTR(-EIDRM); goto out_unlock0; } msg = find_msg(msq, &msgtyp, mode); // [1] 调用 find_msg() 来定位正确的消息。之后检查并unlink消息。 if (!IS_ERR(msg)) { /* * Found a suitable message. * Unlink it from the queue. */ if ((bufsz < msg->m_ts) && !(msgflg & MSG_NOERROR)) { msg = ERR_PTR(-E2BIG); goto out_unlock0; } /* * If we are copying, then do not unlink message and do * not update queue parameters. */ if (msgflg & MSG_COPY) { msg = copy_msg(msg, copy); // [5] 若设置了MSG_COPY,则跳出循环,避免unlink goto out_unlock0; } list_del(&msg->m_list); ... ... } out_unlock0: ipc_unlock_object(&msq->q_perm); wake_up_q(&wake_q); out_unlock1: rcu_read_unlock(); if (IS_ERR(msg)) { free_copy(copy); return PTR_ERR(msg); } bufsz = msg_handler(buf, msg, bufsz); // [2] 调用 do_msg_fill() 把消息从内核拷贝到用户。具体代码如下所示 free_msg(msg); // [3] 拷贝完成后,释放消息。 return bufsz; }

消息拷贝: do_msg_fill() -> store_msg() 。和创建消息的过程一样,先拷贝消息头(msg_msg结构对应的数据),再拷贝segment(msg_msgseg结构对应的数据)。

static long do_msg_fill(void __user *dest, struct msg_msg *msg, size_t bufsz) { struct msgbuf __user *msgp = dest; size_t msgsz; if (put_user(msg->m_type, &msgp->mtype)) return -EFAULT; msgsz = (bufsz > msg->m_ts) ? msg->m_ts : bufsz; // [1] 检查请求的数据长度是否大于 msg->m_ts ,超过则只能获取 msg->m_ts 长度的数据(为了避免越界读)。本例中,msgsz 为0x1fc8字节, if (store_msg(msgp->mtext, msg, msgsz)) // [2] 最后调用 store_msg()将 msgsz也即0x1fc8字节拷贝到用户空间,代码如下所示 return -EFAULT; return msgsz; } int store_msg(void __user *dest, struct msg_msg *msg, size_t len) { size_t alen; struct msg_msgseg *seg; alen = min(len, DATALEN_MSG); // [1] 和创建消息的过程一样,alen=0xfd0 if (copy_to_user(dest, msg 1, alen)) // [2] 先拷贝消息头 return -1; for (seg = msg->next; seg != NULL; seg = seg->next) { // [3] 遍历其他segment len -= alen; dest = (char __user *)dest alen; alen = min(len, DATALEN_SEG); // [4] 本例中为0xff8 if (copy_to_user(dest, seg 1, alen)) // [5] 再拷贝segment return -1; } return 0; }

消息释放:store_msg() 。先释放消息头,再释放segment。

void free_msg(struct msg_msg *msg) { struct msg_msgseg *seg; security_msg_msg_free(msg); seg = msg->next; kfree(msg); // [1] 释放 msg_msg while (seg != NULL) { // [2] 释放 msg_msgseg struct msg_msgseg *tmp = seg->next; cond_resched(); kfree(seg); // [3] seg = tmp; } }

MSG_COPY:见 do_msgrcv() 中 [4]处,如果用flag MSG_COPY来调用 msgrcv() (内核编译时需配置CONFIG_CHECKPOINT_RESTORE选项,默认已配置),就会调用 prepare_copy() 分配临时消息,并调用 copy_msg() 将请求的数据拷贝到该临时消息(见 do_msgrcv() 中 [5]处)。在将消息拷贝到用户空间之后,原始消息会被保留,不会从队列中unlink,然后调用free_msg()删除该临时消息,这对于利用很重要。

为什么?因为本漏洞在第一次UAF的时候,没有泄露正确地址,所以会破坏msg_msg->m_list双链表指针,unlink会触发崩溃。本题的UAF会破坏前16字节,如果某漏洞可以跳过前16字节,是否不需要注意这一点?

void *memdump = malloc(0x1fc8); msgrcv(qid, memdump, 0x1fc8, 1, IPC_NOWAIT | MSG_COPY | MSG_NOERROR);


3. Fire of Salvation 简单模式利用

特点:大小为kmalloc-4096的UAF。

任意读:hardened_usercopy 机制不允许修改size越界读写。可利用UAF篡改msg_msg->m_ts和msg_msg->next(指向的下一个segment前8字节必须为null,避免遍历消息时出现访存崩溃)。

任意写:创建一个需要多次分配堆块的消息(>0xfd0),在拷贝消息头(msg_msg结构)的时候利用userfault进行挂起,然后利用UAF篡改msg_msg->next指向目标地址,目标地址的前8字节必须为NULL(避免崩溃),解除挂起后就能实现任意写。任意写的原理如下图所示:

msg1500路由器设置教程,傻瓜路由器参数设置(3)

3.1 步骤1——泄露内核基址

泄露内核基址:由于开启了FG-KASLR,只能喷射大量shm_file_data对象(kmalloc-32)来泄露地址,因为FG-KASLR是在boot时对函数和某些节进行二次随机化,而shm_file_data->ns这种指向全局结构的指针不会被二次随机化。我们可以传入消息来分配1个kmalloc-4096的消息头和1个kmalloc-32的segment,然后利用UAF改大msg_msg->m_ts,调用msgrcv()读内存,这样就能越界读取多个kmalloc-32结构,泄露地址。注意,需使用MSG_COPY flag避免unlink时崩溃。原理如下图所示:

msg1500路由器设置教程,傻瓜路由器参数设置(4)

首页 12345下一页

栏目热文

文档排行

本站推荐

Copyright © 2018 - 2021 www.yd166.com., All Rights Reserved.