团队名称：星盟安全团队
团长QQ：2462148389
参赛题目：vmfs
目答案(攻击脚本)、详细的题目设计说明和破解思路：详见百度网盘

链接：https://pan.baidu.com/s/16Kxgwoa3CFU8e1fO2XuJkQ?pwd=uirm
提取码：uirm
--来自百度网盘超级会员V7的分享

设计思路：

vmfs

功能

vm 中开启了一个 http 服务，该服务可以运行用户上传的代码，代码文件保存在 /dev/vmfs 驱动中，单独运行 vm 程序是无法执行代码的，因为程序无法找到驱动。

用户可以上传自己的代码，之后发送运行指令，使得代码在 vm 程序中执行，并返回执行得到的结果。

用户态功能：

内核态功能：

用户态漏洞

虚拟机的结构体如下：

在 runFile 函数中，req.size 可以由用户控制，而 vm.code 的大小仅有 0x8000 字节，当 req.size 大于 0x8000 字节时将溢出到后面的 data 结构体。但是，这要求目标文件节点本身就大于 0x8000 字节，否则驱动将会读取失败。

func runFile(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    w.Header().Set("Access-Control-Allow-Origin", "*")

    var req Req
    err := json.NewDecoder(r.Body).Decode(&req)
    if err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }

    f, err := os.OpenFile(dev_path, syscall.O_RDONLY, 0600)
    if err != nil {
        http.Error(w, "Internal Server Error", http.StatusInternalServerError)
        return
    }

    var vm machine
    vm.data = make([]uint64, 0x1000)

    data := user_argv{
        id:             uint64(req.Id),
        addr:           uintptr(unsafe.Pointer(&(vm.code))),
        size:           uint64(req.Size),
        choose_index:   uint64(req.ChooseIndex),
        sort_option:    uint64(0),
    }
    _, _, errno := syscall.Syscall(
        syscall.SYS_IOCTL,
        uintptr(f.Fd()),
        uintptr(VMFS_READ_FILE),
        uintptr(unsafe.Pointer(&data)),
    )

    f.Close()

    if errno != 0 {
        http.Error(w, "Internal Server Error", http.StatusInternalServerError)
        return
    }

    message := VmMessage{
        Text: "success",
        Return: runVM(vm),
    }

    response, err := json.Marshal(message)
    if err != nil {
        http.Error(w, "Internal Server Error", http.StatusInternalServerError)
        return
    }

    w.Write(response)
}

在 createFile 中可以看到程序限制了创建文件的大小，用户无法通过 createFile 请求来创建 大于 0x8000 字节的文件节点。

func createFile(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    w.Header().Set("Access-Control-Allow-Origin", "*")

    var req Req
    err := json.NewDecoder(r.Body).Decode(&req)
    if err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }
    if req.Size > 0x1000 * 8 {
        http.Error(w, "Internal Server Error", http.StatusInternalServerError)
        return
    }
    ...
}

驱动初始化的时候会创建一下大小为 0x10000 节点的文件，因此可以用该文件节点来达到利用目的。

static int struct_initial(void)
{
    int i;
    struct node *tmp = NULL;

    for (i = 0; i < LENGTH; i++)
    {
        list[i] = NULL;
        trash[i].id = NONE;
        trash[i].freed = NULL;
    }


    tmp = (struct node *)kmalloc(sizeof(struct node), GFP_KERNEL);
    if(!tmp)
    {
        return NONE;
    }
    memset(tmp, 0, sizeof(struct node));
    tmp->id = 0x636db8c2;
    tmp->msg_len = 0x10000;
    tmp->msg = (char *)kmalloc(0x10000, GFP_KERNEL);
    if(!(tmp->msg))
    {
        return NONE;
    }

    memset(tmp->msg, 0, 0x10000);

    list[0] = tmp;

    return 0;
}

当控制了 vm.data 结构体之后，我们就拥有了任意地址读写的能力。

func runVM(vm machine)(r uint64){
    r = 0xdeadbeef
    end:
    for vm.pc < 0x1000 {
        switch vm.code[vm.pc] {
        case 0:
            break end
        case 1:
            if vm.code[vm.pc + 1] >= 16 || vm.code[vm.pc + 2] >= 16{
                return
            }
            vm.reg[vm.code[vm.pc + 1]] += vm.reg[vm.code[vm.pc + 2]]
            vm.pc += 3
        case 2:
            if vm.code[vm.pc + 1] >= 16 || vm.code[vm.pc + 2] >= 16{
                return
            }
            vm.reg[vm.code[vm.pc + 1]] -= vm.reg[vm.code[vm.pc + 2]]
            vm.pc += 3
        case 3:
            if vm.code[vm.pc + 1] >= 16 || vm.code[vm.pc + 2] >= 16{
                return
            }
            vm.reg[vm.code[vm.pc + 1]] *= vm.reg[vm.code[vm.pc + 2]]
            vm.pc += 3
        case 4:
            if vm.code[vm.pc + 1] >= 16 || vm.code[vm.pc + 2] >= 16{
                return
            }
            vm.reg[vm.code[vm.pc + 1]] /= vm.reg[vm.code[vm.pc + 2]]
            vm.pc += 3
        case 5:
            if vm.code[vm.pc + 1] >= 16 {
                return
            }
            vm.reg[vm.code[vm.pc + 1]] = vm.code[vm.pc + 2]
            vm.pc += 3
        case 6:
            if vm.code[vm.pc + 1] >= 16 || vm.code[vm.pc + 2] >= uint64(len(vm.data)) {
                return
            }
            vm.reg[vm.code[vm.pc + 1]] = vm.data[vm.code[vm.pc + 2]]
            vm.pc += 3
        case 7:
            if vm.code[vm.pc + 1] >= uint64(len(vm.data)) || vm.code[vm.pc + 2] >= 16 {
                return
            }
            vm.data[vm.code[vm.pc + 1]] = vm.reg[vm.code[vm.pc + 2]]
            vm.pc += 3
        case 8:
            if vm.code[vm.pc + 1] >= 16 || vm.code[vm.pc + 2] >= 16 || vm.reg[vm.code[vm.pc + 2]] >= uint64(len(vm.data)) {
                return
            }
            vm.reg[vm.code[vm.pc + 1]] = vm.data[vm.reg[vm.code[vm.pc + 2]]]
            vm.pc += 3
        case 9:
            if vm.code[vm.pc + 1] >= 16 || vm.code[vm.pc + 2] >= 16 || vm.reg[vm.code[vm.pc + 1]] >= uint64(len(vm.data)) {
                return
            }
            vm.data[vm.reg[vm.code[vm.pc + 1]]] = vm.reg[vm.code[vm.pc + 2]]
            vm.pc += 3
        default:
            return
        }
    }
    r = vm.reg[0]
    return
}

由于用户态还设置了沙箱保护，禁用了execve系统调用。

所以需要攻击者在内存中自行布置攻击代码。

由于go启动的http服务对socket进行了设置，所以这里直接从socket读取内容会失败。

因此需要fork出一个新的进程来保持干净的环境。

同时将父进程挂起，防止系统关机。

随后子进程需要使用 fcntl(0, F_SETFL, 0) 来重置socket，重置之后 socket 才能恢复正常。

内核态漏洞

回收站并不会保存文件节点的地址，而是保存文件节点的索引，当文件处在回收站后，文件节点将不再可读写。驱动提供了四种排序方式，其中选择排序 VMFS_SELECTION_SORT 是不稳定的排序算法，正如数据结构这门课程里面提到的那样 ，当序列中有相同大小的值时，执行选择排序后他们的位置可能会发生变化。若使用选择排序，已删除的节点和未删除的节点就可能会混淆，从而导致UAF漏洞。

举个简单的例子，将下面的序列进行选择排序

此时两个5的顺序发生了变化，结果是5* 排在 了 5后面。

知道了原理后就可以利用该漏洞构造任意地址读写。

由于内核开了 CONFIG_STATIC_USERMODEHELPER 保护，因此无法劫持 modprobe_path 来达到提权目的。同时内核还开启了 CONFIG_HARDENED_USERCOPY ，函数 copy_from_user 和 copy_to_user 无法直接读写 task_struct 和 cred 。

让我们查看源码来寻求绕过方法，首先定位到 CONFIG_HARDENED_USERCOPY 的定义：

__check_heap_object 源码中没有什么方便的绕过方式，因此找到其上一层的调用函数 check_heap_object

其中 virt_addr_valid 判断失败的话则可以直接绕过 __check_heap_object 检查。

virt_addr_valid 函数如下：

通常我们会在内存的第一块区域，所以i=0 。

memblock_is_nomap函数如下：

简单来说只要其物理地址的标志位带有 MEMBLOCK_NOMAP 则会返回 0。

因此我们要做的就是修改 memblock_memory_init_regions[0].flags 为 MEMBLOCK_NOMAP ，这样就可以绕过 __check_heap_object 检查。

恰好 memblock_memory_init_regions[0].flags 位于内核数据段上，因此有任意地址读写能力后很容易就能实现该修改操作。

在该题目中 memblock_memory_init_regions[0].flags 位于 0xffff80000a2ae1f8 地址上。

利用代码：

[培训]内核驱动高级班，冲击BAT一流互联网大厂工作，每周日13:00-18:00直播授课